public void CouldCreateBinaryConverter() { var converter = GetConverter <PreservedBuffer <byte>[]>(); Assert.AreEqual(0, converter.Size); var buffers = new[] { BufferPool.PreserveMemory(10) }; //Assert.Throws<NotImplementedException>(() => //{ converter.SizeOf(buffers, 0, 10, out var temp); //}); }
internal override unsafe void Free(bool finalizing) { ThrowHelper.Assert(IsDisposed); var array = Interlocked.Exchange(ref _array, null); if (array != null) { ThrowHelper.DebugAssert(TypeHelper <T> .IsReferenceOrContainsReferences); // Even if we are finalizing the fields are not collected, because this // object is reachable and hence the fields are reachable. if (!ExternallyOwned) { BufferPool <T> .Return(Unsafe.As <T[]>(array), clearArray : true); } } var pointer = Interlocked.Exchange(ref _pointer, IntPtr.Zero); if (pointer != IntPtr.Zero) { // TODO Switch to mimalloc after updating to new release Marshal.FreeHGlobal(pointer); // Mem.Free((byte*) pointer); BuffersStatistics.ReleasedNativeMemory.InterlockedAdd(_length); } // In PM either pointer or array, never both if (array == null && pointer == IntPtr.Zero) { string msg = "Tried to free already freed PrivateMemory"; #if DEBUG ThrowHelper.ThrowInvalidOperationException(msg); #endif Trace.TraceWarning(msg); return; } ClearFields(); // This instance is clean now. // If we are finalizing then resurrect it by placing it to the pool. // If we are disposing then also add to the pool. var pooled = ObjectPool.Return(this); // If we were finalizing but resurrected then the next time // the instance is dropped the finalizer will not run, // therefore we must re-register. if (pooled && finalizing) { GC.ReRegisterForFinalize(this); } // If we cannot pool the instance and not running from finalizer // then the reference is dropped and finalizer could re-run. // In that case suppress it. // If not pooled and finalizing then the job is done. if (!pooled && !finalizing) { GC.SuppressFinalize(this); } }