Changeset 5e0b6657 for libcfa/src/concurrency/locks.cfa

Timestamp:

Dec 8, 2025, 11:29:33 AM (2 months ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

master

Children:

79ba50c

Parents:

8f448e0 (diff), 79ec8c3 (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 remote-tracking branch 'refs/remotes/origin/master'

File:

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

libcfa/src/concurrency/locks.cfa

@@ -186 +186 @@
 
 // waituntil() support
-bool register_select( blocking_lock & this, select_node & node ) with(this) {
+bool register_select$( blocking_lock & this, select_node & node ) with(this) {
         lock( lock __cfaabi_dbg_ctx2 );
         thread$ * thrd = active_thread();
@@ -218 +218 @@
 }
 
-bool unregister_select( blocking_lock & this, select_node & node ) with(this) {
+bool unregister_select$( blocking_lock & this, select_node & node ) with(this) {
         lock( lock __cfaabi_dbg_ctx2 );
         if ( isListed( node ) ) {
@@ -239 +239 @@
 }
 
-bool on_selected( blocking_lock & this, select_node & node ) { return true; }
+bool on_selected$( blocking_lock & this, select_node & node ) { return true; }
 
 //-----------------------------------------------------------------------------
@@ -583 +583 @@
         }
 }
+
 //-----------------------------------------------------------------------------
-// Semaphore
-void ?{}( semaphore & this, int count = 1 ) {
-        (this.lock){};
-        this.count = count;
-        (this.waiting){};
-}
-void ^?{}(semaphore & this) {}
-
-bool P(semaphore & this) with( this ){
-        lock( lock __cfaabi_dbg_ctx2 );
-        count -= 1;
-        if ( count < 0 ) {
-                // queue current task
-                append( waiting, active_thread() );
-
-                // atomically release spin lock and block
-                unlock( lock );
+// Semaphore, counting
+
+void ?{}( semaphore & sem, ssize_t count = 1 ) with( sem ) {
+        count$ = count;
+        (lock$){};
+        (waiting$){};
+}
+
+bool P( semaphore & sem ) with( sem ) {
+        lock( lock$ __cfaabi_dbg_ctx2 );
+        count$ -= 1;
+        if ( count$ < 0 ) {                                                                     // in use ?
+                append( waiting$, active_thread() );                    // queue current task
+                unlock( lock$ );                                                                // atomically release spin lock and block
                 park();
-                return true;
+                return false;
+        } // if
+        unlock( lock$ );
+        return true;
+}
+
+bool P( semaphore & sem, semaphore & lock ) with( sem ) {
+        lock( lock$ __cfaabi_dbg_ctx2 );
+        if ( &sem == &lock ) {                                                          // perform operation on self ?
+                if ( count$ < 0 ) {                                                             // V my semaphore
+                        unpark( pop_head( waiting$ ) );                         // unblock task at head of waiting list
+                } // if
         } else {
-                unlock( lock );
+                V( lock );                                                                              // V mutex semaphore
+                count$ -= 1;
+        } // if
+
+        if ( count$ < 0 ) {                                                                     // in use ?
+                append( waiting$, active_thread() );                    // queue current task
+                unlock( lock$ );                                                                // atomically release spin lock and block
+                park();
                 return false;
-        }
-}
-
-thread$ * V (semaphore & this, const bool doUnpark ) with( this ) {
+        } // if
+        unlock( lock$ );
+        return true;
+}
+
+bool try_P( semaphore & sem ) with( sem ) {
+        lock( lock$ __cfaabi_dbg_ctx2 );
+        if ( count$ <= 0 ) {                                                            // in use ?
+                unlock( lock$ );
+                return false;
+        } // if
+        count$ -= 1;                                                                            // acquire
+        unlock( lock$ );
+        return true;
+}
+
+bool V( semaphore & sem ) with( sem ) {
         thread$ * thrd = 0p;
-        lock( lock __cfaabi_dbg_ctx2 );
-        count += 1;
-        if ( count <= 0 ) {
-                // remove task at head of waiting list
-                thrd = pop_head( waiting );
-        }
-
-        unlock( lock );
-
-        // make new owner
-        if ( doUnpark ) unpark( thrd );
-
-        return thrd;
-}
-
-bool V(semaphore & this) with( this ) {
-        thread$ * thrd = V(this, true);
+        lock( lock$ __cfaabi_dbg_ctx2 );
+        count$ += 1;
+        if ( count$ <= 0 ) {
+                thrd = pop_head( waiting$ );                                    // remove task at head of waiting list
+        }
+        unlock( lock$ );
+        if ( true ) unpark( thrd );                                             // make new owner
         return thrd != 0p;
 }
 
-bool V(semaphore & this, unsigned diff) with( this ) {
-        thread$ * thrd = 0p;
-        lock( lock __cfaabi_dbg_ctx2 );
-        int release = max(-count, (int)diff);
-        count += diff;
-        for(release) {
-                unpark( pop_head( waiting ) );
-        }
-
-        unlock( lock );
-
-        return thrd != 0p;
-}
-
+size_t V( semaphore & sem, size_t count ) with( sem ) {
+        lock( lock$ __cfaabi_dbg_ctx2 );
+        size_t release = max( (size_t)-count$, count );
+        count$ += count;
+        for ( release ) unpark( pop_head( waiting$ ) );
+        unlock( lock$ );
+        return release;
+}