/// <summary>
/// Waits for the event to become set. We will spin briefly if the event isn't set
/// (assuming a non-0 timeout), before falling back to a true wait.
/// </summary>
/// <param name="millisecondsTimeout">The maximum amount of time to wait.</param>
/// <returns>True if the wait succeeded, false if the timeout expired.</returns>
/// <exception cref="System.ArgumentOutOfRangeException">If the timeout is not within range.</exception>
public bool Wait(int millisecondsTimeout)
{
ThrowIfDisposed();
if (millisecondsTimeout < -1)
{
throw Error.ArgumentOutOfRange("millisecondsTimeout");
}
if (!IsSet)
{
if (millisecondsTimeout == 0)
{
// For 0-timeouts, we just return immediately.
return(false);
}
else
{
#if DEBUG
TraceHelpers.TraceInfo("{0} - tid {1}: ManualResetEventSlim::Wait - doing a spin wait for {2} spins",
m_id, Thread.CurrentThread.ManagedThreadId, SpinCount);
#endif
// We spin briefly before falling back to allocating and/or waiting on a true event.
SpinWait s = new SpinWait();
Stopwatch sw = null;
if (SpinCount > 0)
{
if (millisecondsTimeout != Timeout.Infinite)
{
// We will account for time spent spinning, so that we can decrement it from our
// timeout. In most cases the time spent in this section will be negligible. But
// we can't discount the possibility of our thread being switched out for a lengthy
// period of time. The timeout adjustments only take effect when and if we actually
// decide to block in the kernel below.
sw = Stopwatch.StartNew();
}
for (int i = 0; i < SpinCount; i++)
{
s.SpinOnce();
// Keep rechecking the state. If we've become signaled while we spun above,
// return. This is done with a volatile read to prevent reordering and hoisting
// out of the loop.
if (IsSet)
{
return(true);
}
}
}
if (m_eventObj == null)
{
// Lazily allocate the event. This method internally handles races w/ other threads.
LazyInitializeEvent();
if (IsSet)
{
// If it has since become signaled, there's no need to wait. This is strictly
// unnecessary, but does avoid a kernel transition. Since the allocation could
// have taken some time, this might be worth the extra check in some cases.
return(true);
}
}
#if DEBUG
TraceHelpers.TraceInfo("{0} - tid {1}: ManualResetEventSlim::Wait - entering a real wait",
m_id, Thread.CurrentThread.ManagedThreadId);
#endif
// Do our dynamic spin count accounting. We don't worry about thread safety here.
// It's OK for reads and writes to be carried out non-atomically -- we might miss one
// here or there, but because it's a 4-byte aligned value we are guaranteed no tears.
if (UseDynamicSpinAdjustment)
{
int spinCount = SpinCount;
if (spinCount != 0 && spinCount < MAX_DYNAMIC_SPIN)
{
// We use an algorithm similar to the OS critical section. If our
// spinning didn't work out, we increment the counter so that we increase
// the chances of spinning working the next time.
m_spinCount = ((spinCount + 1) % int.MaxValue) | USE_DYNAMIC_SPIN_MASK;
}
else
{
// If we reached the dynamic spin maximum, and it's still not working, bail.
// We don't want to spin any longer since it's not buying us anything (in fact,
// it's just wasting time). This forces us to go straight to the wait next time.
m_spinCount = 0;
}
}
// If we spun at all, we'll take into account the time elapsed by adjusting
// the timeout value before blocking in the kernel.
int realMillisecondsTimeout = millisecondsTimeout;
if (sw != null)
{
long elapsedMilliseconds = sw.ElapsedMilliseconds;
if (elapsedMilliseconds > int.MaxValue)
{
return(false);
}
TraceHelpers.Assert(elapsedMilliseconds >= 0);
realMillisecondsTimeout -= (int)elapsedMilliseconds;
if (realMillisecondsTimeout <= 0)
{
return(false);
}
}
return(m_eventObj.WaitOne(realMillisecondsTimeout, false));
}
}
return(true);
}