/// <summary>
/// Map a position over a buffer and this indicator owns the counter for reclamation.
/// </summary>
/// <param name="buffer"> containing the counter. </param>
/// <param name="counterId"> identifier of the counter. </param>
/// <param name="countersManager"> to be used for freeing the counter when this is closed. </param>
public UnsafeBufferPosition(UnsafeBuffer buffer, int counterId, CountersManager countersManager)
{
_buffer = buffer;
_counterId = counterId;
_countersManager = countersManager;
_offset = CountersReader.CounterOffset(counterId);
}
public void WhenAllocatedAndDisposed_ShouldFreeMemory()
{
using (var buffer = new UnsafeBuffer(short.MaxValue + 1))
{
GC.KeepAlive(buffer);
}
}
public static void Main()
{
const string channel = "aeron:ipc";
const int streamId = 42;
var buffer = new UnsafeBuffer(new byte[256]);
try
{
using (var aeron = Aeron.Connect())
using (var publisher = aeron.AddPublication(channel, streamId))
using (var subscriber = aeron.AddSubscription(channel, streamId))
{
var message = buffer.PutStringWithoutLengthUtf8(0, "Hello World!");
publisher.Offer(buffer, 0, message);
Console.WriteLine("Message sent...");
while (subscriber.Poll(PrintMessage, 1) == 0)
{
Thread.Sleep(10);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
}
public SingleThreadSegmentPool(int segmentCount)
{
if (segmentCount < 1024)
{
throw new ArgumentException($"SegmentCount must be at least {MinimalSegmentCount}", nameof(segmentCount));
}
var segmentStructureOverhead = segmentCount*Segment.Size;
var segmentData = segmentCount*SegmentSize;
_buffer = new UnsafeBuffer(segmentData + segmentStructureOverhead);
var segments = (Segment*) _buffer.RawBytes;
var data = _buffer.RawBytes + segmentStructureOverhead;
for (var i = 0; i < segmentCount; i++)
{
var s = segments + i;
var buffer = data + i*SegmentSize;
var segment = new Segment(buffer, SegmentSize);
// copy to the memory pointed by s
Native.MemcpyUnmanaged((byte*) s, (byte*) &segment, Segment.Size);
Push(s);
}
}
internal Publication(ClientConductor clientConductor, string channel, int streamId, int sessionId, IReadablePosition positionLimit, LogBuffers logBuffers, long registrationId)
{
var buffers = logBuffers.AtomicBuffers();
var logMetaDataBuffer = buffers[LogBufferDescriptor.LOG_META_DATA_SECTION_INDEX];
for (var i = 0; i < LogBufferDescriptor.PARTITION_COUNT; i++)
{
_termAppenders[i] = new TermAppender(buffers[i], buffers[i + LogBufferDescriptor.PARTITION_COUNT]);
}
var termLength = logBuffers.TermLength();
_maxPayloadLength = LogBufferDescriptor.MtuLength(logMetaDataBuffer) - DataHeaderFlyweight.HEADER_LENGTH;
MaxMessageLength = FrameDescriptor.ComputeMaxMessageLength(termLength);
_clientConductor = clientConductor;
Channel = channel;
StreamId = streamId;
SessionId = sessionId;
InitialTermId = LogBufferDescriptor.InitialTermId(logMetaDataBuffer);
_logMetaDataBuffer = logMetaDataBuffer;
RegistrationId = registrationId;
_positionLimit = positionLimit;
_logBuffers = logBuffers;
_positionBitsToShift = IntUtil.NumberOfTrailingZeros(termLength);
_headerWriter = new HeaderWriter(LogBufferDescriptor.DefaultFrameHeader(logMetaDataBuffer));
}
private void ProcessSquelch(float* audio, int length)
{
if (_squelchThreshold > 0)
{
if (_hissBuffer == null || _hissBuffer.Length != length)
{
_hissBuffer = UnsafeBuffer.Create(length, sizeof(float));
_hissPtr = (float*) _hissBuffer;
}
Utils.Memcpy(_hissPtr, audio, length * sizeof(float));
_hissFilter.Process(_hissPtr, length);
for (var i = 0; i < _hissBuffer.Length; i++)
{
var n = (1 - _noiseAveragingRatio) * _noiseLevel + _noiseAveragingRatio * Math.Abs(_hissPtr[i]);
if (!float.IsNaN(n))
{
_noiseLevel = n;
}
if (_noiseLevel > _noiseThreshold)
{
audio[i] = 0.0f;
}
}
_isSquelchOpen = _noiseLevel < _noiseThreshold;
}
else
{
_isSquelchOpen = true;
}
}
public unsafe ComplexFilter(Complex[] kernel)
: base(ComplexFilter.GetFFTSize(kernel.Length))
{
this._kernelBuffer = UnsafeBuffer.Create(this.FFTSize, sizeof (Complex));
this._kernelPtr = (Complex*) (void*) this._kernelBuffer;
this.SetKernel(kernel);
}
static Trig()
{
_mask = ~(-1 << ResolutionInBits);
var sampleCount = _mask + 1;
_sinBuffer = UnsafeBuffer.Create(sampleCount, sizeof(float));
_cosBuffer = UnsafeBuffer.Create(sampleCount, sizeof(float));
_sinPtr = (float*) _sinBuffer;
_cosPtr = (float*) _cosBuffer;
const float twoPi = (float) (Math.PI * 2.0);
const float pi2 = (float) (Math.PI / 2.0);
_indexScale = sampleCount / twoPi;
for (var i = 0; i < sampleCount; i++)
{
_sinPtr[i] = (float) Math.Sin((i + 0.5f) / sampleCount * twoPi);
_cosPtr[i] = (float) Math.Cos((i + 0.5f) / sampleCount * twoPi);
}
for (var angle = 0.0f; angle < twoPi; angle += pi2)
{
_sinPtr[(int) (angle * _indexScale) & _mask] = (float) Math.Sin(angle);
_cosPtr[(int) (angle * _indexScale) & _mask] = (float) Math.Cos(angle);
}
}
public void Dispose()
{
_coeffBuffer = null;
_queueBuffer = null;
_coeffPtr = null;
_queuePtr = null;
GC.SuppressFinalize(this);
}
public unsafe void Dispose()
{
this._coeffBuffer = (UnsafeBuffer) null;
this._queueBuffer = (UnsafeBuffer) null;
this._coeffPtr = (float*) null;
this._queuePtr = (float*) null;
GC.SuppressFinalize((object) this);
}
public unsafe NoiseFilter(int fftSize = 4096)
: base(fftSize)
{
this._gainBuffer1 = UnsafeBuffer.Create(fftSize, 4);
this._gainPtr1 = (float*) (void*) this._gainBuffer1;
this._gainBuffer2 = UnsafeBuffer.Create(fftSize, 4);
this._gainPtr2 = (float*) (void*) this._gainBuffer2;
}
public void Setup()
{
_consumer = A.Fake<IntObjConsumer<string>>();
_metaData = A.Fake<CountersReader.MetaData>();
_labelsBuffer = new UnsafeBuffer(new byte[NumberOfCounters*CountersReader.METADATA_LENGTH]);
_counterBuffer = new UnsafeBuffer(new byte[NumberOfCounters*CountersReader.COUNTER_LENGTH]);
_manager = new CountersManager(_labelsBuffer, _counterBuffer);
_otherManager = new CountersManager(_labelsBuffer, _counterBuffer);
}
public RdsDecoder()
{
_pllBuffer = UnsafeBuffer.Create(sizeof(Pll));
_pll = (Pll*) _pllBuffer;
_oscBuffer = UnsafeBuffer.Create(sizeof(Oscillator));
_osc = (Oscillator*) _oscBuffer;
_syncFilterBuffer = UnsafeBuffer.Create(sizeof(IirFilter));
_syncFilter = (IirFilter*) _syncFilterBuffer;
}
public unsafe RdsDecoder()
{
this._pllBuffer = UnsafeBuffer.Create(sizeof (Pll));
this._pll = (Pll*) (void*) this._pllBuffer;
this._oscBuffer = UnsafeBuffer.Create(sizeof (Oscillator));
this._osc = (Oscillator*) (void*) this._oscBuffer;
this._syncFilterBuffer = UnsafeBuffer.Create(sizeof (IirFilter));
this._syncFilter = (IirFilter*) (void*) this._syncFilterBuffer;
this._bitDecoder = new RdsDetectorBank();
this._bitDecoder.FrameAvailable += new RdsFrameAvailableDelegate(this.FrameAvailableHandler);
}
public NoiseFilter(int fftSize)
: base(fftSize)
{
_gainBuffer = UnsafeBuffer.Create(fftSize, sizeof(float));
_gainPtr = (float*) _gainBuffer;
_smoothedGainBuffer = UnsafeBuffer.Create(fftSize, sizeof(float));
_smoothedGainPtr = (float*) _smoothedGainBuffer;
_powerBuffer = UnsafeBuffer.Create(fftSize, sizeof(float));
_powerPtr = (float*) _powerBuffer;
}
public unsafe IQBalancer()
{
this._dcRemoverIBuffer = UnsafeBuffer.Create(sizeof (DcRemover));
this._dcRemoverI = (DcRemover*) (void*) this._dcRemoverIBuffer;
this._dcRemoverI->Init(1E-05f);
this._dcRemoverQBuffer = UnsafeBuffer.Create(sizeof (DcRemover));
this._dcRemoverQ = (DcRemover*) (void*) this._dcRemoverQBuffer;
this._dcRemoverQ->Init(1E-05f);
this._windowBuffer = UnsafeBuffer.Create((Array) FilterBuilder.MakeWindow(WindowType.Hamming, 1024));
this._windowPtr = (float*) (void*) this._windowBuffer;
this._isMultithreaded = Environment.ProcessorCount > 1;
}
public unsafe OverlapSaveProcessor(int fftSize)
{
this._fftSize = fftSize;
this._halfSize = this._fftSize / 2;
this._inputPos = this._halfSize;
this._queuepBuffer = UnsafeBuffer.Create(this._fftSize, sizeof (Complex));
this._queuePtr = (Complex*) (void*) this._queuepBuffer;
this._fftBuffer = UnsafeBuffer.Create(this._fftSize, sizeof (Complex));
this._fftPtr = (Complex*) (void*) this._fftBuffer;
this._outputBuffer = UnsafeBuffer.Create(this._halfSize, sizeof (Complex));
this._outputPtr = (Complex*) (void*) this._outputBuffer;
}
public virtual void ShouldPassThroughUnfragmentedMessage()
{
A.CallTo(() => header.Flags).Returns(FrameDescriptor.UNFRAGMENTED);
var srcBuffer = new UnsafeBuffer(new byte[128]);
const int offset = 8;
const int length = 32;
adapter.OnFragment(srcBuffer, offset, length, header);
A.CallTo(() => delegateFragmentHandler(srcBuffer, offset, length, header))
.MustHaveHappened(Repeated.Exactly.Once);
}
public IQBalancer()
{
_dcRemoverIBuffer = UnsafeBuffer.Create(sizeof(DcRemover));
_dcRemoverI = (DcRemover*) _dcRemoverIBuffer;
_dcRemoverI->Init(DcTimeConst);
_dcRemoverQBuffer = UnsafeBuffer.Create(sizeof(DcRemover));
_dcRemoverQ = (DcRemover*) _dcRemoverQBuffer;
_dcRemoverQ->Init(DcTimeConst);
var window = FilterBuilder.MakeWindow(WindowType.Hamming, FFTBins);
_windowBuffer = UnsafeBuffer.Create(window);
_windowPtr = (float*) _windowBuffer;
_isMultithreaded = Environment.ProcessorCount > 1;
}
private void ProcessMono(float* baseBand, float* interleavedStereo, int length)
{
#region Prepare buffer
if (_channelABuffer == null || _channelABuffer.Length != length)
{
_channelABuffer = UnsafeBuffer.Create(length, sizeof(float));
_channelAPtr = (float*)_channelABuffer;
}
#endregion
#region Decimate L+R
Utils.Memcpy(_channelAPtr, baseBand, length * sizeof(float));
_channelADecimator.Process(_channelAPtr, length);
#endregion
#region Filter L+R
length /= _audioDecimationFactor;
_channelAFilter.Process(_channelAPtr, length);
#endregion
#region Process deemphasis
for (var i = 0; i < length; i++)
{
_deemphasisAvgL += _deemphasisAlpha * (_channelAPtr[i] - _deemphasisAvgL);
_channelAPtr[i] = _deemphasisAvgL;
}
#endregion
#region Fill output buffer
for (var i = 0; i < length; i++)
{
var sample = _channelAPtr[i] * AudioGain;
interleavedStereo[i * 2] = sample;
interleavedStereo[i * 2 + 1] = sample;
}
#endregion
}
public void ShouldRejectWriteWhenInsufficientSpace()
{
const int length = 200;
const long head = 0L;
var tail = head + (Capacity - BitUtil.Align(length - RecordDescriptor.Alignment, RecordDescriptor.Alignment));
A.CallTo(() => _buffer.GetLongVolatile(HeadCounterIndex)).Returns(head);
A.CallTo(() => _buffer.GetLongVolatile(TailCounterIndex)).Returns(tail);
var srcBuffer = new UnsafeBuffer(new byte[1024]);
const int srcIndex = 0;
Assert.False(_ringBuffer.Write(MsgTypeID, srcBuffer, srcIndex, length));
A.CallTo(() => _buffer.PutInt(A<int>._, A<int>._)).MustNotHaveHappened();
A.CallTo(() => _buffer.CompareAndSetLong(A<int>._, A<long>._, A<long>._)).MustNotHaveHappened();
A.CallTo(() => _buffer.PutBytes(A<int>._, srcBuffer, A<int>._, A<int>._)).MustNotHaveHappened();
A.CallTo(() => _buffer.PutIntOrdered(A<int>._, A<int>._)).MustNotHaveHappened();
}
public static void Main()
{
var ctx = new Aeron.Context()
.AvailableImageHandler(AvailablePongImageHandler);
var fragmentAssembler = new FragmentAssembler(PongHandler);
Console.WriteLine("Publishing Ping at " + PingChannel + " on stream Id " + PingStreamID);
Console.WriteLine("Subscribing Pong at " + PongChannel + " on stream Id " + PongStreamID);
Console.WriteLine("Message length of " + MessageLength + " bytes");
using (var aeron = Aeron.Connect(ctx))
{
Console.WriteLine("Warming up... " + WarmupNumberOfIterations + " iterations of " + WarmupNumberOfMessages + " messages");
using (var publication = aeron.AddPublication(PingChannel, PingStreamID))
using (var subscription = aeron.AddSubscription(PongChannel, PongStreamID))
using (var byteBuffer = BufferUtil.AllocateDirectAligned(MessageLength, BitUtil.CACHE_LINE_LENGTH))
using (var atomicBuffer = new UnsafeBuffer(byteBuffer))
{
Latch.Wait();
for (var i = 0; i < WarmupNumberOfIterations; i++)
{
RoundTripMessages(atomicBuffer, fragmentAssembler.OnFragment, publication, subscription, WarmupNumberOfMessages);
}
Thread.Sleep(100);
do
{
Histogram.Reset();
Console.WriteLine("Pinging " + NumberOfMessages + " messages");
RoundTripMessages(atomicBuffer, fragmentAssembler.OnFragment, publication, subscription, NumberOfMessages);
Console.WriteLine("Histogram of RTT latencies in microseconds.");
Histogram.OutputPercentileDistribution(Console.Out, outputValueUnitScalingRatio: 1000);
} while (Console.Read() == 'y');
}
}
}
public Resampler(double inputSampleRate, double outputSampleRate, int taps)
{
DoubleToFraction(outputSampleRate / inputSampleRate, out _interpolationFactor, out _decimationFactor);
var filterLenght = (int) (500.0 / 32000 * inputSampleRate) / _interpolationFactor * _interpolationFactor;
_tapsPerPhase = filterLenght / _interpolationFactor;
_firKernelBuffer = UnsafeBuffer.Create(filterLenght, sizeof(float));
_firKernel = (float*) _firKernelBuffer;
var cutoff = Math.Min(inputSampleRate, outputSampleRate) * ProtectedPassband;
var kernel = FilterBuilder.MakeLowPassKernel(inputSampleRate * _interpolationFactor, filterLenght - 1, cutoff, WindowType.BlackmanHarris4);
fixed (float* ptr = kernel)
{
for (var i = 0; i < kernel.Length; i++)
{
ptr[i] *= _interpolationFactor;
}
Utils.Memcpy(_firKernel, ptr, filterLenght * sizeof(float));
}
_firQueueBuffer = UnsafeBuffer.Create(filterLenght, sizeof(float));
_firQueue = (float*) _firQueueBuffer;
}
static unsafe Trig()
{
int length = Trig._mask + 1;
Trig._sinBuffer = UnsafeBuffer.Create(length, 4);
Trig._cosBuffer = UnsafeBuffer.Create(length, 4);
Trig._sinPtr = (float*) (void*) Trig._sinBuffer;
Trig._cosPtr = (float*) (void*) Trig._cosBuffer;
Trig._indexScale = (float) length / 6.283185f;
for (int index = 0; index < length; ++index)
{
Trig._sinPtr[index] = (float) Math.Sin(((double) index + 0.5) / (double) length * 6.28318548202515);
Trig._cosPtr[index] = (float) Math.Cos(((double) index + 0.5) / (double) length * 6.28318548202515);
}
float num = 0.0f;
while ((double) num < 6.28318548202515)
{
Trig._sinPtr[(int) ((double) num * (double) Trig._indexScale) & Trig._mask] = (float) Math.Sin((double) num);
Trig._cosPtr[(int) ((double) num * (double) Trig._indexScale) & Trig._mask] = (float) Math.Cos((double) num);
num += 1.570796f;
}
}
public FftProcessor(int fftSize)
{
_fftSize = fftSize;
_halfSize = fftSize / 2;
_overlapSize = (int) Math.Ceiling(_fftSize * OverlapRatio);
_fftBufferPos = _halfSize;
_blendFactor = 1.0f / _overlapSize;
_fftBuffer = UnsafeBuffer.Create(fftSize, sizeof(Complex));
_fftBufferPtr = (Complex*)_fftBuffer;
_outOverlapBuffer = UnsafeBuffer.Create(_overlapSize, sizeof(float));
_outOverlapPtr = (float*) _outOverlapBuffer;
_overlapBuffer = UnsafeBuffer.Create(fftSize / 2, sizeof(float));
_overlapBufferPtr = (float*)_overlapBuffer;
_sampleBuffer = UnsafeBuffer.Create(fftSize, sizeof(float));
_sampleBufferPtr = (float*)_sampleBuffer;
_sampleBufferHead = _halfSize;
}
public void ShouldWriteToEmptyBuffer()
{
const int length = 8;
var recordLength = length + RecordDescriptor.HeaderLength;
var alignedRecordLength = BitUtil.Align(recordLength, RecordDescriptor.Alignment);
const long tail = 0L;
const long head = 0L;
A.CallTo(() => _buffer.GetLongVolatile(HeadCounterIndex)).Returns(head);
A.CallTo(() => _buffer.GetLongVolatile(TailCounterIndex)).Returns(tail);
A.CallTo(() => _buffer.CompareAndSetLong(TailCounterIndex, tail, tail + alignedRecordLength)).Returns(true);
var srcBuffer = new UnsafeBuffer(new byte[1024]);
const int srcIndex = 0;
Assert.True(_ringBuffer.Write(MsgTypeID, srcBuffer, srcIndex, length));
A.CallTo(() => _buffer.PutLongOrdered((int) tail, RecordDescriptor.MakeHeader(-recordLength, MsgTypeID))).MustHaveHappened()
.Then(A.CallTo(() => _buffer.PutBytes(RecordDescriptor.EncodedMsgOffset((int) tail), srcBuffer, srcIndex, length)).MustHaveHappened())
.Then(A.CallTo(() => _buffer.PutIntOrdered(RecordDescriptor.LengthOffset((int) tail), recordLength)).MustHaveHappened());
}
public unsafe Resampler(double inputSampleRate, double outputSampleRate, int tapsPerPhase = 160, double protectedPassband = 0.45)
{
Resampler.DoubleToFraction(outputSampleRate / inputSampleRate, out this._interpolationFactor, out this._decimationFactor);
this._tapsPerPhase = tapsPerPhase;
int length = tapsPerPhase * this._interpolationFactor;
this._firKernelBuffer = UnsafeBuffer.Create(length, 4);
this._firKernel = (float*) (void*) this._firKernelBuffer;
double cutoffFrequency = Math.Min(inputSampleRate, outputSampleRate) * protectedPassband;
float[] numArray = FilterBuilder.MakeLowPassKernel(inputSampleRate * (double) this._interpolationFactor, length - 1, cutoffFrequency, WindowType.BlackmanHarris4);
fixed (float* numPtr = numArray)
{
for (int index = 0; index < numArray.Length; ++index)
{
IntPtr num1 = (IntPtr) (numPtr + index);
double num2 = (double) *(float*) num1 * (double) this._interpolationFactor;
*(float*) num1 = (float) num2;
}
Utils.Memcpy((void*) this._firKernel, (void*) numPtr, length * 4);
}
this._firQueueBuffer = UnsafeBuffer.Create(length, 4);
this._firQueue = (float*) (void*) this._firQueueBuffer;
}
public unsafe OverlapAddProcessor(int fftSize)
{
this._fftSize = fftSize;
this._halfSize = this._fftSize / 2;
this._inputPos = this._halfSize;
this._queuepBuffer = UnsafeBuffer.Create(this._fftSize, sizeof (Complex));
this._queuePtr = (Complex*) (void*) this._queuepBuffer;
this._windowBuffer = UnsafeBuffer.Create(this._fftSize, 4);
this._windowPtr = (float*) (void*) this._windowBuffer;
this._fftBuffer = UnsafeBuffer.Create(this._fftSize, sizeof (Complex));
this._fftPtr = (Complex*) (void*) this._fftBuffer;
this._outputBuffer = UnsafeBuffer.Create(this._halfSize, sizeof (Complex));
this._outputPtr = (Complex*) (void*) this._outputBuffer;
this._overlapBuffer = UnsafeBuffer.Create(this._halfSize, sizeof (Complex));
this._overlapPtr = (Complex*) (void*) this._overlapBuffer;
double num = Math.PI / 2.0 / (double) (this._halfSize - 1);
for (int index = 0; index < this._halfSize; ++index)
{
double a = (double) index * num;
this._windowPtr[index] = (float) Math.Sin(a);
this._windowPtr[this._fftSize - 1 - index] = this._windowPtr[index];
}
}
/**
* Extracts image pixels into byte array "pixels"
*/
protected unsafe void GetImagePixels()
{
int w = image.Width;
int h = image.Height;
// int type = image.GetType().;
if (w != width ||
h != height
)
{
// create new image with right size/format
Image temp =
new Bitmap(width, height);
Graphics g = Graphics.FromImage(temp);
g.DrawImage(image, 0, 0);
image = temp;
g.Dispose();
}
pixels = new UnsafeBuffer(3 * image.Width * image.Height);
byte * addr = (byte *)pixels.Address;
Bitmap tempBitmap = new Bitmap(image);
for (int th = 0; th < image.Height; th++)
{
for (int tw = 0; tw < image.Width; tw++)
{
Color color = tempBitmap.GetPixel(tw, th);
* addr++ = color.R;
* addr++ = color.G;
* addr++ = color.B;
}
}
//pixels = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
}
public void SetUp()
{
_sendBuffer = new byte[SendBufferCapacity];
_atomicSendBuffer = new UnsafeBuffer(_sendBuffer);
_logMetaDataBuffer = new UnsafeBuffer(new byte[LogBufferDescriptor.LOG_META_DATA_LENGTH]);
_termBuffers = new UnsafeBuffer[LogBufferDescriptor.PARTITION_COUNT];
_termMetaDataBuffers = new UnsafeBuffer[LogBufferDescriptor.PARTITION_COUNT];
_buffers = new UnsafeBuffer[LogBufferDescriptor.PARTITION_COUNT * 2 + 1];
_conductor = A.Fake <ClientConductor>();
_logBuffers = A.Fake <LogBuffers>();
_publicationLimit = A.Fake <IReadablePosition>();
A.CallTo(() => _publicationLimit.Volatile).Returns(2 * SendBufferCapacity);
A.CallTo(() => _logBuffers.AtomicBuffers()).Returns(_buffers);
A.CallTo(() => _logBuffers.TermLength()).Returns(LogBufferDescriptor.TERM_MIN_LENGTH);
LogBufferDescriptor.InitialTermId(_logMetaDataBuffer, TermID1);
LogBufferDescriptor.TimeOfLastStatusMessage(_logMetaDataBuffer, 0);
for (var i = 0; i < LogBufferDescriptor.PARTITION_COUNT; i++)
{
_termBuffers[i] = new UnsafeBuffer(new byte[LogBufferDescriptor.TERM_MIN_LENGTH]);
_termMetaDataBuffers[i] = new UnsafeBuffer(new byte[LogBufferDescriptor.TERM_META_DATA_LENGTH]);
_buffers[i] = _termBuffers[i];
_buffers[i + LogBufferDescriptor.PARTITION_COUNT] = _termMetaDataBuffers[i];
}
_buffers[LogBufferDescriptor.LOG_META_DATA_SECTION_INDEX] = _logMetaDataBuffer;
_publication = new Publication(_conductor, Channel, StreamID1, SessionID1, _publicationLimit, _logBuffers, CorrelationID);
_publication.IncRef();
LogBufferDescriptor.InitialiseTailWithTermId(_termMetaDataBuffers[0], TermID1);
}
public static void RemoveAt(UnsafeList *list, int index)
{
UDebug.Assert(list != null);
UDebug.Assert(list->_items.Ptr != null);
var count = list->_count;
// cast to uint trick, which eliminates < 0 check
if ((uint)index >= (uint)count)
{
throw new IndexOutOfRangeException(ThrowHelper.ArgumentOutOfRange_Index);
}
// reduce count
list->_count = --count;
// if index is still less than count, it means we removed an item
// not at the end of the list, and that we have to shift the items
// down from (index+1, count-index) to (index, count-index)
if (index < count)
{
UnsafeBuffer.Move(list->_items, index + 1, index, count - index);
}
}
public static bool IsActive(MappedByteBuffer cncByteBuffer, IEpochClock epochClock, long timeoutMs,
int versionFieldOffset, int timestampFieldOffset, Action <int> versionCheck, Action <string> logger)
{
if (null == cncByteBuffer)
{
return(false);
}
UnsafeBuffer cncBuffer = new UnsafeBuffer(cncByteBuffer);
long startTimeMs = epochClock.Time();
int cncVersion;
while (0 == (cncVersion = cncBuffer.GetIntVolatile(versionFieldOffset)))
{
if (epochClock.Time() > (startTimeMs + timeoutMs))
{
throw new System.InvalidOperationException("CnC file is created but not initialised.");
}
Sleep(1);
}
versionCheck(cncVersion);
long timestamp = cncBuffer.GetLongVolatile(timestampFieldOffset);
long now = epochClock.Time();
long timestampAge = now - timestamp;
if (null != logger)
{
logger("INFO: heartbeat is (ms): " + timestampAge);
}
return(timestampAge <= timeoutMs);
}
public ClusterMarkFile(DirectoryInfo directory, string filename, IEpochClock epochClock, long timeoutMs,
Action <string> logger)
{
markFile = new MarkFile(
directory,
filename,
MarkFileHeaderDecoder.VersionEncodingOffset(),
MarkFileHeaderDecoder.ActivityTimestampEncodingOffset(),
timeoutMs,
epochClock,
(version) =>
{
if (SemanticVersion.Major(version) != MAJOR_VERSION)
{
throw new ClusterException("mark file major version " + SemanticVersion.Major(version) +
" does not match software:" + AeronCluster.Configuration.PROTOCOL_MAJOR_VERSION);
}
},
logger);
buffer = markFile.Buffer();
headerDecoder.Wrap(buffer, 0, MarkFileHeaderDecoder.BLOCK_LENGTH, MarkFileHeaderDecoder.SCHEMA_VERSION);
errorBuffer = new UnsafeBuffer(buffer, headerDecoder.HeaderLength(), headerDecoder.ErrorBufferLength());
}
public STDTNode(VoidPtr address, int numEntries)
{
version = 1;
unk1 = 0;
unk2 = 0;
entries = new UnsafeBuffer((numEntries * 4));
if (address == null)
{
byte *pOut = (byte *)entries.Address;
for (int i = 0; i < (numEntries * 4); i++)
{
*pOut++ = 0;
}
}
else
{
byte *pIn = (byte *)address;
byte *pOut = (byte *)entries.Address;
for (int i = 0; i < (numEntries * 4); i++)
{
*pOut++ = *pIn++;
}
}
}
int _slotOffset; // Readonly
/// <summary>
/// Allocates a new SPSCRingbuffer. Capacity will be set to a power of 2.
/// </summary>
public static UnsafeMPSCQueue *Allocate <T>(int capacity) where T : unmanaged
{
if (capacity < 1)
{
throw new ArgumentOutOfRangeException(nameof(capacity), string.Format(ThrowHelper.ArgumentOutOfRange_MustBePositive, nameof(capacity)));
}
capacity = Memory.RoundUpToPowerOf2(capacity);
// Required to get the memory size of the Slot + Value
int slotStride = Marshal.SizeOf(new QueueSlot <T>());
int slotAlign = Memory.GetMaxAlignment(sizeof(T), sizeof(int));
int slotOffset = Memory.RoundToAlignment(sizeof(T), slotAlign);
int alignment = Memory.GetAlignment(slotStride);
var sizeOfQueue = Memory.RoundToAlignment(sizeof(UnsafeMPSCQueue), alignment);
var sizeOfArray = slotStride * capacity;
var ptr = Memory.MallocAndZero(sizeOfQueue + sizeOfArray, alignment);
UnsafeMPSCQueue *queue = (UnsafeMPSCQueue *)ptr;
// initialize fixed buffer from same block of memory as the stack
UnsafeBuffer.InitFixed(&queue->_items, (byte *)ptr + sizeOfQueue, capacity, slotStride);
// Read-only values
queue->_mask = capacity - 1;
queue->_slotOffset = slotOffset;
queue->_typeHandle = typeof(T).TypeHandle.Value;
// Reset the queue for use.
Clear(queue);
return(queue);
}
/**
* Flushes any pending data and closes output file.
* If writing to an OutputStream, the stream is not
* closed.
*/
public bool Finish()
{
if (!started)
{
return(false);
}
bool ok = true;
started = false;
try
{
fs.WriteByte(0x3b); // gif trailer
fs.Flush();
if (closeStream)
{
fs.Close();
}
}
catch (IOException)
{
ok = false;
}
// reset for subsequent use
transIndex = 0;
fs = null;
image = null;
pixels = null;
indexedPixels = null;
colorTab = null;
closeStream = false;
firstFrame = true;
return(ok);
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializedObjectReader"/> class based on the specified input stream, output stream and configuration.
/// </summary>
/// <param name="input">The input stream.</param>
/// <param name="output">The output stream.</param>
/// <param name="configuration">The configuration parameters to use for the reader.</param>
/// <param name="label">The memory allocator label to use.</param>
/// <param name="leaveInputOpen">True to leave the input stream open after the reader object is disposed; otherwise, false.</param>
/// <param name="leaveOutputOpen">True to leave the output stream open after the reader object is disposed; otherwise, false.</param>
/// <exception cref="ArgumentException">The configuration is invalid.</exception>
public SerializedObjectReader(Stream input, PackedBinaryStream output, SerializedObjectReaderConfiguration configuration, Allocator label = SerializationConfiguration.DefaultAllocatorLabel, bool leaveInputOpen = true, bool leaveOutputOpen = true)
{
if (configuration.BlockBufferSize < 16)
{
throw new ArgumentException("BlockBufferSize < 16");
}
if (configuration.TokenBufferSize < 16)
{
throw new ArgumentException("TokenBufferSize < 16");
}
m_LeaveOutputOpen = leaveOutputOpen;
m_StreamBlockReader = configuration.UseReadAsync
? (IUnsafeStreamBlockReader) new AsyncBlockReader(input, configuration.BlockBufferSize, leaveInputOpen)
: (IUnsafeStreamBlockReader) new SyncBlockReader(input, configuration.BlockBufferSize, leaveInputOpen);
m_Tokenizer = new JsonTokenizer(configuration.TokenBufferSize, configuration.ValidationType, label);
m_Parser = new NodeParser(m_Tokenizer, configuration.NodeBufferSize, label);
m_BinaryStream = output;
m_BinaryWriter = new PackedBinaryWriter(m_BinaryStream, m_Tokenizer, label);
m_Block = default;
}
public int AppendUnfragmentedMessage(HeaderWriter header, IDirectBuffer srcBuffer, int srcOffset, int length, ReservedValueSupplier reservedValueSupplier, int activeTermId)
#endif
{
int frameLength = length + DataHeaderFlyweight.HEADER_LENGTH;
int alignedLength = BitUtil.Align(frameLength, FrameDescriptor.FRAME_ALIGNMENT);
long rawTail = GetAndAddRawTail(alignedLength);
int termId = LogBufferDescriptor.TermId(rawTail);
long termOffset = rawTail & 0xFFFFFFFFL;
UnsafeBuffer termBuffer = _termBuffer;
int termLength = termBuffer.Capacity;
CheckTerm(activeTermId, termId);
long resultingOffset = termOffset + alignedLength;
if (resultingOffset > termLength)
{
resultingOffset = HandleEndOfLogCondition(termBuffer, termOffset, header, termLength, termId);
}
else
{
int frameOffset = (int)termOffset;
header.Write(termBuffer, frameOffset, frameLength, LogBufferDescriptor.TermId(rawTail));
termBuffer.PutBytes(frameOffset + DataHeaderFlyweight.HEADER_LENGTH, srcBuffer, srcOffset, length);
if (null != reservedValueSupplier)
{
long reservedValue = reservedValueSupplier(termBuffer, frameOffset, frameLength);
termBuffer.PutLong(frameOffset + DataHeaderFlyweight.RESERVED_VALUE_OFFSET, reservedValue, ByteOrder.LittleEndian);
}
FrameDescriptor.FrameLengthOrdered(termBuffer, frameOffset, frameLength);
}
return((int)resultingOffset);
}
public static UnsafeBuffer Decode(MDL0NormalData *header)
{
int count = header->_numVertices;
float scale = VQuant.DeQuantTable[header->_divisor]; //Should always be zero?
int type = (int)ElementCodec.CodecType.XYZ + header->_type;
ElementDecoder decoder = ElementCodec.Decoders[type];
UnsafeBuffer buffer;
if (header->_isNBT != 0)
{
count *= 3; //Format is the same, just with three Vectors each
}
buffer = new UnsafeBuffer(count * 12);
byte *pIn = (byte *)header->Data, pOut = (byte *)buffer.Address;
for (int i = 0; i < count; i++)
{
decoder(ref pIn, ref pOut, scale);
}
return(buffer);
}
public virtual void ShouldAssembleTwoPartMessage()
{
A.CallTo(() => header.Flags).ReturnsNextFromSequence(FrameDescriptor.BEGIN_FRAG_FLAG, FrameDescriptor.END_FRAG_FLAG, FrameDescriptor.END_FRAG_FLAG);
// Need to add this twice because FakeItEasy doesn't fall back to the implementation
var srcBuffer = new UnsafeBuffer(new byte[1024]);
const int offset = 0;
var length = srcBuffer.Capacity/2;
srcBuffer.SetMemory(0, length, 65);
srcBuffer.SetMemory(length, length, 66);
adapter.OnFragment(srcBuffer, offset, length, header);
adapter.OnFragment(srcBuffer, length, length, header);
Func<UnsafeBuffer, bool> bufferAssertion = capturedBuffer =>
{
for (var i = 0; i < srcBuffer.Capacity; i++)
{
if (capturedBuffer.GetByte(i) != srcBuffer.GetByte(i))
{
return false;
}
}
return true;
};
Func<Header, bool> headerAssertion = capturedHeader => capturedHeader.SessionId == SESSION_ID &&
capturedHeader.Flags == FrameDescriptor.END_FRAG_FLAG;
A.CallTo(() => delegateFragmentHandler(
A<UnsafeBuffer>.That.Matches(bufferAssertion, "buffer"),
offset,
length*2,
A<Header>.That.Matches(headerAssertion, "header")))
.MustHaveHappened(Repeated.Exactly.Once);
}
public TBGDNode(VoidPtr address, int numEntries)
{
unk0 = 39; // Default set in Smashville
unk1 = 0;
unk2 = 0;
entries = new UnsafeBuffer((numEntries * 4));
if (address == null)
{
byte *pOut = (byte *)entries.Address;
for (int i = 0; i < (numEntries * 4); i++)
{
*pOut++ = 0;
}
}
else
{
byte *pIn = (byte *)address;
byte *pOut = (byte *)entries.Address;
for (int i = 0; i < (numEntries * 4); i++)
{
*pOut++ = *pIn++;
}
}
}
public unsafe OverlapCrossfadeProcessor(int fftSize, float crossFadingRatio = 0.0f)
{
this._fftSize = fftSize;
this._halfSize = this._fftSize / 2;
this._crossFadingSize = (int) ((double) this._halfSize * (double) crossFadingRatio);
this._outputSize = this._halfSize - this._crossFadingSize;
this._inputPos = this._halfSize + this._crossFadingSize;
this._queuepBuffer = UnsafeBuffer.Create(this._fftSize, sizeof (Complex));
this._queuePtr = (Complex*) (void*) this._queuepBuffer;
this._windowBuffer = UnsafeBuffer.Create(this._crossFadingSize, 4);
this._windowPtr = (float*) (void*) this._windowBuffer;
this._fftBuffer = UnsafeBuffer.Create(this._fftSize, sizeof (Complex));
this._fftPtr = (Complex*) (void*) this._fftBuffer;
this._outputBuffer = UnsafeBuffer.Create(this._outputSize, sizeof (Complex));
this._outputPtr = (Complex*) (void*) this._outputBuffer;
this._crossFadingBuffer = UnsafeBuffer.Create(this._crossFadingSize, sizeof (Complex));
this._crossFadingPtr = (Complex*) (void*) this._crossFadingBuffer;
double num = Math.PI / 2.0 / (double) (this._crossFadingSize - 1);
for (int index = 0; index < this._crossFadingSize; ++index)
{
double a = (double) index * num;
this._windowPtr[index] = (float) Math.Pow(Math.Sin(a), 2.0);
}
}
public ElementDescriptor(MDL0Polygon *polygon)
{
MDL0Header *model = (MDL0Header *)((byte *)polygon + polygon->_mdl0Offset);
byte * pData = (byte *)polygon->DefList;
byte * pCom;
ElementDef *pDef;
int fmtLo, fmtHi;
int grp0, grp1, grp2;
int format;
//Create remap table for vertex weights
RemapTable = new UnsafeBuffer(polygon->_numVertices * 4);
RemapSize = 0;
Stride = 0;
//Read element descriptor from polygon display list
//Use direct access instead!
//May change depending on file version
fmtLo = *(bint *)(pData + 12);
fmtHi = *(bint *)(pData + 18);
grp0 = *(bint *)(pData + 34);
grp1 = *(bint *)(pData + 40);
grp2 = *(bint *)(pData + 46);
//grp1 = *(buint*)(pData + 40);
//grp1 |= (ulong)(*(buint*)(pData + 46)) << 32;
//Build extract script.
//What we're doing is assigning extract commands for elements in the polygon, in true order.
//This allows us to process the polygon blindly, assuming that the definition is accurate.
//Theoretically, this should offer a significant speed bonus.
fixed(int *pDefData = Defs)
fixed(byte *pComData = Commands)
{
pCom = pComData;
pDef = (ElementDef *)pDefData;
//Pos/Norm weight
if (Weighted = (fmtLo & 1) != 0)
{
*pCom++ = (byte)DecodeOp.PosWeight;
Stride++;
}
//Tex matrix
for (int i = 0; i < 8; i++)
{
if (((fmtLo >> (i + 1)) & 1) != 0)
{
*pCom++ = (byte)(DecodeOp.TexMtx0 + i);
Stride++;
}
}
//Positions
format = ((fmtLo >> 9) & 3) - 1;
if (format >= 0)
{
pDef->Input = (byte)format;
pDef->Type = 0;
if (format == 0)
{
throw new NotSupportedException("Direct mode is not suported for polygons!");
//pDef->Scale = (byte)((grp0 >> 4) & 0x1F);
//pDef->Output = (byte)(((grp0 >> 1) & 0x7) + ((grp0 & 1) == 0 ? ElementCodec.CodecType.XY : ElementCodec.CodecType.XYZ));
//pCom[NumCommands++] = (byte)DecodeOp.ElementDirect;
}
else
{
Stride += format;
pDef->Output = 12;
*pCom++ = (byte)DecodeOp.ElementIndexed;
}
pDef++;
}
//Normals
format = ((fmtLo >> 11) & 3) - 1;
if (format >= 0)
{
pDef->Input = (byte)format;
pDef->Type = 1;
if (format == 0)
{
throw new NotSupportedException("Direct mode is not suported for polygons!");
//pDef->Scale = 0; //Implied?
//pDef->Output = (byte)(((grp0 >> 10) & 0x7) + ((grp0 & (1 << 10)) == 0 ? ElementCodec.CodecType.XYZ : ElementCodec.CodecType.XYZ));
//pCom[NumCommands++] = (byte)DecodeOp.ElementDirect;
}
else
{
Stride += format;
pDef->Output = 12;
*pCom++ = (byte)DecodeOp.ElementIndexed;
}
pDef++;
}
//Colors
for (int i = 0; i < 2; i++)
{
format = ((fmtLo >> (i * 2 + 13)) & 3) - 1;
if (format >= 0)
{
pDef->Input = (byte)format;
pDef->Type = (byte)(i + 2);
if (format == 0)
{
throw new NotSupportedException("Direct mode is not suported for polygons!");
//pDef->Output = (byte)((grp0 >> (i * 4 + 14)) & 7);
//pCom[NumCommands++] = (byte)DecodeOp.ElementDirect;
}
else
{
Stride += format;
pDef->Output = 4;
*pCom++ = (byte)DecodeOp.ElementIndexed;
}
pDef++;
}
}
//UVs
for (int i = 0; i < 8; i++)
{
format = ((fmtHi >> (i * 2)) & 3) - 1;
if (format >= 0)
{
pDef->Input = (byte)format;
pDef->Type = (byte)(i + 4);
if (format == 0)
{
throw new NotSupportedException("Direct mode is not suported for polygons!");
//Needs work!
//if (i == 0)
//{
// pDef->Output = (byte)(((grp0 >> 22) & 7) + ((grp0 & 22) == 0 ? ElementCodec.CodecType.S : ElementCodec.CodecType.ST));
// pDef->Scale = (byte)((grp0 >> 25) & 0x1F);
//}
//else
//{
// pDef->Output = (byte)((int)((grp1 >> (i * 9 + 1)) & 7) + ((grp1 & ((ulong)1 << (i * 9 + 1))) == 0 ? ElementCodec.CodecType.S : ElementCodec.CodecType.ST));
// pDef->Scale = (byte)((grp1 >> (i * 9 + 4)) & 0x1F);
//}
//pCom[NumCommands++] = (byte)DecodeOp.ElementDirect;
}
else
{
Stride += format;
pDef->Output = 8;
*pCom++ = (byte)DecodeOp.ElementIndexed;
}
pDef++;
}
}
*pCom = 0;
}
}
private void PatchPointers()
{
_buffer?.Dispose();
//Make a copy of the file's data that we can patch with offsets
_buffer = new UnsafeBuffer(WorkingUncompressed.Length);
Memory.Move(_buffer.Address, WorkingUncompressed.Address, (uint)WorkingUncompressed.Length);
HKXHeader * header = (HKXHeader *)_buffer.Address;
PhysicsOffsetSection *section = header->OffsetSections;
for (int i = 0; i < header->_sectionCount; i++, section++)
{
int dataOffset = section->_dataOffset;
VoidPtr data = _buffer.Address + dataOffset;
int local = section->LocalPatchesLength, global = section->GlobalPatchesLength;
if (section->ExportsLength > 0)
{
Console.WriteLine("Has exports");
}
if (section->ImportsLength > 0)
{
Console.WriteLine("Has imports");
}
//Global patches have to be made before local ones
if (global > 0)
{
//Global patches set offsets from this section to data in another section (or this one)
VoidPtr start = data + section->_globalPatchesOffset;
GlobalPatch *patch = (GlobalPatch *)start;
while ((int)patch - (int)start < global && patch->_dataOffset >= 0 && patch->_pointerOffset >= 0)
{
//Make the pointer offset relative to itself so it's self-contained
int ptrOffset = patch->_pointerOffset;
bint *ptr = (bint *)(data + ptrOffset);
PhysicsOffsetSection *otherSection = &header->OffsetSections[patch->_sectionIndex];
int dOffset = patch->_dataOffset + otherSection->_dataOffset - dataOffset;
int offset = dOffset - ptrOffset;
* ptr = offset;
patch++;
}
}
if (local > 0)
{
//Local patches set offsets to data located elsewhere in this section
VoidPtr start = data + section->_localPatchesOffset;
LocalPatch *patch = (LocalPatch *)start;
while ((int)patch - (int)start < local && patch->_dataOffset >= 0)
{
//Make the pointer offset relative to itself so it's self-contained
int ptrOffset = patch->_pointerOffset;
bint *ptr = (bint *)(data + ptrOffset);
* ptr = patch->_dataOffset - ptrOffset;
patch++;
}
}
}
}
public int AppendFragmentedMessage(
int termId,
int termOffset,
HeaderWriter header,
DirectBufferVector[] vectors,
int length,
int maxPayloadLength,
ReservedValueSupplier reservedValueSupplier)
{
int numMaxPayloads = length / maxPayloadLength;
int remainingPayload = length % maxPayloadLength;
int lastFrameLength = remainingPayload > 0
? BitUtil.Align(remainingPayload + DataHeaderFlyweight.HEADER_LENGTH, FrameDescriptor.FRAME_ALIGNMENT)
: 0;
int requiredLength = (numMaxPayloads * (maxPayloadLength + DataHeaderFlyweight.HEADER_LENGTH)) +
lastFrameLength;
UnsafeBuffer termBuffer = _termBuffer;
int termLength = termBuffer.Capacity;
int resultingOffset = termOffset + requiredLength;
PutRawTailOrdered(termId, resultingOffset);
if (resultingOffset > termLength)
{
resultingOffset = HandleEndOfLogCondition(termBuffer, termOffset, header, termLength, termId);
}
else
{
int frameOffset = termOffset;
byte flags = FrameDescriptor.BEGIN_FRAG_FLAG;
int remaining = length;
int vectorIndex = 0;
int vectorOffset = 0;
do
{
int bytesToWrite = Math.Min(remaining, maxPayloadLength);
int frameLength = bytesToWrite + DataHeaderFlyweight.HEADER_LENGTH;
int alignedLength = BitUtil.Align(frameLength, FrameDescriptor.FRAME_ALIGNMENT);
header.Write(termBuffer, frameOffset, frameLength, termId);
int bytesWritten = 0;
int payloadOffset = frameOffset + DataHeaderFlyweight.HEADER_LENGTH;
do
{
var vector = vectors[vectorIndex];
int vectorRemaining = vector.length - vectorOffset;
int numBytes = Math.Min(bytesToWrite - bytesWritten, vectorRemaining);
termBuffer.PutBytes(payloadOffset, vector.buffer, vector.offset + vectorOffset, numBytes);
bytesWritten += numBytes;
payloadOffset += numBytes;
vectorOffset += numBytes;
if (vectorRemaining <= numBytes)
{
vectorIndex++;
vectorOffset = 0;
}
} while (bytesWritten < bytesToWrite);
if (remaining <= maxPayloadLength)
{
flags |= FrameDescriptor.END_FRAG_FLAG;
}
FrameDescriptor.FrameFlags(termBuffer, frameOffset, flags);
if (null != reservedValueSupplier)
{
long reservedValue = reservedValueSupplier(termBuffer, frameOffset, frameLength);
termBuffer.PutLong(frameOffset + DataHeaderFlyweight.RESERVED_VALUE_OFFSET, reservedValue, ByteOrder.LittleEndian);
}
FrameDescriptor.FrameLengthOrdered(termBuffer, frameOffset, frameLength);
flags = 0;
frameOffset += alignedLength;
remaining -= bytesToWrite;
} while (remaining > 0);
}
return(resultingOffset);
}
/// <summary>
/// Compare and set the raw value of the tail for the given partition.
/// </summary>
/// <param name="metaDataBuffer"> containing the tail counters. </param>
/// <param name="partitionIndex"> for the tail counter. </param>
/// <param name="expectedRawTail"> expected current value. </param>
/// <param name="updateRawTail"> to be applied. </param>
/// <returns> true if the update was successful otherwise false. </returns>
public static bool CasRawTail(UnsafeBuffer metaDataBuffer, int partitionIndex, long expectedRawTail, long updateRawTail)
{
var index = TERM_TAIL_COUNTERS_OFFSET + BitUtil.SIZE_OF_LONG * partitionIndex;
return(metaDataBuffer.CompareAndSetLong(index, expectedRawTail, updateRawTail));
}
public void SetUp()
{
MockClientErrorHandler = A.Fake <ErrorHandler>(options => options.Wrapping(throwable =>
{
if (!SuppressPrintError)
{
Console.WriteLine(throwable.ToString());
Console.Write(throwable.StackTrace);
}
}));
PublicationReady = new PublicationBuffersReadyFlyweight();
CorrelatedMessage = new CorrelatedMessageFlyweight();
ErrorResponse = new ErrorResponseFlyweight();
PublicationReadyBuffer = new UnsafeBuffer(new byte[SEND_BUFFER_CAPACITY]);
CorrelatedMessageBuffer = new UnsafeBuffer(new byte[SEND_BUFFER_CAPACITY]);
ErrorMessageBuffer = new UnsafeBuffer(new byte[SEND_BUFFER_CAPACITY]);
CounterValuesBuffer = new UnsafeBuffer(new byte[COUNTER_BUFFER_LENGTH]);
MockToClientReceiver = A.Fake <CopyBroadcastReceiver>();
MockAvailableImageHandler = A.Fake <AvailableImageHandler>();
MockUnavailableImageHandler = A.Fake <UnavailableImageHandler>();
LogBuffersFactory = A.Fake <ILogBuffersFactory>();
SubscriberPositionMap = new Dictionary <long, long>(); // should return -1 when element does not exist
DriverProxy = A.Fake <DriverProxy>();
A.CallTo(() => DriverProxy.AddPublication(CHANNEL, STREAM_ID_1)).Returns(CORRELATION_ID);
A.CallTo(() => DriverProxy.AddPublication(CHANNEL, STREAM_ID_2)).Returns(CORRELATION_ID_2);
A.CallTo(() => DriverProxy.RemovePublication(CORRELATION_ID)).Returns(CLOSE_CORRELATION_ID);
A.CallTo(() => DriverProxy.AddSubscription(A <string> ._, A <int> ._)).Returns(CORRELATION_ID);
A.CallTo(() => DriverProxy.RemoveSubscription(CORRELATION_ID)).Returns(CLOSE_CORRELATION_ID);
Conductor = new ClientConductor(EpochClock, NanoClock, MockToClientReceiver, LogBuffersFactory, CounterValuesBuffer, DriverProxy, MockClientErrorHandler, MockAvailableImageHandler, MockUnavailableImageHandler, MapMode.ReadOnly, KEEP_ALIVE_INTERVAL, AWAIT_TIMEOUT, NanoUtil.FromMilliseconds(INTER_SERVICE_TIMEOUT_MS), PUBLICATION_CONNECTION_TIMEOUT_MS);
PublicationReady.Wrap(PublicationReadyBuffer, 0);
CorrelatedMessage.Wrap(CorrelatedMessageBuffer, 0);
ErrorResponse.Wrap(ErrorMessageBuffer, 0);
PublicationReady.CorrelationId(CORRELATION_ID);
PublicationReady.SessionId(SESSION_ID_1);
PublicationReady.StreamId(STREAM_ID_1);
PublicationReady.LogFileName(SESSION_ID_1 + "-log");
SubscriberPositionMap.Add(CORRELATION_ID, 0);
CorrelatedMessage.CorrelationId(CLOSE_CORRELATION_ID);
var termBuffersSession1 = new UnsafeBuffer[LogBufferDescriptor.PARTITION_COUNT];
var termBuffersSession2 = new UnsafeBuffer[LogBufferDescriptor.PARTITION_COUNT];
for (var i = 0; i < LogBufferDescriptor.PARTITION_COUNT; i++)
{
termBuffersSession1[i] = new UnsafeBuffer(new byte[TERM_BUFFER_LENGTH]);
termBuffersSession2[i] = new UnsafeBuffer(new byte[TERM_BUFFER_LENGTH]);
}
UnsafeBuffer logMetaDataSession1 = new UnsafeBuffer(new byte[TERM_BUFFER_LENGTH]);
UnsafeBuffer logMetaDataSession2 = new UnsafeBuffer(new byte[TERM_BUFFER_LENGTH]);
IMutableDirectBuffer header1 = DataHeaderFlyweight.CreateDefaultHeader(SESSION_ID_1, STREAM_ID_1, 0);
IMutableDirectBuffer header2 = DataHeaderFlyweight.CreateDefaultHeader(SESSION_ID_2, STREAM_ID_2, 0);
LogBufferDescriptor.StoreDefaultFrameHeader(logMetaDataSession1, header1);
LogBufferDescriptor.StoreDefaultFrameHeader(logMetaDataSession2, header2);
var logBuffersSession1 = A.Fake <LogBuffers>();
var logBuffersSession2 = A.Fake <LogBuffers>();
A.CallTo(() => LogBuffersFactory.Map(SESSION_ID_1 + "-log", A <MapMode> ._)).Returns(logBuffersSession1);
A.CallTo(() => LogBuffersFactory.Map(SESSION_ID_2 + "-log", A <MapMode> ._)).Returns(logBuffersSession2);
A.CallTo(() => logBuffersSession1.TermBuffers()).Returns(termBuffersSession1);
A.CallTo(() => logBuffersSession2.TermBuffers()).Returns(termBuffersSession2);
A.CallTo(() => logBuffersSession1.MetaDataBuffer()).Returns(logMetaDataSession1);
A.CallTo(() => logBuffersSession2.MetaDataBuffer()).Returns(logMetaDataSession2);
}
/// <summary>
/// Set the value of the end of stream position.
/// </summary>
/// <param name="metaDataBuffer"> containing the metadata. </param>
/// <param name="position"> value of the end of stream position </param>
public static void EndOfStreamPosition(UnsafeBuffer metaDataBuffer, long position)
{
metaDataBuffer.PutLongOrdered(LOG_END_OF_STREAM_POSITION_OFFSET, position);
}
public static long RawTailVolatile(UnsafeBuffer metaDataBuffer)
{
var partitionIndex = IndexByTermCount(ActiveTermCount(metaDataBuffer));
return(metaDataBuffer.GetLongVolatile(TERM_TAIL_COUNTERS_OFFSET + BitUtil.SIZE_OF_LONG * partitionIndex));
}
public static void InitialiseTailWithTermId(UnsafeBuffer logMetaData, int partitionIndex, int termId)
{
logMetaData.PutLong(TERM_TAIL_COUNTERS_OFFSET + partitionIndex * BitUtil.SIZE_OF_LONG, PackTail(termId, 0));
}
/// <summary>
/// Set the raw value of the tail for the given partition.
/// </summary>
/// <param name="metaDataBuffer"> containing the tail counters. </param>
/// <param name="partitionIndex"> for the tail counter. </param>
/// <param name="rawTail"> to be stored </param>
public static void RawTailVolatile(UnsafeBuffer metaDataBuffer, int partitionIndex, long rawTail)
{
metaDataBuffer.PutLongVolatile(TERM_TAIL_COUNTERS_OFFSET + BitUtil.SIZE_OF_LONG * partitionIndex,
rawTail);
}
public static UnsafeBuffer DefaultFrameHeader(UnsafeBuffer metaDataBuffer)
{
return(new UnsafeBuffer(metaDataBuffer, LOG_DEFAULT_FRAME_HEADER_OFFSET,
DataHeaderFlyweight.HEADER_LENGTH));
}
public static void ApplyDefaultHeader(UnsafeBuffer metaDataBuffer, UnsafeBuffer termBuffer, int termOffset)
{
termBuffer.PutBytes(termOffset, metaDataBuffer, LOG_DEFAULT_FRAME_HEADER_OFFSET,
DataHeaderFlyweight.HEADER_LENGTH);
}
/// <summary>
/// Set the value of the current active partition index for the producer.
/// </summary>
/// <param name="metaDataBuffer"> containing the metadata. </param>
/// <param name="termCount"> value of the active term count used by the producer of this log. </param>
public static void ActiveTermCount(UnsafeBuffer metaDataBuffer, int termCount)
{
metaDataBuffer.PutInt(LOG_ACTIVE_TERM_COUNT_OFFSET, termCount);
}
/// <summary>
/// Compare and set the value of the current active term count.
/// </summary>
/// <param name="metaDataBuffer"> containing the metadata. </param>
/// <param name="expectedTermCount"> value of the active term count expected in the log </param>
/// <param name="updateTermCount"> value of the active term count to be updated in the log </param>
/// <returns> true if successful otherwise false. </returns>
public static bool CasActiveTermCount(UnsafeBuffer metaDataBuffer, int expectedTermCount, int updateTermCount)
{
return(metaDataBuffer.CompareAndSetInt(LOG_ACTIVE_TERM_COUNT_OFFSET, expectedTermCount, updateTermCount));
}
/// <summary>
/// Get the value of the active term count used by the producer of this log. Consumers may have a different
/// active term count if they are running behind. The read is done with volatile semantics.
/// </summary>
/// <param name="metaDataBuffer"> containing the metadata. </param>
/// <returns> the value of the active term count used by the producer of this log. </returns>
public static int ActiveTermCount(UnsafeBuffer metaDataBuffer)
{
return(metaDataBuffer.GetIntVolatile(LOG_ACTIVE_TERM_COUNT_OFFSET));
}
/// <summary>
/// Peek for new messages in a stream by scanning forward from an initial position. If new messages are found then
/// they will be delivered to the <seealso cref="IControlledFragmentHandler"/> up to a limited position.
///
/// Use a <seealso cref="ControlledFragmentAssembler"/> to assemble messages which span multiple fragments. Scans must also
/// start at the beginning of a message so that the assembler is reset.
///
/// </summary>
/// <param name="initialPosition"> from which to peek forward. </param>
/// <param name="handler"> to which message fragments are delivered. </param>
/// <param name="limitPosition"> up to which can be scanned. </param>
/// <returns> the resulting position after the scan terminates which is a complete message. </returns>
/// <seealso cref="ControlledFragmentAssembler"/>
/// <seealso cref="ImageControlledFragmentAssembler"/>
public long ControlledPeek(long initialPosition, IControlledFragmentHandler handler, long limitPosition)
{
if (_isClosed)
{
return(initialPosition);
}
ValidatePosition(initialPosition);
if (initialPosition >= limitPosition)
{
return(initialPosition);
}
int initialOffset = (int)initialPosition & _termLengthMask;
int offset = initialOffset;
long position = initialPosition;
UnsafeBuffer termBuffer = ActiveTermBuffer(initialPosition);
var header = _header;
int limitOffset = (int)Math.Min(termBuffer.Capacity, (limitPosition - initialPosition) + offset);
_header.Buffer = termBuffer;
long resultingPosition = initialPosition;
try
{
while (offset < limitOffset)
{
int length = FrameDescriptor.FrameLengthVolatile(termBuffer, offset);
if (length <= 0)
{
break;
}
int frameOffset = offset;
offset += BitUtil.Align(length, FrameDescriptor.FRAME_ALIGNMENT);
if (FrameDescriptor.IsPaddingFrame(termBuffer, frameOffset))
{
position += (offset - initialOffset);
initialOffset = offset;
resultingPosition = position;
continue;
}
_header.Offset = frameOffset;
var action = handler.OnFragment(
termBuffer,
frameOffset + DataHeaderFlyweight.HEADER_LENGTH,
length - DataHeaderFlyweight.HEADER_LENGTH,
_header);
if (action == ControlledFragmentHandlerAction.ABORT)
{
break;
}
position += (offset - initialOffset);
initialOffset = offset;
if ((_header.Flags & FrameDescriptor.END_FRAG_FLAG) == FrameDescriptor.END_FRAG_FLAG)
{
resultingPosition = position;
}
if (action == ControlledFragmentHandlerAction.BREAK)
{
break;
}
}
}
catch (Exception t)
{
_errorHandler(t);
}
return(resultingPosition);
}
public static long RawTailVolatile(UnsafeBuffer metaDataBuffer, int partitionIndex)
{
return(metaDataBuffer.GetLongVolatile(TERM_TAIL_COUNTERS_OFFSET + BitUtil.SIZE_OF_LONG * partitionIndex));
}
public JsonValidationResult Validate(UnsafeBuffer <char> buffer, int start, int count)
{
ScheduleValidation(buffer, start, count).Complete();
return(GetResult());
}
/// <summary>
/// Get the value of the end of stream position.
/// </summary>
/// <param name="metaDataBuffer"> containing the metadata. </param>
/// <returns> the value of end of stream position </returns>
public static long EndOfStreamPosition(UnsafeBuffer metaDataBuffer)
{
return(metaDataBuffer.GetLongVolatile(LOG_END_OF_STREAM_POSITION_OFFSET));
}
