internal static long GetLength(ReadCursor begin, ReadCursor end)
{
if (begin.IsDefault)
{
return(0);
}
var segment = begin.Segment;
switch (segment)
{
case IMemoryList <byte> bufferSegment:
return(GetLength(bufferSegment, begin.Index, end.Get <IMemoryList <byte> >(), end.Index));
case byte[] _:
case OwnedMemory <byte> _:
return(end.Index - begin.Index);
}
PipelinesThrowHelper.ThrowInvalidOperationException(ExceptionResource.UnexpectedSegmentType);
return(default);
// Reading
void IPipeReader.Advance(ReadCursor consumed, ReadCursor examined)
{
BufferSegment returnStart = null;
BufferSegment returnEnd = null;
// Reading commit head shared with writer
Action continuation = null;
lock (_sync)
{
bool examinedEverything = false;
if (examined.Segment == _commitHead)
{
examinedEverything = _commitHead != null ? examined.Index == _commitHeadIndex - _commitHead.Start : examined.Index == 0;
}
if (!consumed.IsDefault)
{
if (_readHead == null)
{
PipelinesThrowHelper.ThrowInvalidOperationException(ExceptionResource.AdvanceToInvalidCursor);
return;
}
var consumedSegment = consumed.Get <BufferSegment>();
returnStart = _readHead;
returnEnd = consumedSegment;
// Check if we crossed _maximumSizeLow and complete backpressure
var consumedBytes = ReadCursorOperations.GetLength(returnStart, _readHeadIndex, consumedSegment, consumed.Index);
var oldLength = _length;
_length -= consumedBytes;
if (oldLength >= _maximumSizeLow &&
_length < _maximumSizeLow)
{
continuation = _writerAwaitable.Complete();
}
// Check if we consumed entire last segment
// if we are going to return commit head
// we need to check that there is no writing operation that
// might be using tailspace
if (consumed.Index == returnEnd.Length &&
!(_commitHead == returnEnd && _writingState.IsActive))
{
var nextBlock = returnEnd.NextSegment;
if (_commitHead == returnEnd)
{
_commitHead = nextBlock;
_commitHeadIndex = 0;
}
_readHead = nextBlock;
_readHeadIndex = 0;
returnEnd = nextBlock;
}
else
{
_readHead = consumedSegment;
_readHeadIndex = consumed.Index;
}
}
// We reset the awaitable to not completed if we've examined everything the producer produced so far
// but only if writer is not completed yet
if (examinedEverything && !_writerCompletion.IsCompleted)
{
// Prevent deadlock where reader awaits new data and writer await backpressure
if (!_writerAwaitable.IsCompleted)
{
PipelinesThrowHelper.ThrowInvalidOperationException(ExceptionResource.BackpressureDeadlock);
}
_readerAwaitable.Reset();
}
_readingState.End(ExceptionResource.NoReadToComplete);
while (returnStart != null && returnStart != returnEnd)
{
returnStart.ResetMemory();
ReturnSegmentUnsynchronized(returnStart);
returnStart = returnStart.NextSegment;
}
}
TrySchedule(_writerScheduler, continuation);
}