pinnedMemoryMustReflectBuffersInUse() — netty Function Reference

Source Code

buffer/src/test/java/io/netty/buffer/PooledByteBufAllocatorTest.java lines 871–930

    private static void pinnedMemoryMustReflectBuffersInUse(boolean useThreadLocalCaching) {
        int smallCacheSize;
        int normalCacheSize;
        if (useThreadLocalCaching) {
            smallCacheSize = PooledByteBufAllocator.defaultSmallCacheSize();
            normalCacheSize = PooledByteBufAllocator.defaultNormalCacheSize();
        } else {
            smallCacheSize = 0;
            normalCacheSize = 0;
        }
        int directMemoryCacheAlignment = 0;
        PooledByteBufAllocator alloc = new PooledByteBufAllocator(
                PooledByteBufAllocator.defaultPreferDirect(),
                1,
                1,
                PooledByteBufAllocator.defaultPageSize(),
                PooledByteBufAllocator.defaultMaxOrder(),
                smallCacheSize,
                normalCacheSize,
                useThreadLocalCaching,
                directMemoryCacheAlignment);
        PooledByteBufAllocatorMetric metric = alloc.metric();
        AtomicLong capSum = new AtomicLong();

        for (long index = 0; index < 10000; index++) {
            ThreadLocalRandom rnd = ThreadLocalRandom.current();
            int bufCount = rnd.nextInt(1, 100);
            List<ByteBuf> buffers = new ArrayList<ByteBuf>(bufCount);

            if (index % 2 == 0) {
                // ensure that we allocate a small buffer
                for (int i = 0; i < bufCount; i++) {
                    ByteBuf buf = alloc.directBuffer(rnd.nextInt(8, 128));
                    buffers.add(buf);
                    capSum.addAndGet(buf.capacity());
                }
            } else {
                // allocate a larger buffer
                for (int i = 0; i < bufCount; i++) {
                    ByteBuf buf = alloc.directBuffer(rnd.nextInt(1024, 1024 * 100));
                    buffers.add(buf);
                    capSum.addAndGet(buf.capacity());
                }
            }

            if (index % 100 == 0) {
                long used = usedMemory(metric.directArenas());
                long pinned = alloc.pinnedDirectMemory();
                assertThat(capSum.get()).isLessThanOrEqualTo(pinned);
                assertThat(pinned).isLessThanOrEqualTo(used);
            }

            for (ByteBuf buffer : buffers) {
                buffer.release();
            }
            capSum.set(0);
            // After releasing all buffers, pinned memory must be zero
            assertThat(alloc.pinnedDirectMemory()).isZero();
        }
    }