ByteBufZeroingBenchmark Class — netty Architecture

Source Code

microbench/src/main/java/io/netty/buffer/ByteBufZeroingBenchmark.java lines 33–125

@State(Scope.Benchmark)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 10, time = 400, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 5, time = 200, timeUnit = TimeUnit.MILLISECONDS)
public class ByteBufZeroingBenchmark extends AbstractMicrobenchmark {

    @Param({
            "1",
            "2",
            "3",
            "4",
            "7",
            "8",
            "15",
            "64",
            "65",
            "1024",
    })
    private int bytes = 1024;
    @Param({
            "true",
            "false",
    })
    private boolean direct;
    @Param({
            "true",
            "false",
    })
    private boolean pooled;
    @Param({
            "false",
    })
    public String checkAccessible;

    @Param({
            "false",
    })
    public String checkBounds;
    @Param({
            "0",
            "1",
    })
    public int startOffset;
    private ByteBuf buffer;
    private int offset;

    @Setup
    public void setup() {
        System.setProperty("io.netty.buffer.checkAccessible", checkAccessible);
        System.setProperty("io.netty.buffer.checkBounds", checkBounds);
        ByteBufAllocator allocator = pooled? PooledByteBufAllocator.DEFAULT : UnpooledByteBufAllocator.DEFAULT;
        int capacityRequired = startOffset + bytes;
        offset = 0;
        buffer = direct? alignedDirectAllocation(allocator, capacityRequired, 8) :
                allocator.heapBuffer(capacityRequired, capacityRequired);
        if (startOffset > 0) {
            offset += startOffset;
        }
    }

    private ByteBuf alignedDirectAllocation(ByteBufAllocator allocator, int bytes, final int alignment) {
        ByteBuf buffer = allocator.directBuffer(bytes + alignment, bytes + alignment);
        final long address = buffer.memoryAddress();
        final int remainder = (int) address % alignment;
        final int nextAlignedOffset = alignment - remainder;
        this.offset = nextAlignedOffset;
        return buffer;
    }

    @Benchmark
    public ByteBuf setZero() {
        final ByteBuf buffer = this.buffer;
        buffer.setZero(offset, bytes);
        return buffer;
    }

    @Benchmark
    public ByteBuf setBytes() {
        final ByteBuf buffer = this.buffer;
        final int offset = this.offset;