ByteBufAllocatorAllocPatternBenchmark Class — netty Architecture

Source Code

microbench/src/main/java/io/netty/microbench/buffer/ByteBufAllocatorAllocPatternBenchmark.java lines 45–629

@Warmup(iterations = 10, time = 1)
@Measurement(iterations = 10, time = 1)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Benchmark)
@BenchmarkMode(Mode.AverageTime)
@Threads(1)
public class ByteBufAllocatorAllocPatternBenchmark extends AbstractMicrobenchmark {

    public enum AllocatorType {
        ADAPTIVE(AdaptiveByteBufAllocator::new),
        POOLED(() -> PooledByteBufAllocator.DEFAULT);

        private final Supplier<ByteBufAllocator> factory;

        AllocatorType(Supplier<ByteBufAllocator> factory) {
            this.factory = factory;
        }

        private ByteBufAllocator create() {
            return factory.get();
        }
    }

    @Param({ "ADAPTIVE" })
    public AllocatorType allocatorType;

    @Param({ "0", "200000" })
    public int pollutionIterations;

    private ByteBufAllocator allocator;

    @State(Scope.Thread)
    public static class AllocationPatternState {
        private int[] releaseIndexes;
        private int[] sizes;
        private int nextReleaseIndex;
        private int nextSizeIndex;
        private ByteBuf[] buffers;
        private ByteBufAllocator allocator;

        @Setup
        public void setup(ByteBufAllocatorAllocPatternBenchmark benchmark) {
            this.allocator = benchmark.allocator;
            releaseIndexes = new int[MAX_LIVE_BUFFERS];
            sizes = new int[MathUtil.findNextPositivePowerOfTwo(FLATTEND_SIZE_ARRAY.length)];
            SplittableRandom rand = new SplittableRandom(SEED);
            // Pre-generate the to be released index.
            for (int i = 0; i < releaseIndexes.length; i++) {
                releaseIndexes[i] = rand.nextInt(releaseIndexes.length);
            }
            // Shuffle the `flattendSizeArray` to `sizes`.
            for (int i = 0; i < sizes.length; i++) {
                int sizeIndex = rand.nextInt(FLATTEND_SIZE_ARRAY.length);
                sizes[i] = FLATTEND_SIZE_ARRAY[sizeIndex];
            }
            nextReleaseIndex = 0;
            nextSizeIndex = 0;
            buffers = new ByteBuf[MAX_LIVE_BUFFERS];
        }

        private int getNextReleaseIndex() {
            int index = nextReleaseIndex;
            nextReleaseIndex = (nextReleaseIndex + 1) & (releaseIndexes.length - 1);
            return releaseIndexes[index];
        }

        private int getNextSizeIndex() {
            int index = nextSizeIndex;
            nextSizeIndex = (nextSizeIndex + 1) & (sizes.length - 1);
            return index;
        }

        @CompilerControl(CompilerControl.Mode.DONT_INLINE)
        private static void release(ByteBuf buf) {
            buf.release();
        }

        @CompilerControl(CompilerControl.Mode.DONT_INLINE)
        private static ByteBuf allocateHeap(ByteBufAllocator allocator, int size) {
            return allocator.heapBuffer(size);
        }