public void WaitForCursor(long sequence, IRingBuffer ringBuffer) { while (ringBuffer.Cursor != sequence) { // busy spin } }
public void WaitForCursor(long sequence, IRingBuffer ringBuffer) { while (ringBuffer.Cursor != sequence) { // busy spin } }
public Pipeline3StepLatencyPerfTest() { InitHistogram(); InitStopwatchTimeCostNs(); ringBuffer = new RingBuffer <ValueEntry>(new ValueEntryFactory(), SIZE, new SingleThreadedStrategy(), new BusySpinStrategy <ValueEntry>()); stepOneConsumerBarrier = ringBuffer.CreateConsumerBarrier(); stepOneFunctionHandler = new LatencyStepHandler(FunctionStep.ONE, _histogram, _stopwatchTimeCostNs, _stopwatch); stepOneBatchConsumer = new BatchConsumer <ValueEntry>(stepOneConsumerBarrier, stepOneFunctionHandler); stepTwoConsumerBarrier = ringBuffer.CreateConsumerBarrier(stepOneBatchConsumer); stepTwoFunctionHandler = new LatencyStepHandler(FunctionStep.TWO, _histogram, _stopwatchTimeCostNs, _stopwatch); stepTwoBatchConsumer = new BatchConsumer <ValueEntry>(stepTwoConsumerBarrier, stepTwoFunctionHandler); stepThreeConsumerBarrier = ringBuffer.CreateConsumerBarrier(stepTwoBatchConsumer); stepThreeFunctionHandler = new LatencyStepHandler(FunctionStep.THREE, _histogram, _stopwatchTimeCostNs, _stopwatch); stepThreeBatchConsumer = new BatchConsumer <ValueEntry>(stepThreeConsumerBarrier, stepThreeFunctionHandler); producerBarrier = ringBuffer.CreateProducerBarrier(stepThreeBatchConsumer); stepOneQueue = new BlockingCollection <long>(SIZE); stepTwoQueue = new BlockingCollection <long>(SIZE); stepThreeQueue = new BlockingCollection <long>(SIZE); stepOneQueueConsumer = new LatencyStepQueueConsumer( FunctionStep.ONE, stepOneQueue, stepTwoQueue, _histogram, _stopwatchTimeCostNs, _stopwatch); stepTwoQueueConsumer = new LatencyStepQueueConsumer( FunctionStep.TWO, stepTwoQueue, stepThreeQueue, _histogram, _stopwatchTimeCostNs, _stopwatch); stepThreeQueueConsumer = new LatencyStepQueueConsumer( FunctionStep.THREE, stepThreeQueue, null, _histogram, _stopwatchTimeCostNs, _stopwatch); }
public SystemSnapshotTracker(long journaledSequence, int frequency, IRingBuffer <SnapshotItem> snapshotRing, IRepository repository) { if (journaledSequence < 0) { throw new ArgumentOutOfRangeException("journaledSequence"); } if (frequency < 100) { throw new ArgumentOutOfRangeException("frequency"); } if (snapshotRing == null) { throw new ArgumentNullException("snapshotRing"); } if (repository == null) { throw new ArgumentNullException("repository"); } this.frequency = frequency; this.nextSnapshotSequence = ((journaledSequence / this.frequency) * this.frequency) + this.frequency; this.snapshotRing = snapshotRing; this.repository = repository; }
private void Restore(BootstrapInfo info, IRingBuffer <TransformationItem> transformRing, IRingBuffer <JournalItem> journalRing) { var startingSequence = Math.Min(info.DispatchSequence + 1, info.SnapshotSequence + 1); Log.InfoFormat("Restoring from sequence {0}, will dispatch and will replay messages (this could take some time...).", startingSequence); var replayed = false; foreach (var message in this.store.Load(startingSequence)) { replayed = Replay(info, transformRing, message) || replayed; this.Dispatch(info, journalRing, message); if (message.Sequence % 25000 == 0) { Log.InfoFormat("Pushed message sequence {0} for replay", message.Sequence); } } Log.Info("All journaled messages restored into transformation disruptor; awaiting transformation completion."); if (!replayed) { this.OnComplete(true); } }
public long WaitFor(IConsumer[] consumers, IRingBuffer <T> ringBuffer, IConsumerBarrier <T> barrier, long sequence) { long availableSequence; if (0 == consumers.Length) { while ((availableSequence = ringBuffer.Cursor) < sequence) { if (barrier.IsAlerted()) { throw AlertException.ALERT_EXCEPTION; } } } else { while ((availableSequence = Util.GetMinimumSequence(consumers)) < sequence) { if (barrier.IsAlerted()) { throw AlertException.ALERT_EXCEPTION; } } } return(availableSequence); }
public TransformationHandler( long journaledSequence, IRingBuffer <JournalItem> journalRing, IDeliveryHandler deliveryHandler, ISystemSnapshotTracker snapshot) { if (journaledSequence < 0) { throw new ArgumentOutOfRangeException("journaledSequence"); } if (journalRing == null) { throw new ArgumentNullException("journalRing"); } if (deliveryHandler == null) { throw new ArgumentNullException("deliveryHandler"); } if (snapshot == null) { throw new ArgumentNullException("snapshot"); } this.currentSequnce = journaledSequence; this.journalRing = journalRing; this.deliveryHandler = deliveryHandler; this.snapshot = snapshot; this.canHandle = true; }
public RingBufferConsumer( IRingBuffer <TMessage> messageQueue, ISequenceBarrier sequenceBarrier, IMessageHandler <TMessage> batchMessageHandler) { this._messageBuffer = messageQueue; this._sequenceBarrier = sequenceBarrier; this._batchMessageHandler = batchMessageHandler; }
private static void Publish(SystemSnapshotStreamReader reader, IRingBuffer <BootstrapItem> ring) { foreach (var memento in reader.Read()) { var next = ring.Next(); var claimed = ring[next]; claimed.AsSnapshot(memento.Item1, memento.Item2, memento.Item3); ring.Publish(next); } }
/// <summary> /// Attempts to pop the next available value from the front of the buffer. /// </summary> static public bool TryPopFront <T>(this IRingBuffer <T> ioBuffer, out T outValue) { if (ioBuffer.Count <= 0) { outValue = default(T); return(false); } outValue = ioBuffer.PopFront(); return(true); }
/// <summary> /// Attempts to peek the next available value from the back of the buffer. /// </summary> static public bool TryPeekBack <T>(this IRingBuffer <T> inBuffer, out T outValue) { if (inBuffer.Count <= 0) { outValue = default(T); return(false); } outValue = inBuffer.PeekBack(); return(true); }
/// <summary> /// Shuffles the given array. /// </summary> static public void Shuffle <T>(this Random inRandom, IRingBuffer <T> inBuffer) { int i = inBuffer.Count; int j; while (--i > 0) { T old = inBuffer[i]; inBuffer[i] = inBuffer[j = inRandom.Next(i + 1)]; inBuffer[j] = old; } }
/// <summary> /// Shuffles a region within the given array. /// </summary> static public void Shuffle <T>(this Random inRandom, IRingBuffer <T> inBuffer, int inIndex, int inLength) { int i = Math.Min(inIndex + inLength, inBuffer.Count); int j; while (--i > inIndex) { T old = inBuffer[i]; inBuffer[i] = inBuffer[j = inRandom.Next(inIndex, i + 1)]; inBuffer[j] = old; } }
private static void Consume(IRingBuffer <int> buffer, ref bool shouldStop) { while (!shouldStop || !buffer.IsEmpty()) { if (!buffer.IsEmpty()) { Thread.Sleep(500); Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Consume data[{0}] on Thread [{1}]", buffer.Dequeue(), Thread.CurrentThread.Name); Console.ResetColor(); } } }
public static void Parallel(IRingBuffer ringBuffer) { var threadPushing = new Thread(() => Pushing(ringBuffer)); var threadPopping = new Thread(() => Popping(ringBuffer)); threadPushing.Start(); threadPopping.Start(); Thread.Sleep(500); threadPopping.Interrupt(); threadPushing.Interrupt(); }
public void SetUp() { NopBuffer = Substitute.For <IRingBuffer>(); ABuffer = Substitute.For <IRingBuffer>(); AbBuffer = Substitute.For <IRingBuffer>(); Registry = new ActorRegistry(new[] { Tuple.Create(new ActorDescriptor(new NopHandler()), NopBuffer, NoopId), Tuple.Create(new ActorDescriptor(new AHandler()), ABuffer, AId), Tuple.Create(new ActorDescriptor(new ABHandler()), AbBuffer, ABId) }); }
public DriverProxy(IRingBuffer toDriverCommandBuffer) { if (toDriverCommandBuffer == null) throw new ArgumentNullException(nameof(toDriverCommandBuffer)); _toDriverCommandBuffer = toDriverCommandBuffer; _publicationMessage.Wrap(_buffer, 0); _subscriptionMessage.Wrap(_buffer, 0); _correlatedMessage.Wrap(_keepaliveBuffer, 0); _removeMessage.Wrap(_buffer, 0); _clientId = toDriverCommandBuffer.NextCorrelationId(); }
private static void Popping(IRingBuffer ringBuffer) { Console.WriteLine($"Popping thread: {Thread.CurrentThread.ManagedThreadId}"); Console.WriteLine("Start popping"); var stopwatch = new Stopwatch(); stopwatch.Start(); uint nbOfElementsPopped = 0; try { var spleepCount = 0; while (true) { if (spleepCount == 5) { break; } if (ringBuffer.Size() == 0) { Thread.Sleep(2); spleepCount += 1; continue; } spleepCount = 0; var r = ringBuffer.Pop(); nbOfElementsPopped += 1; } } catch (EmptyRingException e) { Console.WriteLine(e.Message); } finally { stopwatch.Stop(); Console.WriteLine($"Popping done in {stopwatch.ElapsedMilliseconds} milliseconds"); // Doesn't pop every elements due to push concurrency (NoConcurrency implementation), thread should write on the same slot // Pop 3 000 000 elements as expected with write concurrency implementation // Sometimes pop only 1 951 424 elements, correspond to 3 000 000 - 1048576 (ring size) // Issue : Read misses one complete tour of the ring Console.WriteLine($"Nb of element popped : {nbOfElementsPopped}"); } }
private static void Produce(IRingBuffer <int> buffer, ref bool shouldStop) { Thread.Sleep(500); int i = 0; while (i <= 100) { if (!buffer.IsFull()) { // Console.WriteLine("Produce data [{0}] Thread[{1}]", i, Thread.CurrentThread.Name); Thread.Sleep(500); buffer.Enqueue(i++); } } shouldStop = true; }
public DriverProxy(IRingBuffer toDriverCommandBuffer) { if (toDriverCommandBuffer == null) { throw new ArgumentNullException(nameof(toDriverCommandBuffer)); } _toDriverCommandBuffer = toDriverCommandBuffer; _publicationMessage.Wrap(_buffer, 0); _subscriptionMessage.Wrap(_buffer, 0); _correlatedMessage.Wrap(_keepaliveBuffer, 0); _removeMessage.Wrap(_buffer, 0); _clientId = toDriverCommandBuffer.NextCorrelationId(); }
private static bool Replay(BootstrapInfo info, IRingBuffer <TransformationItem> transformRing, JournaledMessage message) { if (message.Sequence <= info.SnapshotSequence) { return(false); } var next = transformRing.Next(); var claimed = transformRing[next]; claimed.AsJournaledMessage(message.Sequence, message.SerializedBody, message.SerializedType, message.SerializedHeaders); transformRing.Publish(next); return(true); }
private static void Pushing(IRingBuffer ringBuffer) { Console.WriteLine($"Pushing thread: {Thread.CurrentThread.ManagedThreadId}"); Console.WriteLine("Start pushing"); Console.WriteLine($"Nb of elements to push: {NbOfPush}"); var stopwatch = new Stopwatch(); stopwatch.Start(); foreach (var i in Enumerable.Range(0, NbOfPush)) { ringBuffer.Push(i); } stopwatch.Stop(); Console.WriteLine($"Pushing done in {stopwatch.ElapsedMilliseconds} milliseconds"); }
private void TryTakeSystemSnapshot(IRepository repository, IRingBuffer <SnapshotItem> ringBuffer, BootstrapInfo info) { if ((info.JournaledSequence - info.SnapshotSequence) <= this.snapshotFrequency) { return; } var items = repository.Items; var remaining = items.Count; foreach (var hydratable in items) { var next = ringBuffer.Next(); var claimed = ringBuffer[next]; claimed.AsPartOfSystemSnapshot(info.JournaledSequence, --remaining, hydratable.Key, hydratable.Memento, hydratable.MementoType); ringBuffer.Publish(next); } }
public static void Parallel(IRingBuffer ringBuffer) { var threadPushing1 = new Thread(() => Pushing(ringBuffer, 1)); var threadPushing2 = new Thread(() => Pushing(ringBuffer, 2)); var threadPushing3 = new Thread(() => Pushing(ringBuffer, 3)); var threadPopping1 = new Thread(() => Popping(ringBuffer, 1)); var threadPopping2 = new Thread(() => Popping(ringBuffer, 2)); var threadPopping3 = new Thread(() => Popping(ringBuffer, 3)); threadPopping1.Start(); threadPopping2.Start(); threadPopping3.Start(); threadPushing1.Start(); threadPushing2.Start(); threadPushing3.Start(); Thread.Sleep(500); }
public DriverProxy(IRingBuffer toDriverCommandBuffer, long clientId) { if (toDriverCommandBuffer == null) { throw new ArgumentNullException(nameof(toDriverCommandBuffer)); } _toDriverCommandBuffer = toDriverCommandBuffer; _publicationMessage.Wrap(_buffer, 0); _subscriptionMessage.Wrap(_buffer, 0); _correlatedMessage.Wrap(_buffer, 0); _removeMessage.Wrap(_buffer, 0); _destinationMessage.Wrap(_buffer, 0); _correlatedMessage.ClientId(clientId); }
public Runner(IRingBuffer buffer, IStructSizeCounter counter, Func <Type, int> messageIdGetter, int batchSize, params IActor[] actors) { Buffer = buffer; _batchSize = batchSize; if (actors.Length > 1) { var actor = new CompositeActor(actors, counter, messageIdGetter); _batchAware = actor; _handler = actor.MessageHandler; Descriptor = actor.Descriptor; } else { _handler = new MessageReader(actors[0], counter, messageIdGetter).MessageHandlerImpl; Descriptor = new ActorDescriptor(actors[0]); _batchAware = actors[0] as IBatchAware; } }
public Runner(IRingBuffer buffer, IStructSizeCounter counter, Func<Type, int> messageIdGetter, int batchSize, params IActor[] actors) { Buffer = buffer; _batchSize = batchSize; if (actors.Length > 1) { var actor = new CompositeActor(actors, counter, messageIdGetter); _batchAware = actor; _handler = actor.MessageHandler; Descriptor = actor.Descriptor; } else { _handler = new MessageReader(actors[0], counter, messageIdGetter).MessageHandlerImpl; Descriptor = new ActorDescriptor(actors[0]); _batchAware = actors[0] as IBatchAware; } }
private static void Popping(IRingBuffer ringBuffer) { Console.WriteLine($"Popping thread: {Thread.CurrentThread.ManagedThreadId}"); Console.WriteLine("Start popping"); var stopwatch = new Stopwatch(); stopwatch.Start(); uint nbOfElementsPopped = 0; try { var spleepCount = 0; while (true) { if (spleepCount == 5) { break; } if (ringBuffer.Size() == 0) { Thread.Sleep(2); spleepCount += 1; continue; } spleepCount = 0; var r = ringBuffer.Pop(); nbOfElementsPopped += 1; } } catch (EmptyRingException e) { Console.WriteLine(e.Message); } finally { stopwatch.Stop(); Console.WriteLine($"Popping done in {stopwatch.ElapsedMilliseconds} milliseconds"); Console.WriteLine($"Nb of element popped : {nbOfElementsPopped}"); } }
public long WaitFor(IConsumer[] consumers, IRingBuffer <T> ringBuffer, IConsumerBarrier <T> barrier, long sequence, long timeout) { long availableSequence; if ((availableSequence = ringBuffer.Cursor) < sequence) { lock (_lock) { try { while ((availableSequence = ringBuffer.Cursor) < sequence) { if (barrier.IsAlerted()) { throw AlertException.ALERT_EXCEPTION; } if (!_waithandle.WaitOne((int)timeout)) { break; } } } catch { } } } if (0 != consumers.Length) { while ((availableSequence = Util.GetMinimumSequence(consumers)) < sequence) { if (barrier.IsAlerted()) { throw AlertException.ALERT_EXCEPTION; } } } return(availableSequence); }
public long WaitFor(IConsumer[] consumers, IRingBuffer <T> ringBuffer, IConsumerBarrier <T> barrier, long sequence, long timeout) { long currentTime = _timer.ElapsedMilliseconds; long cutoff = currentTime + timeout; long availableSequence; if (0 == consumers.Length) { while ((availableSequence = ringBuffer.Cursor) < sequence) { if (barrier.IsAlerted()) { throw AlertException.ALERT_EXCEPTION; } ThreadYield(); if (_timer.ElapsedMilliseconds > cutoff) { break; } } } else { while ((availableSequence = Util.GetMinimumSequence(consumers)) < sequence) { if (barrier.IsAlerted()) { throw AlertException.ALERT_EXCEPTION; } ThreadYield(); if (_timer.ElapsedMilliseconds > cutoff) { break; } } } return(availableSequence); }
public MessageListener(Func <IMessageReceiver> receiverFactory, IRingBuffer <TransformationItem> ring, DuplicateStore duplicates) { if (receiverFactory == null) { throw new ArgumentNullException("receiverFactory"); } if (ring == null) { throw new ArgumentNullException("ring"); } if (duplicates == null) { throw new ArgumentNullException("duplicates"); } this.receiverFactory = receiverFactory; this.ring = ring; this.duplicates = duplicates; }
private void Write <TMessage>(ref TMessage msg, Envelope envelope, IRingBuffer buffer) where TMessage : struct { var successful = _writer.Write(ref envelope, ref msg, buffer); if (successful == false) { var wait = new SpinWait(); var counter = 1; do { if (counter >= _throwAfterNTrials) { throw new Exception("Cannot proceed with a write"); } counter += 1; wait.SpinOnce(); successful = _writer.Write(ref envelope, ref msg, buffer); } while (successful == false); } }
public Transformer(IRepository repository, IRingBuffer <SnapshotItem> ring, ITimeoutWatcher watcher) { if (repository == null) { throw new ArgumentNullException("repository"); } if (ring == null) { throw new ArgumentNullException("ring"); } if (watcher == null) { throw new ArgumentNullException("watcher"); } this.repository = repository; this.ring = ring; this.watcher = watcher; }
/// <summary> /// This is called automatically by <seealso cref="Connect()"/> and its overloads. /// There is no need to call it from a client application. It is responsible for providing default /// values for options that are not individually changed through field setters. /// </summary> /// <returns> this Aeron.Context for method chaining. </returns> public Context Conclude() { try { _cncFile = new FileInfo(Path.Combine(_aeronDirectoryName, CncFileDescriptor.CNC_FILE)); if (_epochClock == null) { _epochClock = new SystemEpochClock(); } if (_nanoClock == null) { _nanoClock = new SystemNanoClock(); } if (_idleStrategy == null) { _idleStrategy = new SleepingIdleStrategy(IdleSleepMs); } if (CncFile() != null) { _cncByteBuffer = IoUtil.MapExistingFile(CncFile().FullName); _cncMetaDataBuffer = CncFileDescriptor.CreateMetaDataBuffer(_cncByteBuffer); var cncVersion = _cncMetaDataBuffer.GetInt(CncFileDescriptor.CncVersionOffset(0)); if (CncFileDescriptor.CNC_VERSION != cncVersion) { throw new InvalidOperationException( "aeron cnc file version not understood: version=" + cncVersion); } } if (_toClientBuffer == null) { var receiver = new BroadcastReceiver(CncFileDescriptor.CreateToClientsBuffer(_cncByteBuffer, _cncMetaDataBuffer)); _toClientBuffer = new CopyBroadcastReceiver(receiver); } if (_toDriverBuffer == null) { _toDriverBuffer = new ManyToOneRingBuffer(CncFileDescriptor.CreateToDriverBuffer(_cncByteBuffer, _cncMetaDataBuffer)); } if (CountersMetaDataBuffer() == null) { CountersMetaDataBuffer(CncFileDescriptor.CreateCountersMetaDataBuffer(_cncByteBuffer, _cncMetaDataBuffer)); } if (CountersValuesBuffer() == null) { CountersValuesBuffer(CncFileDescriptor.CreateCountersValuesBuffer(_cncByteBuffer, _cncMetaDataBuffer)); } _interServiceTimeout = CncFileDescriptor.ClientLivenessTimeout(_cncMetaDataBuffer); if (_logBuffersFactory == null) { _logBuffersFactory = new MappedLogBuffersFactory(); } if (_errorHandler == null) { _errorHandler = DEFAULT_ERROR_HANDLER; } if (_availableImageHandler == null) { _availableImageHandler = image => { }; } if (_unavailableImageHandler == null) { _unavailableImageHandler = image => { }; } } catch ( Exception ex) { Console.WriteLine("***"); Console.WriteLine("***"); Console.WriteLine("Failed to connect to the Media Driver - is it currently running?"); Console.WriteLine("***"); Console.WriteLine("***"); throw new InvalidOperationException("Could not initialise communication buffers", ex); } return this; }
/// <summary> /// This method is used for testing and debugging. /// </summary> /// <param name="toDriverBuffer"> Injected RingBuffer. </param> /// <returns> this Aeron.Context for method chaining. </returns> public Context ToDriverBuffer(IRingBuffer toDriverBuffer) { _toDriverBuffer = toDriverBuffer; return this; }
//* Construct a {@link IConsumer} that simply tracks a {@link RingBuffer}. public NoOpConsumer(IRingBuffer ringBuffer) { _ringBuffer = ringBuffer; }
public Pipeline3StepLatencyPerfTest() { InitHistogram(); InitStopwatchTimeCostNs(); ringBuffer = new RingBuffer<ValueEntry>(new ValueEntryFactory(), SIZE, new SingleThreadedStrategy(), new BusySpinStrategy<ValueEntry>()); stepOneConsumerBarrier = ringBuffer.CreateConsumerBarrier(); stepOneFunctionHandler = new LatencyStepHandler(FunctionStep.ONE, _histogram, _stopwatchTimeCostNs, _stopwatch); stepOneBatchConsumer = new BatchConsumer<ValueEntry>(stepOneConsumerBarrier, stepOneFunctionHandler); stepTwoConsumerBarrier = ringBuffer.CreateConsumerBarrier(stepOneBatchConsumer); stepTwoFunctionHandler = new LatencyStepHandler(FunctionStep.TWO, _histogram, _stopwatchTimeCostNs, _stopwatch); stepTwoBatchConsumer = new BatchConsumer<ValueEntry>(stepTwoConsumerBarrier, stepTwoFunctionHandler); stepThreeConsumerBarrier = ringBuffer.CreateConsumerBarrier(stepTwoBatchConsumer); stepThreeFunctionHandler = new LatencyStepHandler(FunctionStep.THREE, _histogram, _stopwatchTimeCostNs, _stopwatch); stepThreeBatchConsumer = new BatchConsumer<ValueEntry>(stepThreeConsumerBarrier, stepThreeFunctionHandler); producerBarrier = ringBuffer.CreateProducerBarrier(stepThreeBatchConsumer); stepOneQueue = new BlockingCollection<long>(SIZE); stepTwoQueue = new BlockingCollection<long>(SIZE); stepThreeQueue = new BlockingCollection<long>(SIZE); stepOneQueueConsumer = new LatencyStepQueueConsumer( FunctionStep.ONE, stepOneQueue, stepTwoQueue, _histogram, _stopwatchTimeCostNs, _stopwatch); stepTwoQueueConsumer = new LatencyStepQueueConsumer( FunctionStep.TWO, stepTwoQueue, stepThreeQueue, _histogram, _stopwatchTimeCostNs, _stopwatch); stepThreeQueueConsumer = new LatencyStepQueueConsumer( FunctionStep.THREE, stepThreeQueue, null, _histogram, _stopwatchTimeCostNs, _stopwatch); }
public void WaitForCursor(long sequence, IRingBuffer ringBuffer) { // no op for this class }