AlignedPooledByteBufAllocatorTest Class — netty Architecture

Source Code

buffer/src/test/java/io/netty/buffer/AlignedPooledByteBufAllocatorTest.java lines 27–136

public class AlignedPooledByteBufAllocatorTest extends PooledByteBufAllocatorTest {
    @Override
    protected PooledByteBufAllocator newAllocator(boolean preferDirect) {
        assumeTrue(PooledByteBufAllocator.isDirectMemoryCacheAlignmentSupported());
        int directMemoryCacheAlignment = 1;
        return new PooledByteBufAllocator(
                preferDirect,
                PooledByteBufAllocator.defaultNumHeapArena(),
                PooledByteBufAllocator.defaultNumDirectArena(),
                PooledByteBufAllocator.defaultPageSize(),
                11,
                PooledByteBufAllocator.defaultSmallCacheSize(),
                64,
                PooledByteBufAllocator.defaultUseCacheForAllThreads(),
                directMemoryCacheAlignment);
    }

    // https://github.com/netty/netty/issues/11955
    @Test
    public void testCorrectElementSize() {
        assumeTrue(PooledByteBufAllocator.isDirectMemoryCacheAlignmentSupported());
        ByteBufAllocator allocator = new PooledByteBufAllocator(
                true,
                PooledByteBufAllocator.defaultNumHeapArena(),
                PooledByteBufAllocator.defaultNumDirectArena(),
                PooledByteBufAllocator.defaultPageSize(),
                11,
                PooledByteBufAllocator.defaultSmallCacheSize(),
                64,
                PooledByteBufAllocator.defaultUseCacheForAllThreads(),
                64);

        ByteBuf a = allocator.directBuffer(0, 16384);
        ByteBuf b = allocator.directBuffer(0, 16384);
        a.capacity(16);
        assertEquals(16, a.capacity());
        b.capacity(16);
        assertEquals(16, b.capacity());
        a.capacity(17);
        assertEquals(17, a.capacity());
        b.capacity(18);
        assertEquals(18, b.capacity());
        assertTrue(a.release());
        assertTrue(b.release());
    }

    @Test
    public void testDirectSubpageReleaseLock() throws InterruptedException {
        assumeTrue(PooledByteBufAllocator.isDirectMemoryCacheAlignmentSupported());
        int initialCapacity = 0;
        int directMemoryCacheAlignment = 32;
        PooledByteBufAllocator allocator = new PooledByteBufAllocator(
                true,
                0,
                1,
                PooledByteBufAllocator.defaultPageSize(),
                PooledByteBufAllocator.defaultMaxOrder(),
                0,
                0,
                false,
                directMemoryCacheAlignment);

        final ByteBuf wrapper = allocator.directBuffer(initialCapacity, 16);
        PooledByteBuf<?> unwrapped = pooledByteBuf(wrapper);
        // Get the smallSubpagePools[] array in arena.
        @SuppressWarnings("unchecked")
        PoolSubpage<byte[]>[] smallSubpagePools = (PoolSubpage<byte[]>[]) unwrapped.chunk.arena.smallSubpagePools;
        PoolSubpage<byte[]> head = null;
        for (PoolSubpage<byte[]> subpage : smallSubpagePools) {
            if (subpage.next != subpage) {
                // Find the head subpage which the byteBuf belongs to.
                head = subpage;
                break;
            }
        }
        assertNotNull(head);
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // Because the head subpage was already locked in the main thread, so this should hang and wait.
                wrapper.release();