public static ValueEventPoller <T> Create <T>(IValueDataProvider <T> dataProvider, ISequencer sequencer, Sequence sequence, Sequence cursorSequence, params ISequence[] gatingSequences)
where T : struct
{
var dependentSequences = new DependentSequenceGroup(cursorSequence, gatingSequences);
return(new ValueEventPoller <T>(dataProvider, sequencer, sequence, dependentSequences));
}
public ValueEventPoller(IValueDataProvider <T> dataProvider, ISequencer sequencer, ISequence sequence, DependentSequenceGroup dependentSequences)
{
_dataProvider = dataProvider;
_sequencer = sequencer;
_sequence = sequence;
_dependentSequences = dependentSequences;
}
public CustomSequenceBarrier(ISequencer sequencer, IWaitStrategy waitStrategy, Sequence cursorSequence, ISequence[] dependentSequences)
{
_sequencer = sequencer;
_waitStrategy = waitStrategy;
_dependentSequences = new DependentSequenceGroup(cursorSequence, dependentSequences);
_cancellationTokenSource = new CancellationTokenSource();
}
public void ShouldGetCursorValueAsValueWhenThereAreNoDependentSequences()
{
var cursor = new Sequence(42);
var dependentSequences = new DependentSequenceGroup(cursor);
var value = dependentSequences.Value;
Assert.AreEqual(42, value);
}
public void ShouldGetCursorValue()
{
var cursor = new Sequence(42);
var dependentSequences = new DependentSequenceGroup(cursor);
var cursorValue = dependentSequences.CursorValue;
Assert.AreEqual(42, cursorValue);
}
public SequenceWaitResult WaitFor(long sequence, DependentSequenceGroup dependentSequences, CancellationToken cancellationToken)
{
long availableSequence;
while ((availableSequence = dependentSequences.Value) < sequence)
{
cancellationToken.ThrowIfCancellationRequested();
}
return(availableSequence);
}
public AsyncSequenceBarrier(ISequencer sequencer, IWaitStrategy waitStrategy, Sequence cursorSequence, ISequence[] dependentSequences)
{
if (waitStrategy is not IAsyncWaitStrategy asyncWaitStrategy)
{
throw new InvalidOperationException($"The disruptor must be configured with an async wait strategy (e.g.: {nameof(AsyncWaitStrategy)}");
}
_sequencer = sequencer;
_waitStrategy = asyncWaitStrategy;
_dependentSequences = new DependentSequenceGroup(cursorSequence, dependentSequences);
_cancellationTokenSource = new CancellationTokenSource();
}
public SequenceWaitResult WaitFor(long sequence, DependentSequenceGroup dependentSequences, CancellationToken cancellationToken)
{
long availableSequence;
int counter = _retries;
while ((availableSequence = dependentSequences.Value) < sequence)
{
counter = ApplyWaitMethod(cancellationToken, counter);
}
return(availableSequence);
}
public void ShouldGetMinimumValueFromCustomSequences([Range(1, 4)] int dependentSequenceCount)
{
var cursor = new Sequence();
var random = new Random();
var sequences = Enumerable.Range(0, dependentSequenceCount)
.Select(_ => new ConstantSequence(random.Next(1000)))
.Cast <ISequence>()
.ToArray();
var dependentSequences = new DependentSequenceGroup(cursor, sequences);
var value = dependentSequences.Value;
var expectedValue = sequences.Select(x => x.Value).Min();
Assert.AreEqual(expectedValue, value);
}
public void ShouldWaitMultipleTimesAsync()
{
// Arrange
var waitStrategy = CreateWaitStrategy();
var sequence1 = new Sequence();
var waitTask1 = Task.Run(async() =>
{
var cancellationTokenSource = new CancellationTokenSource();
var dependentSequences = new DependentSequenceGroup(Cursor);
for (var i = 0; i < 500; i++)
{
await waitStrategy.WaitForAsync(i, dependentSequences, cancellationTokenSource.Token).ConfigureAwait(false);
sequence1.SetValue(i);
}
});
var waitTask2 = Task.Run(async() =>
{
var cancellationTokenSource = new CancellationTokenSource();
var dependentSequences = new DependentSequenceGroup(Cursor, sequence1);
for (var i = 0; i < 500; i++)
{
await waitStrategy.WaitForAsync(i, dependentSequences, cancellationTokenSource.Token).ConfigureAwait(false);
}
});
// Act
for (var i = 0; i < 500; i++)
{
if (i % 50 == 0)
{
Thread.Sleep(1);
}
Cursor.SetValue(i);
waitStrategy.SignalAllWhenBlocking();
}
// Assert
AssertIsCompleted(waitTask1);
AssertIsCompleted(waitTask2);
}
public SequenceWaitResult WaitFor(long sequence, DependentSequenceGroup dependentSequences, CancellationToken cancellationToken)
{
long startTime = 0;
int counter = _spinTries;
do
{
long availableSequence;
if ((availableSequence = dependentSequences.Value) >= sequence)
{
return(availableSequence);
}
if (0 == --counter)
{
if (0 == startTime)
{
startTime = GetSystemTimeTicks();
}
else
{
var timeDelta = GetSystemTimeTicks() - startTime;
if (timeDelta > _yieldTimeoutTicks)
{
return(_fallbackStrategy.WaitFor(sequence, dependentSequences, cancellationToken));
}
if (timeDelta > _spinTimeoutTicks)
{
Thread.Yield();
}
}
counter = _spinTries;
}
}while (true);
}
public SequenceWaitResult WaitFor(long sequence, DependentSequenceGroup dependentSequences, CancellationToken cancellationToken)
{
return(dependentSequences.SpinWaitFor(sequence, cancellationToken));
}
public WorkerPoolInfo(WorkerPool <T> workerPool, DependentSequenceGroup dependentSequences)
{
_workerPool = workerPool;
DependentSequences = dependentSequences;
IsEndOfChain = true;
}
