Changes in / [6ff08d8:a953c2e3]

Files:

• libcfa/src/concurrency/locks.hfa (modified) (1 diff)
• tests/unified_locking/fast.cfa (modified) (1 diff)
• tests/unified_locking/lin_backoff.cfa (deleted)
• tests/unified_locking/mutex_test.hfa (deleted)
• tests/unified_locking/thread_test.cfa (modified) (4 diffs)

libcfa/src/concurrency/locks.hfa

@@ -276 +276 @@
 static inline void  ?{}( linear_backoff_then_block_lock & this ) { this{4, 1024, 16, 0}; }
 static inline void ^?{}( linear_backoff_then_block_lock & this ) {}
-static inline void ?{}( linear_backoff_then_block_lock & this, linear_backoff_then_block_lock this2 ) = void;
-static inline void ?=?( linear_backoff_then_block_lock & this, linear_backoff_then_block_lock this2 ) = void;
 
 static inline bool internal_try_lock(linear_backoff_then_block_lock & this, size_t & compare_val) with(this) {

tests/unified_locking/fast.cfa

@@ +1 @@
+#include <fstream.hfa>
 #include <locks.hfa>
+#include <thread.hfa>
 
-#define LOCK fast_lock
-#include "mutex_test.hfa"
+const unsigned int num_times = 50;
+
+struct MutexObj {
+        fast_lock l;
+        thread$ * id;
+        uint32_t sum;
+};
+
+MutexObj mo;
+
+void trash() {
+        unsigned t[100];
+        for(i; 100) {
+                t[i] = 0xDEADBEEF;
+        }
+}
+
+uint32_t cs() {
+        thread$ * me = active_thread();
+        uint32_t value;
+        lock(mo.l);
+        {
+                uint32_t tsum = mo.sum;
+                mo.id = me;
+                yield(random(5));
+                value = ((uint32_t)random()) ^ ((uint32_t)me);
+                if(mo.id != me) sout | "Intruder!";
+                mo.sum = tsum + value;
+        }
+        unlock(mo.l);
+        return value;
+}
+
+thread LockCheck {
+        uint32_t sum;
+};
+
+void main(LockCheck & this) {
+        this.sum = 0;
+        for(num_times) {
+                trash();
+                this.sum += cs();
+                trash();
+                yield(random(10));
+        }
+}
 
 int main() {
-    test();
+        uint32_t sum = -32;
+        mo.sum = -32;
+        processor p[2];
+        sout | "Starting";
+        {
+                LockCheck checkers[13];
+                for(i;13) {
+                        sum += join(checkers[i]).sum;
+                }
+        }
+        sout | "Done!";
+        if(sum == mo.sum) sout | "Match!";
+        else sout | "No Match!" | sum | "vs" | mo.sum;
 }

tests/unified_locking/thread_test.cfa

@@ -8 +8 @@
 static unsigned int threadCount = 2;
 static unsigned int lockCount = 1;
-static unsigned int total_times = 320000;
-static unsigned int num_times;
+static unsigned int num_times = 10000;
 static const int workBufferSize = 16;
 static unsigned int work_unlocked = 10000;
@@ -26 +25 @@
 thread worker {
     linear_backoff_then_block_lock * locks;
-    bool improved;
 };
 
-void ?{}( worker & w, linear_backoff_then_block_lock * locks, bool improved ) {
+void ?{}( worker & w, linear_backoff_then_block_lock * locks ) {
         w.locks = locks;
-    w.improved = improved;
 }
 
+linear_backoff_then_block_lock norm_lock;
 
 void main( worker & this ) with(this) {
@@ -39 +37 @@
     for (int i = 0; i < workBufferSize; i += 1) buffer[i] = rand() % 1024;
     unsigned int lck = rand() % lockCount;
-    linear_backoff_then_block_lock * curr_lock = &locks[lck];
+    linear_backoff_then_block_lock * curr_lock = locks;//[lck];
     for (unsigned int i = 0; i < num_times; i++) {
         dowork(buffer, work_unlocked);
-        if (improved) lock_improved(*curr_lock);
-        else lock(*curr_lock);
+        lock(*curr_lock);
+        //printf("lock: %d %p ENTER\n", i, &curr_lock);
+        //lock(norm_lock);
         dowork(buffer, work_locked);
+        //printf("lock: %d %p LEAVE\n", i, &curr_lock);
         unlock(*curr_lock);
+        //unlock(norm_lock);
         lck = rand() % lockCount;
-        curr_lock = &locks[lck];
+        //curr_lock = locks[lck];
     }
 }
 
-
 int main(int argc, char* argv[]) {
     switch (argc) {
-        case 7:
-            work_unlocked = atoi(argv[5]);
-        case 6:
-            work_locked = atoi(argv[5]);
         case 5:
             num_times = atoi(argv[4]);
@@ -72 +68 @@
     }
         processor p[threadCount];
-    linear_backoff_then_block_lock locks[lockCount];
+    linear_backoff_then_block_lock locks;//[lockCount];
+    printf("lock allocation address: %p \n", &locks);
     worker * worker_arr[taskCount];
-    num_times = total_times  / taskCount;
 
-        //printf("Start Test: martin lock simple\n");
+        printf("Start Test: martin lock simple\n");
         clock_t begin = clock();
         for (unsigned int i = 0; i < taskCount; i++) {
-        worker_arr[i] = new( locks, false );
+        worker_arr[i] = new( &locks );
     }
     for (unsigned int i = 0; i < taskCount; i++) {
-        delete( worker_arr[i] );
+        free( worker_arr[i] );
     }
         clock_t end = clock();
         double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
-        printf("norm: %f\n", time_spent);
-
-    //printf("Start Test: martin lock improved\n");
-        begin = clock();
-        for (unsigned int i = 0; i < taskCount; i++) {
-        worker_arr[i] = new( locks, true );
-    }
-    for (unsigned int i = 0; i < taskCount; i++) {
-        delete( worker_arr[i] );
-    }
-        end = clock();
-        time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
-        printf("improved: %f\n", time_spent);
+        printf("Done Test, time: %f\n", time_spent);
 }