AllocationPatternState Class — netty Architecture

Source Code

microbench/src/main/java/io/netty/microbench/buffer/ByteBufAllocatorAllocPatternBenchmark.java lines 76–173

    @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);
        }

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

        @CompilerControl(CompilerControl.Mode.DONT_INLINE)
        public void performDirectAllocation() {
            int size = sizes[getNextSizeIndex()];
            int releaseIndex = getNextReleaseIndex();
            ByteBuf[] buffers = this.buffers;
            ByteBuf oldBuf = buffers[releaseIndex];
            if (oldBuf != null) {
                release(oldBuf);
            }
            ByteBuf newBuf = allocateDirect(allocator, size);
            buffers[releaseIndex] = newBuf;
        }

        @CompilerControl(CompilerControl.Mode.DONT_INLINE)
        public void performHeapAllocation() {
            int size = sizes[getNextSizeIndex()];
            int releaseIndex = getNextReleaseIndex();
            ByteBuf oldBuf = buffers[releaseIndex];
            if (oldBuf != null) {
                release(oldBuf);
            }
            ByteBuf newBuf = allocateHeap(allocator, size);
            buffers[releaseIndex] = newBuf;
        }