//
// Constructors.
//
public StTimer(bool notificationTimer)
{
if (notificationTimer)
{
tmrEvent = new StNotificationEvent();
}
else
{
tmrEvent = new StSynchronizationEvent();
}
state = INACTIVE;
cbparker = new CbParker(TimerCallback);
timer = new RawTimer(cbparker);
}
//
// Signals a waitable and waits unconditionally on another
// as an atomic operation.
//
public static void SignalAndWait(StWaitable tos, StWaitable tow)
{
SignalAndWait(tos, tow, StCancelArgs.None);
}
//
// Signals a waitable and waits on another as an atomic
// operation, activating the specified cancellers.
//
public static bool SignalAndWait(StWaitable tos, StWaitable tow, StCancelArgs cargs)
{
//
// Create a parker to execute the WaitAny prologue on the
// *tow* waitable.
//
StParker pk = new StParker();
WaitBlock hint = null;
int sc = 0;
WaitBlock wb = tow._WaitAnyPrologue(pk, StParkStatus.Success, ref hint, ref sc);
//
// Signal the *tos* waitable.
//
if (!tos._Release())
{
//
// The signal operation failed. So, try to cancel the parker and,
// if successful, cancel the acquire attempt; otherwise, wait until
// the thread is unparked and, then, undo the acquire.
//
if (pk.TryCancel())
{
tow._CancelAcquire(wb, hint);
}
else
{
pk.Park();
tow._UndoAcquire();
}
//
// Report the failure appropriately.
//
throw tos._SignalException;
}
//
// Park the current thread, activating the specified cancellers
// and spinning if appropriate.
//
int ws = pk.Park(sc, cargs);
//
// If we acquired, execute the WaitOne epilogue and return success.
//
if (ws == StParkStatus.Success)
{
tow._WaitEpilogue();
return(true);
}
//
// The acquire operation was cancelled; so, cancel the acquire
// attempt and report the failure appropriately.
//
tow._CancelAcquire(wb, hint);
StCancelArgs.ThrowIfException(ws);
return(false);
}
internal static bool WaitAllInternal(StWaitable[] ws, WaitHandle[] hs, StCancelArgs cargs)
{
if (ws == null)
{
throw new ArgumentNullException("ws");
}
int nevts;
int len = ws.Length;
StWaitable[] sws = new StWaitable[len];
WaitHandle[] shs = null;
int waitHint = SortAndCheckAllowAcquire(ws, sws, out nevts);
if (waitHint < 0)
{
throw new ArgumentException("There are duplicate waitables", "ws");
}
if (hs != null)
{
shs = Sort(hs);
if (shs == null)
{
throw new ArgumentException("There are duplicate wait handles", "hs");
}
}
if (waitHint != 0 && shs != null && !WaitHandle.WaitAll(shs, 0))
{
waitHint = 0;
}
//
// Return success if all synchronizers are notification events and are set.
//
if (waitHint != 0 && nevts == 0)
{
return(true);
}
if (waitHint == 0 && cargs.Timeout == 0)
{
return(false);
}
//
// If a timeout was specified, get the current time in order
// to adjust the timeout value later, if we re-wait.
//
int lastTime = (cargs.Timeout != Timeout.Infinite) ? Environment.TickCount : 0;
WaitBlock[] wbs = null;
WaitBlock[] hints = null;
do
{
if (waitHint == 0)
{
//
// Create the wait block arrays if this is the first time
// that we execute the acquire-all prologue.
//
if (wbs == null)
{
wbs = new WaitBlock[len];
hints = new WaitBlock[len];
}
//
// Create a parker for cooperative release, specifying as many
// releasers as the number of waitables. The parker because is
// not reused because other threads may have references to it.
//
StParker pk = shs != null
? new StParker(len, EventBasedParkSpotFactory.Current.
Create(new WaitAllBehavior(shs)))
: new StParker(len);
int gsc = 1;
int sc = 0;
for (int i = 0; i < len; i++)
{
if ((wbs[i] = sws[i]._WaitAllPrologue(pk, ref hints[i], ref sc)) == null)
{
if (pk.TryLock())
{
pk.UnparkSelf(StParkStatus.StateChange);
}
}
else if (gsc != 0)
{
if (sc == 0)
{
gsc = 0;
}
else if (sc > gsc)
{
gsc = sc;
}
}
}
int wst = pk.Park(gsc, cargs);
//
// If the wait was cancelled due to timeout, alert or interrupt,
// cancel the acquire attempt on all waitables where we actually
// inserted wait blocks.
//
if (wst != StParkStatus.StateChange)
{
for (int i = 0; i < len; i++)
{
WaitBlock wb = wbs[i];
if (wb != null)
{
sws[i]._CancelAcquire(wb, hints[i]);
}
}
StCancelArgs.ThrowIfException(wst);
return(false);
}
}
//
// All waitables where we inserted wait blocks seem to allow
// an immediate acquire operation; so, try to acquire all of
// them that are not notification events.
//
int idx;
for (idx = 0; idx < nevts; idx++)
{
if (!sws[idx]._TryAcquire())
{
break;
}
}
//
// If all synchronizers were acquired, return success.
//
if (idx == nevts)
{
return(true);
}
//
// We failed to acquire all waitables, so undo the acquires
// that we did above.
//
while (--idx >= 0)
{
sws[idx]._UndoAcquire();
}
if (shs != null)
{
for (int i = 0; i < shs.Length; i++)
{
shs[i].UndoAcquire();
}
}
//
// If a timeout was specified, adjust the timeout value
// that will be used on the next wait.
//
if (!cargs.AdjustTimeout(ref lastTime))
{
return(false);
}
waitHint = 0;
} while (true);
}
internal static int WaitAnyInternal(StWaitable[] ws, WaitHandle[] hs, StCancelArgs cargs)
{
int len = ws.Length;
//
// First, we scan the *ws* array trying to acquire one of the
// synchronizers.
//
for (int i = 0; i < len; i++)
{
if (ws[i]._TryAcquire())
{
return(StParkStatus.Success + i);
}
}
if (cargs.Timeout == 0)
{
return(StParkStatus.Timeout);
}
//
// Create a parker and execute the WaitAny prologue on all
// waitables. We stop executing prologues as soon as we detect
// that the acquire operation was accomplished.
//
StParker pk = hs != null
? new StParker(EventBasedParkSpotFactory.Current.
Create(new WaitAnyBehavior(hs, len)))
: new StParker(1);
WaitBlock[] wbs = new WaitBlock[len];
WaitBlock[] hints = new WaitBlock[len];
int lv = -1;
int sc = 0;
int gsc = 0;
for (int i = 0; !pk.IsLocked && i < len; i++)
{
StWaitable w = ws[i];
if ((wbs[i] = w._WaitAnyPrologue(pk, i, ref hints[i], ref sc)) == null)
{
if (pk.TryLock())
{
pk.UnparkSelf(i);
}
else
{
w._UndoAcquire();
}
break;
}
//
// Adjust the global spin count.
//
if (gsc < sc)
{
gsc = sc;
}
lv = i;
}
int wst = pk.Park(gsc, cargs);
StWaitable acq = wst >= StParkStatus.Success && wst < len ? ws[wst] : null;
//
// Cancel the acquire attempt on all waitables where we executed
// the WaitAny prologue, except the one we acquired.
//
for (int i = 0; i <= lv; i++)
{
StWaitable w = ws[i];
if (w != acq)
{
w._CancelAcquire(wbs[i], hints[i]);
}
}
if (wst >= StParkStatus.Success && wst < len + (hs != null ? hs.Length : 0))
{
if (acq != null)
{
acq._WaitEpilogue();
}
return(wst);
}
StCancelArgs.ThrowIfException(wst);
return(StParkStatus.Timeout);
}
//
// Constructor: registers a wait with a Waitable synchronizer.
//
internal StRegisteredWait(StWaitable waitObject, WaitOrTimerCallback callback,
object cbState, int timeout, bool executeOnce)
{
//
// Validate the arguments.
//
if (timeout == 0)
{
throw new ArgumentOutOfRangeException("\"timeout\" can't be zero");
}
if (callback == null)
{
throw new ArgumentOutOfRangeException("\"callback\" can't be null");
}
if ((waitObject is StReentrantFairLock) || (waitObject is StReentrantReadWriteLock))
{
throw new InvalidOperationException("can't register waits on reentrant locks");
}
if ((waitObject is StNotificationEvent) && !executeOnce)
{
throw new InvalidOperationException("Notification event can't register waits"
+ " to execute more than once");
}
//
// Initialize the register wait fields
//
waitable = waitObject;
cbparker = new CbParker(UnparkCallback);
toTimer = new RawTimer(cbparker);
this.timeout = timeout;
this.executeOnce = executeOnce;
this.callback = callback;
this.cbState = (cbState != null) ? cbState : this;
//
// Execute the WaitAny prologue on the waitable.
//
int ignored = 0;
waitBlock = waitObject._WaitAnyPrologue(cbparker, StParkStatus.Success, ref hint,
ref ignored);
//
// Set the registered wait state to active and enable the
// unpark callback.
//
state = ACTIVE;
int ws = cbparker.EnableCallback(timeout, toTimer);
if (ws != StParkStatus.Pending)
{
//
// The acquire operation was already accomplished. To prevent
// uncontrolled reentrancy, the unpark callback is executed inline.
//
UnparkCallback(ws);
}
}
