Use ByteBuf#writeShort/writeMedium instead of writeBytes

Motivation: 1. Some encoders used a `ByteBuf#writeBytes` to write short constant byte array (2-3 bytes). This can be replaced with more faster `ByteBuf#writeShort` or `ByteBuf#writeMedium` which do not access the memory. 2. Two chained calls of the `ByteBuf#setByte` with constants can be replaced with one `ByteBuf#setShort` to reduce index checks. 3. The signature of method `HttpHeadersEncoder#encoderHeader` has an unnecessary `throws`. Modifications: 1. Use `ByteBuf#writeShort` or `ByteBuf#writeMedium` instead of `ByteBuf#writeBytes` for the constants. 2. Use `ByteBuf#setShort` instead of chained call of the `ByteBuf#setByte` with constants. 3. Remove an unnecessary `throws` from `HttpHeadersEncoder#encoderHeader`. Result: A bit faster writes constants into buffers.
dschobel · Jul 10, 2017 · df568c7 · df568c7
1 parent 83db2b0
commit df568c7
Show file tree

Hide file tree

Showing 11 changed files with 280 additions and 100 deletions.
diff --git a/buffer/src/main/java/io/netty/buffer/ByteBufUtil.java b/buffer/src/main/java/io/netty/buffer/ByteBufUtil.java
@@ -387,6 +387,30 @@ public static long swapLong(long value) {
         return Long.reverseBytes(value);
     }
 
+    /**
+     * Writes a big-endian 16-bit short integer to the buffer.
+     */
+    @SuppressWarnings("deprecation")
+    public static ByteBuf writeShortBE(ByteBuf buf, int shortValue) {
+        return buf.order() == ByteOrder.BIG_ENDIAN? buf.writeShort(shortValue) : buf.writeShortLE(shortValue);
+    }
+
+    /**
+     * Sets a big-endian 16-bit short integer to the buffer.
+     */
+    @SuppressWarnings("deprecation")
+    public static ByteBuf setShortBE(ByteBuf buf, int index, int shortValue) {
+        return buf.order() == ByteOrder.BIG_ENDIAN? buf.setShort(index, shortValue) : buf.setShortLE(index, shortValue);
+    }
+
+    /**
+     * Writes a big-endian 24-bit medium integer to the buffer.
+     */
+    @SuppressWarnings("deprecation")
+    public static ByteBuf writeMediumBE(ByteBuf buf, int mediumValue) {
+        return buf.order() == ByteOrder.BIG_ENDIAN? buf.writeMedium(mediumValue) : buf.writeMediumLE(mediumValue);
+    }
+
     /**
      * Read the given amount of bytes into a new {@link ByteBuf} that is allocated from the {@link ByteBufAllocator}.
      */

diff --git a/buffer/src/test/java/io/netty/buffer/ByteBufUtilTest.java b/buffer/src/test/java/io/netty/buffer/ByteBufUtilTest.java
@@ -19,6 +19,7 @@
 import io.netty.util.CharsetUtil;
 import org.junit.Test;
 
+import java.nio.ByteOrder;
 import java.nio.charset.Charset;
 import java.util.Arrays;
 import java.util.Random;
@@ -129,6 +130,66 @@ public void notEqualsBufferUnderflow() {
                 -1));
     }
 
