Changes in libcfa/src/concurrency/locks.hfa [a45e21c:d30e3eb]

File:

• libcfa/src/concurrency/locks.hfa (modified) (6 diffs)

libcfa/src/concurrency/locks.hfa

@@ -32 +32 @@
 #include <fstream.hfa>
 
+
 // futex headers
 #include <linux/futex.h>      /* Definition of FUTEX_* constants */
@@ -154 +155 @@
 // futex_mutex
 
+// - No cond var support
 // - Kernel thd blocking alternative to the spinlock
 // - No ownership (will deadlock on reacq)
@@ -183 +185 @@
         int state;
 
-        for( int spin = 4; spin < 1024; spin += spin) {
-                state = 0;
-                // if unlocked, lock and return
-                if (internal_try_lock(this, state)) return;
-                if (2 == state) break;
-                for (int i = 0; i < spin; i++) Pause();
-        }
-
-        // // no contention try to acquire
-        // if (internal_try_lock(this, state)) return;
+        
+        // // linear backoff omitted for now
+        // for( int spin = 4; spin < 1024; spin += spin) {
+        //      state = 0;
+        //      // if unlocked, lock and return
+        //      if (internal_try_lock(this, state)) return;
+        //      if (2 == state) break;
+        //      for (int i = 0; i < spin; i++) Pause();
+        // }
+
+        // no contention try to acquire
+        if (internal_try_lock(this, state)) return;
         
         // if not in contended state, set to be in contended state
@@ -205 +209 @@
 
 static inline void unlock(futex_mutex & this) with(this) {
-        // if uncontended do atomic unlock and then return
-    if (__atomic_exchange_n(&val, 0, __ATOMIC_RELEASE) == 1) return;
+        // if uncontended do atomice unlock and then return
+        if (__atomic_fetch_sub(&val, 1, __ATOMIC_RELEASE) == 1) return; // TODO: try acq/rel
         
         // otherwise threads are blocked so we must wake one
+        __atomic_store_n((int *)&val, 0, __ATOMIC_RELEASE);
         futex((int *)&val, FUTEX_WAKE, 1);
 }
@@ -217 +222 @@
 // to set recursion count after getting signalled;
 static inline void on_wakeup( futex_mutex & f, size_t recursion ) {}
-
-//-----------------------------------------------------------------------------
-// go_mutex
-
-// - Kernel thd blocking alternative to the spinlock
-// - No ownership (will deadlock on reacq)
-// - Golang's flavour of mutex
-// - Impl taken from Golang: src/runtime/lock_futex.go
-struct go_mutex {
-        // lock state any state other than UNLOCKED is locked
-        // enum LockState { UNLOCKED = 0, LOCKED = 1, SLEEPING = 2 };
-        
-        // stores a lock state
-        int val; 
-};
-
-static inline void  ?{}( go_mutex & this ) with(this) { val = 0; }
-
-static inline bool internal_try_lock(go_mutex & this, int & compare_val, int new_val ) with(this) {
-        return __atomic_compare_exchange_n((int*)&val, (int*)&compare_val, new_val, false, __ATOMIC_ACQUIRE, __ATOMIC_ACQUIRE);
-}
-
-static inline int internal_exchange(go_mutex & this, int swap ) with(this) {
-        return __atomic_exchange_n((int*)&val, swap, __ATOMIC_ACQUIRE);
-}
-
-const int __go_mtx_spins = 4;
-const int __go_mtx_pauses = 30;
-// if this is called recursively IT WILL DEADLOCK!!!!!
-static inline void lock(go_mutex & this) with(this) {
-        int state, init_state;
-
-    // speculative grab
-    state = internal_exchange(this, 1);
-    if ( !state ) return; // state == 0
-    init_state = state;
-    for (;;) {
-        for( int i = 0; i < __go_mtx_spins; i++ ) {
-            while( !val ) { // lock unlocked
-                state = 0;
-                if (internal_try_lock(this, state, init_state)) return;
-            }
-            for (int i = 0; i < __go_mtx_pauses; i++) Pause();
-        }
-
-        while( !val ) { // lock unlocked
-            state = 0;
-            if (internal_try_lock(this, state, init_state)) return;
-        }
-        sched_yield();
-        
-        // if not in contended state, set to be in contended state
-        state = internal_exchange(this, 2);
-        if ( !state ) return; // state == 0
-        init_state = 2;
-        futex((int*)&val, FUTEX_WAIT, 2); // if val is not 2 this returns with EWOULDBLOCK
-    }
-}
-
-static inline void unlock( go_mutex & this ) with(this) {
-        // if uncontended do atomic unlock and then return
-    if (__atomic_exchange_n(&val, 0, __ATOMIC_RELEASE) == 1) return;
-        
-        // otherwise threads are blocked so we must wake one
-        futex((int *)&val, FUTEX_WAKE, 1);
-}
-
-static inline void on_notify( go_mutex & f, thread$ * t){ unpark(t); }
-static inline size_t on_wait( go_mutex & f ) {unlock(f); return 0;}
-static inline void on_wakeup( go_mutex & f, size_t recursion ) {}
 
 //-----------------------------------------------------------------------------
@@ -336 +271 @@
         this.lock_value = 0;
 }
-
-static inline void  ^?{}( exp_backoff_then_block_lock & this ){}
 
 static inline bool internal_try_lock(exp_backoff_then_block_lock & this, size_t & compare_val) with(this) {