private int AwaitRecoveryCounter(CountersReader counters) { idleStrategy.Reset(); int counterId = RecoveryState.FindCounterId(counters); while (CountersReader.NULL_COUNTER_ID == counterId) { CheckInterruptedStatus(); idleStrategy.Idle(); counterId = RecoveryState.FindCounterId(counters); } return(counterId); }
public void MarkSnapshot( long snapshotTypeId, long logPosition, long leadershipTermId, int snapshotIndex, SnapshotMark snapshotMark, ClusterTimeUnit timeUnit, int appVersion) { idleStrategy.Reset(); while (true) { long result = publication.TryClaim(ENCODED_MARKER_LENGTH, bufferClaim); if (result > 0) { snapshotMarkerEncoder .WrapAndApplyHeader(bufferClaim.Buffer, bufferClaim.Offset, messageHeaderEncoder) .TypeId(snapshotTypeId) .LogPosition(logPosition) .LeadershipTermId(leadershipTermId) .Index(snapshotIndex) .Mark(snapshotMark) .TimeUnit(timeUnit) .AppVersion(appVersion); bufferClaim.Commit(); break; } CheckResultAndIdle(result); } }
private void AwaitActiveLog() { idleStrategy.Reset(); while (null == _activeLogEvent) { _serviceAdapter.Poll(); CheckInterruptedStatus(); idleStrategy.Idle(); } }
public static void PingHandler(Publication pongPublication, UnsafeBuffer buffer, int offset, int length) { if (pongPublication.Offer(buffer, offset, length) > 0L) { return; } PingHandlerIdleStrategy.Reset(); while (pongPublication.Offer(buffer, offset, length) < 0L) { PingHandlerIdleStrategy.Idle(); } }
private bool Offer(int length) { retryIdleStrategy.Reset(); int attempts = retryAttempts; while (true) { long result; if ((result = publication.Offer(buffer, 0, MessageHeaderEncoder.ENCODED_LENGTH + length)) > 0) { return(true); } if (result == Publication.CLOSED) { throw new System.InvalidOperationException("connection to the archive has been closed"); } if (result == Publication.NOT_CONNECTED) { throw new System.InvalidOperationException("connection to the archive is no longer available"); } if (result == Publication.MAX_POSITION_EXCEEDED) { throw new System.InvalidOperationException("publication failed due to max position being reached"); } if (--attempts <= 0) { return(false); } retryIdleStrategy.Idle(); } }
private void AwaitResponse(long correlationId) { _driverException = null; var nowNs = _nanoClock.NanoTime(); var deadlineNs = nowNs + _driverTimeoutNs; CheckTimeouts(nowNs); _awaitingIdleStrategy.Reset(); do { if (null == _driverAgentInvoker) { _awaitingIdleStrategy.Idle(); } else { _driverAgentInvoker.Invoke(); } Service(correlationId); if (_driverEventsAdapter.ReceivedCorrelationId == correlationId) { _stashedChannel = null; RegistrationException ex = _driverException; if (null != _driverException) { _driverException = null; throw ex; } return; } try { Thread.Sleep(1); } catch (ThreadInterruptedException) { _isTerminating = true; throw new AgentTerminationException("thread interrupted"); } } while (deadlineNs - _nanoClock.NanoTime() > 0); throw new DriverTimeoutException("no response from MediaDriver within (ms):" + _driverTimeoutMs); }
private static void RoundTripMessages(UnsafeBuffer buffer, IFragmentHandler fragmentHandler, Publication publication, Subscription subscription, int count) { for (var i = 0; i < count; i++) { do { buffer.PutLong(0, Stopwatch.GetTimestamp()); } while (publication.Offer(buffer, 0, MessageLength) < 0L); PollingIdleStrategy.Reset(); while (subscription.Poll(fragmentHandler, FragmentCountLimit) <= 0) { PollingIdleStrategy.Idle(); } } }
private static void Publish <T>(T message, Publication publication, IIdleStrategy offerIdleStrategy, IMutableDirectBuffer buffer) { var serTm = Util.Serialize(message); var length = serTm.Length; buffer.PutBytes(0, serTm); offerIdleStrategy.Reset(); while (!Offer(publication, buffer, length)) { // The offer failed, which is usually due to the publication // being temporarily blocked. Retry the offer after a short // spin/yield/sleep, depending on the chosen IdleStrategy. //backPressureCount++; offerIdleStrategy.Idle(); } //reporter.OnMessage(1, length); }
public static void Main() { if (MessageLength < BitUtil.SIZE_OF_LONG) { throw new ArgumentException($"Message length must be at least {BitUtil.SIZE_OF_LONG:D} bytes"); } ComputerSpecifications.Dump(); var context = new Aeron.Context(); var reporter = new RateReporter(1000, PrintRate); _reporterThread = new Thread(_ => reporter.Run()); _reporterThread.Start(); // Connect to media driver and add publication to send messages on the configured channel and stream ID. // The Aeron and Publication classes implement AutoCloseable, and will automatically // clean up resources when this try block is finished. using (var aeron = Aeron.Connect(context)) using (var publication = aeron.AddPublication(Channel, StreamID)) using (var byteBuffer = BufferUtil.AllocateDirectAligned(MessageLength, BitUtil.CACHE_LINE_LENGTH)) using (var buffer = new UnsafeBuffer(byteBuffer)) { do { _printingActive = true; Console.WriteLine($"Streaming {NumberOfMessages} messages of {(RandomMessageLength ? " random" : "")} size {MessageLength} bytes to {Channel} on stream Id {StreamID}"); long backPressureCount = 0; for (long i = 0; i < NumberOfMessages; i++) { var length = LengthGenerator.AsInt; buffer.PutLong(0, i); OfferIdleStrategy.Reset(); while (publication.Offer(buffer, 0, length) < 0L) { // The offer failed, which is usually due to the publication // being temporarily blocked. Retry the offer after a short // spin/yield/sleep, depending on the chosen IdleStrategy. backPressureCount++; OfferIdleStrategy.Idle(); } reporter.OnMessage(1, length); } Console.WriteLine("Done streaming. Back pressure ratio " + (double)backPressureCount / NumberOfMessages); if (0 < LingerTimeoutMs) { Console.WriteLine("Lingering for " + LingerTimeoutMs + " milliseconds..."); Thread.Sleep((int)LingerTimeoutMs); } _printingActive = false; Console.WriteLine("Execute again?"); } while (Console.ReadLine() == "y"); } reporter.Halt(); _reporterThread.Join(); }