Provides a pool of buffers that can be used to efficiently allocate memory for asynchronous socket operations
상속: IBufferPool
예제 #1
0
 public void BufferPoolConstructorTest3()
 {
     long SlabSize = -1;
     int InitialSlabs = 1;
     int SubsequentSlabs = 1;
     BufferPool target = new BufferPool(SlabSize, InitialSlabs, SubsequentSlabs);
 }
예제 #2
0
 public void BufferPoolConstructorTest()
 {
     long SlabSize = 2 * 1024 * 1024; //2 MB
     int InitialSlabs = 1;
     int SubsequentSlabs = 1;
     BufferPool target = new BufferPool(SlabSize, InitialSlabs, SubsequentSlabs);
     Assert.AreEqual<long>(InitialSlabs, target.InitialSlabs);
     Assert.AreEqual<long>(SubsequentSlabs, target.SubsequentSlabs);
     Assert.AreEqual<long>(SlabSize, target.SlabSize);
 }
예제 #3
0
 public void SubsequentSlabsTest()
 {
     long SlabSize = BufferPool.MinimumSlabSize; //Minimum Slab size
     int InitialSlabs = 1;
     int SubsequentSlabs = 41;
     BufferPool target = new BufferPool(SlabSize, InitialSlabs, SubsequentSlabs);
     target.GetBuffer(SlabSize);
     target.GetBuffer(SlabSize);
     Assert.AreEqual<long>(SubsequentSlabs, target.SubsequentSlabs);
     Assert.AreEqual<long>(SubsequentSlabs + InitialSlabs, target.SlabCount);
 }
예제 #4
0
        public void TryFreeSlabTest()
        {
            long SlabSize = BufferPool.MinimumSlabSize;
            int InitialSlabs = 1;
            int SubsequentSlabs = 3;
            BufferPool target = new BufferPool(SlabSize, InitialSlabs, SubsequentSlabs);
            Assert.AreEqual<long>(InitialSlabs, target.SlabCount);

            //GetBuffer of slab size
            IBuffer buff1 = target.GetBuffer(SlabSize);
            //confirm that slabcount is 1
            Assert.AreEqual<long>(InitialSlabs, target.SlabCount);

            //Try to free a slab and do a recount -- slabcount should remain 1
            target.TryFreeSlab();
            Assert.AreEqual<long>(InitialSlabs, target.SlabCount);

            //Get it again to force construction of 3 new slabs
            IBuffer buff2 = target.GetBuffer(SlabSize);
            Assert.AreEqual<long>(SubsequentSlabs + InitialSlabs, target.SlabCount);

            //Free a slab and do a recount
            target.TryFreeSlab();
            Assert.AreEqual<long>(SubsequentSlabs + InitialSlabs - 1, target.SlabCount);

            //Free a slab and do a recount -- slabcount should not budge since only one slab is free
            target.TryFreeSlab();
            Assert.AreEqual<long>(SubsequentSlabs + InitialSlabs - 1, target.SlabCount);

            //Try to free a slab and do a recount
            //Free 1st buffer
            buff1.Dispose();
            target.TryFreeSlab();
            Assert.AreEqual<long>(SubsequentSlabs + InitialSlabs - 2, target.SlabCount);

            //Try to free a slab and do a recount -- slabcount shouldn't go below two
            target.TryFreeSlab();
            Assert.AreEqual<long>(SubsequentSlabs + InitialSlabs - 2, target.SlabCount);

            //Free buffer, try to free a slab and do a recount -- slabcount should now be back to 1
            buff2.Dispose();
            target.TryFreeSlab();
            Assert.AreEqual<long>(SubsequentSlabs + InitialSlabs - 3, target.SlabCount);
        }
예제 #5
0
        public void SlabSizeTest()
        {
            //Test for slab of minimum slab size
            long SlabSize = 1; //1 byte
            int InitialSlabs = 1;
            int SubsequentSlabs = 1;
            BufferPool target = new BufferPool(SlabSize, InitialSlabs, SubsequentSlabs);
            Assert.AreEqual<long>(Math.Max(SlabSize, BufferPool.MinimumSlabSize),target.SlabSize);

            //Test for slab of minimum slab size + 1 byte
            SlabSize = BufferPool.MinimumSlabSize + 1;
            InitialSlabs = 1;
            SubsequentSlabs = 1;
            target = new BufferPool(SlabSize, InitialSlabs, SubsequentSlabs);
            Assert.AreEqual<long>(Math.Max(SlabSize, BufferPool.MinimumSlabSize), target.SlabSize);
        }
예제 #6
0
 public void InitialSlabsTest()
 {
     long SlabSize = 1024; //1 KB
     int InitialSlabs = 41;
     int SubsequentSlabs = 1;
     BufferPool target = new BufferPool(SlabSize, InitialSlabs, SubsequentSlabs);
     Assert.AreEqual<long>(InitialSlabs, target.InitialSlabs);
 }
예제 #7
0
 public void GetBufferTest2()
 {
     long SlabSize = 2 * 1024 * 1024;
     int InitialSlabs = 1;
     int SubsequentSlabs = 1;
     BufferPool target = new BufferPool(SlabSize, InitialSlabs, SubsequentSlabs);
     long length = -1;
     IBuffer actual;
     actual = target.GetBuffer(length);
 }
예제 #8
0
        public void GetBufferTest()
        {
            long SlabSize = 2 * 1024 * 1024;
            int InitialSlabs = 1;
            int SubsequentSlabs = 1;
            BufferPool target = new BufferPool(SlabSize, InitialSlabs, SubsequentSlabs);
            long length = 20 * 1024;
            IBuffer actual;
            actual = target.GetBuffer(length);
            Assert.AreEqual(length, actual.Size);

            //Confirm that zero-length buffers work
            long length2 = 0;
            actual = target.GetBuffer(length2);
            Assert.AreEqual(length2, actual.Size);

            //Get another buffer and confirm that it is contiguous from the first acquired buffer.
            //i.e. the zero buffer "in-between" didn't cause any harm
            long length3 = 100 * 1024;
            actual = target.GetBuffer(length3);
            Assert.AreEqual(length3, actual.Size);
            Assert.IsTrue(actual.GetSegments()[0].Offset == length);
        }
예제 #9
0
        /// <summary>
        /// Initializes a new instance of the MemorySlab class
        /// </summary>
        /// <param name="size">Size, in bytes, of slab</param>
        /// <param name="pool">BufferPool associated with the slab</param>
        internal MemorySlab(long size, BufferPool pool)
        {
            if (size < 1)
            {
                //Can't have zero length or -ve slabs
                throw new ArgumentOutOfRangeException("size");
            }

            //NOTE: Pool parameter is allowed to be null for testing purposes

            if (System.IntPtr.Size > 4)
            {
                is64BitMachine = true;
            }
            else
            {
                is64BitMachine = false;
            }

            // lock is unnecessary in this instance constructor
            //lock (sync)
            //{
                FreeSpace first;
                if (!dictStartLoc.TryGetValue(0, out first))
                {
                    AddFreeBlock(0, size, false);
                    this.slabSize = size;
                    this.pool = pool;
                    // GC.Collect(); //Perform Garbage Collection before creating large array -- commented out but may be useful
                    array = new byte[size];
                }
            //}
        }