Changeset 797a193 for libcfa/src/concurrency/locks.cfa

Timestamp:

Dec 22, 2020, 12:50:46 PM (2 years ago)

Author:

caparsons <caparson@…>

Branches:

arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

26a249c, 302ef2a

Parents:

fe97de26

Message:

cleaned up locks code and added comments

File:

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

libcfa/src/concurrency/locks.cfa

@@ -1 +1 @@
 #include "locks.hfa"
 #include "kernel_private.hfa"
-#include <stdlib.h>
-#include <stdio.h>
 
 #include <kernel.hfa>
 #include <stdlib.hfa>
-#include <thread.hfa>
 
 ///////////////////////////////////////////////////////////////////
@@ -61 +58 @@
 void lock( blocking_lock & this ) with( this ) {
         lock( lock __cfaabi_dbg_ctx2 );
-        if ( owner == active_thread() && !multi_acquisition) {
+        if ( owner == active_thread() && !multi_acquisition) { // single acquisition lock is held by current thread
                 abort("A single acquisition lock holder attempted to reacquire the lock resulting in a deadlock.");
-        } else if ( owner != 0p && owner != active_thread() ) {
+        } else if ( owner != 0p && owner != active_thread() ) { // lock is held by some other thread
                 addTail( blocked_threads, *active_thread() );
                 wait_count++;
                 unlock( lock );
                 park( );
-        } else if ( owner == active_thread() && multi_acquisition ) {
+        } else if ( owner == active_thread() && multi_acquisition ) { // multi acquisition lock is held by current thread
                 recursion_count++;
                 unlock( lock );
-        } else {
+        } else { // lock isn't held
                 owner = active_thread();
                 recursion_count = 1;
@@ -81 +78 @@
         bool ret = false;
         lock( lock __cfaabi_dbg_ctx2 );
-        if ( owner == 0p ) {
+        if ( owner == 0p ) { // lock isn't held
                 owner = active_thread();
                 recursion_count = 1;
                 ret = true;
-        } else if ( owner == active_thread() && multi_acquisition ) {
+        } else if ( owner == active_thread() && multi_acquisition ) { // multi acquisition lock is held by current thread
                 recursion_count++;
                 ret = true;
@@ -94 +91 @@
 
 void unlock_error_check( blocking_lock & this ) with( this ) {
-        if ( owner == 0p ){ // no owner implies lock isn't held
+        if ( owner == 0p ){ // lock isn't held
                 abort( "There was an attempt to release a lock that isn't held" ); 
         } else if ( strict_owner && owner != active_thread() ) {
@@ -113 +110 @@
         unlock_error_check( this );
         recursion_count--;
-        if ( recursion_count == 0 ) {
+        if ( recursion_count == 0 ) { // if recursion count is zero release lock and set new owner if one is waiting
                 pop_and_set_new_owner( this );
         }
@@ -131 +128 @@
 }
 
-void add_( blocking_lock & this, $thread * t ) with( this ) {
+void on_notify( blocking_lock & this, $thread * t ) with( this ) {
     lock( lock __cfaabi_dbg_ctx2 );
-        if ( owner != 0p ) {
+        if ( owner != 0p ) { // lock held
                 addTail( blocked_threads, *t );
                 wait_count++;
                 unlock( lock );
-        } else {
+        } else {        // lock not held
                 owner = t;
                 recursion_count = 1;
@@ -145 +142 @@
 }
 
-void remove_( blocking_lock & this ) with( this ) {
+void on_wait( blocking_lock & this ) with( this ) {
     lock( lock __cfaabi_dbg_ctx2 );
         unlock_error_check( this );
@@ -156 +153 @@
 ///////////////////////////////////////////////////////////////////
 
-// This is temporary until an inheritance bug is fixed
+// These routines are temporary until an inheritance bug is fixed
 
 void lock( single_acquisition_lock & this ){ lock( (blocking_lock &)this ); }
 void unlock( single_acquisition_lock & this ){ unlock( (blocking_lock &)this ); }
-void add_( single_acquisition_lock & this, struct $thread * t ){ add_( (blocking_lock &)this, t ); }
-void remove_( single_acquisition_lock & this ){ remove_( (blocking_lock &)this ); }
+void on_notify( single_acquisition_lock & this, struct $thread * t ){ on_notify( (blocking_lock &)this, t ); }
+void on_wait( single_acquisition_lock & this ){ on_wait( (blocking_lock &)this ); }
 void set_recursion_count( single_acquisition_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
 size_t get_recursion_count( single_acquisition_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }
@@ -167 +164 @@
 void lock( owner_lock & this ){ lock( (blocking_lock &)this ); }
 void unlock( owner_lock & this ){ unlock( (blocking_lock &)this ); }
-void add_( owner_lock & this, struct $thread * t ){ add_( (blocking_lock &)this, t ); }
-void remove_( owner_lock & this ){ remove_( (blocking_lock &)this ); }
+void on_notify( owner_lock & this, struct $thread * t ){ on_notify( (blocking_lock &)this, t ); }
+void on_wait( owner_lock & this ){ on_wait( (blocking_lock &)this ); }
 void set_recursion_count( owner_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
 size_t get_recursion_count( owner_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }
@@ -174 +171 @@
 void lock( multiple_acquisition_lock & this ){ lock( (blocking_lock &)this ); }
 void unlock( multiple_acquisition_lock & this ){ unlock( (blocking_lock &)this ); }
-void add_( multiple_acquisition_lock & this, struct $thread * t ){ add_( (blocking_lock &)this, t ); }
-void remove_( multiple_acquisition_lock & this ){ remove_( (blocking_lock &)this ); }
+void on_notify( multiple_acquisition_lock & this, struct $thread * t ){ on_notify( (blocking_lock &)this, t ); }
+void on_wait( multiple_acquisition_lock & this ){ on_wait( (blocking_lock &)this ); }
 void set_recursion_count( multiple_acquisition_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
 size_t get_recursion_count( multiple_acquisition_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }
@@ -188 +185 @@
         // This condition_variable member is called from the kernel, and therefore, cannot block, but it can spin.
             lock( cond->lock __cfaabi_dbg_ctx2 );
-            if ( listed(i) ) {                  // is thread on queue
+
+            // this check is necessary to avoid a race condition since this timeout handler 
+            //  may still be called after a thread has been removed from the queue but 
+            //  before the alarm is unregistered
+            if ( listed(i) ) {                                                  // is thread on queue
                 i->signalled = false;
-                cond->last_thread = i;          // REMOVE THIS AFTER DEBUG
-                        remove( cond->blocked_threads, *i );             //remove this thread O(1)
+                        remove( cond->blocked_threads, *i );    // remove this thread O(1)
                         cond->count--;
-                        if( !i->lock ) {
-                                unpark( i->t );
+                        if( i->lock ) {
+                                on_notify(*i->lock, i->t);                      // call lock's on_notify if a lock was passed
                 } else {
-                        add_(*i->lock, i->t);                   // call lock's add_
+                        unpark( i->t );                                         // otherwise wake thread
                 }
             }
@@ -202 +202 @@
         }
 
+        // 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 ); }
 
@@ -208 +209 @@
                 this.blocked_threads{};
                 this.count = 0;
-                this.last_thread = 0p; // REMOVE AFTER DEBUG
         }
 
@@ -224 +224 @@
                         count--;
                         if (popped.lock) {
-                                add_(*popped.lock, popped.t);
+                                on_notify(*popped.lock, popped.t); // if lock passed call on_notify
                         } else {
-                                unpark(popped.t);
+                                unpark(popped.t); // otherwise wake thread
                         }
                 }
@@ -258 +258 @@
 
         size_t queue_and_get_recursion( condition_variable(L) & this, info_thread(L) * i ) with(this) {
-                addTail( blocked_threads, *i );
+                addTail( blocked_threads, *i ); // add info_thread to waiting queue
                 count++;
                 size_t recursion_count = 0;
-                if (i->lock) {
+                if (i->lock) { // if lock was passed get recursion count to reset to after waking thread
                         recursion_count = get_recursion_count(*i->lock);
-                        remove_( *i->lock );
+                        on_wait( *i->lock );
                 }
                 return recursion_count;
@@ -287 +287 @@
                 unlock( lock );
                 park();
-                unregister_self( &node_wrap.alarm_node );
-                if (info.lock) set_recursion_count(*info.lock, recursion_count);
+                unregister_self( &node_wrap.alarm_node ); // unregisters alarm so it doesn't go off if this happens first
+                if (info.lock) set_recursion_count(*info.lock, recursion_count); // resets recursion count here after waking
         }