static int TryAcquireWrite( _Inout_ ReadWriteLock* self ) { volatile LockFields* lock = (LockFields*)self; size_t oldState, state, swapState; for(;;) { oldState = ReadLockState(lock); state = oldState | OWN_EXCLUSIVE; /* Skipped when the lock is empty. */ if (oldState != 0) { /* Detect whether there are existing owners. */ if (LockOwners(oldState) != 0) return 0; /* Someone must be waiting. Acquiring would jump the queue. */ if (((CurrentTick() - LockUnfair(oldState)) & 14) != 0) return 0; } /* Ready to take exclusive ownership. */ swapState = Atomic_CompareAndSwap(LockState(lock), oldState, state); if (swapState == oldState) return 1; } }
static int TryAcquireRead( _Inout_ ReadWriteLock* self ) { volatile LockFields* lock = (LockFields*)self; size_t oldState, state, swapState; for(;;) { oldState = ReadLockState(lock); state = oldState + 1; /* Skipped when owners is the only active field * and we did not try to add too many shared owners. */ if (state >= OWN_EXCLUSIVE) { /* Detect whether adding another shared owner is impossible. */ if (LockOwners(oldState) >= OWN_MAXSHARED) return 0; /* If writer == exit, no writers are waiting. */ if ((LockWriter(state) ^ LockExit(state)) != 0) { /* Writers are waiting. Acquiring would jump the queue. */ if (((CurrentTick() - LockUnfair(oldState)) & 14) != 0) return 0; } } /* Ready to take shared ownership. */ swapState = Atomic_CompareAndSwap(LockState(lock), oldState, state); if (swapState == oldState) return 1; } }
/// <summary> /// Try begin general method if another method is not running currently. General methods don't include StopConfiguration /// </summary> MI_Result TryBeginLcmOperation( _In_z_ const MI_Char* methodName, _Outptr_result_maybenull_ MI_Instance **cimErrorDetails) { MI_Char* originalMethodName; int waitResult = 0; *cimErrorDetails = NULL; originalMethodName = (MI_Char*)Atomic_CompareAndSwap(&g_activeOperationMethodName, (ptrdiff_t) NULL, (ptrdiff_t)methodName); if (originalMethodName != NULL) { // We silently let GetMetaConfiguration to go if the active operation is not SetMetaConfiguration if (Tcscasecmp(originalMethodName, MSFT_DSCLocalConfigManager_SendMetaConfigurationApply) == 0 || Tcscasecmp(methodName, MSFT_DSCLocalConfigManager_GetMetaConfiguration) != 0) { return GetCimMIError3Params(MI_RESULT_FAILED, cimErrorDetails, ID_LCM_MULTIPLE_METHOD_REQUEST, methodName, originalMethodName, methodName); } } waitResult = Sem_TimedWait(&g_h_ConfigurationStoppedEvent, (int)0); //Ignore the result return MI_RESULT_OK; }
void CheckInjector() { /* The injector might not know we are here. * Open up the injector refresh semaphore for this process. * Then signal it once and wait for the NitsFT to be patched. */ if (Atomic_CompareAndSwap(&NITS_PRESENCE_STUB, NitsPresenceUnknown, NitsStubbedOut) == NitsPresenceUnknown) { #if defined(_MSC_VER) || defined(ENABLE_UNITTESTING) // on linux; if we are not building to run unittests, // in that case this will be a no-op and all further calls will bail out since // NITS_PRESENCE_STUB will be NitsStubbedOut after we get here. LoadInjectorIfRequired(); SignalInjector(); #endif /* Re-enter through the function table. This should be patched! */ } else { //printf("\nsignalSent was already 1\n"); } /* The function table should be unchanged. The caller will attempt to * replace itself with the simple stub, since the check is complete. */ }
void CScriptThread::OnQueryJobDone() { //次函数从db线程调用过来 if( !Atomic_CompareAndSwap( &m_nHasDbResult, m_nHasDbResult, 1 ) ) PutSemaphore(&m_smThread); }
static void QueueAcquireWrite( _Inout_ ReadWriteLock* self ) { volatile LockFields* lock = (LockFields*)self; size_t oldState, state, swapState, preQueuedState; size_t waitFor, key, spinState, spinCount; for (;;) { oldState = ReadLockState(lock); state = oldState; /* If there is no queue, we are the first one to wait; * allow unfairness for the current timer tick. */ if (state <= OWN_EXCLUSIVE) LockUnfair(state) = CurrentTick(); /* Wait for the most recent thread to enter the queue. */ waitFor = LockEntry(state); if (++LockEntry(state) == LockExit(state)) { /* The queue arithmetic will wrap if we continue. */ Thread_Yield(); continue; } /* Make reader threads coming in wait for us. */ LockWriter(state) = LockEntry(state); swapState = Atomic_CompareAndSwap(LockState(lock), oldState, state); if (swapState == oldState) break; } /* This thread now has a place in the queue. * Threads behind us may be depending on us to wake them up. */ preQueuedState = oldState; key = (size_t)lock ^ waitFor; spinState = LockSpin(oldState); for (;;) { /* Avoid write prefetching since we expect to wait. */ oldState = *(ptrdiff_t*)lock; if (LockExit(oldState) != waitFor || LockOwners(oldState) != 0) { /* The thread ahead of us still hasn't acquired, * or some reader or writer owns the lock right now. */ if (((CurrentTick() - LockUnfair(oldState)) & 14) == 0 && LockEntry(oldState) - LockExit(oldState) >= 2 && LockEntry(oldState) == LockEntry(preQueuedState) + 1 && LockOwners(oldState) == 0) { /* Under certain conditions, we can acquire immediately if we * are the last thread in line and undo joining the queue. */ if (preQueuedState <= OWN_EXCLUSIVE) state = OWN_EXCLUSIVE; else { state = oldState + OWN_EXCLUSIVE; LockEntry(state) = LockEntry(preQueuedState); LockWriter(state) = LockWriter(preQueuedState); } /* Atomically de-queue and acquire unfairly. */ swapState = Atomic_CompareAndSwap(LockState(lock), oldState, state); if (swapState == oldState) return; continue; } /* spinState being low means spinning usually works. * Use a high count if it has been working recently. */ spinCount = (spinState & SPIN_SIGN) ? CONDLOCK_LOW_SPINCOUNT : CONDLOCK_HIGH_SPINCOUNT; /* Spin and/or block until something changes. * Adjust the spin field based on whether spinning worked. */ if (CondLock_Wait(key, (ptrdiff_t*)lock, oldState, spinCount)) spinState = (spinState > 2) ? (spinState - 2) : 0; else spinState = (spinState < SPIN_MAX) ? (spinState + 1) : spinState; continue; } state = oldState + OWN_EXCLUSIVE; /* Bump the exit ticket number. We're leaving the queue. */ LockExit(state)++; /* Zero the top 4 fields if the queue is now empty. */ if (LockExit(state) == LockEntry(state)) state = LockOwners(state); else { /* Not empty, but we just acquired fairly. * Allow unfairness for a while. */ LockUnfair(state) = CurrentTick(); LockSpin(state) = spinState; } /* Ready to take exclusive ownership. */ swapState = Atomic_CompareAndSwap(LockState(lock), oldState, state); if (swapState == oldState) return; } }
static void QueueAcquireRead( _Inout_ ReadWriteLock* self ) { volatile LockFields* lock = (LockFields*)self; size_t oldState, state, swapState, preQueuedState; size_t waitFor, diff, key, spinState, spinCount; for (;;) { oldState = ReadLockState(lock); state = oldState; /* If there is no queue, we are the first one to wait; * allow unfairness for the current timer tick. */ if (state <= OWN_EXCLUSIVE) LockUnfair(state) = CurrentTick(); /* Insert a barrier every half revolution. * This stops writer arithmetic from wrapping. */ if ((LockEntry(state) & ~FIELD_SIGN) == 0) LockWriter(state) = LockEntry(state); if (++LockEntry(state) == LockExit(state)) { /* The queue arithmetic will wrap if we continue. */ Thread_Yield(); continue; } swapState = Atomic_CompareAndSwap(LockState(lock), oldState, state); if (swapState == oldState) break; } /* This thread now has a place in the queue. * Threads behind us may be depending on us to wake them up. */ /* Wait for the most recent writer to enter the queue. */ waitFor = LockWriter(state); key = (size_t)lock ^ waitFor; preQueuedState = oldState; spinState = LockSpin(oldState); for (;;) { /* Avoid write prefetching since we expect to wait. */ oldState = *(ptrdiff_t*)lock; diff = LockExit(oldState) - waitFor; if ((diff & FIELD_SIGN) == 0) { /* The writer ahead of us in line already acquired. * Someone could have beat us unfairly. * Just wait for the current owner. */ waitFor = LockExit(oldState); key = (size_t)lock ^ waitFor; } if ((diff & FIELD_SIGN) != 0 || (LockOwners(oldState) == OWN_EXCLUSIVE)) { /* The writer ahead of us still hasn't acquired, * or someone owns the lock exclusively right now. */ if (((CurrentTick() - LockUnfair(oldState)) & 14) == 0 && LockEntry(oldState) - LockExit(oldState) >= 2 && LockEntry(oldState) == LockEntry(preQueuedState) + 1 && (LockOwners(oldState) < OWN_MAXSHARED)) { /* Under certain conditions, we can acquire immediately if we * are the last thread in line and undo joining the queue. */ if (preQueuedState <= OWN_EXCLUSIVE) state = LockOwners(oldState) + 1; else { state = oldState + 1; LockEntry(state) = LockEntry(preQueuedState); LockWriter(state) = LockWriter(preQueuedState); } /* Atomically de-queue and acquire unfairly. */ swapState = Atomic_CompareAndSwap(LockState(lock), oldState, state); if (swapState == oldState) return; continue; } /* spinState being low means spinning usually works. * Use a high count if it has been working recently. */ spinCount = (spinState & SPIN_SIGN) ? CONDLOCK_LOW_SPINCOUNT : CONDLOCK_HIGH_SPINCOUNT; /* Spin and/or block until something changes. * Adjust the spin field based on whether spinning worked. */ if (CondLock_Wait(key, (ptrdiff_t*)lock, oldState, spinCount)) spinState = (spinState > 2) ? (spinState - 2) : 0; else spinState = (spinState < SPIN_MAX) ? (spinState + 1) : spinState; continue; } if (LockOwners(oldState) == OWN_MAXSHARED) { /* The owner arithmetic will overflow if we continue. */ Thread_Yield(); continue; } state = oldState + 1; /* Bump the exit ticket number. We're leaving the queue. */ LockExit(state)++; /* Zero the top 4 fields if the queue is now empty. */ if (LockExit(state) == LockEntry(state)) state = LockOwners(state); else { /* Not empty, but we just acquired fairly. * Allow unfairness for a while. */ LockUnfair(state) = CurrentTick(); LockSpin(state) = spinState; } /* Ready to take shared ownership. */ swapState = Atomic_CompareAndSwap(LockState(lock), oldState, state); if (swapState == oldState) break; } if ((LockExit(state) & ~FIELD_SIGN) == 0) { /* Wakes those waiting on the artificial barrier inserted each half * revolution (see above). */ key = (size_t)lock ^ LockExit(state); CondLock_Broadcast(key); } }
void CachedLock_AcquireWrite( _Inout_ CachedLock* self ) { ptrdiff_t oldState, state, swapState; ptrdiff_t oldMask, zeroMask, index; volatile ptrdiff_t* master = &self->master; /* The order of steps here is important. * 1) Stop shared readers from racing through the latches. * 2) Scan the latches to find inactive ones. * 3) Get exclusive access to the central lock. * 4) Wait for existing shared readers in the latches to leave. * * Doing (3) before (1) lets readers race through the latches if the * central lock is still held by a reader from previous contention. * Doing (3) before (2) leads to deadlock if there are no active latches * and another writer gets the central lock first. * Doing (3) after (4) lets readers race through the central lock. */ for (;;) { oldState = PAL_PREFETCH(master); /* The first thread atomically sets s_masterMask. */ if (oldState == 0) state = s_masterMask + MASTER_INCREMENT; else state = oldState + MASTER_INCREMENT; swapState = Atomic_CompareAndSwap(master, oldState, state); if (swapState == oldState) break; } /* Reader threads will now observe that master != 0. */ if (oldState == 0) { /* This is the thread that set s_masterMask. */ zeroMask = 0; for (index = 0; index < POOL_LINES; index++) { /* Determine if all shared threads are gone. */ if (self->latches[LATCHES_PER_LINE * index] == 0) zeroMask |= ((ptrdiff_t)1 << index); } /* Determine if there are any CPUs with shared threads remaining. * Other exclusive threads could be waiting. */ if ((Atomic_And(master, ~zeroMask) & MASTER_MASK) == 0) CondLock_Broadcast((ptrdiff_t)self); } ReadWriteLock_AcquireWrite(&self->lock); for (;;) { /* Wait for all the latches to empty. */ oldMask = *master; if ((oldMask & MASTER_MASK) == 0) return; CondLock_Wait((ptrdiff_t)self, master, oldMask, CONDLOCK_DEFAULT_SPINCOUNT); } }