public void Fill(ref Payload payload)
{
Head = payload.Head;
Calculator = payload.Calculator;
_length = payload.Length;
_position = payload.Position;
}
public Payload(Segment *head, IndexCalculator calculator, int length, int position)
{
Head = head;
Calculator = calculator;
Length = length;
Position = position;
}
/// <summary>
/// Adds segments, returning the initial segment of the newly added chain.
/// </summary>
/// <param name="segmentsToObtain"></param>
/// <returns>Returns the initial segment of the newly added chain.</returns>
private Segment *AddSegments(int segmentsToObtain)
{
Segment *segment;
if (_pool.TryPop(segmentsToObtain, out segment) == segmentsToObtain)
{
if (Head == null)
{
Head = segment;
_tail = GetTailOrThis(segment);
}
else
{
// attach the new segment to the end O(1)
_tail->Next = segment;
_tail = GetTailOrThis(segment); // rewrite tail O(number of segments added)
}
var s = segment;
while (s != null)
{
_capacity += s->Length;
s = s->Next;
}
return(segment);
}
else
{
// not enough elements taken, release and throw
_pool.Push(segment);
throw new Exception("Not enough memory in the pool");
}
}
public void Consume(MessageHandler handler, ref Segment *head)
{
var current = head;
while (current != null)
{
var firstAvailablePosition = *(long *)current->Buffer;
var offset = SegmentHeaderSize;
while (offset < firstAvailablePosition)
{
var header = current->Buffer + offset;
var messageHeader = (Header *)header;
handler(messageHeader->MessageTypeId,
new ByteChunk(header + sizeof(Header), messageHeader->ChunkLength));
offset += GetNeededBytes(messageHeader->ChunkLength);
}
current = current->Next;
}
if (head != null)
{
_pool.Push(head);
head = null;
}
}
public void Fill(ref Payload payload)
{
Head = payload.Head;
Calculator = payload.Calculator;
_length = payload.Length;
_position = payload.Position;
}
public OneSegmentOnlyPool()
{
_handle = GCHandle.Alloc(_managedBytes, GCHandleType.Pinned);
var bytes = (byte*) _handle.AddrOfPinnedObject();
_segment = (Segment*) (bytes + SingleThreadSegmentPool.SegmentSize);
*_segment = new Segment(bytes, SingleThreadSegmentPool.SegmentSize);
SegmentLength = SingleThreadSegmentPool.SegmentSize;
}
public void Push(Segment *segment)
{
if (_segment != null)
{
throw new InvalidOperationException();
}
_segment = segment;
}
public OneSegmentOnlyPool()
{
_handle = GCHandle.Alloc(_managedBytes, GCHandleType.Pinned);
var bytes = (byte *)_handle.AddrOfPinnedObject();
_segment = (Segment *)(bytes + SingleThreadSegmentPool.SegmentSize);
*_segment = new Segment(bytes, SingleThreadSegmentPool.SegmentSize);
SegmentLength = SingleThreadSegmentPool.SegmentSize;
}
public void Push(Segment* segment)
{
if (_segment != null)
{
throw new InvalidOperationException();
}
_segment = segment;
}
/// <summary>
/// Wraps the whole content from this instance in a context object. This effectively means that no segments are returned to the pool but rather are passes by ref in the context.
/// </summary>
/// <param name="ctx">The context to be returned.</param>
// ReSharper disable once RedundantAssignment
public void WrapInContext(ref Payload ctx)
{
ctx = new Payload(Head, Calculator, _length, _position);
Head = null;
_tail = null;
_length = 0;
_position = 0;
_capacity = 0;
}
/// <summary>
/// Wraps the whole content from this instance in a context object. This effectively means that no segments are returned to the pool but rather are passes by ref in the context.
/// </summary>
/// <param name="ctx">The context to be returned.</param>
// ReSharper disable once RedundantAssignment
public void WrapInContext(ref Payload ctx)
{
ctx = new Payload(Head, Calculator, _length, _position);
Head = null;
_tail = null;
_length = 0;
_position = 0;
_capacity = 0;
}
public void Write <TMessage>(ref Envelope envelope, ref TMessage message, ref Segment *head)
where TMessage : struct
{
if (head == null)
{
head = PopNew();
}
_currentHead = head;
_writer.Write(ref envelope, ref message, this);
}
private unsafe void MergeSegments()
{
int num = 0;
while (true)
{
int num2;
while (true)
{
if (num >= this.m_segments.Count)
{
return;
}
num2 = num + 1;
break;
}
while (true)
{
if (num2 >= this.m_segments.Count)
{
num++;
break;
}
Segment segment = this.m_segments[num];
Segment segment2 = this.m_segments[num2];
int num3 = 0;
if ((segment.Min.X == segment2.Min.X) && (segment.Max.X == segment2.Max.X))
{
num3++;
}
if ((segment.Min.Y == segment2.Min.Y) && (segment.Max.Y == segment2.Max.Y))
{
num3++;
}
if ((segment.Min.Z == segment2.Min.Z) && (segment.Max.Z == segment2.Max.Z))
{
num3++;
}
if ((num3 == 2) && (((segment.Min.X == (segment2.Max.X + 1)) || (((segment.Max.X + 1) == segment2.Min.X) || ((segment.Min.Y == (segment2.Max.Y + 1)) || (((segment.Max.Y + 1) == segment2.Min.Y) || (segment.Min.Z == (segment2.Max.Z + 1)))))) || ((segment.Max.Z + 1) == segment2.Min.Z)))
{
Segment *segmentPtr1 = (Segment *)ref segment;
segmentPtr1->Min = Vector3I.Min(segment.Min, segment2.Min);
Segment *segmentPtr2 = (Segment *)ref segment;
segmentPtr2->Max = Vector3I.Max(segment.Max, segment2.Max);
this.m_segments[num] = segment;
this.m_segments.RemoveAt(num2);
continue;
}
num2++;
}
}
}
public bool TryPop(out Segment *result)
{
if (_head == null)
{
result = null;
return(false);
}
result = _head;
_head = _head->Next;
result->Next = null;
return(true);
}
protected static Segment *GetTailOrThis(Segment *segment)
{
if (segment == null)
{
return(null);
}
var tail = segment;
while (tail->Next != null)
{
tail = tail->Next;
}
return(tail);
}
public override void SetLength(long value)
{
if (value < 0)
{
throw new ArgumentException("Length must be greater than 0", "value");
}
if (value == 0)
{
if (Head != null)
{
_pool.Push(Head);
}
Head = null;
_tail = null;
_length = 0;
_position = 0;
_capacity = 0;
return;
}
var currentNumberOfSegments = Calculator.GetSegmentIndex(_length);
var nextNumberOfSegments = Calculator.GetSegmentIndex(value);
if (currentNumberOfSegments < nextNumberOfSegments)
{
// enlarging the stream is fast with _tail remembered
var segmentsToAdd = nextNumberOfSegments - currentNumberOfSegments;
AddSegments(segmentsToAdd);
}
else if (currentNumberOfSegments > nextNumberOfSegments)
{
throw new NotImplementedException("Not implemented yet");
}
_length = (int) value;
if (_position > value)
{
_position = (int) value;
}
}
public override void SetLength(long value)
{
if (value < 0)
{
throw new ArgumentException("Length must be greater than 0", "value");
}
if (value == 0)
{
if (Head != null)
{
_pool.Push(Head);
}
Head = null;
_tail = null;
_length = 0;
_position = 0;
_capacity = 0;
return;
}
var currentNumberOfSegments = Calculator.GetSegmentIndex(_length);
var nextNumberOfSegments = Calculator.GetSegmentIndex(value);
if (currentNumberOfSegments < nextNumberOfSegments)
{
// enlarging the stream is fast with _tail remembered
var segmentsToAdd = nextNumberOfSegments - currentNumberOfSegments;
AddSegments(segmentsToAdd);
}
else if (currentNumberOfSegments > nextNumberOfSegments)
{
throw new NotImplementedException("Not implemented yet");
}
_length = (int)value;
if (_position > value)
{
_position = (int)value;
}
}
public void Push(Segment *segment)
{
if (segment->Length != SegmentLength)
{
throw new ArgumentException(
"The segment length is different from the segment sizes of this pool. Are you trying to push a segment from another pool maybe?");
}
var tail = segment->Tail;
if (tail == null)
{
segment->Next = _head;
}
else
{
tail->Next = _head;
}
_head = segment;
}
private bool TryWriteToSegment(int messagetypeid, ByteChunk chunk, Segment *segment,
int neededBytes)
{
var firstAvailablePosition = (long *)segment->Buffer;
if (*firstAvailablePosition + neededBytes <= _segmentLength)
{
var buffer = segment->Buffer + *firstAvailablePosition;
var header = (Header *)buffer;
header->MessageTypeId = messagetypeid;
header->ChunkLength = chunk.Length;
Native.MemcpyUnmanaged(buffer + sizeof(Header), chunk.Pointer, chunk.Length);
*firstAvailablePosition += neededBytes;
return(true);
}
return(false);
}
public int TryPop(int numberOfSegmentsToRetrieve, out Segment *startingSegment)
{
if (_head == null)
{
startingSegment = null;
return(0);
}
var next = _head;
var nodesCount = 1;
for (; nodesCount < numberOfSegmentsToRetrieve && next->Next != null; nodesCount++)
{
next = next->Next;
}
startingSegment = _head;
_head = next->Next;
next->Next = null; // cut the end
return(nodesCount);
}
public TimerWheel(ActorId thisActor, ISegmentPool pool, IMessageWriter writer, MessageHandler handler,
TimeSpan tickLength, Func <long> getTicks, long ticksPerSecond)
{
_envelope = new Envelope(thisActor);
_pool = pool;
_handler = handler;
_getTicks = getTicks;
_store = new SegmentChainMessageStore(writer, pool);
var segment = _pool.Pop();
_wheel = (Segment **)segment->Buffer;
_segment = segment;
// ensure clean wheel
for (var i = 0; i < TimeoutsPerSegment; i++)
{
_wheel[i] = null;
}
_ticksPerMilisecond = ticksPerSecond / 1000;
_clockTickDurationInStopWatch = (long)tickLength.TotalMilliseconds * _ticksPerMilisecond;
_startTime = _getTicks();
}
public Segment(byte* buffer, int length)
{
Buffer = buffer;
Length = length;
Next = null;
}
public Segment(byte *buffer, int length)
{
Buffer = buffer;
Length = length;
Next = null;
}
public bool TryPop(out Segment* result)
{
if (_head == null)
{
result = null;
return false;
}
result = _head;
_head = _head->Next;
result->Next = null;
return true;
}
public void Push(Segment* segment)
{
if (segment->Length != SegmentLength)
{
throw new ArgumentException(
"The segment length is different from the segment sizes of this pool. Are you trying to push a segment from another pool maybe?");
}
var tail = segment->Tail;
if (tail == null)
{
segment->Next = _head;
}
else
{
tail->Next = _head;
}
_head = segment;
}
public int TryPop(int numberOfSegmentsToRetrieve, out Segment* startingSegment)
{
if (_head == null)
{
startingSegment = null;
return 0;
}
var next = _head;
var nodesCount = 1;
for (; nodesCount < numberOfSegmentsToRetrieve && next->Next != null; nodesCount++)
{
next = next->Next;
}
startingSegment = _head;
_head = next->Next;
next->Next = null; // cut the end
return nodesCount;
}
/// <summary>
/// Adds segments, returning the initial segment of the newly added chain.
/// </summary>
/// <param name="segmentsToObtain"></param>
/// <returns>Returns the initial segment of the newly added chain.</returns>
private Segment* AddSegments(int segmentsToObtain)
{
Segment* segment;
if (_pool.TryPop(segmentsToObtain, out segment) == segmentsToObtain)
{
if (Head == null)
{
Head = segment;
_tail = GetTailOrThis(segment);
}
else
{
// attach the new segment to the end O(1)
_tail->Next = segment;
_tail = GetTailOrThis(segment); // rewrite tail O(number of segments added)
}
var s = segment;
while (s != null)
{
_capacity += s->Length;
s = s->Next;
}
return segment;
}
else
{
// not enough elements taken, release and throw
_pool.Push(segment);
throw new Exception("Not enough memory in the pool");
}
}
public bool TryPop(out Segment *result)
{
result = _segment;
_segment = null;
return(result != null);
}
public Payload(Segment* head, IndexCalculator calculator, int length, int position)
{
Head = head;
Calculator = calculator;
Length = length;
Position = position;
}
public bool TryPop(out Segment* result)
{
result = _segment;
_segment = null;
return result != null;
}
public int TryPop(int numberOfSegmentsToRetrieve, out Segment *startingSegment)
{
throw new System.NotImplementedException();
}