+    @SuppressWarnings("deprecation")
+    @Test
+    public void writeShortBE() {
+        int expected = 0x1234;
+
+        ByteBuf buf = Unpooled.buffer(2).order(ByteOrder.BIG_ENDIAN);
+        ByteBufUtil.writeShortBE(buf, expected);
+        assertEquals(expected, buf.readShort());
+        buf.resetReaderIndex();
+        assertEquals(ByteBufUtil.swapShort((short) expected), buf.readShortLE());
+        buf.release();
+
+        buf = Unpooled.buffer(2).order(ByteOrder.LITTLE_ENDIAN);
+        ByteBufUtil.writeShortBE(buf, expected);
+        assertEquals((short) expected, buf.readShortLE());
+        buf.resetReaderIndex();
+        assertEquals(ByteBufUtil.swapShort((short) expected), buf.readShort());
+        buf.release();
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    public void setShortBE() {
+        int shortValue = 0x1234;
+
+        ByteBuf buf = Unpooled.wrappedBuffer(new byte[2]).order(ByteOrder.BIG_ENDIAN);
+        ByteBufUtil.setShortBE(buf, 0, shortValue);
+        assertEquals(shortValue, buf.readShort());
+        buf.resetReaderIndex();
+        assertEquals(ByteBufUtil.swapShort((short) shortValue), buf.readShortLE());
+        buf.release();
+
+        buf = Unpooled.wrappedBuffer(new byte[2]).order(ByteOrder.LITTLE_ENDIAN);
+        ByteBufUtil.setShortBE(buf, 0, shortValue);
+        assertEquals((short) shortValue, buf.readShortLE());
+        buf.resetReaderIndex();
+        assertEquals(ByteBufUtil.swapShort((short) shortValue), buf.readShort());
+        buf.release();
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    public void writeMediumBE() {
+        int mediumValue = 0x123456;
+
+        ByteBuf buf = Unpooled.buffer(4).order(ByteOrder.BIG_ENDIAN);
+        ByteBufUtil.writeMediumBE(buf, mediumValue);
+        assertEquals(mediumValue, buf.readMedium());
+        buf.resetReaderIndex();
+        assertEquals(ByteBufUtil.swapMedium(mediumValue), buf.readMediumLE());
+        buf.release();
+
+        buf = Unpooled.buffer(4).order(ByteOrder.LITTLE_ENDIAN);
+        ByteBufUtil.writeMediumBE(buf, mediumValue);
+        assertEquals(mediumValue, buf.readMediumLE());
+        buf.resetReaderIndex();
+        assertEquals(ByteBufUtil.swapMedium(mediumValue), buf.readMedium());
+        buf.release();
+    }
+
     @Test
     public void testWriteUsAscii() {
         String usAscii = "NettyRocks";

diff --git a/codec-http/src/main/java/io/netty/handler/codec/http/HttpHeadersEncoder.java b/codec-http/src/main/java/io/netty/handler/codec/http/HttpHeadersEncoder.java
@@ -21,25 +21,29 @@
 import io.netty.util.AsciiString;
 import io.netty.util.CharsetUtil;
 
+import static io.netty.handler.codec.http.HttpConstants.*;
+import static io.netty.handler.codec.http.HttpObjectEncoder.CRLF_SHORT;
+
 final class HttpHeadersEncoder {
+    private static final int COLON_AND_SPACE_SHORT = (COLON << 8) | SP;
 
     private HttpHeadersEncoder() {
     }
 
-    static void encoderHeader(CharSequence name, CharSequence value, ByteBuf buf) throws Exception {
+    static void encoderHeader(CharSequence name, CharSequence value, ByteBuf buf) {
         final int nameLen = name.length();
         final int valueLen = value.length();
         final int entryLen = nameLen + valueLen + 4;
         buf.ensureWritable(entryLen);
         int offset = buf.writerIndex();
         writeAscii(buf, offset, name);
         offset += nameLen;
-        buf.setByte(offset ++, ':');
-        buf.setByte(offset ++, ' ');
+        ByteBufUtil.setShortBE(buf, offset, COLON_AND_SPACE_SHORT);
+        offset += 2;
         writeAscii(buf, offset, value);
         offset += valueLen;
-        buf.setByte(offset ++, '\r');
-        buf.setByte(offset ++, '\n');
+        ByteBufUtil.setShortBE(buf, offset, CRLF_SHORT);
+        offset += 2;
         buf.writerIndex(offset);
     }
 

diff --git a/codec-http/src/main/java/io/netty/handler/codec/http/HttpObjectEncoder.java b/codec-http/src/main/java/io/netty/handler/codec/http/HttpObjectEncoder.java
@@ -16,11 +16,11 @@
 package io.netty.handler.codec.http;
 
 import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufUtil;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.FileRegion;
 import io.netty.handler.codec.MessageToMessageEncoder;
 import io.netty.util.CharsetUtil;
-import io.netty.util.internal.PlatformDependent;
 import io.netty.util.internal.StringUtil;
 
 import java.util.Iterator;
@@ -47,10 +47,10 @@
  * implement all abstract methods properly.
  */
 public abstract class HttpObjectEncoder<H extends HttpMessage> extends MessageToMessageEncoder<Object> {
-    static final byte[] CRLF = { CR, LF };
-    private static final byte[] ZERO_CRLF = { '0', CR, LF };
+    static final int CRLF_SHORT = (CR << 8) | LF;
+    private static final int ZERO_CRLF_MEDIUM = ('0' << 16) | CRLF_SHORT;
     private static final byte[] ZERO_CRLF_CRLF = { '0', CR, LF, CR, LF };
-    private static final ByteBuf CRLF_BUF = unreleasableBuffer(directBuffer(CRLF.length).writeBytes(CRLF));
+    private static final ByteBuf CRLF_BUF = unreleasableBuffer(directBuffer(2).writeByte(CR).writeByte(LF));
     private static final ByteBuf ZERO_CRLF_CRLF_BUF = unreleasableBuffer(directBuffer(ZERO_CRLF_CRLF.length)
             .writeBytes(ZERO_CRLF_CRLF));
 
@@ -77,7 +77,7 @@ protected void encode(ChannelHandlerContext ctx, Object msg, List<Object> out) t
             // Encode the message.
             encodeInitialLine(buf, m);
             encodeHeaders(m.headers(), buf);
-            buf.writeBytes(CRLF);
+            ByteBufUtil.writeShortBE(buf, CRLF_SHORT);
             state = isContentAlwaysEmpty(m) ? ST_CONTENT_ALWAYS_EMPTY :
                     HttpUtil.isTransferEncodingChunked(m) ? ST_CONTENT_CHUNK : ST_CONTENT_NON_CHUNK;
         }
@@ -153,7 +153,7 @@ protected void encode(ChannelHandlerContext ctx, Object msg, List<Object> out) t
     /**
      * Encode the {@link HttpHeaders} into a {@link ByteBuf}.
      */
-    protected void encodeHeaders(HttpHeaders headers, ByteBuf buf) throws Exception {
+    protected void encodeHeaders(HttpHeaders headers, ByteBuf buf) {
         Iterator<Entry<CharSequence, CharSequence>> iter = headers.iteratorCharSequence();
         while (iter.hasNext()) {
             Entry<CharSequence, CharSequence> header = iter.next();
@@ -166,7 +166,7 @@ private void encodeChunkedContent(ChannelHandlerContext ctx, Object msg, long co
             String lengthHex = Long.toHexString(contentLength);
             ByteBuf buf = ctx.alloc().buffer(lengthHex.length() + 2);
             buf.writeCharSequence(lengthHex, CharsetUtil.US_ASCII);
-            buf.writeBytes(CRLF);
+            ByteBufUtil.writeShortBE(buf, CRLF_SHORT);
             out.add(buf);
             out.add(encodeAndRetain(msg));
             out.add(CRLF_BUF.duplicate());
@@ -178,19 +178,14 @@ private void encodeChunkedContent(ChannelHandlerContext ctx, Object msg, long co
                 out.add(ZERO_CRLF_CRLF_BUF.duplicate());
             } else {
                 ByteBuf buf = ctx.alloc().buffer();
-                buf.writeBytes(ZERO_CRLF);
-                try {
-                    encodeHeaders(headers, buf);
-                } catch (Exception ex) {
-                    buf.release();
-                    PlatformDependent.throwException(ex);
-                }
-                buf.writeBytes(CRLF);
+                ByteBufUtil.writeMediumBE(buf, ZERO_CRLF_MEDIUM);
+                encodeHeaders(headers, buf);
+                ByteBufUtil.writeShortBE(buf, CRLF_SHORT);
                 out.add(buf);
             }
         } else if (contentLength == 0) {
             // Need to produce some output otherwise an
-            // IllegalstateException will be thrown
+            // IllegalStateException will be thrown
             out.add(EMPTY_BUFFER);
         }
     }

diff --git a/codec-http/src/main/java/io/netty/handler/codec/http/HttpRequestEncoder.java b/codec-http/src/main/java/io/netty/handler/codec/http/HttpRequestEncoder.java
@@ -28,6 +28,8 @@
 public class HttpRequestEncoder extends HttpObjectEncoder<HttpRequest> {
     private static final char SLASH = '/';
     private static final char QUESTION_MARK = '?';
+    private static final int SLASH_AND_SPACE_SHORT = (SLASH << 8) | SP;
+    private static final int SPACE_SLASH_AND_SPACE_MEDIUM = (SP << 16) | SLASH_AND_SPACE_SHORT;
 
     @Override
     public boolean acceptOutboundMessage(Object msg) throws Exception {
@@ -37,37 +39,42 @@ public boolean acceptOutboundMessage(Object msg) throws Exception {
     @Override
     protected void encodeInitialLine(ByteBuf buf, HttpRequest request) throws Exception {
         ByteBufUtil.copy(request.method().asciiName(), buf);
-        buf.writeByte(SP);
 
-        // Add / as absolute path if no is present.
-        // See http://tools.ietf.org/html/rfc2616#section-5.1.2
         String uri = request.uri();
 
         if (uri.isEmpty()) {
-            uri += SLASH;
+            // Add " / " as absolute path if uri is not present.
+            // See http://tools.ietf.org/html/rfc2616#section-5.1.2
+            ByteBufUtil.writeMediumBE(buf, SPACE_SLASH_AND_SPACE_MEDIUM);
         } else {
+            CharSequence uriCharSequence = uri;
+            boolean needSlash = false;
             int start = uri.indexOf("://");
             if (start != -1 && uri.charAt(0) != SLASH) {
-                int startIndex = start + 3;
+                start += 3;
                 // Correctly handle query params.
                 // See https://github.com/netty/netty/issues/2732
-                int index = uri.indexOf(QUESTION_MARK, startIndex);
+                int index = uri.indexOf(QUESTION_MARK, start);
                 if (index == -1) {
-                    if (uri.lastIndexOf(SLASH) <= startIndex) {
-                        uri += SLASH;
+                    if (uri.lastIndexOf(SLASH) <= start) {
+                        needSlash = true;
                     }
                 } else {
-                    if (uri.lastIndexOf(SLASH, index) <= startIndex) {
-                        uri = new StringBuilder(uri).insert(index, SLASH).toString();
+                    if (uri.lastIndexOf(SLASH, index) <= start) {
+                        uriCharSequence = new StringBuilder(uri).insert(index, SLASH);
                     }
                 }
             }
+            buf.writeByte(SP).writeCharSequence(uriCharSequence, CharsetUtil.UTF_8);
+            if (needSlash) {
+                // write "/ " after uri
+                ByteBufUtil.writeShortBE(buf, SLASH_AND_SPACE_SHORT);
+            } else {
+                buf.writeByte(SP);
+            }
         }
 
-        buf.writeCharSequence(uri, CharsetUtil.UTF_8);
-
-        buf.writeByte(SP);
         request.protocolVersion().encode(buf);
-        buf.writeBytes(CRLF);
+        ByteBufUtil.writeShortBE(buf, CRLF_SHORT);
     }
 }
diff --git a/codec-http/src/main/java/io/netty/handler/codec/http/HttpResponseEncoder.java b/codec-http/src/main/java/io/netty/handler/codec/http/HttpResponseEncoder.java
@@ -16,6 +16,7 @@
 package io.netty.handler.codec.http;
 
 import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufUtil;
 
 import static io.netty.handler.codec.http.HttpConstants.*;
 
@@ -35,6 +36,6 @@ protected void encodeInitialLine(ByteBuf buf, HttpResponse response) throws Exce
         response.protocolVersion().encode(buf);
         buf.writeByte(SP);
         response.status().encode(buf);
-        buf.writeBytes(CRLF);
+        ByteBufUtil.writeShortBE(buf, CRLF_SHORT);
     }
 }
diff --git a/codec-http/src/main/java/io/netty/handler/codec/rtsp/RtspEncoder.java b/codec-http/src/main/java/io/netty/handler/codec/rtsp/RtspEncoder.java
@@ -15,9 +15,6 @@
  */
 package io.netty.handler.codec.rtsp;
 
-import static io.netty.handler.codec.http.HttpConstants.CR;
-import static io.netty.handler.codec.http.HttpConstants.LF;
-import static io.netty.handler.codec.http.HttpConstants.SP;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufUtil;
 import io.netty.handler.codec.UnsupportedMessageTypeException;
@@ -29,15 +26,14 @@
 import io.netty.util.CharsetUtil;
 import io.netty.util.internal.StringUtil;
 
+import static io.netty.handler.codec.http.HttpConstants.*;
+
 /**
  * Encodes an RTSP message represented in {@link HttpMessage} or an {@link HttpContent} into
  * a {@link ByteBuf}.
  */
 public class RtspEncoder extends HttpObjectEncoder<HttpMessage> {
-    /**
-     * Constant for CRLF.
-     */
-    private static final byte[] CRLF = {CR, LF};
+    private static final int CRLF_SHORT = (CR << 8) | LF;
 
     @Override
     public boolean acceptOutboundMessage(final Object msg)
@@ -55,15 +51,15 @@ protected void encodeInitialLine(final ByteBuf buf, final HttpMessage message)
             buf.writeCharSequence(request.uri(), CharsetUtil.UTF_8);
             buf.writeByte(SP);
             buf.writeCharSequence(request.protocolVersion().toString(), CharsetUtil.US_ASCII);
-            buf.writeBytes(CRLF);
+            ByteBufUtil.writeShortBE(buf, CRLF_SHORT);
         } else if (message instanceof HttpResponse) {
             HttpResponse response = (HttpResponse) message;
             buf.writeCharSequence(response.protocolVersion().toString(), CharsetUtil.US_ASCII);
             buf.writeByte(SP);
             ByteBufUtil.copy(response.status().codeAsText(), buf);
             buf.writeByte(SP);
             buf.writeCharSequence(response.status().reasonPhrase(), CharsetUtil.US_ASCII);
-            buf.writeBytes(CRLF);
+            ByteBufUtil.writeShortBE(buf, CRLF_SHORT);
         } else {
             throw new UnsupportedMessageTypeException("Unsupported type "
                                 + StringUtil.simpleClassName(message));