public static void NoRelease_AfterDispose() { OwnedMemory <int> block = MemoryPool <int> .Shared.Rent(42); block.Release(); block.Dispose(); Assert.Throws <ObjectDisposedException>(() => block.Release()); }
static void MemoryHandleDoubleFree(OwnedMemory <byte> buffer) { var memory = buffer.Memory; var handle = memory.Retain(pin: true); buffer.Retain(); handle.Dispose(); handle.Dispose(); Assert.True(buffer.Release()); Assert.False(buffer.Release()); }
static void BufferLifetimeBasics(OwnedMemory <byte> buffer) { Memory <byte> copyStoredForLater; try { Memory <byte> memory = buffer.Memory; Memory <byte> slice = memory.Slice(10); copyStoredForLater = slice; var handle = slice.Retain(); try { Assert.Throws <InvalidOperationException>(() => { // memory is reserved; premature dispose check fires buffer.Dispose(); }); } finally { handle.Dispose(); // release reservation } buffer.Release(); } finally { buffer.Dispose(); // can finish dispose with no exception } Assert.ThrowsAny <ObjectDisposedException>(() => { // memory is disposed; cannot use copy stored for later var span = copyStoredForLater.Span; }); Assert.True(buffer.IsDisposed); }
static void OverRelease(OwnedMemory <byte> buffer) { Assert.ThrowsAny <InvalidOperationException>(() => { buffer.Release(); }); }
static void Dispose(OwnedMemory <byte> buffer) { var length = buffer.Length; buffer.Release(); buffer.Dispose(); Assert.True(buffer.IsDisposed); Assert.ThrowsAny <ObjectDisposedException>(() => { var ignore = buffer.Span; }); Assert.ThrowsAny <ObjectDisposedException>(() => { buffer.Span.Slice(0, length); }); Assert.ThrowsAny <ObjectDisposedException>(() => { buffer.Pin(); }); Assert.ThrowsAny <ObjectDisposedException>(() => { var rwBuffer = buffer.Memory; }); Assert.ThrowsAny <ObjectDisposedException>((Action)(() => { ReadOnlyMemory <byte> roBuffer = buffer.Memory; })); }
public static void ExtraDisposesAreIgnored() { OwnedMemory <int> block = MemoryPool <int> .Shared.Rent(42); block.Release(); block.Dispose(); block.Dispose(); }
public static void RentWithDefaultSize() { using (OwnedMemory <int> block = MemoryPool <int> .Shared.Rent(minBufferSize: -1)) { Assert.True(block.Length >= 1); block.Release(); } }
public static void IsDisposedWhenReleased() { OwnedMemory <int> block = MemoryPool <int> .Shared.Rent(42); block.Release(); Assert.True(block.IsDisposed); }
public static void NoTryGetArrayAfterDispose() { OwnedMemory <int> block = MemoryPool <int> .Shared.Rent(42); Memory <int> memory = block.Memory; block.Release(); block.Dispose(); Assert.Throws <ObjectDisposedException>(() => MemoryMarshal.TryGetArray(memory, out ArraySegment <int> arraySegment)); }
public void Dispose() { Debug.Assert(_buffer.HasOutstandingReferences); _buffer.Release(); if (!_buffer.HasOutstandingReferences) { _buffer.Dispose(); } }
public void Dispose() { Debug.Assert(_buffer.ReferenceCount >= 1); _buffer.Release(); if (_buffer.ReferenceCount == 0) { _buffer.Dispose(); } }
public static void DisposingTheSharedPoolIsANop() { MemoryPool <int> mp = MemoryPool <int> .Shared; mp.Dispose(); mp.Dispose(); using (OwnedMemory <int> block = mp.Rent(10)) { Assert.True(block.Length >= 10); block.Release(); } }
public static void RefCounting() { using (OwnedMemory <int> block = MemoryPool <int> .Shared.Rent(42)) { block.Retain(); block.Retain(); block.Retain(); bool moreToGo; moreToGo = block.Release(); Assert.True(moreToGo); moreToGo = block.Release(); Assert.True(moreToGo); moreToGo = block.Release(); Assert.False(moreToGo); Assert.Throws <InvalidOperationException>(() => block.Release()); } }
public override bool Release() { _pool.CheckDisposed(); _ownedMemory.Release(); int newRefCount = Interlocked.Decrement(ref _referenceCount); if (newRefCount < 0) { throw new InvalidOperationException(); } if (newRefCount == 0) { _returned = true; return(false); } return(true); }
public static void MemoryPoolTryGetArray() { using (OwnedMemory <int> block = MemoryPool <int> .Shared.Rent(42)) { Memory <int> memory = block.Memory; bool success = MemoryMarshal.TryGetArray(memory, out ArraySegment <int> arraySegment); Assert.True(success); Assert.Equal(block.Length, arraySegment.Count); unsafe { void *pSpan = Unsafe.AsPointer(ref MemoryMarshal.GetReference(block.Span)); fixed(int *pArray = arraySegment.Array) { Assert.Equal((IntPtr)pSpan, (IntPtr)pArray); } } block.Release(); } }
public static void MemoryPoolPin(int byteOffset) { MemoryPool <int> pool = MemoryPool <int> .Shared; using (OwnedMemory <int> block = pool.Rent(10)) { Span <int> sp = block.Span; Assert.Equal(block.Length, sp.Length); using (MemoryHandle newMemoryHandle = block.Pin(byteOffset: byteOffset)) { unsafe { void *pSpan = Unsafe.AsPointer(ref MemoryMarshal.GetReference(sp)); Assert.Equal((IntPtr)pSpan, ((IntPtr)newMemoryHandle.Pointer) - byteOffset); } } block.Release(); } }
public void ReleasedBlockWorks() { using (var pool = new MemoryPool()) { var block1 = pool.Rent(1); block1.Retain(); block1.Release(); OwnedMemory <byte> block2 = null; // Lease-return until we get same block while (block1 != block2) { block2 = pool.Rent(1); block2.Retain(); block2.Release(); } Assert.True(block2.Span.Length > 0); } }
public void ResetMemory() { _ownedMemory.Release(); _ownedMemory = null; _memory = default; }
protected override void Dispose(bool disposing) { _rentedBuffer.Release(); //_rentedBuffer.Dispose(); base.Dispose(disposing); }
public JsonObject Parse(ReadOnlySpan <byte> utf8Json, MemoryPool <byte> pool = null) { _pool = pool; if (_pool == null) { _pool = MemoryPool <byte> .Shared; } _scratchManager = _pool.Rent(utf8Json.Length * 4); _scratchMemory = _scratchManager.Memory; int dbLength = _scratchMemory.Length / 2; _db = _scratchMemory.Slice(0, dbLength); _stack = new TwoStacks(_scratchMemory.Slice(dbLength)); _values = utf8Json; _insideObject = 0; _insideArray = 0; _tokenType = 0; _valuesIndex = 0; _dbIndex = 0; _jsonStartIsObject = false; SkipWhitespace(); _jsonStartIsObject = _values[_valuesIndex] == '{'; int arrayItemsCount = 0; int numberOfRowsForMembers = 0; while (Read()) { var tokenType = _tokenType; switch (tokenType) { case JsonTokenType.ObjectStart: AppendDbRow(JsonObject.JsonValueType.Object, _valuesIndex); while (!_stack.TryPushObject(numberOfRowsForMembers)) { ResizeDb(); } numberOfRowsForMembers = 0; break; case JsonTokenType.ObjectEnd: WriteMachineEndian(_db.Span.Slice(FindLocation(_stack.ObjectStackCount - 1, true)), ref numberOfRowsForMembers); numberOfRowsForMembers += _stack.PopObject(); break; case JsonTokenType.ArrayStart: AppendDbRow(JsonObject.JsonValueType.Array, _valuesIndex); while (!_stack.TryPushArray(arrayItemsCount)) { ResizeDb(); } arrayItemsCount = 0; break; case JsonTokenType.ArrayEnd: WriteMachineEndian(_db.Span.Slice(FindLocation(_stack.ArrayStackCount - 1, false)), ref arrayItemsCount); arrayItemsCount = _stack.PopArray(); break; case JsonTokenType.Property: ParsePropertyName(); ParseValue(); numberOfRowsForMembers++; numberOfRowsForMembers++; break; case JsonTokenType.Value: ParseValue(); arrayItemsCount++; numberOfRowsForMembers++; break; default: throw new ArgumentOutOfRangeException(); } } var result = new JsonObject(_values, _db.Slice(0, _dbIndex).Span, _pool, _scratchManager); _scratchManager.Release(); _scratchManager = null; return(result); }
public static void IsRetainedWhenReturned() { OwnedMemory <int> block = MemoryPool <int> .Shared.Rent(42); Assert.False(block.Release()); }
public void ResetMemory() { _owned.Release(); _owned = null; }