//
// 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 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);
}
