コード例 #1
0
        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();
        }
コード例 #2
0
        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();
        }
コード例 #3
0
ファイル: ArrayMemoryTests.cs プロジェクト: pangfd/Spreads
        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();
        }
コード例 #4
0
        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();
        }
コード例 #5
0
ファイル: ArrayMemoryTests.cs プロジェクト: pangfd/Spreads
        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();
        }
コード例 #6
0
ファイル: ArrayMemoryTests.cs プロジェクト: wang-shun/Spreads
        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();
        }
コード例 #7
0
ファイル: ArrayMemoryTests.cs プロジェクト: pangfd/Spreads
        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();
        }
コード例 #8
0
        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();
        }
コード例 #9
0
        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();
        }
コード例 #10
0
ファイル: ArrayMemoryTests.cs プロジェクト: pangfd/Spreads
        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();
        }
コード例 #11
0
ファイル: ArrayMemoryTests.cs プロジェクト: pangfd/Spreads
        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();
        }
コード例 #12
0
ファイル: ArrayMemoryTests.cs プロジェクト: pangfd/Spreads
        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();
        }
コード例 #13
0
        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();
        }
コード例 #14
0
ファイル: ArrayMemoryTests.cs プロジェクト: wang-shun/Spreads
        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();
        }