Changeset 74ec742 for libcfa/src/concurrency/locks.cfa

Timestamp:

May 20, 2022, 10:36:45 AM (3 years ago)

Author:

m3zulfiq <m3zulfiq@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

25fa20a

Parents:

29d8c02 (diff), 7831e8fb (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

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

libcfa/src/concurrency/locks.cfa

@@ -24 +24 @@
 #include <stdlib.hfa>
 
+#pragma GCC visibility push(default)
+
 //-----------------------------------------------------------------------------
 // info_thread
@@ -116 +118 @@
 }
 
-void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
+static void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
         thread$ * t = &try_pop_front( blocked_threads );
         owner = t;
@@ -192 +194 @@
         void ^?{}( alarm_node_wrap(L) & this ) { }
 
-        void timeout_handler ( alarm_node_wrap(L) & this ) with( this ) {
+        static 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 );
@@ -216 +218 @@
 
         // this casts the alarm node to our wrapped type since we used type erasure
-        void alarm_node_wrap_cast( alarm_node_t & a ) { timeout_handler( (alarm_node_wrap(L) &)a ); }
+        static void alarm_node_wrap_cast( alarm_node_t & a ) { timeout_handler( (alarm_node_wrap(L) &)a ); }
 }
 
 //-----------------------------------------------------------------------------
-// condition variable
+// Synchronization Locks
 forall(L & | is_blocking_lock(L)) {
 
+        //-----------------------------------------------------------------------------
+        // condition variable
         void ?{}( condition_variable(L) & this ){
                 this.lock{};
@@ -231 +235 @@
         void ^?{}( condition_variable(L) & this ){ }
 
-        void process_popped( condition_variable(L) & this, info_thread(L) & popped ) with( this ) {
+        static void process_popped( condition_variable(L) & this, info_thread(L) & popped ) with( this ) {
                 if(&popped != 0p) {
                         popped.signalled = true;
@@ -276 +280 @@
         int counter( condition_variable(L) & this ) with(this) { return count; }
 
-        size_t queue_and_get_recursion( condition_variable(L) & this, info_thread(L) * i ) with(this) {
+        static 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 );
@@ -289 +293 @@
 
         // helper for wait()'s' with no timeout
-        void queue_info_thread( condition_variable(L) & this, info_thread(L) & i ) with(this) {
+        static 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);
@@ -306 +310 @@
 
         // helper for wait()'s' with a timeout
-        void queue_info_thread_timeout( condition_variable(L) & this, info_thread(L) & info, Duration t, Alarm_Callback callback ) with(this) {
+        static 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);
@@ -337 +341 @@
         bool wait( condition_variable(L) & this, L & l, Duration duration                 ) with(this) { WAIT_TIME( 0   , &l , duration ) }
         bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) { WAIT_TIME( info, &l , duration ) }
+
+        //-----------------------------------------------------------------------------
+        // fast_cond_var
+        void  ?{}( fast_cond_var(L) & this ){
+                this.blocked_threads{};
+                #ifdef __CFA_DEBUG__
+                this.lock_used = 0p;
+                #endif
+        }
+        void ^?{}( fast_cond_var(L) & this ){ }
+
+        bool notify_one( fast_cond_var(L) & this ) with(this) {
+                bool ret = ! blocked_threads`isEmpty;
+                if ( ret ) {
+                        info_thread(L) & popped = try_pop_front( blocked_threads );
+                        on_notify(*popped.lock, popped.t);
+                }
+                return ret;
+        }
+        bool notify_all( fast_cond_var(L) & this ) with(this) {
+                bool ret = ! blocked_threads`isEmpty;
+                while( ! blocked_threads`isEmpty ) {
+                        info_thread(L) & popped = try_pop_front( blocked_threads );
+                        on_notify(*popped.lock, popped.t);
+                }
+                return ret;
+        }
+
+        uintptr_t front( fast_cond_var(L) & this ) with(this) { return blocked_threads`isEmpty ? NULL : blocked_threads`first.info; }
+        bool empty ( fast_cond_var(L) & this ) with(this) { return blocked_threads`isEmpty; }
+
+        void wait( fast_cond_var(L) & this, L & l ) {
+                wait( this, l, 0 );
+        }
+
+        void wait( fast_cond_var(L) & this, L & l, uintptr_t info ) with(this) {
+                // brand cond lock with lock
+                #ifdef __CFA_DEBUG__
+                        if ( lock_used == 0p ) lock_used = &l;
+                        else { assert(lock_used == &l); }
+                #endif
+                info_thread( L ) i = { active_thread(), info, &l };
+                insert_last( blocked_threads, i );
+                size_t recursion_count = on_wait( *i.lock );
+                park( );
+                on_wakeup(*i.lock, recursion_count);
+        }
 }