EpollSocketChannelBenchmark Class — netty Architecture

Source Code

microbench/src/main/java/io/netty/microbench/channel/epoll/EpollSocketChannelBenchmark.java lines 40–158

public class EpollSocketChannelBenchmark extends AbstractMicrobenchmark {
    private static final Runnable runnable = new Runnable() {
        @Override
        public void run() { }
    };

    private EventLoopGroup group;
    private Channel serverChan;
    private Channel chan;
    private ByteBuf abyte;
    private Future<?> future;

    @Setup
    public void setup() throws Exception {
        group = new MultiThreadIoEventLoopGroup(1, EpollIoHandler.newFactory());

        // add an arbitrary timeout to make the timer reschedule
        future = group.schedule(new Runnable() {
            @Override
            public void run() {
                throw new AssertionError();
            }
        }, 5, TimeUnit.MINUTES);
        serverChan = new ServerBootstrap()
            .channel(EpollServerSocketChannel.class)
            .group(group)
            .childHandler(new ChannelInitializer<Channel>() {
                @Override
                protected void initChannel(Channel ch) {
                    ch.pipeline().addLast(new ChannelDuplexHandler() {
                        @Override
                        public void channelRead(ChannelHandlerContext ctx, Object msg) {
                            if (msg instanceof ByteBuf) {
                                ctx.writeAndFlush(msg, ctx.voidPromise());
                            } else {
                                throw new AssertionError();
                            }
                        }
                    });
                }
            })
            .bind(0)
            .sync()
            .channel();
    chan = new Bootstrap()
        .channel(EpollSocketChannel.class)
        .handler(new ChannelInitializer<Channel>() {
            @Override
            protected void initChannel(Channel ch) {
                ch.pipeline().addLast(new ChannelDuplexHandler() {

                private ChannelPromise lastWritePromise;

                    @Override
                    public void channelRead(ChannelHandlerContext ctx, Object msg) {
                        if (msg instanceof ByteBuf) {

                            ByteBuf buf = (ByteBuf) msg;
                            try {
                                if (buf.readableBytes() == 1) {
                                    lastWritePromise.trySuccess();
                                    lastWritePromise = null;
                                } else {
                                    throw new AssertionError();
                                }
                            } finally {
                                buf.release();
                            }
                        } else {
                            throw new AssertionError();
                        }
                    }

                    @Override
                    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)
                            throws Exception {
                        if (lastWritePromise != null) {
                            throw new IllegalStateException();
                        }
                        lastWritePromise = promise;
                        super.write(ctx, msg, ctx.voidPromise());