ByteBufAllocatorBenchmark Class — netty Architecture

Source Code

microbench/src/main/java/io/netty/microbench/buffer/ByteBufAllocatorBenchmark.java lines 37–181

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

    private static final ByteBufAllocator unpooledAllocator = new UnpooledByteBufAllocator(true);
    private static final ByteBufAllocator pooledAllocator =
            new PooledByteBufAllocator(true, 4, 4, 8192, 11, 0, 0, 0, true, 0);
    private static final ByteBufAllocator adaptiveAllocator = new AdaptiveByteBufAllocator();

    private static final int MAX_LIVE_BUFFERS = 8192;
    private static final ByteBuf[] unpooledHeapBuffers = new ByteBuf[MAX_LIVE_BUFFERS];
    private static final ByteBuf[] unpooledDirectBuffers = new ByteBuf[MAX_LIVE_BUFFERS];
    private static final ByteBuf[] pooledHeapBuffers = new ByteBuf[MAX_LIVE_BUFFERS];
    private static final ByteBuf[] pooledDirectBuffers = new ByteBuf[MAX_LIVE_BUFFERS];
    private static final ByteBuf[] defaultPooledHeapBuffers = new ByteBuf[MAX_LIVE_BUFFERS];
    private static final ByteBuf[] defaultPooledDirectBuffers = new ByteBuf[MAX_LIVE_BUFFERS];
    private static final ByteBuf[] adaptiveHeapBuffers = new ByteBuf[MAX_LIVE_BUFFERS];
    private static final ByteBuf[] adaptiveDirectBuffers = new ByteBuf[MAX_LIVE_BUFFERS];

    @Param({
            "00000",
            "00256",
            "01024",
            "04096",
            "16384",
            "65536",
    })
    public int size;
    private static final short[] NEXT_INDEXES = new short[128 * 1024];
    private static final int NEXT_INDEX_MASK = NEXT_INDEXES.length - 1;
    private int nextIndex;

    static {
        Random r = new Random();
        r.setSeed(42);
        for (int i = 0; i < NEXT_INDEXES.length; i++) {
            NEXT_INDEXES[i] = (short) r.nextInt(MAX_LIVE_BUFFERS);
        }
    }

    private int nextIndex() {
        this.nextIndex = (nextIndex + 1) & NEXT_INDEX_MASK;
        return NEXT_INDEXES[nextIndex];
    }

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

    @Benchmark
    public void unpooledHeapAllocAndFree() {
        int idx = nextIndex();
        ByteBuf oldBuf = unpooledHeapBuffers[idx];
        if (oldBuf != null) {
            oldBuf.release();
        }
        unpooledHeapBuffers[idx] = unpooledAllocator.heapBuffer(size);
    }

    @Benchmark
    public void unpooledDirectAllocAndFree() {
        int idx = nextIndex();
        ByteBuf oldBuf = unpooledDirectBuffers[idx];
        if (oldBuf != null) {
            oldBuf.release();