Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/concurrency/locks.hfa

    rfece3d9 rbeeff61e  
    4444// - change messy big blocking lock from inheritance to composition to remove need for flags
    4545
    46 typedef void (*__cfa_pre_park)( void * );
    47 
    48 static inline void pre_park_noop( void * ) {}
    49 
    50 //-----------------------------------------------------------------------------
    51 // is_blocking_lock
    52 forall( L & | sized(L) )
    53 trait is_blocking_lock {
    54         // For synchronization locks to use when acquiring
    55         void on_notify( L &, struct thread$ * );
    56 
    57         // For synchronization locks to use when releasing
    58         size_t on_wait( L &, __cfa_pre_park pp_fn, void * pp_datum );
    59 
    60         // to set recursion count after getting signalled;
    61         void on_wakeup( L &, size_t recursion );
    62 };
    63 
    64 static inline void pre_park_then_park( __cfa_pre_park pp_fn, void * pp_datum ) {
    65     pp_fn( pp_datum );
    66     park();
    67 }
    68 
    6946//-----------------------------------------------------------------------------
    7047// Semaphore
    … …  
    9269static inline bool   try_lock ( single_acquisition_lock & this ) { return try_lock( (blocking_lock &)this ); }
    9370static inline void   unlock   ( single_acquisition_lock & this ) { unlock  ( (blocking_lock &)this ); }
    94 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 ); }
     71static inline size_t on_wait  ( single_acquisition_lock & this ) { return on_wait ( (blocking_lock &)this ); }
    9572static inline void   on_wakeup( single_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
    9673static inline void   on_notify( single_acquisition_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); }
    … …  
    10986static inline bool   try_lock ( owner_lock & this ) { return try_lock( (blocking_lock &)this ); }
    11087static inline void   unlock   ( owner_lock & this ) { unlock  ( (blocking_lock &)this ); }
    111 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 ); }
     88static inline size_t on_wait  ( owner_lock & this ) { return on_wait ( (blocking_lock &)this ); }
    11289static inline void   on_wakeup( owner_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
    11390static inline void   on_notify( owner_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); }
    … …  
    241218
    242219static inline void on_notify( futex_mutex & f, thread$ * t){ unpark(t); }
    243 static inline size_t on_wait( futex_mutex & this, __cfa_pre_park pp_fn, void * pp_datum ) {
    244     unlock( this );
    245     pre_park_then_park( pp_fn, pp_datum );
    246     return 0;
    247 }
     220static inline size_t on_wait( futex_mutex & f ) { unlock(f); park(); return 0; }
    248221
    249222// to set recursion count after getting signalled;
    … …  
    315288
    316289static inline void on_notify( go_mutex & f, thread$ * t){ unpark( t ); }
    317 static inline size_t on_wait( go_mutex & this, __cfa_pre_park pp_fn, void * pp_datum ) {
    318     unlock( this );
    319     pre_park_then_park( pp_fn, pp_datum );
    320     return 0;
    321 }
     290static inline size_t on_wait( go_mutex & f ) { unlock( f ); park(); return 0; }
    322291static inline void on_wakeup( go_mutex & f, size_t recursion ) {}
    323292
    … …  
    393362
    394363static inline void on_notify( exp_backoff_then_block_lock & this, struct thread$ * t ) { unpark( t ); }
    395 static inline size_t on_wait( exp_backoff_then_block_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) {
    396     unlock( this );
    397     pre_park_then_park( pp_fn, pp_datum );
    398     return 0;
    399 }
     364static inline size_t on_wait( exp_backoff_then_block_lock & this ) { unlock( this ); park(); return 0; }
    400365static inline void on_wakeup( exp_backoff_then_block_lock & this, size_t recursion ) { lock( this ); }
    401366
    … …  
    454419    unlock( lock );
    455420}
    456 static inline size_t on_wait( fast_block_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) {
    457     unlock( this );
    458     pre_park_then_park( pp_fn, pp_datum );
    459     return 0;
    460 }
     421static inline size_t on_wait( fast_block_lock & this) { unlock(this); park(); return 0; }
    461422static inline void on_wakeup( fast_block_lock & this, size_t recursion ) { }
    462423
    … …  
    536497}
    537498
    538 static inline void on_notify( simple_owner_lock & this, thread$ * t ) with(this) {
     499static inline void on_notify(simple_owner_lock & this, thread$ * t ) with(this) {
    539500        lock( lock __cfaabi_dbg_ctx2 );
    540501        // lock held
    … …  
    551512}
    552513
    553 static inline size_t on_wait( simple_owner_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) with(this) {
     514static inline size_t on_wait( simple_owner_lock & this ) with(this) {
    554515        lock( lock __cfaabi_dbg_ctx2 );
    555516        /* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );
    … …  
    563524    active_thread()->link_node = (void *)&node;
    564525        unlock( lock );
    565 
    566     pre_park_then_park( pp_fn, pp_datum );
     526    park();
    567527
    568528        return ret;
    … …  
    664624        unpark(t);
    665625}
    666 static inline size_t on_wait( spin_queue_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) {
    667     unlock( this );
    668     pre_park_then_park( pp_fn, pp_datum );
    669     return 0;
    670 }
     626static inline size_t on_wait( spin_queue_lock & this ) { unlock( this ); park(); return 0; }
    671627static inline void on_wakeup( spin_queue_lock & this, size_t recursion ) { lock( this ); }
    672628
    … …  
    709665
    710666static inline void on_notify( mcs_block_spin_lock & this, struct thread$ * t ) { unpark( t ); }
    711 static inline size_t on_wait( mcs_block_spin_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) {
    712     unlock( this );
    713     pre_park_then_park( pp_fn, pp_datum );
    714     return 0;
    715 }
     667static inline size_t on_wait( mcs_block_spin_lock & this) { unlock( this ); park(); return 0; }
    716668static inline void on_wakeup( mcs_block_spin_lock & this, size_t recursion ) {lock( this ); }
    717669
    … …  
    765717        unpark(t);
    766718}
    767 static inline size_t on_wait( block_spin_lock & this, __cfa_pre_park pp_fn, void * pp_datum ) {
    768     unlock( this );
    769     pre_park_then_park( pp_fn, pp_datum );
    770     return 0;
    771 }
     719static inline size_t on_wait( block_spin_lock & this ) { unlock( this ); park(); return 0; }
    772720static inline void on_wakeup( block_spin_lock & this, size_t recursion ) with(this) {
    773721        // now we acquire the entire block_spin_lock upon waking up
    … …  
    776724        unlock( lock ); // Now we release the internal fast_spin_lock
    777725}
     726
     727//-----------------------------------------------------------------------------
     728// is_blocking_lock
     729forall( L & | sized(L) )
     730trait is_blocking_lock {
     731        // For synchronization locks to use when acquiring
     732        void on_notify( L &, struct thread$ * );
     733
     734        // For synchronization locks to use when releasing
     735        size_t on_wait( L & );
     736
     737        // to set recursion count after getting signalled;
     738        void on_wakeup( L &, size_t recursion );
     739};
    778740
    779741//-----------------------------------------------------------------------------
Note: See TracChangeset for help on using the changeset viewer.