Optimize writeCharacters for NIO Buffers.

- Remove extra bounds checking.
- Add ASCII fast-loop similar to String.getBytes().

Author: vbabanin

bson/src/main/org/bson/ByteBuf.java

@@ -136,6 +136,8 @@ public interface ByteBuf  {
      */
     byte[] array();
 
+    boolean hasArray();
+
     /**
      * Returns this buffer's limit.
      *

bson/src/main/org/bson/ByteBufNIO.java

@@ -108,6 +108,11 @@ public byte[] array() {
         return buf.array();
     }
 
+    @Override
+    public boolean hasArray() {
+        return buf.hasArray();
+    }
+
     @Override
     public int limit() {
         return buf.limit();

bson/src/main/org/bson/io/OutputBuffer.java

@@ -196,7 +196,7 @@ public void writeLong(final long value) {
         writeInt64(value);
     }
 
-    private int writeCharacters(final String str, final boolean checkForNullCharacters) {
+    protected int writeCharacters(final String str, final boolean checkForNullCharacters) {
         int len = str.length();
         int total = 0;
 

driver-core/src/main/com/mongodb/internal/connection/ByteBufferBsonOutput.java

@@ -16,6 +16,7 @@
 
 package com.mongodb.internal.connection;
 
+import org.bson.BsonSerializationException;
 import org.bson.ByteBuf;
 import org.bson.io.OutputBuffer;
 
@@ -25,8 +26,10 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import static com.mongodb.assertions.Assertions.assertFalse;
 import static com.mongodb.assertions.Assertions.assertTrue;
 import static com.mongodb.assertions.Assertions.notNull;
+import static java.lang.String.format;
 
 /**
  * <p>This class is not part of the public API and may be removed or changed at any time</p>
@@ -100,6 +103,11 @@ private ByteBuf getCurrentByteBuffer() {
         return getByteBufferAtIndex(curBufferIndex);
     }
 
+    private ByteBuf getNextByteBuffer() {
+        assertFalse(bufferList.get(curBufferIndex).hasRemaining());
+        return getByteBufferAtIndex(++curBufferIndex);
+    }
+
     private ByteBuf getByteBufferAtIndex(final int index) {
         if (bufferList.size() < index + 1) {
             bufferList.add(bufferProvider.getBuffer(index >= (MAX_SHIFT - INITIAL_SHIFT)
@@ -282,4 +290,128 @@ private static final class BufferPositionPair {
             this.position = position;
         }
     }
+
+    protected int writeCharacters(final String str, final boolean checkNullTermination) {
+        int len = str.length();
+        int sp = 0;
+        int prevPos = position;
+
+        ByteBuf buf = getCurrentByteBuffer();
+        int currBufferPos = buf.position();
+        int limit = buf.limit();
+        int remaining = limit - currBufferPos;
+
+        if (buf instanceof PowerOfTwoBufferPool.PooledByteBufNIO && buf.hasArray()) {
+            byte[] dst = buf.array();
+            if (remaining >= str.length() + 1) {
+                sp = writeOnArrayAscii(str, dst, currBufferPos, checkNullTermination);
+                currBufferPos += sp;
+                if (sp == len) {
+                    dst[currBufferPos++] = 0;
+                    position += sp + 1;
+                    buf.position(currBufferPos);
+                    return sp + 1;
+                }
+                position += sp;
+                buf.position(currBufferPos);
+            }
+        }
+
+        while (sp < len) {
+            remaining = limit - currBufferPos;
+            int c = str.charAt(sp);
+
+            if (checkNullTermination && c == 0x0) {
+                throw new BsonSerializationException(
+                        format("BSON cstring '%s' is not valid because it contains a null character " + "at index %d", str, sp));
+            }
+
+            if (c < 0x80) {
+                if (remaining == 0) {
+                    buf = getNextByteBuffer();
+                    currBufferPos = 0;
+                    limit = buf.limit();
+                }
+                buf.put((byte) c);
+                currBufferPos++;
+                position++;
+            } else if (c < 0x800) {
+                if (remaining < 2) {
+                    write((byte) (0xc0 + (c >> 6)));
+                    write((byte) (0x80 + (c & 0x3f)));
+
+                    buf = getCurrentByteBuffer();
+                    currBufferPos = buf.position();
+                    limit = buf.limit();
+                } else {
+                    buf.put((byte) (0xc0 + (c >> 6)));
+                    buf.put((byte) (0x80 + (c & 0x3f)));
+                    currBufferPos += 2;
+                    position += 2;
+                }
+            } else {
+                c = Character.codePointAt(str, sp);
+                if (c < 0x10000) {
+                    if (remaining < 3) {
+                        write((byte) (0xe0 + (c >> 12)));
+                        write((byte) (0x80 + ((c >> 6) & 0x3f)));
+                        write((byte) (0x80 + (c & 0x3f)));
+
+                        buf = getCurrentByteBuffer();
+                        currBufferPos = buf.position();
+                        limit = buf.limit();
+                    } else {
+                        buf.put((byte) (0xe0 + (c >> 12)));
+                        buf.put((byte) (0x80 + ((c >> 6) & 0x3f)));
+                        buf.put((byte) (0x80 + (c & 0x3f)));
+                        currBufferPos += 3;
+                        position += 3;
+                    }
+                } else {
+                    if (remaining < 4) {
+                        write((byte) (0xf0 + (c >> 18)));
+                        write((byte) (0x80 + ((c >> 12) & 0x3f)));
+                        write((byte) (0x80 + ((c >> 6) & 0x3f)));
+                        write((byte) (0x80 + (c & 0x3f)));
+
+                        buf = getCurrentByteBuffer();
+                        currBufferPos = buf.position();
+                        limit = buf.limit();
+                    } else {
+                        buf.put((byte) (0xf0 + (c >> 18)));
+                        buf.put((byte) (0x80 + ((c >> 12) & 0x3f)));
+                        buf.put((byte) (0x80 + ((c >> 6) & 0x3f)));
+                        buf.put((byte) (0x80 + (c & 0x3f)));
+                        currBufferPos += 4;
+                        position += 4;
+                    }
+                }
+            }
+            sp += Character.charCount(c);
+        }
+
+        getCurrentByteBuffer().put((byte) 0);
+        position++;
+        return position - prevPos;
+    }
+
+    private static int writeOnArrayAscii(final String str,
+                                         final byte[] dst,
+                                         final int currentPos,
+                                         final boolean checkNullTermination) {
+        int pos = currentPos;
+        int sp = 0;
+        for (; sp < str.length(); sp++, pos++) {
+            char c = str.charAt(sp);
+            if (checkNullTermination && c == 0) {
+                throw new BsonSerializationException(
+                        format("BSON cstring '%s' is not valid because it contains a null character " + "at index %d", str, sp));
+            }
+            if (c >= 0x80) {
+                break;
+            }
+            dst[pos] = (byte) c;
+        }
+        return sp;
+    }
 }

driver-core/src/main/com/mongodb/internal/connection/CompositeByteBuf.java

@@ -213,6 +213,11 @@ public byte[] array() {
         throw new UnsupportedOperationException("Not implemented yet!");
     }
 
+    @Override
+    public boolean hasArray() {
+        return false;
+    }
+
     @Override
     public ByteBuf limit(final int newLimit) {
         if (newLimit < 0 || newLimit > capacity()) {

driver-core/src/main/com/mongodb/internal/connection/PowerOfTwoBufferPool.java

@@ -156,7 +156,7 @@ static int roundUpToNextHighestPowerOfTwo(final int size) {
         return v;
     }
 
-    private class PooledByteBufNIO extends ByteBufNIO {
+    public class PooledByteBufNIO extends ByteBufNIO {
 
         PooledByteBufNIO(final ByteBuffer buf) {
             super(buf);

driver-core/src/main/com/mongodb/internal/connection/netty/NettyByteBuf.java

@@ -100,6 +100,11 @@ public byte[] array() {
         return proxied.array();
     }
 
+    @Override
+    public boolean hasArray() {
+        return proxied.hasArray();
+    }
+
     @Override
     public int limit() {
         if (isWriting) {