Changes in / [a953c2e3:6ff08d8]

Files:

• libcfa/src/concurrency/locks.hfa (modified) (1 diff)
• tests/unified_locking/fast.cfa (modified) (1 diff)
• tests/unified_locking/lin_backoff.cfa (added)
• tests/unified_locking/mutex_test.hfa (added)
• 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>
 
-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));
-        }
-}
+#define LOCK fast_lock
+#include "mutex_test.hfa"
 
 int main() {
-        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;
+    test();
 }

tests/unified_locking/thread_test.cfa

@@ -8 +8 @@
 static unsigned int threadCount = 2;
 static unsigned int lockCount = 1;
-static unsigned int num_times = 10000;
+static unsigned int total_times = 320000;
+static unsigned int num_times;
 static const int workBufferSize = 16;
 static unsigned int work_unlocked = 10000;
@@ -25 +26 @@
 thread worker {
     linear_backoff_then_block_lock * locks;
+    bool improved;
 };
 
-void ?{}( worker & w, linear_backoff_then_block_lock * locks ) {
+void ?{}( worker & w, linear_backoff_then_block_lock * locks, bool improved ) {
         w.locks = locks;
+    w.improved = improved;
 }
 
-linear_backoff_then_block_lock norm_lock;
 
 void main( worker & this ) with(this) {
@@ -37 +39 @@
     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);
-        lock(*curr_lock);
-        //printf("lock: %d %p ENTER\n", i, &curr_lock);
-        //lock(norm_lock);
+        if (improved) lock_improved(*curr_lock);
+        else lock(*curr_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]);
@@ -68 +72 @@
     }
         processor p[threadCount];
-    linear_backoff_then_block_lock locks;//[lockCount];
-    printf("lock allocation address: %p \n", &locks);
+    linear_backoff_then_block_lock locks[lockCount];
     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 );
+        worker_arr[i] = new( locks, false );
     }
     for (unsigned int i = 0; i < taskCount; i++) {
-        free( worker_arr[i] );
+        delete( worker_arr[i] );
     }
         clock_t end = clock();
         double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
-        printf("Done Test, time: %f\n", time_spent);
+        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);
 }