// Possible lock states are MUTEX_UNLOCKED, MUTEX_LOCKED and MUTEX_SLEEPING. // MUTEX_SLEEPING means that there is presumably at least one sleeping thread. // Note that there can be spinning threads during all states - they do not // affect mutex's state. void runtime_lock(Lock *l) { uint32 i, v, wait, spin; if(runtime_m()->locks++ < 0) runtime_throw("runtime_lock: lock count"); // Speculative grab for lock. v = runtime_xchg(&l->key, MUTEX_LOCKED); if(v == MUTEX_UNLOCKED) return; // wait is either MUTEX_LOCKED or MUTEX_SLEEPING // depending on whether there is a thread sleeping // on this mutex. If we ever change l->key from // MUTEX_SLEEPING to some other value, we must be // careful to change it back to MUTEX_SLEEPING before // returning, to ensure that the sleeping thread gets // its wakeup call. wait = v; // On uniprocessor's, no point spinning. // On multiprocessors, spin for ACTIVE_SPIN attempts. spin = 0; if(runtime_ncpu > 1) spin = ACTIVE_SPIN; for(;;) { // Try for lock, spinning. for(i = 0; i < spin; i++) { while(l->key == MUTEX_UNLOCKED) if(runtime_cas(&l->key, MUTEX_UNLOCKED, wait)) return; runtime_procyield(ACTIVE_SPIN_CNT); } // Try for lock, rescheduling. for(i=0; i < PASSIVE_SPIN; i++) { while(l->key == MUTEX_UNLOCKED) if(runtime_cas(&l->key, MUTEX_UNLOCKED, wait)) return; runtime_osyield(); } // Sleep. v = runtime_xchg(&l->key, MUTEX_SLEEPING); if(v == MUTEX_UNLOCKED) return; wait = MUTEX_SLEEPING; runtime_futexsleep(&l->key, MUTEX_SLEEPING, -1); } }
void runtime_notewakeup(Note *n) { if(runtime_xchg((uint32*)&n->key, 1)) runtime_throw("notewakeup - double wakeup"); runtime_futexwakeup((uint32*)&n->key, 1); }
void runtime_unlock(Lock *l) { uint32 v; if(--runtime_m()->locks < 0) runtime_throw("runtime_unlock: lock count"); v = runtime_xchg(&l->key, MUTEX_UNLOCKED); if(v == MUTEX_UNLOCKED) runtime_throw("unlock of unlocked lock"); if(v == MUTEX_SLEEPING) runtime_futexwakeup(&l->key, 1); }
void runtime_notewakeup(Note *n) { runtime_xchg(&n->key, 1); runtime_futexwakeup(&n->key, 1); }