ByteBufAllocateAndGrowBenchmark Class — netty Architecture

Source Code

microbench/src/main/java/io/netty/microbench/buffer/ByteBufAllocateAndGrowBenchmark.java lines 37–125

@State(Scope.Benchmark)
public class ByteBufAllocateAndGrowBenchmark extends AbstractMicrobenchmark {

    private static final ByteBufAllocator pooledAllocator = PooledByteBufAllocator.DEFAULT;
    private static final ByteBufAllocator adaptiveAllocator = new AdaptiveByteBufAllocator();

    private static final int MAX_LIVE_BUFFERS = 2048;
    private static final Random rand = new Random();
    private static final ByteBuf[] pooledDirectBuffers = new ByteBuf[MAX_LIVE_BUFFERS];
    private static final ByteBuf[] adaptiveDirectBuffers = new ByteBuf[MAX_LIVE_BUFFERS];

    @Param({
            "00256",
            "01024",
            "04096",
            "16384",
            "65536",
    })
    public int size;

    @TearDown
    public void releaseBuffers() {
        List<ByteBuf[]> bufferLists = Arrays.asList(
                pooledDirectBuffers,
                adaptiveDirectBuffers);
        for (ByteBuf[] bufs : bufferLists) {
            for (ByteBuf buf : bufs) {
                if (buf != null && buf.refCnt() > 0) {
                    buf.release();
                }
            }
            Arrays.fill(bufs, null);
        }
    }

    @Benchmark
    public void pooledDirectAllocAndFree(BufStats stats) {
        int idx = rand.nextInt(pooledDirectBuffers.length);
        ByteBuf oldBuf = pooledDirectBuffers[idx];
        if (oldBuf != null) {
            oldBuf.release();
        }
        ByteBuf buf = pooledAllocator.directBuffer();
        expandBuffer(buf, stats);
        pooledDirectBuffers[idx] = buf;
    }

    @Benchmark
    public void adaptiveDirectAllocAndFree(BufStats stats) {
        int idx = rand.nextInt(adaptiveDirectBuffers.length);
        ByteBuf oldBuf = adaptiveDirectBuffers[idx];
        if (oldBuf != null) {
            oldBuf.release();
        }
        ByteBuf buf = adaptiveAllocator.directBuffer();
        expandBuffer(buf, stats);
        adaptiveDirectBuffers[idx] = buf;
    }

    private void expandBuffer(ByteBuf buf, BufStats stats) {
        stats.record(buf);
        while (buf.capacity() < size) {
            buf.capacity(2 * buf.capacity());
            stats.record(buf);
        }
    }

    @State(Scope.Thread)
    @AuxCounters
    public static class BufStats {
        long bufCounts;
        long bufSizeSum;
        long bufFastCapSum;

        void record(ByteBuf byteBuf) {
            bufCounts++;
            bufSizeSum += byteBuf.capacity();
            bufFastCapSum += byteBuf.maxFastWritableBytes();
        }

        public double avgSize() {