/// <summary>
/// Wait for the given sequence to be available
/// </summary>
/// <param name="sequence">sequence to be waited on.</param>
/// <param name="cursor">Ring buffer cursor on which to wait.</param>
/// <param name="dependents">dependents further back the chain that must advance first</param>
/// <param name="barrier">barrier the <see cref="IEventProcessor"/> is waiting on.</param>
/// <returns>the sequence that is available which may be greater than the requested sequence.</returns>
public long WaitFor(long sequence, Sequence cursor, Sequence[] dependents, ISequenceBarrier barrier)
{
long availableSequence;
var spinWait = default(SpinWait);
if (dependents.Length == 0)
{
while ((availableSequence = cursor.Value) < sequence) // volatile read
{
barrier.CheckAlert();
spinWait.SpinOnce();
if (spinWait.Count > 5000)
break;
}
}
else
{
while ((availableSequence = Util.GetMinimumSequence(dependents)) < sequence)
{
barrier.CheckAlert();
spinWait.SpinOnce();
if (spinWait.Count > 5000)
break;
}
}
return availableSequence;
}
/// <summary>
/// <see cref="IWaitStrategy.WaitFor"/>
/// </summary>
public long WaitFor(long sequence, Sequence cursor, ISequence dependentSequence, ISequenceBarrier barrier)
{
var timeSpan = _timeout;
if (cursor.Value < sequence)
{
lock (_gate)
{
while (cursor.Value < sequence)
{
barrier.CheckAlert();
if (!Monitor.Wait(_gate, timeSpan))
{
throw TimeoutException.Instance;
}
}
}
}
var aggressiveSpinWait = new AggressiveSpinWait();
long availableSequence;
while ((availableSequence = dependentSequence.Value) < sequence)
{
barrier.CheckAlert();
aggressiveSpinWait.SpinOnce();
}
return(availableSequence);
}
public long WaitFor(
long sequence,
ISequence cursor,
ISequence dependentSequence,
ISequenceBarrier barrier)
{
var timeoutInMillis = _timeoutInMillis;
if (cursor.GetValue() < sequence)
{
lock (_mutex)
{
while (cursor.GetValue() < sequence)
{
barrier.CheckAlert();
if (!Monitor.Wait(_mutex, timeoutInMillis))
{
throw new TimeoutException();
}
}
}
}
long availableSequence;
while ((availableSequence = dependentSequence.GetValue()) < sequence)
{
barrier.CheckAlert();
}
return(availableSequence);
}
public long WaitOnLock(long sequence,
Sequence cursorSequence,
Sequence dependentSequence, ISequenceBarrier barrier, TimeSpan timeOut)
{
var availableSequence = cursorSequence.Value; // volatile read
if (availableSequence < sequence)
{
Monitor.Enter(_gate);
try
{
++_numWaiters;
while ((availableSequence = cursorSequence.Value) < sequence) // volatile read
{
barrier.CheckAlert();
Monitor.Wait(_gate, timeOut);
}
}
finally
{
--_numWaiters;
Monitor.Exit(_gate);
}
}
while ((availableSequence = dependentSequence.Value) < sequence)
{
barrier.CheckAlert();
}
return(availableSequence);
}
/// <summary>
/// Wait for the given sequence to be available
/// </summary>
/// <param name="sequence">sequence to be waited on.</param>
/// <param name="cursor">Ring buffer cursor on which to wait.</param>
/// <param name="dependents">dependents further back the chain that must advance first</param>
/// <param name="barrier">barrier the <see cref="IEventProcessor"/> is waiting on.</param>
/// <returns>the sequence that is available which may be greater than the requested sequence.</returns>
public long WaitFor(long sequence, Sequence cursor, Sequence[] dependents, ISequenceBarrier barrier)
{
long availableSequence;
var spinWait = default(SpinWait);
if (dependents.Length == 0)
{
while ((availableSequence = cursor.Value) < sequence) // volatile read
{
barrier.CheckAlert();
spinWait.SpinOnce();
if (spinWait.Count > 5000)
{
break;
}
}
}
else
{
while ((availableSequence = Util.GetMinimumSequence(dependents)) < sequence)
{
barrier.CheckAlert();
spinWait.SpinOnce();
if (spinWait.Count > 5000)
{
break;
}
}
}
return(availableSequence);
}
public long WaitFor(long sequence, Sequence cursor, Sequence dependentSequence, ISequenceBarrier barrier)
{
VerifyTimeOut();
long availableSequence;
if ((availableSequence = cursor.Value) < sequence)
{
Monitor.Enter(gate);
try
{
while ((availableSequence = cursor.Value) < sequence)
{
barrier.CheckAlert();
var wait = Monitor.Wait(gate, timeOut);
if (!wait)
{
throw TimeoutException.INSTANCE;
}
}
}
finally
{
Monitor.Exit(gate);
}
}
while ((availableSequence = dependentSequence.Value) < sequence)
{
barrier.CheckAlert();
}
return(availableSequence);
}
/// <summary>
/// Wait for the given sequence to be available
/// </summary>
/// <param name="sequence">sequence to be waited on.</param>
/// <param name="cursor">Ring buffer cursor on which to wait.</param>
/// <param name="dependents">dependents further back the chain that must advance first</param>
/// <param name="barrier">barrier the <see cref="IEventProcessor"/> is waiting on.</param>
/// <returns>the sequence that is available which may be greater than the requested sequence.</returns>
public long WaitFor(long sequence, Sequence cursor, Sequence[] dependents, ISequenceBarrier barrier)
{
var availableSequence = cursor.Value; // volatile read
if (availableSequence < sequence)
{
Monitor.Enter(_gate);
try
{
while ((availableSequence = cursor.Value) < sequence) // volatile read
{
barrier.CheckAlert();
Monitor.Wait(_gate);
}
}
finally
{
Monitor.Exit(_gate);
}
}
if (dependents.Length != 0)
{
while ((availableSequence = Util.GetMinimumSequence(dependents)) < sequence)
{
barrier.CheckAlert();
}
}
return availableSequence;
}
public long WaitFor(long sequence, ISequence cursor, ISequence dependentSequence, ISequenceBarrier barrier)
{
if (cursor.GetValue() < sequence)
{
lock (mutex)
{
while (cursor.GetValue() < sequence)
{
barrier.CheckAlert();
Monitor.Wait(mutex);
}
}
}
long availableSequence;
var spinWait = new AggressiveSpinWait();
while ((availableSequence = dependentSequence.GetValue()) < sequence)
{
barrier.CheckAlert();
spinWait.SpinOnce();
}
return(availableSequence);
}
/// <summary>
/// <see cref="IWaitStrategy.WaitFor"/>
/// </summary>
public long WaitFor(long sequence, Sequence cursor, ISequence dependentSequence, ISequenceBarrier barrier)
{
var timeSpan = _timeout;
if (cursor.Value < sequence)
{
lock (_gate)
{
while (cursor.Value < sequence)
{
barrier.CheckAlert();
if (!Monitor.Wait(_gate, timeSpan))
{
throw TimeoutException.Instance;
}
}
}
}
long availableSequence;
while ((availableSequence = dependentSequence.Value) < sequence)
{
barrier.CheckAlert();
}
return availableSequence;
}
/// <summary>
/// <see cref="IWaitStrategy.WaitFor"/>.
/// </summary>
public long WaitFor(long sequence, Sequence cursor, ISequence dependentSequence, ISequenceBarrier barrier)
{
var milliseconds = _timeoutInMilliseconds;
long availableSequence;
if (cursor.Value < sequence)
{
lock (_lock)
{
while (cursor.Value < sequence)
{
Interlocked.Exchange(ref _signalNeeded, 1);
barrier.CheckAlert();
if (!Monitor.Wait(_lock, milliseconds))
{
throw TimeoutException.Instance;
}
}
}
}
while ((availableSequence = dependentSequence.Value) < sequence)
{
barrier.CheckAlert();
}
return availableSequence;
}
/// <summary>
/// Wait for the given sequence to be available
/// </summary>
/// <param name="sequence">sequence to be waited on.</param>
/// <param name="cursor">Ring buffer cursor on which to wait.</param>
/// <param name="dependents">dependents further back the chain that must advance first</param>
/// <param name="barrier">barrier the <see cref="IEventProcessor"/> is waiting on.</param>
/// <returns>the sequence that is available which may be greater than the requested sequence.</returns>
public long WaitFor(long sequence, Sequence cursor, Sequence dependentSequence, ISequenceBarrier barrier)
{
var availableSequence = cursor.Value; // volatile read
if (availableSequence < sequence)
{
//SpinLock 与 Monitor相比是个轻量级的同步原语
//实际测试下来使用 SpinLock 性能优于Monitor
//Monitor.Enter(gate);
var lockToken = false;
spinLock.Enter(ref lockToken);
try
{
while ((availableSequence = cursor.Value) < sequence) // volatile read
{
barrier.CheckAlert();
//Monitor.Wait(gate);
mres.Wait();
}
}
finally
{
//Monitor.Exit(gate);
if (lockToken)
{
spinLock.Exit();
}
}
}
while ((availableSequence = dependentSequence.Value) < sequence)
{
barrier.CheckAlert();
}
return(availableSequence);
}
/// <summary>
/// <see cref="IWaitStrategy.WaitFor"/>.
/// </summary>
public long WaitFor(long sequence, Sequence cursor, ISequence dependentSequence, ISequenceBarrier barrier)
{
var milliseconds = _timeoutInMilliseconds;
long availableSequence;
if (cursor.Value < sequence)
{
lock (_lock)
{
while (cursor.Value < sequence)
{
Interlocked.Exchange(ref _signalNeeded, 1);
barrier.CheckAlert();
if (!Monitor.Wait(_lock, milliseconds))
{
throw TimeoutException.Instance;
}
}
}
}
var aggressiveSpinWait = new AggressiveSpinWait();
while ((availableSequence = dependentSequence.Value) < sequence)
{
barrier.CheckAlert();
aggressiveSpinWait.SpinOnce();
}
return(availableSequence);
}
/// <summary>
/// Wait for the given sequence to be available with a timeout specified.
/// </summary>
/// <param name="sequence">sequence to be waited on.</param>
/// <param name="cursor">cursor on which to wait.</param>
/// <param name="dependents">dependents further back the chain that must advance first</param>
/// <param name="barrier">barrier the processor is waiting on.</param>
/// <param name="timeout">timeout value to abort after.</param>
/// <returns>the sequence that is available which may be greater than the requested sequence.</returns>
/// <exception cref="AlertException">AlertException if the status of the Disruptor has changed.</exception>
public long WaitFor(long sequence, Sequence cursor, Sequence[] dependents, ISequenceBarrier barrier, TimeSpan timeout)
{
long availableSequence;
var spinWait = default(SpinWait);
var sw = Stopwatch.StartNew();
if (dependents.Length == 0)
{
while ((availableSequence = cursor.Value) < sequence) // volatile read
{
barrier.CheckAlert();
spinWait.SpinOnce();
if (sw.Elapsed > timeout)
{
break;
}
}
}
else
{
while ((availableSequence = Util.GetMinimumSequence(dependents)) < sequence)
{
barrier.CheckAlert();
spinWait.SpinOnce();
if (sw.Elapsed > timeout)
{
break;
}
}
}
return availableSequence;
}
/// <summary>
/// Wait for the given sequence to be available
/// </summary>
/// <param name="sequence">sequence to be waited on.</param>
/// <param name="cursor">Ring buffer cursor on which to wait.</param>
/// <param name="dependents">dependents further back the chain that must advance first</param>
/// <param name="barrier">barrier the <see cref="IEventProcessor"/> is waiting on.</param>
/// <returns>the sequence that is available which may be greater than the requested sequence.</returns>
public long WaitFor(long sequence, Sequence cursor, Sequence[] dependents, ISequenceBarrier barrier)
{
var availableSequence = cursor.Value; // volatile read
if (availableSequence < sequence)
{
Monitor.Enter(_gate);
try
{
++_numWaiters;
while ((availableSequence = cursor.Value) < sequence) // volatile read
{
barrier.CheckAlert();
Monitor.Wait(_gate);
}
}
finally
{
--_numWaiters;
Monitor.Exit(_gate);
}
}
if (dependents.Length != 0)
{
while ((availableSequence = Util.GetMinimumSequence(dependents)) < sequence)
{
barrier.CheckAlert();
}
}
return(availableSequence);
}
public long WaitFor(long sequence, ISequence cursor, ISequence dependentSequence, ISequenceBarrier barrier)
{
long availableSequence;
if (cursor.GetValue() < sequence)
{
lock (_mutex)
{
do
{
Interlocked.Exchange(ref _signalNeeded, 1);
if (cursor.GetValue() >= sequence)
{
break;
}
barrier.CheckAlert();
Monitor.Wait(_mutex);
} while (cursor.GetValue() < sequence);
}
}
var spinWait = new AggressiveSpinWait();
while ((availableSequence = dependentSequence.GetValue()) < sequence)
{
barrier.CheckAlert();
spinWait.SpinOnce();
}
return(availableSequence);
}
/// <summary>
/// <see cref="IWaitStrategy.WaitFor"/>
/// </summary>
public long WaitFor(long sequence, Sequence cursor, ISequence dependentSequence, ISequenceBarrier barrier)
{
if (cursor.Value < sequence)
{
lock (_gate)
{
while (cursor.Value < sequence)
{
barrier.CheckAlert();
Monitor.Wait(_gate);
}
}
}
var spinWait = new SpinWait();
long availableSequence;
while ((availableSequence = dependentSequence.Value) < sequence)
{
barrier.CheckAlert();
spinWait.SpinOnce();
}
return(availableSequence);
}
/// <summary>
/// Wait for the given sequence to be available with a timeout specified.
/// </summary>
/// <param name="sequence">sequence to be waited on.</param>
/// <param name="cursor">cursor on which to wait.</param>
/// <param name="dependents">dependents further back the chain that must advance first</param>
/// <param name="barrier">barrier the processor is waiting on.</param>
/// <param name="timeout">timeout value to abort after.</param>
/// <returns>the sequence that is available which may be greater than the requested sequence.</returns>
/// <exception cref="AlertException">AlertException if the status of the Disruptor has changed.</exception>
public long WaitFor(long sequence, Sequence cursor, Sequence[] dependents, ISequenceBarrier barrier, TimeSpan timeout)
{
long availableSequence;
var spinWait = new SpinWait();
var sw = Stopwatch.StartNew();
if (dependents.Length == 0)
{
while ((availableSequence = cursor.Value) < sequence) // volatile read
{
barrier.CheckAlert();
spinWait.SpinOnce();
if (sw.Elapsed > timeout)
{
break;
}
}
}
else
{
while ((availableSequence = Util.GetMinimumSequence(dependents)) < sequence)
{
barrier.CheckAlert();
spinWait.SpinOnce();
if (sw.Elapsed > timeout)
{
break;
}
}
}
return(availableSequence);
}
/// <summary>
/// <see cref="IWaitStrategy.WaitFor"/>
/// </summary>
public long WaitFor(long sequence, Sequence cursor, ISequence dependentSequence, ISequenceBarrier barrier)
{
long availableSequence;
while ((availableSequence = dependentSequence.Value) < sequence)
{
barrier.CheckAlert();
}
return(availableSequence);
}
/// <summary>
/// <see cref="IWaitStrategy.WaitFor"/>
/// </summary>
public long WaitFor(long sequence, Sequence cursor, ISequence dependentSequence, ISequenceBarrier barrier)
{
long availableSequence;
while ((availableSequence = dependentSequence.Value) < sequence)
{
barrier.CheckAlert();
}
return availableSequence;
}
/// <summary>
/// Wait for the given sequence to be available
/// </summary>
/// <param name="sequence">sequence to be waited on.</param>
/// <param name="cursor">Ring buffer cursor on which to wait.</param>
/// <param name="dependents">dependents further back the chain that must advance first</param>
/// <param name="barrier">barrier the <see cref="IEventProcessor"/> is waiting on.</param>
/// <returns>the sequence that is available which may be greater than the requested sequence.</returns>
public long WaitFor(long sequence, Sequence cursor, Sequence[] dependents, ISequenceBarrier barrier)
{
long availableSequence;
if (dependents.Length == 0)
{
while ((availableSequence = cursor.Value) < sequence) // volatile read
{
barrier.CheckAlert();
}
}
else
{
while ((availableSequence = Util.GetMinimumSequence(dependents)) < sequence)
{
barrier.CheckAlert();
}
}
return(availableSequence);
}
/// <summary>
/// Wait for the given sequence to be available
/// </summary>
/// <param name="sequence">sequence to be waited on.</param>
/// <param name="cursor">Ring buffer cursor on which to wait.</param>
/// <param name="dependents">dependents further back the chain that must advance first</param>
/// <param name="barrier">barrier the <see cref="IEventProcessor"/> is waiting on.</param>
/// <returns>the sequence that is available which may be greater than the requested sequence.</returns>
public long WaitFor(long sequence, Sequence cursor, Sequence[] dependents, ISequenceBarrier barrier)
{
long availableSequence;
if (dependents.Length == 0)
{
while ((availableSequence = cursor.Value) < sequence) // volatile read
{
barrier.CheckAlert();
}
}
else
{
while ((availableSequence = Util.GetMinimumSequence(dependents)) < sequence)
{
barrier.CheckAlert();
}
}
return availableSequence;
}
public long WaitFor(long sequence, ISequence cursor, ISequence dependentSequence, ISequenceBarrier barrier)
{
long availableSequence;
var spinWait = default(AggressiveSpinWait);
while ((availableSequence = dependentSequence.GetValue()) < sequence)
{
barrier.CheckAlert();
spinWait.SpinOnce();
}
return(availableSequence);
}
/// <summary>
/// <see cref="IWaitStrategy.WaitFor"/>
/// </summary>
public long WaitFor(long sequence, Sequence cursor, ISequence dependentSequence, ISequenceBarrier barrier)
{
if (cursor.Value < sequence)
{
lock (_gate)
{
while (cursor.Value < sequence)
{
barrier.CheckAlert();
Monitor.Wait(_gate);
}
}
}
long availableSequence;
while ((availableSequence = dependentSequence.Value) < sequence)
{
barrier.CheckAlert();
}
return availableSequence;
}
public long WaitFor(long sequence, Sequence cursor, Sequence dependentSequence, ISequenceBarrier barrier)
{
long availableSequence;
if ((availableSequence = dependentSequence.Value) < sequence)
{
bool lockToken = false;
Monitor.Enter(obj, ref lockToken);
try
{
do
{
signalNeeded.WriteFullFence(true);
if ((availableSequence = dependentSequence.Value) >= sequence)
{
break;
}
barrier.CheckAlert();
Monitor.Wait(obj);
}while ((availableSequence = dependentSequence.Value) < sequence);
}
finally
{
if (lockToken)
{
Monitor.Exit(obj);
}
}
}
while ((availableSequence = dependentSequence.Value) < sequence)
{
barrier.CheckAlert();
}
return(availableSequence);
}
/// <summary>
/// Wait for the given sequence to be available with a timeout specified.
/// </summary>
/// <param name="sequence">sequence to be waited on.</param>
/// <param name="cursor">cursor on which to wait.</param>
/// <param name="dependents">dependents further back the chain that must advance first</param>
/// <param name="barrier">barrier the processor is waiting on.</param>
/// <param name="timeout">timeout value to abort after.</param>
/// <returns>the sequence that is available which may be greater than the requested sequence.</returns>
/// <exception cref="AlertException">AlertException if the status of the Disruptor has changed.</exception>
public long WaitFor(long sequence, Sequence cursor, Sequence[] dependents, ISequenceBarrier barrier,
TimeSpan timeout)
{
long availableSequence;
if ((availableSequence = cursor.Value) < sequence)
{
Monitor.Enter(_gate);
try
{
++_numWaiters;
while ((availableSequence = cursor.Value) < sequence)
{
barrier.CheckAlert();
if (!Monitor.Wait(_gate, timeout))
{
break;
}
}
}
finally
{
--_numWaiters;
Monitor.Exit(_gate);
}
}
if (dependents.Length != 0)
{
while ((availableSequence = Util.GetMinimumSequence(dependents)) < sequence)
{
barrier.CheckAlert();
}
}
return(availableSequence);
}
public long WaitFor(long sequence, Sequence cursor, Sequence dependentSequence, ISequenceBarrier barrier)
{
long availableSequence;
if ((availableSequence = dependentSequence.Value) < sequence)
{
bool lockToken = false;
Monitor.Enter(obj, ref lockToken);
try
{
do
{
signalNeeded.WriteFullFence(true);
if ((availableSequence = dependentSequence.Value) >= sequence)
{
break;
}
barrier.CheckAlert();
Monitor.Wait(obj);
}
while ((availableSequence = dependentSequence.Value) < sequence);
}
finally
{
if (lockToken)
Monitor.Exit(obj);
}
}
while ((availableSequence = dependentSequence.Value) < sequence)
{
barrier.CheckAlert();
}
return availableSequence;
}
private static int ApplyWaitMethod(ISequenceBarrier barrier, int counter)
{
barrier.CheckAlert();
if (counter == 0)
{
Thread.Yield();
}
else
{
--counter;
}
return(counter);
}
private int ApplyWaitMethod(ISequenceBarrier barrier, int counter)
{
barrier.CheckAlert();
if (0 == counter)
{
Thread.Yield ();
}
else
{
--counter;
}
return counter;
}
private int ApplyWaitMethod(ISequenceBarrier barrier, int counter)
{
barrier.CheckAlert();
if (counter > 100)
{
--counter;
}
else if (counter > 0)
{
--counter;
Thread.Yield();
}
else
{
Thread.Sleep(_sleepTimeMillis);
}
return(counter);
}
private static int ApplyWaitMethod(ISequenceBarrier barrier, int counter)
{
barrier.CheckAlert();
if (counter > 100)
{
--counter;
}
else if (counter > 0)
{
--counter;
Thread.Yield();
}
else
{
Thread.Sleep(0);
}
return counter;
}
private int ApplyWaitMethod(ISequenceBarrier barrier, int counter)
{
barrier.CheckAlert();
if (counter > 100)
{
--counter;
}
else if (counter > 0)
{
--counter;
Thread.Sleep(0);
}
else
{
spinWait.SpinOnce();
//LockSupport.parkNanos(1L);
}
return counter;
}
private int ApplyWaitMethod(ISequenceBarrier barrier, int counter)
{
barrier.CheckAlert();
if (counter > 100)
{
--counter;
}
else if (counter > 0)
{
--counter;
Thread.Sleep(0);
}
else
{
spinWait.SpinOnce();
//LockSupport.parkNanos(1L);
}
return(counter);
}
private static int ApplyWaitMethod(ISequenceBarrier barrier, int counter)
{
barrier.CheckAlert();
if (counter > 100)
{
--counter;
}
#if NETSTANDARD2_0
else if (counter > 0)
{
--counter;
Thread.Yield();
}
#endif
else
{
Thread.Sleep(0);
}
return(counter);
}
/// <summary>
/// Wait for the given sequence to be available with a timeout specified.
/// </summary>
/// <param name="sequence">sequence to be waited on.</param>
/// <param name="cursor">cursor on which to wait.</param>
/// <param name="dependents">dependents further back the chain that must advance first</param>
/// <param name="barrier">barrier the processor is waiting on.</param>
/// <param name="timeout">timeout value to abort after.</param>
/// <returns>the sequence that is available which may be greater than the requested sequence.</returns>
/// <exception cref="AlertException">AlertException if the status of the Disruptor has changed.</exception>
public long WaitFor(long sequence, Sequence cursor, Sequence[] dependents, ISequenceBarrier barrier,
TimeSpan timeout)
{
long availableSequence;
if ((availableSequence = cursor.Value) < sequence)
{
Monitor.Enter(_gate);
try
{
++_numWaiters;
while ((availableSequence = cursor.Value) < sequence)
{
barrier.CheckAlert();
if(!Monitor.Wait(_gate, timeout))
{
break;
}
}
}
finally
{
--_numWaiters;
Monitor.Exit(_gate);
}
}
if (dependents.Length != 0)
{
while ((availableSequence = Util.GetMinimumSequence(dependents)) < sequence)
{
barrier.CheckAlert();
}
}
return availableSequence;
}
private static int ApplyWaitMethod(ISequenceBarrier barrier, int counter)
{
const int SLEEP1_INTERVAL = 128;
const int SLEEP0_INTERVAL = 8;
int yiled_cnt;
barrier.CheckAlert();
if (counter >= MaxSpinTries)
{
yiled_cnt = counter - MaxSpinTries;
++counter;
if ((yiled_cnt % SLEEP1_INTERVAL) == (SLEEP1_INTERVAL - 1))
{
Thread.Sleep(1);
}
else if ((yiled_cnt % SLEEP0_INTERVAL) == (SLEEP0_INTERVAL - 1))
{
Thread.Sleep(0);
}
else
{
if (!Thread.Yield())
{
Thread.SpinWait(1);
}
}
++counter;
}
else
{
++counter;
Thread.SpinWait(1);
}
return(counter);
}
public long WaitOnLock(long sequence,
Sequence cursorSequence,
Sequence dependentSequence, ISequenceBarrier barrier,TimeSpan timeOut)
{
var availableSequence = cursorSequence.Value; // volatile read
if (availableSequence < sequence)
{
Monitor.Enter(_gate);
try
{
++_numWaiters;
while ((availableSequence = cursorSequence.Value) < sequence) // volatile read
{
barrier.CheckAlert();
Monitor.Wait(_gate, timeOut);
}
}
finally
{
--_numWaiters;
Monitor.Exit(_gate);
}
}
while ((availableSequence = dependentSequence.Value) < sequence)
{
barrier.CheckAlert();
}
return availableSequence;
}
private static int ApplyWaitMethod(ISequenceBarrier barrier, int counter)
{
const int SLEEP1_INTERVAL = 128;
const int SLEEP0_INTERVAL = 8;
int yiled_cnt;
barrier.CheckAlert();
if (counter >= MaxSpinTries)
{
yiled_cnt = counter - MaxSpinTries;
++counter;
if ((yiled_cnt % SLEEP1_INTERVAL) == (SLEEP1_INTERVAL - 1))
{
Thread.Sleep(1);
}
else if ((yiled_cnt % SLEEP0_INTERVAL) == (SLEEP0_INTERVAL - 1))
{
Thread.Sleep(0);
}
else
{
if (!Thread.Yield())
{
Thread.SpinWait(1);
}
}
++counter;
}
else
{
++counter;
Thread.SpinWait(1);
}
return counter;
}
public void CheckAlert()
{
_target.CheckAlert();
}