ByteBufAccessBenchmark Class — netty Architecture

Source Code

microbench/src/main/java/io/netty/buffer/ByteBufAccessBenchmark.java lines 37–299

@Warmup(iterations = 10, time = 1)
@Measurement(iterations = 10, time = 1)
@Fork(2)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class ByteBufAccessBenchmark extends AbstractMicrobenchmark {

    static final class NioFacade extends WrappedByteBuf {
        private final ByteBuffer byteBuffer;
        private final CleanableDirectBuffer cleanable;

        NioFacade(CleanableDirectBuffer buffer) {
            super(Unpooled.EMPTY_BUFFER);
            byteBuffer = buffer.buffer();
            cleanable = buffer;
        }
        @Override
        public ByteBuf setLong(int index, long value) {
            byteBuffer.putLong(index, value);
            return this;
        }
        @Override
        public long getLong(int index) {
            return byteBuffer.getLong(index);
        }
        @Override
        public byte readByte() {
            return byteBuffer.get();
        }
        @Override
        public ByteBuf touch() {
            // hack since WrappedByteBuf.readerIndex(int) is final
            byteBuffer.position(0);
            return this;
        }
        @Override
        public boolean release() {
            cleanable.clean();
            return true;
        }
    }

    public enum ByteBufType {
        UNSAFE {
            @Override
            ByteBuf newBuffer() {
                return new UnpooledUnsafeDirectByteBuf(
                        UnpooledByteBufAllocator.DEFAULT, 64, 64).setIndex(0, 64);
            }
        },
        DIRECT {
            @Override
            ByteBuf newBuffer() {
                return new UnpooledDirectByteBuf(
                        UnpooledByteBufAllocator.DEFAULT, 64, 64).setIndex(0, 64);
            }
        },
        UNSAFE_SLICE {
            @Override
            ByteBuf newBuffer() {
                return UNSAFE.newBuffer().slice(16, 48);
            }
        },
        UNSAFE_RETAINED_SLICE {
            @Override
            ByteBuf newBuffer() {
                ByteBuf pooledBuffer = PooledByteBufAllocator.DEFAULT.directBuffer(64, 64)
                        .setIndex(0, 64);
                if (!(pooledBuffer instanceof PooledUnsafeDirectByteBuf)) {
                    throw new IllegalStateException("Expected PooledUnsafeDirectByteBuf");
                }
                try {
                    return pooledBuffer.retainedSlice(16, 48);
                } finally {
                    pooledBuffer.release();
                }
            }
        },
        HEAP {
            @Override
            ByteBuf newBuffer() {