public void RentReturnPinnedSlicesRetainablePoolBadBehavior() { // Rent many then return many var maxBuffers = 32; // 2 var buffersToTake = 128; var pool = new RetainableMemoryPool <Byte>(RetainableMemoryPool <Byte> .DefaultFactory); var list = new List <RetainableMemory <byte> >(); using (Benchmark.Run("FullCycle")) { for (int i = 0; i < buffersToTake; i++) { list.Add(pool.RentMemory(64 * 1024)); } for (int i = 0; i < buffersToTake; i++) { list[i].Dispose(); } } Console.WriteLine("Disposing pool"); pool.Dispose(); }
public void RentReturnBenchmarkRetainablePoolOverCapacity() { #if !DEBUG var count = 10_000; #else var count = 1_0; #endif var capacity = 25; var batch = capacity * 2; var pool = new RetainableMemoryPool <Byte>(RetainableMemoryPool <Byte> .DefaultFactory); var list = new List <RetainableMemory <byte> >(batch); using (Benchmark.Run("FullCycle", count * batch)) { for (int i = 0; i < count; i++) { for (int j = 0; j < batch; j++) { list.Add(pool.RentMemory(32 * 1024)); } foreach (var arrayMemory in list) { arrayMemory.Dispose(); } list.Clear(); } } pool.Dispose(); }
public void RentReturnPinnedSlicesRetainablePool() { var maxBuffers = 128 / 64; // 2 var pool = new RetainableMemoryPool <byte>(null, 32 * 1024, 1024 * 1024, maxBuffers, 0); var list = new List <RetainableMemory <byte> >(); using (Benchmark.Run("FullCycle")) { for (int i = 0; i < maxBuffers * 2; i++) { list.Add(pool.RentMemory(64 * 1024)); } for (int i = 0; i < maxBuffers; i++) { ((IDisposable)list[i]).Dispose(); } for (int i = 2; i < maxBuffers * 2; i++) { pool.ReturnInternal(list[i]); } } pool.Dispose(); }
public void RefCountOfPooled() { var pool = new RetainableMemoryPool <Byte>(RetainableMemoryPool <Byte> .DefaultFactory); var buf = (PrivateMemory <byte>)pool.Rent(100); Assert.IsTrue(buf.IsPoolable); Console.WriteLine($"rented: {buf.ReferenceCount}"); buf.Dispose(); Assert.IsTrue(buf.IsDisposed); Assert.IsTrue(buf.IsPooled); Console.WriteLine($"returned: {buf.ReferenceCount}"); Console.WriteLine($"pooled: {buf.IsPooled}"); Assert.Throws <ObjectDisposedException>(() => { var _ = buf.Retain(); }); pool.Dispose(); }
public void RefCountOfPooled() { var pool = new RetainableMemoryPool <byte>(null, 16, 1024 * 1024, 50, 2); var buf = (ArrayMemory <byte>)pool.Rent(100); Assert.IsTrue(buf.IsPoolable); Console.WriteLine($"rented: {buf.ReferenceCount}"); pool.ReturnInternal(buf); Assert.IsTrue(buf.IsDisposed); Assert.IsTrue(buf.IsPooled); Console.WriteLine($"returned: {buf.ReferenceCount}"); Console.WriteLine($"pooled: {buf.IsPooled}"); Assert.Throws <ObjectDisposedException>(() => { var _ = buf.Retain(); }); pool.Dispose(); }
public void RentReturnBenchmarkRetainablePoolOverCapacity() { var count = 1_000_000; var capacity = 25; var batch = capacity * 2; var pool = new RetainableMemoryPool <byte>((p, l) => { var am = ArrayMemory <byte> .Create(l, pin: true); // Attach pool am._pool = p; return(am); }, 16, 1024 * 1024, capacity, 0); var list = new List <RetainableMemory <byte> >(batch); using (Benchmark.Run("FullCycle", count * batch)) { for (int i = 0; i < count; i++) { for (int j = 0; j < batch; j++) { list.Add(pool.RentMemory(32 * 1024)); } foreach (var arrayMemory in list) { pool.Return(arrayMemory); } list.Clear(); } } pool.Dispose(); }
public void ConcurrentRentReturn() { #if !DEBUG var count = 100_000_000; #else var count = 1_000; #endif var pool = new RetainableMemoryPool <byte>(null, 16, 1024 * 1024, 50, 2); var tasks = new List <Task>(); var taskCount = 1; // 6x2 cores var mre = new ManualResetEventSlim(false); Action action = () => { mre.Wait(); for (int i = 0; i < count; i++) { // ReSharper disable once AccessToDisposedClosure var memory = pool.RentMemory(32 * 1024); //(memory.Pin(0)).Dispose(); //if (memory.IsDisposed || memory.IsRetained) //{ // Assert.Fail(); //} // ReSharper disable once AccessToDisposedClosure pool.ReturnInternal(memory); //if (i % 1000000 == 0) //{ // Console.WriteLine(i); //} } }; for (int i = 0; i < taskCount; i++) { tasks.Add(Task.Run(action)); } //Console.WriteLine("Set affinity and press enter"); //Console.ReadLine(); using (Benchmark.Run("FullCycle", count * taskCount)) { mre.Set(); Task.WhenAll(tasks).Wait(); } pool.Dispose(); }
public void PoolReturnsSameSizeUsingSlices(int maxBucketsToTry) { var pool = new RetainableMemoryPool <byte>(null, 16, 8 * 1024 * 1024, maxBuffersPerBucketPerCore: 8, maxBucketsToTry); var cw = new ConditionalWeakTable <byte[], object>(); var list = new List <ArrayMemory <byte> >(); ArraySegment <byte> prev = default; for (int r = 0; r < TestUtils.GetBenchCount(50, 5); r++) { for (int i = 0; i < TestUtils.GetBenchCount(10240, 1024); i++) { const int sizeKb = 1; var buf = (ArrayMemory <byte>)pool.Rent(sizeKb * 1024); list.Add(buf); if (!cw.TryGetValue(buf.Array, out var id)) { id = (object)i; cw.Add(buf.Array, id); } Assert.IsFalse(buf.ArraySegment.Array == prev.Array && buf.ArraySegment.Offset == prev.Offset, $"different segments at {i}"); prev = buf.ArraySegment; Assert.AreEqual(sizeKb * 1024, buf.Length, $"at {i}"); //Console.Write( // $"{i}: {(int) id} - {buf.Array.Length} - {buf.ArraySegment.Offset} - {buf.ArraySegment.Count}"); //Console.WriteLine(); //if (i > 8 && i <= 23) //{ // Assert.AreEqual(sizeKb * 2 * 1024, buf.Array.Length, $"at {i}"); // Assert.AreEqual((i & 1) * sizeKb * 1024, buf.ArraySegment.Offset, $"at {i}"); //} } foreach (var buf in list) { buf.Dispose(); //pool.Return(buf); } list.Clear(); } pool.Dispose(); }
public void CouldDisposePoolWithFreeSpace() { var maxBuffers = 10; var pool = new RetainableMemoryPool <Byte>(RetainableMemoryPool <Byte> .DefaultFactory); using (Benchmark.Run("FullCycle")) { for (int i = 0; i < maxBuffers / 2; i++) { var memory = pool.RentMemory(64 * 1024); memory.Dispose(); // pool.ReturnInternal(memory); } } pool.Dispose(); }
public void CouldDisposePoolWithFreeSpace() { var maxBuffers = 10; var pool = new RetainableMemoryPool <byte>(null, 32 * 1024, 1024 * 1024, maxBuffers, 0); using (Benchmark.Run("FullCycle")) { for (int i = 0; i < maxBuffers / 2; i++) { var memory = pool.RentMemory(64 * 1024); pool.ReturnInternal(memory); } } pool.Dispose(); }
public void RentReturnPinnedSlicesRetainablePoolBadBehaviorDropped() { // Rent many then return many var maxBuffers = 32; // 2 #if !DEBUG var buffersToTake = 1_00_000; #else var buffersToTake = 1_000; #endif var pool = new RetainableMemoryPool <byte>(null, 32 * 1024, 1024 * 1024, maxBuffers, 0); using (Benchmark.Run("FullCycle", buffersToTake)) { for (int i = 0; i < buffersToTake; i++) { // ReSharper disable once UnusedVariable var memory = pool.RentMemory(64 * 1024); // pool.Return(memory); //if (i % 100_000 == 0) //{ // Console.WriteLine(i); //} if (i % 1000 == 0) { GC.Collect(2, GCCollectionMode.Forced, true); GC.WaitForPendingFinalizers(); GC.Collect(2, GCCollectionMode.Forced, true); GC.WaitForPendingFinalizers(); } } GC.Collect(2, GCCollectionMode.Forced, true); GC.WaitForPendingFinalizers(); GC.Collect(2, GCCollectionMode.Forced, true); GC.WaitForPendingFinalizers(); } Console.WriteLine("Disposing pool"); pool.Dispose(); }
public void RentReturnDefaultRetainablePoolBench() { #if !DEBUG var count = 10_000_000; #else var count = 1_000; #endif var pool = new RetainableMemoryPool <byte>(null, 16, 1024 * 1024, 50, 2); for (int i = 0; i < 1000; i++) { var memory = pool.RentMemory(32 * 1024); memory.Increment(); memory.Decrement(); // ((IDisposable)memory).Dispose(); //(memory.Pin(0)).Dispose(); //if (memory.IsDisposed || memory.IsRetained) //{ // Assert.Fail(); //} // pool.Return(memory); } for (int _ = 0; _ < 20; _++) { using (Benchmark.Run("RentReturn", count)) { for (int i = 0; i < count; i++) { var memory = pool.RentMemory(32 * 1024); //(memory.Pin(0)).Dispose(); //if (memory.IsDisposed || memory.IsRetained) //{ // Assert.Fail(); //} pool.Return(memory, false); } } } Benchmark.Dump(); pool.Dispose(); }
public void RentReturnDefaultRetainablePoolBench() { var count = TestUtils.GetBenchCount(1_000_000, 1_000); var pool = new RetainableMemoryPool <byte>(null, 16, 1024 * 1024, 50, 2); for (int i = 0; i < 1000; i++) { var memory = pool.RentMemory(32 * 1024); memory.Increment(); memory.Decrement(); // memory.Dispose(); //(memory.Pin(0)).Dispose(); //if (memory.IsDisposed || memory.IsRetained) //{ // Assert.Fail(); //} // pool.Return(memory); } for (int _ = 0; _ < 20; _++) { using (Benchmark.Run("RentReturn", count)) { for (int i = 0; i < count; i++) { var memory = pool.RentMemory(32 * 1024); //(memory.Pin(0)).Dispose(); //if (memory.IsDisposed || memory.IsRetained) //{ // Assert.Fail(); //} memory.Dispose(); } } } Benchmark.Dump(); pool.Dispose(); }
public void RentReturnBenchmarkRetainablePool() { var count = 100_000_000; var pool = new RetainableMemoryPool <byte>(null, 16, 1024 * 1024, 50, 2); for (int i = 0; i < 1000; i++) { var memory = pool.RentMemory(32 * 1024); memory.Increment(); memory.Decrement(); // ((IDisposable)memory).Dispose(); //(memory.Pin(0)).Dispose(); //if (memory.IsDisposed || memory.IsRetained) //{ // Assert.Fail(); //} // pool.Return(memory); } using (Benchmark.Run("FullCycle", count)) { for (int i = 0; i < count; i++) { var memory = pool.RentMemory(32 * 1024); //(memory.Pin(0)).Dispose(); //if (memory.IsDisposed || memory.IsRetained) //{ // Assert.Fail(); //} pool.Return(memory); } } pool.Dispose(); }