Netty application optimization - performance

Question

I'm writing a local HTTP server based on Netty. When I make a stress test, I'm limited on 400 requests/second.
To optimize my server, I've written a simple server based on Netty, that just sends "Hello World" to the client, and I launched a stress test with Gatling 2, and with this server, I've got the same result (limited to 400 req/s).
I use Yourkit for profiling, there is no extra GC activity, and my open/closed sockets are limited to 480 sockets/s.
I work with a MacBook Pro, with 4 cores, 16 GB of RAM, and I use Netty 4.1.
I'm surprised to be limited at 400 req/s, because the result of other benchmark tests show >20 000 req/s, or more. I understand that there are hardware limits, but 400 req/s, for a sending "hello World" on a 4 cores + 16 GB of Ram is very low.
Thank you in advance for your help, I don't know where to begin to optimize my Netty code.
Are there any concrete guidelines of optimizing Netty?
Here the source code of my hello world server, followed by the handler of my connections:
public class TestServer {
private static final Logger logger = LogManager.getLogger("TestServer");
int nbSockets = 0 ;
EventLoopGroup pool = new NioEventLoopGroup() ;
private void init(int port) {
EventLoopGroup bossGroup = new NioEventLoopGroup(100) ;
try {
long t1 = System.currentTimeMillis() ;
ServerBootstrap b = new ServerBootstrap().group(bossGroup);
b.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
#Override
public void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast("decoder", new HttpRequestDecoder(8192, 8192 * 2,
8192 * 2));
ch.pipeline().addLast("encoder", new HttpResponseEncoder());
ch.pipeline().addLast(new TestServerHandler(TestServer.this));
}
#Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
System.err.println("Error");
super.exceptionCaught(ctx,cause);
}
})
.option(ChannelOption.SO_BACKLOG, 100000)
.option(ChannelOption.SO_KEEPALIVE,false)
.option(ChannelOption.TCP_NODELAY,false)
.option(ChannelOption.SO_REUSEADDR,true)
.option(ChannelOption.CONNECT_TIMEOUT_MILLIS,10000)
.childOption(ChannelOption.SO_KEEPALIVE, true);
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);;
scheduler.scheduleAtFixedRate(new Runnable() {
#Override
public void run() {
System.err.println(nbSockets);
nbSockets = 0 ;
}
},1, 1,TimeUnit.SECONDS) ;
// Bind and start to accept incoming connections.
ChannelFuture f = b.bind(port).sync();
f.channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
bossGroup.shutdownGracefully();
System.err.println("Coucou");
}
}
public static void main(String[] args) {
TestServer testServer = new TestServer() ;
testServer.init(8888);
}
}
and here is the source code of my handler:
public class TestServerHandler extends ChannelInboundHandlerAdapter {
private final TestServer testServer;
public TestServerHandler(TestServer testServer) {
this.testServer = testServer ;
}
#Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
try {
process(ctx, msg);
} catch (Throwable e) {
e.printStackTrace();
}
}
public void process(ChannelHandlerContext ctx, Object msg) throws Exception {
ctx.channel().writeAndFlush(buildHttpResponse()).addListener(new GenericFutureListener<Future<? super Void>>() {
#Override
public void operationComplete(Future<? super Void> future) throws Exception {
ctx.channel().close() ;
testServer.nbSockets ++ ;
}
}) ;
}
public DefaultFullHttpResponse buildHttpResponse() {
String body = "hello world" ;
byte[] bytes = body.getBytes(Charset.forName("UTF-8"));
ByteBuf byteContent = Unpooled.copiedBuffer(bytes);
HttpResponseStatus httpResponseStatus =HttpResponseStatus.OK;
DefaultFullHttpResponse httpResponse = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,
httpResponseStatus, byteContent);
return httpResponse;
}
}

Answer 1

You've disabled keep-alive and are closing the connection on every request, so I suspect you spend most of your time opening and closing HTTP connections.
because the result of other benchmark tests show >20 000 req/s, or more
Which other benchmarks are you referring to? There's a very good chance they were both pooling connections, and using HTTP pipelining, hence a very different usage from yours.
Back to your original question (how to optimize Netty), there's two kind of things you could do:
Micro-optimize allocations: using pooled ByteBuffers, or even better computing them only once
Switch to native epoll transport (Linux only)
But all those improvement won't probably amount to much compare to connection handling.