Changeset 6b33e89 for libcfa/src/concurrency/locks.hfa

Timestamp:

Apr 25, 2025, 7:39:09 AM (8 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

65bd3c2

Parents:

b195498

Message:

change backquote call to regular call

File:

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

libcfa/src/concurrency/locks.hfa

@@ -11 +11 @@
 // Created On       : Thu Jan 21 19:46:50 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Dec 24 09:36:52 2024
-// Update Count     : 16
+// Last Modified On : Fri Apr 25 07:14:16 2025
+// Update Count     : 22
 //
 
@@ -56 +56 @@
 
 static inline void pre_park_then_park( __cfa_pre_park pp_fn, void * pp_datum ) {
-    pp_fn( pp_datum );
-    park();
+        pp_fn( pp_datum );
+        park();
 }
 
@@ -63 +63 @@
 
 #define DEFAULT_ON_NOTIFY( lock_type ) \
-    static inline void on_notify( lock_type & /*this*/, thread$ * t ){ unpark( t ); }
+        static inline void on_notify( lock_type & /*this*/, thread$ * t ){ unpark( t ); }
 
 #define DEFAULT_ON_WAIT( lock_type ) \
-    static inline size_t on_wait( lock_type & this, __cfa_pre_park pp_fn, void * pp_datum ) { \
-        unlock( this ); \
-        pre_park_then_park( pp_fn, pp_datum ); \
-        return 0; \
-    }
+        static inline size_t on_wait( lock_type & this, __cfa_pre_park pp_fn, void * pp_datum ) { \
+                unlock( this ); \
+                pre_park_then_park( pp_fn, pp_datum ); \
+                return 0; \
+        }
 
 // on_wakeup impl if lock should be reacquired after waking up
 #define DEFAULT_ON_WAKEUP_REACQ( lock_type ) \
-    static inline void on_wakeup( lock_type & this, size_t /*recursion*/ ) { lock( this ); }
+        static inline void on_wakeup( lock_type & this, size_t /*recursion*/ ) { lock( this ); }
 
 // on_wakeup impl if lock will not be reacquired after waking up
 #define DEFAULT_ON_WAKEUP_NO_REACQ( lock_type ) \
-    static inline void on_wakeup( lock_type & /*this*/, size_t /*recursion*/ ) {}
+        static inline void on_wakeup( lock_type & /*this*/, size_t /*recursion*/ ) {}
 
 
@@ -142 +142 @@
 static inline void ?{}( mcs_node & this ) { this.next = 0p; }
 
-static inline mcs_node * volatile & ?`next ( mcs_node * node ) {
+static inline mcs_node * volatile & next( mcs_node * node ) {
         return node->next;
 }
@@ -156 +156 @@
 
 static inline void unlock( mcs_lock & l, mcs_node & n ) {
-        mcs_node * next = advance( l.queue, &n );
-        if ( next ) post( next->sem );
+        mcs_node * nxt = advance( l.queue, &n );
+        if ( nxt ) post( nxt->sem );
 }
 
@@ -181 +181 @@
 
 static inline void lock( mcs_spin_lock & l, mcs_spin_node & n ) {
-    n.locked = true;
+        n.locked = true;
 
         #if defined( __ARM_ARCH )
@@ -187 +187 @@
         #endif
 
-        mcs_spin_node * prev = __atomic_exchange_n( &l.queue.tail, &n, __ATOMIC_SEQ_CST );
-        if ( prev == 0p ) return;
-        prev->next = &n;
+        mcs_spin_node * prev_val = __atomic_exchange_n( &l.queue.tail, &n, __ATOMIC_SEQ_CST );
+        if ( prev_val == 0p ) return;
+        prev_val->next = &n;
         
         #if defined( __ARM_ARCH )
@@ -234 +234 @@
 // to use for FUTEX_WAKE and FUTEX_WAIT (other futex calls will need more params)
 static inline int futex( int *uaddr, int futex_op, int val ) {
-    return syscall( SYS_futex, uaddr, futex_op, val, NULL, NULL, 0 );
+        return syscall( SYS_futex, uaddr, futex_op, val, NULL, NULL, 0 );
 }
 
@@ -271 +271 @@
 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 ( __atomic_exchange_n( &val, 0, __ATOMIC_RELEASE ) == 1 ) return;
         
         // otherwise threads are blocked so we must wake one
@@ -311 +311 @@
         int state, init_state;
 
-    // speculative grab
-    state = internal_exchange( this, 1 );
-    if ( ! state ) return;                                                              // state == 0
-    init_state = state;
-    for () {
-        for ( 4 ) {
-            while ( ! val ) {                                                   // lock unlocked
-                state = 0;
-                if ( internal_try_lock( this, state, init_state ) ) return;
-            }
-            for ( 30 ) 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
-    }
+        // speculative grab
+        state = internal_exchange( this, 1 );
+        if ( ! state ) return;                                                          // state == 0
+        init_state = state;
+        for () {
+                for ( 4 ) {
+                        while ( ! val ) {                                                       // lock unlocked
+                                state = 0;
+                                if ( internal_try_lock( this, state, init_state ) ) return;
+                        }
+                        for ( 30 ) 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;
+        if ( __atomic_exchange_n( &val, 0, __ATOMIC_RELEASE ) == 1 ) return;
         
         // otherwise threads are blocked so we must wake one
@@ -384 +384 @@
 
 static inline bool block( exp_backoff_then_block_lock & this ) with( this ) {
-    lock( spinlock __cfaabi_dbg_ctx2 );
-    if ( __atomic_load_n( &lock_value, __ATOMIC_SEQ_CST ) != 2 ) {
-        unlock( spinlock );
-        return true;
-    }
-    insert_last( blocked_threads, *active_thread() );
-    unlock( spinlock );
+        lock( spinlock __cfaabi_dbg_ctx2 );
+        if ( __atomic_load_n( &lock_value, __ATOMIC_SEQ_CST ) != 2 ) {
+                unlock( spinlock );
+                return true;
+        }
+        insert_last( blocked_threads, *active_thread() );
+        unlock( spinlock );
         park( );
         return true;
@@ -415 +415 @@
 
 static inline void unlock( exp_backoff_then_block_lock & this ) with( this ) {
-    if ( __atomic_exchange_n( &lock_value, 0, __ATOMIC_RELEASE ) == 1 ) return;
-    lock( spinlock __cfaabi_dbg_ctx2 );
-    thread$ * t = &try_pop_front( blocked_threads );
-    unlock( spinlock );
-    unpark( t );
+        if ( __atomic_exchange_n( &lock_value, 0, __ATOMIC_RELEASE ) == 1 ) return;
+        lock( spinlock __cfaabi_dbg_ctx2 );
+        thread$ * t = &remove_first( blocked_threads );
+        unlock( spinlock );
+        unpark( t );
 }
 
@@ -469 +469 @@
         lock( lock __cfaabi_dbg_ctx2 );
         /* paranoid */ verifyf( held != false, "Attempt to release lock %p that isn't held", &this );
-        thread$ * t = &try_pop_front( blocked_threads );
+        thread$ * t = &remove_first( blocked_threads );
         held = ( t ? true : false );
         unpark( t );
@@ -476 +476 @@
 
 static inline void on_notify( fast_block_lock & this, struct thread$ * t ) with( this ) {
-    lock( lock __cfaabi_dbg_ctx2 );
-    insert_last( blocked_threads, *t );
-    unlock( lock );
+        lock( lock __cfaabi_dbg_ctx2 );
+        insert_last( blocked_threads, *t );
+        unlock( lock );
 }
 DEFAULT_ON_WAIT( fast_block_lock )
@@ -521 +521 @@
 
         if ( owner != 0p ) {
-        select_node node;
+                select_node node;
                 insert_last( blocked_threads, node );
                 unlock( lock );
@@ -533 +533 @@
 
 static inline void pop_node( simple_owner_lock & this ) with( this ) {
-    __handle_waituntil_OR( blocked_threads );
-    select_node * node = &try_pop_front( blocked_threads );
-    if ( node ) {
-        owner = node->blocked_thread;
-        recursion_count = 1;
-        // if ( ! node->clause_status || __make_select_node_available( *node ) ) unpark( node->blocked_thread );
-        wake_one( blocked_threads, *node );
-    } else {
-        owner = 0p;
-        recursion_count = 0;
-    }
+        __handle_waituntil_OR( blocked_threads );
+        select_node * node = &remove_first( blocked_threads );
+        if ( node ) {
+                owner = node->blocked_thread;
+                recursion_count = 1;
+                // if ( ! node->clause_status || __make_select_node_available( *node ) ) unpark( node->blocked_thread );
+                wake_one( blocked_threads, *node );
+        } else {
+                owner = 0p;
+                recursion_count = 0;
+        }
 }
 
@@ -582 +582 @@
         pop_node( this );
 
-    select_node node;
-    active_thread()->link_node = (void *)&node;
-        unlock( lock );
-
-    pre_park_then_park( pp_fn, pp_datum );
+        select_node node;
+        active_thread()->link_node = (void *)&node;
+        unlock( lock );
+
+        pre_park_then_park( pp_fn, pp_datum );
 
         return ret;
@@ -595 +595 @@
 // waituntil() support
 static inline bool register_select( simple_owner_lock & this, select_node & node ) with( this ) {
-    lock( lock __cfaabi_dbg_ctx2 );
-
-    // check if we can complete operation. If so race to establish winner in special OR case
-    if ( ! node.park_counter && ( owner == active_thread() || owner == 0p ) ) {
-        if ( ! __make_select_node_available( node ) ) { // we didn't win the race so give up on registering
-           unlock( lock );
-           return false;
-        }
-    }
-
-    if ( owner == active_thread() ) {
+        lock( lock __cfaabi_dbg_ctx2 );
+
+        // check if we can complete operation. If so race to establish winner in special OR case
+        if ( ! node.park_counter && ( owner == active_thread() || owner == 0p ) ) {
+                if ( ! __make_select_node_available( node ) ) { // we didn't win the race so give up on registering
+                        unlock( lock );
+                        return false;
+                }
+        }
+
+        if ( owner == active_thread() ) {
                 recursion_count++;
-        if ( node.park_counter ) __make_select_node_available( node );
-        unlock( lock );
+                if ( node.park_counter ) __make_select_node_available( node );
+                unlock( lock );
                 return true;
         }
 
-    if ( owner != 0p ) {
+        if ( owner != 0p ) {
                 insert_last( blocked_threads, node );
                 unlock( lock );
                 return false;
         }
-    
+        
         owner = active_thread();
         recursion_count = 1;
 
-    if ( node.park_counter ) __make_select_node_available( node );
-    unlock( lock );
-    return true;
+        if ( node.park_counter ) __make_select_node_available( node );
+        unlock( lock );
+        return true;
 }
 
 static inline bool unregister_select( simple_owner_lock & this, select_node & node ) with( this ) {
-    lock( lock __cfaabi_dbg_ctx2 );
-    if ( node`isListed ) {
-        remove( node );
-        unlock( lock );
-        return false;
-    }
-
-    if ( owner == active_thread() ) {
-        recursion_count--;
-        if ( recursion_count == 0 ) {
-            pop_node( this );
-        }
-    }
-    unlock( lock );
-    return false;
+        lock( lock __cfaabi_dbg_ctx2 );
+        if ( isListed( node ) ) {
+                remove( node );
+                unlock( lock );
+                return false;
+        }
+
+        if ( owner == active_thread() ) {
+                recursion_count--;
+                if ( recursion_count == 0 ) {
+                        pop_node( this );
+                }
+        }
+        unlock( lock );
+        return false;
 }