Changeset a6b48f6

Timestamp:

Dec 24, 2024, 10:52:13 AM (2 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

2853d6f, 5db580e

Parents:

4f4ae60

Message:

formatting, comment out unused parameter names to remove warnings

Location:

libcfa/src

Files:

• collections/lockfree.hfa (modified) (4 diffs)
• concurrency/locks.hfa (modified) (44 diffs)
• concurrency/select.hfa (modified) (1 diff)

libcfa/src/collections/lockfree.hfa ¶

@@ -6 +6 @@
 #include <bits/defs.hfa>
 
-forall( T &) {
+forall( T & ) {
         //------------------------------------------------------------
         // Queue based on the MCS lock
@@ -200 +200 @@
 forall( T & )
 struct LinkData {
-        T * volatile top;                                                               // pointer to stack top
-        uintptr_t count;                                                                // count each push
+        T * volatile top;                                                                       // pointer to stack top
+        uintptr_t count;                                                                        // count each push
 };
 
@@ -215 +215 @@
 }; // Link
 
-forall( T | sized(T) | { Link(T) * ?`next( T * ); } ) {
+forall( T /*| sized(T)*/ | { Link(T) * ?`next( T * ); } ) {
         struct StackLF {
                 Link(T) stack;
@@ -235 +235 @@
                         Link(T) t @= stack;                                                     // atomic assignment unnecessary, or use CAA
                         for () {                                                                        // busy wait
-                                if ( t.data.top == 0p ) return 0p;                              // empty stack ?
+                                if ( t.data.top == 0p ) return 0p;              // empty stack ?
                                 Link(T) * next = ( t.data.top )`next;
                                 if ( __atomic_compare_exchange_n( &stack.atom, &t.atom, (Link(T))@{ (LinkData(T))@{ next->data.top, t.data.count } }.atom, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST ) ) return t.data.top; // attempt to update top node

libcfa/src/concurrency/locks.hfa ¶

@@ -10 +10 @@
 // Author           : Colby Alexander Parsons
 // Created On       : Thu Jan 21 19:46:50 2021
-// Last Modified By :
-// Last Modified On :
-// Update Count     :
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Dec 24 09:36:52 2024
+// Update Count     : 16
 //
 
@@ -33 +33 @@
 
 // futex headers
-#include <linux/futex.h>      /* Definition of FUTEX_* constants */
-#include <sys/syscall.h>      /* Definition of SYS_* constants */
-#include <unistd.h>           /* Definition of syscall routine */
+#include <linux/futex.h>                                                                // Definition of FUTEX_* constants
+#include <sys/syscall.h>                                                                // Definition of SYS_* constants
+#include <unistd.h>                                                                             // Definition of syscall routine
 
 typedef void (*__cfa_pre_park)( void * );
@@ -43 +43 @@
 //-----------------------------------------------------------------------------
 // is_blocking_lock
-forall( L & | sized(L) )
+forall( L & /*| sized( L )*/ )
 trait is_blocking_lock {
         // For synchronization locks to use when acquiring
@@ -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 ) \
@@ -74 +74 @@
 // 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*/ ) {}
 
 
@@ -87 +87 @@
         __spinlock_t lock;
         int count;
-        __queue_t(thread$) waiting;
-};
-
-void  ?{}(semaphore & this, int count = 1);
-void ^?{}(semaphore & this);
-bool   P (semaphore & this);
-bool   V (semaphore & this);
-bool   V (semaphore & this, unsigned count);
-thread$ * V (semaphore & this, bool );
+        __queue_t( thread$) waiting;
+};
+
+void ?{}( semaphore & this, int count = 1 );
+void ^?{}( semaphore & this );
+bool P( semaphore & this );
+bool V( semaphore & this );
+bool V( semaphore & this, unsigned count );
+thread$ * V( semaphore & this, bool );
 
 //----------
@@ -102 +102 @@
 };
 
-static inline void  ?{}( single_acquisition_lock & this ) {((blocking_lock &)this){ false, false };}
+static inline void ?{}( single_acquisition_lock & this ) { ((blocking_lock &)this){ false, false }; }
 static inline void ^?{}( single_acquisition_lock & this ) {}
-static inline void   lock     ( single_acquisition_lock & this ) { lock    ( (blocking_lock &)this ); }
-static inline bool   try_lock ( single_acquisition_lock & this ) { return try_lock( (blocking_lock &)this ); }
-static inline void   unlock   ( single_acquisition_lock & this ) { unlock  ( (blocking_lock &)this ); }
-static inline size_t on_wait  ( single_acquisition_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) { return on_wait ( (blocking_lock &)this, pp_fn, pp_datum ); }
-static inline void   on_wakeup( single_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
-static inline void   on_notify( single_acquisition_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); }
-static inline bool   register_select( single_acquisition_lock & this, select_node & node ) { return register_select( (blocking_lock &)this, node ); }
-static inline bool   unregister_select( single_acquisition_lock & this, select_node & node ) { return unregister_select( (blocking_lock &)this, node ); }
-static inline bool   on_selected( single_acquisition_lock & this, select_node & node ) { return on_selected( (blocking_lock &)this, node ); }
+static inline void lock( single_acquisition_lock & this ) { lock( (blocking_lock &)this ); }
+static inline bool try_lock( single_acquisition_lock & this ) { return try_lock( (blocking_lock &)this ); }
+static inline void unlock( single_acquisition_lock & this ) { unlock( (blocking_lock &)this ); }
+static inline size_t on_wait( single_acquisition_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) { return on_wait ( (blocking_lock &)this, pp_fn, pp_datum ); }
+static inline void on_wakeup( single_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
+static inline void on_notify( single_acquisition_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); }
+static inline bool register_select( single_acquisition_lock & this, select_node & node ) { return register_select( (blocking_lock &)this, node ); }
+static inline bool unregister_select( single_acquisition_lock & this, select_node & node ) { return unregister_select( (blocking_lock &)this, node ); }
+static inline bool on_selected( single_acquisition_lock & this, select_node & node ) { return on_selected( (blocking_lock &)this, node ); }
 __CFA_SELECT_GET_TYPE( single_acquisition_lock );
 
@@ -120 +120 @@
 };
 
-static inline void  ?{}( owner_lock & this ) {((blocking_lock &)this){ true, true };}
+static inline void ?{}( owner_lock & this ) { ((blocking_lock &)this){ true, true }; }
 static inline void ^?{}( owner_lock & this ) {}
-static inline void   lock     ( owner_lock & this ) { lock    ( (blocking_lock &)this ); }
-static inline bool   try_lock ( owner_lock & this ) { return try_lock( (blocking_lock &)this ); }
-static inline void   unlock   ( owner_lock & this ) { unlock  ( (blocking_lock &)this ); }
-static inline size_t on_wait  ( owner_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) { return on_wait ( (blocking_lock &)this, pp_fn, pp_datum ); }
-static inline void   on_wakeup( owner_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
-static inline void   on_notify( owner_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); }
-static inline bool   register_select( owner_lock & this, select_node & node ) { return register_select( (blocking_lock &)this, node ); }
-static inline bool   unregister_select( owner_lock & this, select_node & node ) { return unregister_select( (blocking_lock &)this, node ); }
-static inline bool   on_selected( owner_lock & this, select_node & node ) { return on_selected( (blocking_lock &)this, node ); }
+static inline void lock( owner_lock & this ) { lock( (blocking_lock &)this ); }
+static inline bool try_lock( owner_lock & this ) { return try_lock( (blocking_lock &)this ); }
+static inline void unlock( owner_lock & this ) { unlock( (blocking_lock &)this ); }
+static inline size_t on_wait( owner_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) { return on_wait ( (blocking_lock &)this, pp_fn, pp_datum ); }
+static inline void on_wakeup( owner_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
+static inline void on_notify( owner_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); }
+static inline bool register_select( owner_lock & this, select_node & node ) { return register_select( (blocking_lock &)this, node ); }
+static inline bool unregister_select( owner_lock & this, select_node & node ) { return unregister_select( (blocking_lock &)this, node ); }
+static inline bool on_selected( owner_lock & this, select_node & node ) { return on_selected( (blocking_lock &)this, node ); }
 __CFA_SELECT_GET_TYPE( owner_lock );
 
@@ -147 +147 @@
 
 struct mcs_lock {
-        mcs_queue(mcs_node) queue;
+        mcs_queue( mcs_node ) queue;
 };
 
 static inline void lock( mcs_lock & l, mcs_node & n ) {
-        if(push(l.queue, &n))
-                wait(n.sem);
-}
-
-static inline void unlock(mcs_lock & l, mcs_node & n) {
-        mcs_node * next = advance(l.queue, &n);
-        if(next) post(next->sem);
+        if ( push( l.queue, &n ) )
+                wait( n.sem );
+}
+
+static inline void unlock( mcs_lock & l, mcs_node & n ) {
+        mcs_node * next = advance( l.queue, &n );
+        if ( next ) post( next->sem );
 }
 
@@ -183 +183 @@
     n.locked = true;
 
-        #if defined(__ARM_ARCH)
+        #if defined( __ARM_ARCH )
         __asm__ __volatile__ ( "DMB ISH" ::: );
         #endif
 
-        mcs_spin_node * prev = __atomic_exchange_n(&l.queue.tail, &n, __ATOMIC_SEQ_CST);
-        if( prev == 0p ) return;
+        mcs_spin_node * prev = __atomic_exchange_n( &l.queue.tail, &n, __ATOMIC_SEQ_CST );
+        if ( prev == 0p ) return;
         prev->next = &n;
         
-        #if defined(__ARM_ARCH)
+        #if defined( __ARM_ARCH )
         __asm__ __volatile__ ( "DMB ISH" ::: );
         #endif
 
-        while( __atomic_load_n(&n.locked, __ATOMIC_RELAXED) ) Pause();
-
-        #if defined(__ARM_ARCH)
+        while ( __atomic_load_n( &n.locked, __ATOMIC_RELAXED ) ) Pause();
+
+        #if defined( __ARM_ARCH )
         __asm__ __volatile__ ( "DMB ISH" ::: );
         #endif
 }
 
-static inline void unlock(mcs_spin_lock & l, mcs_spin_node & n) {
-        #if defined(__ARM_ARCH)
+static inline void unlock( mcs_spin_lock & l, mcs_spin_node & n ) {
+        #if defined( __ARM_ARCH )
         __asm__ __volatile__ ( "DMB ISH" ::: );
         #endif
 
         mcs_spin_node * n_ptr = &n;
-        if (__atomic_compare_exchange_n(&l.queue.tail, &n_ptr, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) return;
-        while (__atomic_load_n(&n.next, __ATOMIC_RELAXED) == 0p) Pause();
-
-        #if defined(__ARM_ARCH)
+        if ( __atomic_compare_exchange_n( &l.queue.tail, &n_ptr, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST ) ) return;
+        while ( __atomic_load_n( &n.next, __ATOMIC_RELAXED ) == 0p ) Pause();
+
+        #if defined( __ARM_ARCH )
         __asm__ __volatile__ ( "DMB ISH" ::: );
         #endif
@@ -233 +233 @@
 
 // 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);
-}
-
-static inline void ?{}( futex_mutex & this ) with(this) { val = 0; }
-
-static inline bool internal_try_lock( futex_mutex & this, int & compare_val) with(this) {
-        return __atomic_compare_exchange_n((int*)&val, (int*)&compare_val, 1, false, __ATOMIC_ACQUIRE, __ATOMIC_ACQUIRE);
-}
-
-static inline int internal_exchange( futex_mutex & this ) with(this) {
-        return __atomic_exchange_n((int*)&val, 2, __ATOMIC_ACQUIRE);
+static inline int futex( int *uaddr, int futex_op, int val ) {
+    return syscall( SYS_futex, uaddr, futex_op, val, NULL, NULL, 0 );
+}
+
+static inline void ?{}( futex_mutex & this ) with( this ) { val = 0; }
+
+static inline bool internal_try_lock( futex_mutex & this, int & compare_val ) with( this ) {
+        return __atomic_compare_exchange_n( (int*)&val, (int*)&compare_val, 1, false, __ATOMIC_ACQUIRE, __ATOMIC_ACQUIRE );
+}
+
+static inline int internal_exchange( futex_mutex & this ) with( this ) {
+        return __atomic_exchange_n(( int*)&val, 2, __ATOMIC_ACQUIRE );
 }
 
 // if this is called recursively IT WILL DEADLOCK!!!!!
-static inline void lock( futex_mutex & this ) with(this) {
+static inline void lock( futex_mutex & this ) with( this ) {
         int state;
 
-        for( int spin = 4; spin < 1024; spin += spin) {
+        for ( spin; 4 ~ 1024 ~ spin ) {
                 state = 0;
                 // if unlocked, lock and return
-                if (internal_try_lock(this, state)) return;
-                if (2 == state) break;
-                for (int i = 0; i < spin; i++) Pause();
+                if ( internal_try_lock( this, state ) ) return;
+                if ( state == 2 ) break;
+                for ( spin ) Pause();
         }
         
         // if not in contended state, set to be in contended state
-        if (state != 2) state = internal_exchange(this);
+        if ( state != 2 ) state = internal_exchange( this );
 
         // block and spin until we win the lock
-        while (state != 0) {
-                futex((int*)&val, FUTEX_WAIT, 2); // if val is not 2 this returns with EWOULDBLOCK
-                state = internal_exchange(this);
-        }
-}
-
-static inline void unlock(futex_mutex & this) with(this) {
+        while ( state != 0 ) {
+                futex( (int*)&val, FUTEX_WAIT, 2 ); // if val is not 2 this returns with EWOULDBLOCK
+                state = internal_exchange( this );
+        }
+}
+
+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
-        futex((int *)&val, FUTEX_WAKE, 1);
+        futex(( int *)&val, FUTEX_WAKE, 1 );
 }
 
@@ -295 +295 @@
         int val; 
 };
-static inline void  ?{}( go_mutex & this ) with(this) { val = 0; }
+static inline void  ?{}( go_mutex & this ) with( this ) { val = 0; }
 static inline void ?{}( go_mutex & this, go_mutex this2 ) = void;
 static inline void ?=?( go_mutex & this, go_mutex this2 ) = void;
 
-static inline bool internal_try_lock(go_mutex & this, int & compare_val, int new_val ) with(this) {
-        return __atomic_compare_exchange_n((int*)&val, (int*)&compare_val, new_val, false, __ATOMIC_ACQUIRE, __ATOMIC_ACQUIRE);
-}
-
-static inline int internal_exchange(go_mutex & this, int swap ) with(this) {
-        return __atomic_exchange_n((int*)&val, swap, __ATOMIC_ACQUIRE);
+static inline bool internal_try_lock( go_mutex & this, int & compare_val, int new_val ) with( this ) {
+        return __atomic_compare_exchange_n( (int*)&val, (int*)&compare_val, new_val, false, __ATOMIC_ACQUIRE, __ATOMIC_ACQUIRE );
+}
+
+static inline int internal_exchange( go_mutex & this, int swap ) with( this ) {
+        return __atomic_exchange_n( (int*)&val, swap, __ATOMIC_ACQUIRE );
 }
 
@@ -312 +312 @@
 
     // speculative grab
-    state = internal_exchange(this, 1);
-    if ( !state ) return; // state == 0
+    state = internal_exchange( this, 1 );
+    if ( ! state ) return;                                                              // state == 0
     init_state = state;
-    for (;;) {
-        for( int i = 0; i < 4; i++ ) {
-            while( !val ) { // lock unlocked
+    for () {
+        for ( 4 ) {
+            while ( ! val ) {                                                   // lock unlocked
                 state = 0;
                 if ( internal_try_lock( this, state, init_state ) ) return;
             }
-            for (int i = 0; i < 30; i++) Pause();
+            for ( 30 ) Pause();
         }
 
-        while( !val ) { // lock unlocked
+        while ( ! val ) {                                                               // lock unlocked
             state = 0;
             if ( internal_try_lock( this, state, init_state ) ) return;
@@ -332 +332 @@
         // if not in contended state, set to be in contended state
         state = internal_exchange( this, 2 );
-        if ( !state ) return; // state == 0
+        if ( ! state ) return;                                                  // state == 0
         init_state = 2;
-        futex( (int*)&val, FUTEX_WAIT, 2 ); // if val is not 2 this returns with EWOULDBLOCK
+        futex( (int*)&val, FUTEX_WAIT, 2 );                             // if val is not 2 this returns with EWOULDBLOCK
     }
 }
 
-static inline void unlock( go_mutex & this ) with(this) {
+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
@@ -373 +373 @@
 static inline void  ^?{}( exp_backoff_then_block_lock & this ){}
 
-static inline bool internal_try_lock( exp_backoff_then_block_lock & this, size_t & compare_val ) with(this) {
-        return __atomic_compare_exchange_n(&lock_value, &compare_val, 1, false, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED);
+static inline bool internal_try_lock( exp_backoff_then_block_lock & this, size_t & compare_val ) with( this ) {
+        return __atomic_compare_exchange_n( &lock_value, &compare_val, 1, false, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED );
 }
 
 static inline bool try_lock( exp_backoff_then_block_lock & this ) { size_t compare_val = 0; return internal_try_lock( this, compare_val ); }
 
-static inline bool try_lock_contention( exp_backoff_then_block_lock & this ) with(this) {
-        return !__atomic_exchange_n( &lock_value, 2, __ATOMIC_ACQUIRE );
-}
-
-static inline bool block( exp_backoff_then_block_lock & this ) with(this) {
+static inline bool try_lock_contention( exp_backoff_then_block_lock & this ) with( this ) {
+        return ! __atomic_exchange_n( &lock_value, 2, __ATOMIC_ACQUIRE );
+}
+
+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) {
+    if ( __atomic_load_n( &lock_value, __ATOMIC_SEQ_CST ) != 2 ) {
         unlock( spinlock );
         return true;
@@ -395 +395 @@
 }
 
-static inline void lock( exp_backoff_then_block_lock & this ) with(this) {
+static inline void lock( exp_backoff_then_block_lock & this ) with( this ) {
         size_t compare_val = 0;
         int spin = 4;
 
         // linear backoff
-        for( ;; ) {
+        for () {
                 compare_val = 0;
-                if (internal_try_lock(this, compare_val)) return;
-                if (2 == compare_val) break;
-                for (int i = 0; i < spin; i++) Pause();
-                if (spin >= 1024) break;
+                if ( internal_try_lock( this, compare_val ) ) return;
+                if ( compare_val == 2 ) break;
+                for ( spin ) Pause();
+                if ( spin >= 1024 ) break;
                 spin += spin;
         }
 
-        if(2 != compare_val && try_lock_contention(this)) return;
+        if ( 2 != compare_val && try_lock_contention( this ) ) return;
         // block until signalled
-        while (block(this)) if(try_lock_contention(this)) return;
-}
-
-static inline void unlock( exp_backoff_then_block_lock & this ) with(this) {
-    if (__atomic_exchange_n(&lock_value, 0, __ATOMIC_RELEASE) == 1) return;
+        while ( block( this ) ) if ( try_lock_contention( this ) ) return;
+}
+
+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 );
@@ -444 +444 @@
 };
 
-static inline void  ?{}( fast_block_lock & this ) with(this) {
+static inline void  ?{}( fast_block_lock & this ) with( this ) {
         lock{};
         blocked_threads{};
@@ -454 +454 @@
 
 // if this is called recursively IT WILL DEADLOCK!!!!!
-static inline void lock( fast_block_lock & this ) with(this) {
+static inline void lock( fast_block_lock & this ) with( this ) {
         lock( lock __cfaabi_dbg_ctx2 );
         if ( held ) {
@@ -466 +466 @@
 }
 
-static inline void unlock( fast_block_lock & this ) with(this) {
+static inline void unlock( fast_block_lock & this ) with( this ) {
         lock( lock __cfaabi_dbg_ctx2 );
         /* paranoid */ verifyf( held != false, "Attempt to release lock %p that isn't held", &this );
@@ -475 +475 @@
 }
 
-static inline void on_notify( fast_block_lock & this, struct thread$ * t ) with(this) {
+static inline void on_notify( fast_block_lock & this, struct thread$ * t ) with( this ) {
     lock( lock __cfaabi_dbg_ctx2 );
     insert_last( blocked_threads, *t );
@@ -503 +503 @@
 };
 
-static inline void  ?{}( simple_owner_lock & this ) with(this) {
+static inline void  ?{}( simple_owner_lock & this ) with( this ) {
         lock{};
         blocked_threads{};
@@ -513 +513 @@
 static inline void ?=?( simple_owner_lock & this, simple_owner_lock this2 ) = void;
 
-static inline void lock( simple_owner_lock & this ) with(this) {
+static inline void lock( simple_owner_lock & this ) with( this ) {
         if ( owner == active_thread() ) {
                 recursion_count++;
@@ -532 +532 @@
 }
 
-static inline void pop_node( simple_owner_lock & this ) with(this) {
+static inline void pop_node( simple_owner_lock & this ) with( this ) {
     __handle_waituntil_OR( blocked_threads );
     select_node * node = &try_pop_front( blocked_threads );
@@ -538 +538 @@
         owner = node->blocked_thread;
         recursion_count = 1;
-        // if ( !node->clause_status || __make_select_node_available( *node ) ) unpark( node->blocked_thread );
+        // if ( ! node->clause_status || __make_select_node_available( *node ) ) unpark( node->blocked_thread );
         wake_one( blocked_threads, *node );
     } else {
@@ -546 +546 @@
 }
 
-static inline void unlock( simple_owner_lock & this ) with(this) {
+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 );
@@ -558 +558 @@
 }
 
-static inline void on_notify( simple_owner_lock & this, thread$ * t ) with(this) {
+static inline void on_notify( simple_owner_lock & this, thread$ * t ) with( this ) {
         lock( lock __cfaabi_dbg_ctx2 );
         // lock held
@@ -573 +573 @@
 }
 
-static inline size_t on_wait( simple_owner_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) with(this) {
+static inline size_t on_wait( simple_owner_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) with( this ) {
         lock( lock __cfaabi_dbg_ctx2 );
         /* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );
@@ -591 +591 @@
 }
 
-static inline void on_wakeup( simple_owner_lock & this, size_t recursion ) with(this) { recursion_count = recursion; }
+static inline void on_wakeup( simple_owner_lock & this, size_t recursion ) with( this ) { recursion_count = recursion; }
 
 // waituntil() support
-static inline bool register_select( simple_owner_lock & this, select_node & node ) with(this) {
+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
+    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;
@@ -626 +626 @@
 }
 
-static inline bool unregister_select( simple_owner_lock & this, select_node & node ) with(this) {
+static inline bool unregister_select( simple_owner_lock & this, select_node & node ) with( this ) {
     lock( lock __cfaabi_dbg_ctx2 );
     if ( node`isListed ) {
@@ -644 +644 @@
 }
 
-static inline bool on_selected( simple_owner_lock & this, select_node & node ) { return true; }
+static inline bool on_selected( simple_owner_lock & /*this*/, select_node & /*node*/ ) { return true; }
 __CFA_SELECT_GET_TYPE( simple_owner_lock );
 
@@ -662 +662 @@
 };
 
-static inline void  ?{}( spin_queue_lock & this ) with(this) {
+static inline void  ?{}( spin_queue_lock & this ) with( this ) {
         lock{};
         held = false;
@@ -671 +671 @@
 
 // if this is called recursively IT WILL DEADLOCK!
-static inline void lock( spin_queue_lock & this ) with(this) {
+static inline void lock( spin_queue_lock & this ) with( this ) {
         mcs_spin_node node;
         lock( lock, node );
-        while(__atomic_load_n(&held, __ATOMIC_SEQ_CST)) Pause();
-        __atomic_store_n(&held, true, __ATOMIC_SEQ_CST);
+        while ( __atomic_load_n( &held, __ATOMIC_SEQ_CST ) ) Pause();
+        __atomic_store_n( &held, true, __ATOMIC_SEQ_CST );
         unlock( lock, node );
 }
 
-static inline void unlock( spin_queue_lock & this ) with(this) {
-        __atomic_store_n(&held, false, __ATOMIC_RELEASE);
+static inline void unlock( spin_queue_lock & this ) with( this ) {
+        __atomic_store_n( &held, false, __ATOMIC_RELEASE );
 }
 
@@ -702 +702 @@
 };
 
-static inline void  ?{}( mcs_block_spin_lock & this ) with(this) {
+static inline void  ?{}( mcs_block_spin_lock & this ) with( this ) {
         lock{};
         held = false;
@@ -711 +711 @@
 
 // if this is called recursively IT WILL DEADLOCK!!!!!
-static inline void lock( mcs_block_spin_lock & this ) with(this) {
+static inline void lock( mcs_block_spin_lock & this ) with( this ) {
         mcs_node node;
         lock( lock, node );
-        while(__atomic_load_n(&held, __ATOMIC_SEQ_CST)) Pause();
-        __atomic_store_n(&held, true, __ATOMIC_SEQ_CST);
+        while ( __atomic_load_n( &held, __ATOMIC_SEQ_CST ) ) Pause();
+        __atomic_store_n( &held, true, __ATOMIC_SEQ_CST );
         unlock( lock, node );
 }
 
-static inline void unlock(mcs_block_spin_lock & this) with(this) {
-        __atomic_store_n(&held, false, __ATOMIC_SEQ_CST);
+static inline void unlock( mcs_block_spin_lock & this ) with( this ) {
+        __atomic_store_n( &held, false, __ATOMIC_SEQ_CST );
 }
 
@@ -742 +742 @@
 };
 
-static inline void  ?{}( block_spin_lock & this ) with(this) {
+static inline void  ?{}( block_spin_lock & this ) with( this ) {
         lock{};
         held = false;
@@ -751 +751 @@
 
 // if this is called recursively IT WILL DEADLOCK!!!!!
-static inline void lock( block_spin_lock & this ) with(this) {
+static inline void lock( block_spin_lock & this ) with( this ) {
         lock( lock );
-        while(__atomic_load_n(&held, __ATOMIC_SEQ_CST)) Pause();
-        __atomic_store_n(&held, true, __ATOMIC_RELEASE);
+        while ( __atomic_load_n( &held, __ATOMIC_SEQ_CST ) ) Pause();
+        __atomic_store_n( &held, true, __ATOMIC_RELEASE );
         unlock( lock );
 }
 
-static inline void unlock( block_spin_lock & this ) with(this) {
-        __atomic_store_n(&held, false, __ATOMIC_RELEASE);
-}
-
-static inline void on_notify( block_spin_lock & this, struct thread$ * t ) with(this.lock) {
+static inline void unlock( block_spin_lock & this ) with( this ) {
+        __atomic_store_n( &held, false, __ATOMIC_RELEASE );
+}
+
+static inline void on_notify( block_spin_lock & this, struct thread$ * t ) with( this.lock ) {
         // first we acquire internal fast_block_lock
         lock( lock __cfaabi_dbg_ctx2 );
@@ -774 +774 @@
         unlock( lock );
 
-        unpark(t);
+        unpark( t );
 }
 DEFAULT_ON_WAIT( block_spin_lock )
-static inline void on_wakeup( block_spin_lock & this, size_t recursion ) with(this) {
+        static inline void on_wakeup( block_spin_lock & this, size_t /*recursion*/ ) with( this ) {
         // now we acquire the entire block_spin_lock upon waking up
-        while(__atomic_load_n(&held, __ATOMIC_SEQ_CST)) Pause();
-        __atomic_store_n(&held, true, __ATOMIC_RELEASE);
+        while ( __atomic_load_n( &held, __ATOMIC_SEQ_CST ) ) Pause();
+        __atomic_store_n( &held, true, __ATOMIC_RELEASE );
         unlock( lock ); // Now we release the internal fast_spin_lock
 }
@@ -788 +788 @@
 // // the info thread is a wrapper around a thread used
 // // to store extra data for use in the condition variable
-forall(L & | is_blocking_lock(L)) {
+forall( L & | is_blocking_lock( L ) ) {
         struct info_thread;
 }
@@ -794 +794 @@
 //-----------------------------------------------------------------------------
 // Synchronization Locks
-forall(L & | is_blocking_lock(L)) {
+forall( L & | is_blocking_lock( L ) ) {
 
         //-----------------------------------------------------------------------------
@@ -810 +810 @@
 
                 // List of blocked threads
-                dlist( info_thread(L) ) blocked_threads;
+                dlist( info_thread( L ) ) blocked_threads;
 
                 // Count of current blocked threads
@@ -816 +816 @@
         };
 
-
-        void  ?{}( condition_variable(L) & this );
-        void ^?{}( condition_variable(L) & this );
-
-        bool notify_one( condition_variable(L) & this );
-        bool notify_all( condition_variable(L) & this );
-
-        uintptr_t front( condition_variable(L) & this );
-
-        bool empty  ( condition_variable(L) & this );
-        int  counter( condition_variable(L) & this );
-
-        void wait( condition_variable(L) & this );
-        void wait( condition_variable(L) & this, uintptr_t info );
-        bool wait( condition_variable(L) & this, Duration duration );
-        bool wait( condition_variable(L) & this, uintptr_t info, Duration duration );
-
-        void wait( condition_variable(L) & this, L & l );
-        void wait( condition_variable(L) & this, L & l, uintptr_t info );
-        bool wait( condition_variable(L) & this, L & l, Duration duration );
-        bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration );
+        void ?{}( condition_variable( L ) & this );
+        void ^?{}( condition_variable( L ) & this );
+
+        bool notify_one( condition_variable( L ) & this );
+        bool notify_all( condition_variable( L ) & this );
+
+        uintptr_t front( condition_variable( L ) & this );
+
+        bool empty  ( condition_variable( L ) & this );
+        int  counter( condition_variable( L ) & this );
+
+        void wait( condition_variable( L ) & this );
+        void wait( condition_variable( L ) & this, uintptr_t info );
+        bool wait( condition_variable( L ) & this, Duration duration );
+        bool wait( condition_variable( L ) & this, uintptr_t info, Duration duration );
+
+        void wait( condition_variable( L ) & this, L & l );
+        void wait( condition_variable( L ) & this, L & l, uintptr_t info );
+        bool wait( condition_variable( L ) & this, L & l, Duration duration );
+        bool wait( condition_variable( L ) & this, L & l, uintptr_t info, Duration duration );
 
         //-----------------------------------------------------------------------------
@@ -848 +847 @@
         struct fast_cond_var {
                 // List of blocked threads
-                dlist( info_thread(L) ) blocked_threads;
+                dlist( info_thread( L ) ) blocked_threads;
                 #ifdef __CFA_DEBUG__
                 L * lock_used;
@@ -854 +853 @@
         };
 
-        void  ?{}( fast_cond_var(L) & this );
-        void ^?{}( fast_cond_var(L) & this );
-
-        bool notify_one( fast_cond_var(L) & this );
-        bool notify_all( fast_cond_var(L) & this );
-
-        uintptr_t front( fast_cond_var(L) & this );
-        bool empty  ( fast_cond_var(L) & this );
-
-        void wait( fast_cond_var(L) & this, L & l );
-        void wait( fast_cond_var(L) & this, L & l, uintptr_t info );
+        void ?{}( fast_cond_var( L ) & this );
+        void ^?{}( fast_cond_var( L ) & this );
+
+        bool notify_one( fast_cond_var( L ) & this );
+        bool notify_all( fast_cond_var( L ) & this );
+
+        uintptr_t front( fast_cond_var( L ) & this );
+        bool empty  ( fast_cond_var( L ) & this );
+
+        void wait( fast_cond_var( L ) & this, L & l );
+        void wait( fast_cond_var( L ) & this, L & l, uintptr_t info );
 
 
@@ -874 +873 @@
 
         struct pthread_cond_var {
-                dlist( info_thread(L) ) blocked_threads;
+                dlist( info_thread( L ) ) blocked_threads;
                 __spinlock_t lock;
         };
 
-        void  ?{}( pthread_cond_var(L) & this );
-        void ^?{}( pthread_cond_var(L) & this );
-
-        bool notify_one( pthread_cond_var(L) & this );
-        bool notify_all( pthread_cond_var(L) & this );
-
-        uintptr_t front( pthread_cond_var(L) & this );
-        bool empty ( pthread_cond_var(L) & this );
-
-        void wait( pthread_cond_var(L) & this, L & l );
-        void wait( pthread_cond_var(L) & this, L & l, uintptr_t info );
-        bool wait( pthread_cond_var(L) & this, L & l, timespec t );
-        bool wait( pthread_cond_var(L) & this, L & l, uintptr_t info, timespec t );
-}
+        void  ?{}( pthread_cond_var( L ) & this );
+        void ^?{}( pthread_cond_var( L ) & this );
+
+        bool notify_one( pthread_cond_var( L ) & this );
+        bool notify_all( pthread_cond_var( L ) & this );
+
+        uintptr_t front( pthread_cond_var( L ) & this );
+        bool empty ( pthread_cond_var( L ) & this );
+
+        void wait( pthread_cond_var( L ) & this, L & l );
+        void wait( pthread_cond_var( L ) & this, L & l, uintptr_t info );
+        bool wait( pthread_cond_var( L ) & this, L & l, timespec t );
+        bool wait( pthread_cond_var( L ) & this, L & l, uintptr_t info, timespec t );
+}

libcfa/src/concurrency/select.hfa ¶

@@ -184 +184 @@
 
 // wake one thread from the list
-static inline void wake_one( dlist( select_node ) & queue, select_node & popped ) {
+static inline void wake_one( dlist( select_node ) & /*queue*/, select_node & popped ) {
     if ( !popped.clause_status                              // normal case, node is not a select node
         || ( popped.clause_status && !popped.park_counter ) // If popped link is special case OR selecting unpark but don't call __make_select_node_available