//
// Executes the unpark callback.
//
private void UnparkCallback(int ws) {
Debug.Assert(ws == StParkStatus.Success || ws == StParkStatus.Timeout ||
ws == StParkStatus.WaitCancelled);
//
// If the registered wait was cancelled, cancel the acquire
// attempt and return immediately.
//
if (ws == StParkStatus.WaitCancelled) {
waitable._CancelAcquire(waitBlock, hint);
return;
}
//
// Set state to *our busy* grabing the current state, and execute
// the unpark callback processing.
//
StParker myBusy = new SentinelParker();
StParker oldState = Interlocked.Exchange<StParker>(ref state, myBusy);
do {
//
// If the acquire operation was cancelled, cancel the acquire
// attempt on the waitable.
//
if (ws != StParkStatus.Success) {
waitable._CancelAcquire(waitBlock, hint);
}
//
// Execute the user callback routine.
//
cbtid = Thread.CurrentThread.ManagedThreadId;
callback(cbState, ws == StParkStatus.Timeout);
cbtid = 0;
//
// If the registered wait was configured to execute once or
// there is an unregister in progress, set the state to INACTIVE.
// If a thread is waiting to unregister, unpark it.
//
if (executeOnce || !(oldState is SentinelParker)) {
if (!(oldState is SentinelParker)) {
oldState.Unpark(StParkStatus.Success);
} else {
state = INACTIVE;
}
return;
}
//
// We must re-register with the Waitable.
// So, initialize the parker and execute the WaitAny prologue.
//
cbparker.Reset(1);
int ignored = 0;
waitBlock = waitable._WaitAnyPrologue(cbparker, StParkStatus.Success, ref hint,
ref ignored);
//
// Enable the unpark callback.
//
ws = cbparker.EnableCallback(timeout, toTimer);
if (ws == StParkStatus.Pending) {
//
// If the *state* field constains still *my busy* set it to ACTIVE.
//
if (state == myBusy) {
Interlocked.CompareExchange<StParker>(ref state, ACTIVE, myBusy);
}
return;
}
//
// The waitable was already signalled. So, execute the unpark
// callback inline.
//
} while (true);
}
//
// Executes the timer callback
//
internal void TimerCallback(int ws) {
Debug.Assert(ws == StParkStatus.Timeout || ws == StParkStatus.TimerCancelled);
//
// If the timer was cancelled, return immediately.
//
if (ws == StParkStatus.TimerCancelled) {
return;
}
//
// Set timer state to *our busy* state, grabing the current state and
// execute the timer callback processing.
//
SentinelParker myBusy = new SentinelParker();
StParker oldState = Interlocked.Exchange<StParker>(ref state, myBusy);
do {
//
// Signals the timer's event.
//
tmrEvent.Signal();
//
// Call the user-defined callback, if specified.
//
if (callback != null) {
cbtid = Thread.CurrentThread.ManagedThreadId;
callback(cbState, true);
cbtid = 0;
}
//
// If the timer isn't periodic or if someone is trying to
// cancel it, process cancellation.
//
if (period == 0 || !(oldState is SentinelParker)) {
if (!(oldState is SentinelParker)) {
oldState.Unpark(StParkStatus.Success);
} else {
state = INACTIVE;
}
return;
}
//
// Initialize the timer's parker.
//
cbparker.Reset();
//
// Compute the timer delay and enable the unpark callback.
//
int timeout;
if (useDueTime) {
timeout = dueTime;
useDueTime = false;
} else {
timeout = period | (1 << 31);
}
if ((ws = cbparker.EnableCallback(timeout, timer)) == StParkStatus.Pending) {
if (state == myBusy) {
Interlocked.CompareExchange<StParker>(ref state, ACTIVE, myBusy);
}
return;
}
//
// The timer already expired. So, execute the timer
// callback inline.
//
} while (true);
}
