public DiamondPath1P3CDisruptorWithAffinityPerfTest()
: base(100 * Million)
{
_scheduler = new RoundRobinThreadAffinedTaskScheduler(4);
_disruptor = new Disruptor <FizzBuzzEvent>(() => new FizzBuzzEvent(),
new SingleThreadedClaimStrategy(Size),
new YieldingWaitStrategy(),
_scheduler);
_mru = new ManualResetEvent(false);
_fizzEventHandler = new FizzBuzzEventHandler(FizzBuzzStep.Fizz, Iterations, _mru);
_buzzEventHandler = new FizzBuzzEventHandler(FizzBuzzStep.Buzz, Iterations, _mru);
_fizzBuzzEventHandler = new FizzBuzzEventHandler(FizzBuzzStep.FizzBuzz, Iterations, _mru);
_disruptor.HandleEventsWith(_fizzEventHandler, _buzzEventHandler)
.Then(_fizzBuzzEventHandler);
_ringBuffer = _disruptor.RingBuffer;
}
public Pipeline3StepLatencyDisruptorWithAffinityPerfTest()
: base(2 * Million)
{
_scheduler = new RoundRobinThreadAffinedTaskScheduler(4);
_disruptor = new Dsl.Disruptor <ValueEvent>(() => new ValueEvent(),
new SingleThreadedClaimStrategy(Size),
new YieldingWaitStrategy(),
_scheduler);
_mru = new ManualResetEvent(false);
_stepOneFunctionEventHandler = new LatencyStepEventHandler(FunctionStep.One, Histogram, StopwatchTimestampCostInNano, TicksToNanos, Iterations, _mru);
_stepTwoFunctionEventHandler = new LatencyStepEventHandler(FunctionStep.Two, Histogram, StopwatchTimestampCostInNano, TicksToNanos, Iterations, _mru);
_stepThreeFunctionEventHandler = new LatencyStepEventHandler(FunctionStep.Three, Histogram, StopwatchTimestampCostInNano, TicksToNanos, Iterations, _mru);
_disruptor.HandleEventsWith(_stepOneFunctionEventHandler)
.Then(_stepTwoFunctionEventHandler)
.Then(_stepThreeFunctionEventHandler);
_ringBuffer = _disruptor.RingBuffer;
}
public Sequencer3P1CDisruptorWithAffinityPerfTest()
: base(20 * Million)
{
_scheduler = new RoundRobinThreadAffinedTaskScheduler(4);
_disruptor = new Disruptor <ValueEvent>(() => new ValueEvent(),
new MultiThreadedLowContentionClaimStrategy(Size),
new YieldingWaitStrategy(),
_scheduler);
_mru = new ManualResetEvent(false);
_eventHandler = new ValueAdditionEventHandler(Iterations * NumProducers, _mru);
_disruptor.HandleEventsWith(_eventHandler);
_valueProducers = new ValueProducer[NumProducers];
_ringBuffer = _disruptor.RingBuffer;
for (int i = 0; i < NumProducers; i++)
{
_valueProducers[i] = new ValueProducer(_testStartBarrier, _ringBuffer, Iterations);
}
}
public OneToOneRawThroughputTest()
{
_taskScheduler = new RoundRobinThreadAffinedTaskScheduler(2);
_myRunnable = new MyRunnable(_sequencer);
_sequencer.AddGatingSequences(_myRunnable.Sequence);
}
public Context Start(Action <Exception> exceptionAction = null)
{
var module = AppDomain.CurrentDomain.DefineDynamicAssembly(
new AssemblyName("RampUp_MessageWriter_" + Guid.NewGuid()),
AssemblyBuilderAccess.Run).DefineDynamicModule("main");
InitMessageTypesDictionary();
var writer = MessageWriterBuilder.Build(_counter, GetMessageId, _messageTypes.ToArray(), module);
var runners = _registrations.Select(f => f()).ToList();
if (_featureActors.Count > 0)
{
runners.Add(BuildRunner(_featureActors, new Bus()));
}
var registry = CreateRegistry(runners);
foreach (var kvp in _runnerBusMap)
{
var index = runners.FindIndex(r => ReferenceEquals(r, kvp.Key));
kvp.Value.Init(GetId(index), registry, ThrowAfterNTrials, writer);
}
var source = new CancellationTokenSource();
var end = new ManualResetEventSlim();
var ctx = new Context(source, end, new Bus(new ActorId(0), registry, ThrowAfterNTrials, writer));
var token = source.Token;
_scheduler = new RoundRobinThreadAffinedTaskScheduler(runners.Count);
var factory = new TaskFactory(_scheduler);
var runningTasks = runners.Select(runner =>
{
return(factory.StartNew(() =>
{
try
{
while (token.IsCancellationRequested == false)
{
BatchInfo info;
runner.SpinOnce(out info);
}
}
catch (TaskCanceledException)
{
}
catch (Exception)
{
source.Cancel();
throw;
}
}, token));
}).ToArray();
// ReSharper disable once MethodSupportsCancellation
Task.WhenAll(runningTasks).ContinueWith(t =>
{
_scheduler.Dispose();
foreach (var buffer in _buffers)
{
buffer.Dispose();
}
ctx.Exception = t.Exception;
if (t.Exception != null)
{
exceptionAction?.Invoke(t.Exception);
}
end.Set();
});
return(ctx);
}
protected override long RunDisruptorPass()
{
var ob = Observable.Create <long>(o =>
{
var cancel = new CancellationDisposable(); // internally creates a new CancellationTokenSource
Scheduler.Default.Schedule(() =>
{
for (long i = 0; i < ITERATIONS; i++)
{
//Thread.Sleep(200); // here we do the long lasting background operation
if (!cancel.Token.IsCancellationRequested) // check cancel token periodically
{
o.OnNext(i++);
}
else
{
Console.WriteLine("Aborting because cancel event was signaled!");
o.OnCompleted();
return;
}
}
}
);
return(cancel);
}
);
var spinwait = default(SpinWait);
//var latch = new CountdownEvent(1);
var latch = new ManualResetEvent(false);
var expectedCount = myRunnable.GetSequence.Value + ITERATIONS;
myRunnable.Reset(latch, expectedCount);
var _scheduler = new RoundRobinThreadAffinedTaskScheduler(4);
//TaskScheduler.Default调度器 CPU 约在 50 % 两个繁忙，两个空闲
//
Task.Factory.StartNew(myRunnable.Run, CancellationToken.None, TaskCreationOptions.None, TestTaskScheduler);
var start = Stopwatch.StartNew();
var sequencer = this.sequencer;
//var range = Observable.Range(0, 1000 * 1000 * 100, Scheduler.Default)
// .Subscribe(i => {
// long next = sequencer.Next();
// sequencer.Publish(next);
// });
// var subscription = ob.Subscribe(i =>
for (long i = 0; i < ITERATIONS; i++)
{
long next = sequencer.Next();
sequencer.Publish(next);
}
//);
latch.WaitOne();
long opsPerSecond = (ITERATIONS * 1000L) / start.ElapsedMilliseconds;
WaitForEventProcessorSequence(expectedCount, spinwait, myRunnable);
return(opsPerSecond);
}
