ScheduleFutureTaskBenchmark Class — netty Architecture

Source Code

microbench/src/main/java/io/netty/util/concurrent/ScheduleFutureTaskBenchmark.java lines 36–111

@Warmup(iterations = 5, time = 3, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 10, time = 3, timeUnit = TimeUnit.SECONDS)
@State(Scope.Benchmark)
public class ScheduleFutureTaskBenchmark extends AbstractMicrobenchmark {

    static final Callable<Void> NO_OP = new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            return null;
        }
    };

    @State(Scope.Thread)
    public static class ThreadState {

        @Param({ "100000" })
        int num;

        AbstractScheduledEventExecutor eventLoop;

        @Setup(Level.Trial)
        public void reset() {
            eventLoop = (AbstractScheduledEventExecutor) new MultiThreadIoEventLoopGroup(
                    1, NioIoHandler.newFactory()).next();
        }

        @Setup(Level.Invocation)
        public void clear() {
            eventLoop.submit(new Runnable() {
                @Override
                public void run() {
                    eventLoop.cancelScheduledTasks();
                }
            }).awaitUninterruptibly();
        }

        @TearDown(Level.Trial)
        public void shutdown() {
            clear();
            eventLoop.parent().shutdownGracefully().awaitUninterruptibly();
        }
    }

    @Benchmark
    @Threads(3)
    public Future<?> scheduleLots(final ThreadState threadState) {
        return threadState.eventLoop.submit(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= threadState.num; i++) {
                    threadState.eventLoop.schedule(NO_OP, i, TimeUnit.HOURS);
                }
            }
        }).syncUninterruptibly();
    }

    @Benchmark
    @Threads(1)
    public Future<?> scheduleLotsOutsideLoop(final ThreadState threadState) {
        final AbstractScheduledEventExecutor eventLoop = threadState.eventLoop;
        for (int i = 1; i <= threadState.num; i++) {
            eventLoop.schedule(NO_OP, i, TimeUnit.HOURS);
        }
        return null;
    }

    @Benchmark
    @Threads(1)
    public Future<?> scheduleCancelLotsOutsideLoop(final ThreadState threadState) {
        final AbstractScheduledEventExecutor eventLoop = threadState.eventLoop;
        for (int i = 1; i <= threadState.num; i++) {
            eventLoop.schedule(NO_OP, i, TimeUnit.HOURS).cancel(false);
        }
        return null;
    }
}