Changes in libcfa/src/concurrency/locks.cfa [c18bf9e:305aaef]

File:

• libcfa/src/concurrency/locks.cfa (modified) (10 diffs)

libcfa/src/concurrency/locks.cfa

@@ -24 +24 @@
 #include <stdlib.hfa>
 
-#pragma GCC visibility push(default)
-
 //-----------------------------------------------------------------------------
 // info_thread
@@ -118 +116 @@
 }
 
-static void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
+void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
         thread$ * t = &try_pop_front( blocked_threads );
         owner = t;
@@ -176 +174 @@
         recursion_count = recursion;
 }
+
+//-----------------------------------------------------------------------------
+// simple_owner_lock
+
+static inline void lock(simple_owner_lock & this) with(this) {
+        if (owner == active_thread()) {
+                recursion_count++;
+                return;
+        }
+        lock( lock __cfaabi_dbg_ctx2 );
+
+        if (owner != 0p) {
+                insert_last( blocked_threads, *active_thread() );
+                unlock( lock );
+                park( );
+                return;
+        }
+        owner = active_thread();
+        recursion_count = 1;
+        unlock( lock );
+}
+
+void pop_and_set_new_owner( simple_owner_lock & this ) with( this ) {
+        thread$ * t = &try_pop_front( blocked_threads );
+        owner = t;
+        recursion_count = ( t ? 1 : 0 );
+        unpark( t );
+}
+
+static inline void unlock(simple_owner_lock & this) with(this) {
+        lock( lock __cfaabi_dbg_ctx2 );
+        /* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );
+        /* paranoid */ verifyf( owner == active_thread(), "Thread %p other than the owner %p attempted to release owner lock %p", owner, active_thread(), &this );
+        // if recursion count is zero release lock and set new owner if one is waiting
+        recursion_count--;
+        if ( recursion_count == 0 ) {
+                pop_and_set_new_owner( this );
+        }
+        unlock( lock );
+}
+
+static inline void on_notify(simple_owner_lock & this, struct thread$ * t ) with(this) {
+        lock( lock __cfaabi_dbg_ctx2 );
+        // lock held
+        if ( owner != 0p ) {
+                insert_last( blocked_threads, *t );
+                unlock( lock );
+        }
+        // lock not held
+        else {
+                owner = t;
+                recursion_count = 1;
+                unpark( t );
+                unlock( lock );
+        }
+}
+
+static inline size_t on_wait(simple_owner_lock & this) with(this) { 
+        lock( lock __cfaabi_dbg_ctx2 );
+        /* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );
+        /* paranoid */ verifyf( owner == active_thread(), "Thread %p other than the owner %p attempted to release owner lock %p", owner, active_thread(), &this );
+
+        size_t ret = recursion_count;
+
+        pop_and_set_new_owner( this );
+
+        unlock( lock );
+        return ret;
+}
+
+static inline void on_wakeup(simple_owner_lock & this, size_t recursion ) with(this) { recursion_count = recursion; }
+
 
 //-----------------------------------------------------------------------------
@@ -194 +264 @@
         void ^?{}( alarm_node_wrap(L) & this ) { }
 
-        static void timeout_handler ( alarm_node_wrap(L) & this ) with( this ) {
+        void timeout_handler ( alarm_node_wrap(L) & this ) with( this ) {
                 // This condition_variable member is called from the kernel, and therefore, cannot block, but it can spin.
                 lock( cond->lock __cfaabi_dbg_ctx2 );
@@ -218 +288 @@
 
         // this casts the alarm node to our wrapped type since we used type erasure
-        static void alarm_node_wrap_cast( alarm_node_t & a ) { timeout_handler( (alarm_node_wrap(L) &)a ); }
+        void alarm_node_wrap_cast( alarm_node_t & a ) { timeout_handler( (alarm_node_wrap(L) &)a ); }
 }
 
@@ -235 +305 @@
         void ^?{}( condition_variable(L) & this ){ }
 
-        static void process_popped( condition_variable(L) & this, info_thread(L) & popped ) with( this ) {
+        void process_popped( condition_variable(L) & this, info_thread(L) & popped ) with( this ) {
                 if(&popped != 0p) {
                         popped.signalled = true;
@@ -280 +350 @@
         int counter( condition_variable(L) & this ) with(this) { return count; }
 
-        static size_t queue_and_get_recursion( condition_variable(L) & this, info_thread(L) * i ) with(this) {
+        size_t queue_and_get_recursion( condition_variable(L) & this, info_thread(L) * i ) with(this) {
                 // add info_thread to waiting queue
                 insert_last( blocked_threads, *i );
@@ -293 +363 @@
 
         // helper for wait()'s' with no timeout
-        static void queue_info_thread( condition_variable(L) & this, info_thread(L) & i ) with(this) {
+        void queue_info_thread( condition_variable(L) & this, info_thread(L) & i ) with(this) {
                 lock( lock __cfaabi_dbg_ctx2 );
                 size_t recursion_count = queue_and_get_recursion(this, &i);
@@ -310 +380 @@
 
         // helper for wait()'s' with a timeout
-        static void queue_info_thread_timeout( condition_variable(L) & this, info_thread(L) & info, Duration t, Alarm_Callback callback ) with(this) {
+        void queue_info_thread_timeout( condition_variable(L) & this, info_thread(L) & info, Duration t, Alarm_Callback callback ) with(this) {
                 lock( lock __cfaabi_dbg_ctx2 );
                 size_t recursion_count = queue_and_get_recursion(this, &info);
@@ -345 +415 @@
         // fast_cond_var
         void  ?{}( fast_cond_var(L) & this ){
-                this.blocked_threads{};
+                this.blocked_threads{}; 
                 #ifdef __CFA_DEBUG__
                 this.lock_used = 0p;