RecyclerBenchmark Class — netty Architecture

Source Code

microbench/src/main/java/io/netty/microbench/util/RecyclerBenchmark.java lines 42–220

@Warmup(iterations = AbstractMicrobenchmarkBase.DEFAULT_WARMUP_ITERATIONS, time = 1)
@Measurement(iterations = AbstractMicrobenchmarkBase.DEFAULT_MEASURE_ITERATIONS, time = 1)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class RecyclerBenchmark extends AbstractMicrobenchmark {

    @Override
    protected ChainedOptionsBuilder newOptionsBuilder() throws Exception {
        return super.newOptionsBuilder().addProfiler("gc");
    }

    @Benchmark
    public DummyObject plainNew() {
        return new DummyObject();
    }

    @Benchmark
    public DummyObject recyclerGetAndOrphan(ProducerConsumerState state) {
        return state.recycler.get();
    }

    @Benchmark
    public DummyObject recyclerGetAndRecycle(ProducerConsumerState state) {
        DummyObject o = state.recycler.get();
        o.recycle();
        return o;
    }

    @Benchmark
    public DummyObject recyclerGetAndUnguardedRecycle(ProducerConsumerState state) {
        DummyObject o = state.recycler.get();
        o.unguardedRecycle();
        return o;
    }

    @State(Scope.Benchmark)
    public static class ProducerConsumerState {

        @Param({ "false", "true" })
        boolean unguarded;

        @Param({ "false", "true" })
        boolean fastThreadLocal;

        Queue<DummyObject> queue;

        Recycler<DummyObject> recycler;

        @Setup
        public void init(BenchmarkParams params) {
            if (params.getBenchmark().endsWith("roducerConsumer")) {
                final int threads = params.getThreads();
                if (threads != 2) {
                    throw new IllegalStateException("ProducerConsumerState only supports exactly 2 threads");
                }
            }
            queue = PlatformDependent.hasUnsafe()?
                    new SpscArrayQueue<>(100) : new SpscAtomicArrayQueue<>(100);
            recycler = !fastThreadLocal?
                    new Recycler<DummyObject>(Thread.currentThread(), unguarded) {
                        @Override
                        protected DummyObject newObject(Recycler.Handle<DummyObject> handle) {
                            return new DummyObject((EnhancedHandle<DummyObject>) handle);
                        }
                    } :
                    new Recycler<DummyObject>(unguarded) {
                        @Override
                        protected DummyObject newObject(Recycler.Handle<DummyObject> handle) {
                            return new DummyObject((EnhancedHandle<DummyObject>) handle);
                        }
                    };
        }
    }

    @AuxCounters
    @State(Scope.Thread)
    public static class ProducerStats {
        public long fullQ;
    }

    // The allocation stats are the main thing interesting about this benchmark