Merge branch 'main' into string-opt

# Conflicts:
#	driver-core/src/test/unit/com/mongodb/internal/connection/ByteBufferBsonOutputTest.java

Author: vbabanin

.evergreen/.evg.yml

@@ -770,6 +770,8 @@ functions:
       type: test
       params:
         working_dir: "src"
+        env:
+          PROVIDER: ${PROVIDER}
         script: |
           ${PREPARE_SHELL}
           PROJECT_DIRECTORY=${PROJECT_DIRECTORY} .evergreen/run-perf-tests.sh
@@ -1540,6 +1542,22 @@ tasks:
   # Do not rename this task – renaming resets the performance time series
     - name: "perf"
       tags: ["perf"]
+      # Benchmark could exceed 1 hour of execution.
+      exec_timeout_secs: 7200
+      commands:
+        - func: "bootstrap mongo-orchestration"
+          vars:
+            VERSION: "v8.0-perf"
+            TOPOLOGY: "server"
+            SSL: "nossl"
+            AUTH: "noauth"
+        - func: "run perf tests"
+        - func: "send dashboard data"
+
+    - name: "perf-netty"
+      tags: [ "perf" ]
+      # Benchmark could exceed 1 hour of execution.
+      exec_timeout_secs: 7200
       commands:
         - func: "bootstrap mongo-orchestration"
           vars:
@@ -1548,6 +1566,8 @@ tasks:
             SSL: "nossl"
             AUTH: "noauth"
         - func: "run perf tests"
+          vars:
+            PROVIDER: "Netty"
         - func: "send dashboard data"
 
     - name: "aws-lambda-deployed-task"
@@ -2263,6 +2283,7 @@ buildvariants:
   run_on: rhel90-dbx-perf-large
   tasks:
     - name: "perf"
+    - name: "perf-netty"
 
 - name: plain-auth-test
   display_name: "PLAIN (LDAP) Auth test"

.evergreen/run-perf-tests.sh

@@ -17,8 +17,14 @@ RELATIVE_DIR_PATH="$(dirname "${BASH_SOURCE:-$0}")"
 export TEST_PATH="${PROJECT_DIRECTORY}/driver-performance-test-data/"
 export OUTPUT_FILE="${PROJECT_DIRECTORY}/results.json"
 
+if [ "${PROVIDER}" = "Netty" ]; then
+    TASK="driver-benchmarks:runNetty"
+else
+    TASK="driver-benchmarks:run"
+fi
+
 start_time=$(date +%s)
-./gradlew -Dorg.mongodb.benchmarks.data=${TEST_PATH} -Dorg.mongodb.benchmarks.output=${OUTPUT_FILE} driver-benchmarks:run
+./gradlew -Dorg.mongodb.benchmarks.data=${TEST_PATH} -Dorg.mongodb.benchmarks.output=${OUTPUT_FILE} ${TASK}
 end_time=$(date +%s)
 elapsed_secs=$((end_time-start_time))
 

bom/build.gradle.kts

@@ -40,6 +40,7 @@ dependencies {
         api(project(":bson-kotlinx"))
         api(project(":driver-kotlin-coroutine"))
         api(project(":driver-kotlin-sync"))
+        api(project(":driver-kotlin-extensions"))
 
         api(project(":bson-scala"))
         api(project(":driver-scala"))

bson/src/main/org/bson/BsonBinaryWriter.java

@@ -24,6 +24,7 @@
 import java.util.List;
 import java.util.Stack;
 
+import static java.lang.Math.max;
 import static java.lang.String.format;
 import static org.bson.assertions.Assertions.notNull;
 
@@ -37,8 +38,37 @@ public class BsonBinaryWriter extends AbstractBsonWriter {
 
     private final BsonOutput bsonOutput;
     private final Stack<Integer> maxDocumentSizeStack = new Stack<>();
+    private static final int ARRAY_INDEXES_CACHE_SIZE = 1000;
+    private static final byte[] ARRAY_INDEXES_BUFFER;
+    private static final int[] ARRAY_INDEXES_OFFSETS;
+    private static final int[] ARRAY_INDEXES_LENGTHS;
     private Mark mark;
 
+    static {
+        ARRAY_INDEXES_LENGTHS = new int[ARRAY_INDEXES_CACHE_SIZE];
+        ARRAY_INDEXES_OFFSETS = new int[ARRAY_INDEXES_CACHE_SIZE];
+        int totalSize = 0;
+        for (int i = 0; i < ARRAY_INDEXES_CACHE_SIZE; i++) {
+            totalSize += (int) (Math.log10(max(i, 1))
+                    + 1 // number of digits
+                    + 1); // +1 for null terminator
+        }
+        ARRAY_INDEXES_BUFFER = new byte[totalSize];
+
+        // Fill buffer
+        int offset = 0;
+        for (int i = 0; i < ARRAY_INDEXES_CACHE_SIZE; i++) {
+            String string = Integer.toString(i);
+            int length = string.length();
+            for (int j = 0; j < length; j++) {
+                ARRAY_INDEXES_BUFFER[offset++] = (byte) string.charAt(j);
+            }
+            ARRAY_INDEXES_BUFFER[offset++] = 0;
+            ARRAY_INDEXES_OFFSETS[i] = offset - (length + 1);
+            ARRAY_INDEXES_LENGTHS[i] = length + 1;  // +1 for null terminator
+        }
+    }
+
     /**
      * Construct an instance.
      *
@@ -259,7 +289,7 @@ public void doWriteNull() {
     public void doWriteObjectId(final ObjectId value) {
         bsonOutput.writeByte(BsonType.OBJECT_ID.getValue());
         writeCurrentName();
-        bsonOutput.writeBytes(value.toByteArray());
+        bsonOutput.writeObjectId(value);
     }
 
     @Override
@@ -397,7 +427,14 @@ public void reset() {
 
     private void writeCurrentName() {
         if (getContext().getContextType() == BsonContextType.ARRAY) {
-            bsonOutput.writeCString(Integer.toString(getContext().index++));
+            int index = getContext().index++;
+            if (index >= ARRAY_INDEXES_CACHE_SIZE) {
+                bsonOutput.writeCString(Integer.toString(index));
+            } else {
+                bsonOutput.writeBytes(ARRAY_INDEXES_BUFFER,
+                        ARRAY_INDEXES_OFFSETS[index],
+                        ARRAY_INDEXES_LENGTHS[index]);
+            }
         } else {
             bsonOutput.writeCString(getName());
         }

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

@@ -106,6 +106,54 @@ public interface ByteBuf  {
      */
     ByteBuf put(byte b);
 
+    /**
+     * Writes the given int value into this buffer at the current position,
+     * using the current byte order, and increments the position by 4.
+     *
+     * @param b the int value to be written
+     * @return this buffer
+     * @throws java.nio.BufferOverflowException if there are fewer than 4 bytes remaining in this buffer
+     * @throws java.nio.ReadOnlyBufferException if this buffer is read-only
+     * @since 5.4
+     */
+    ByteBuf putInt(int b);
+
+    /**
+     * Writes the given int value into this buffer at the current position,
+     * using the current byte order, and increments the position by 4.
+     *
+     * @param b the int value to be written
+     * @return this buffer
+     * @throws java.nio.BufferOverflowException if there are fewer than 4 bytes remaining in this buffer
+     * @throws java.nio.ReadOnlyBufferException if this buffer is read-only
+     * @since 5.4
+     */
+    ByteBuf putInt(int index, int b);
+
+    /**
+     * Writes the given double value into this buffer at the current position,
+     * using the current byte order, and increments the position by 8.
+     *
+     * @param b the double value to be written
+     * @return this buffer
+     * @throws java.nio.BufferOverflowException if there are fewer than 8 bytes remaining in this buffer
+     * @throws java.nio.ReadOnlyBufferException if this buffer is read-only
+     * @since 5.4
+     */
+    ByteBuf putDouble(double b);
+
+    /**
+     * Writes the given long value into this buffer at the current position,
+     * using the current byte order, and increments the position by 8.
+     *
+     * @param b the long value to be written
+     * @return this buffer
+     * @throws java.nio.BufferOverflowException if there are fewer than 8 bytes remaining in this buffer
+     * @throws java.nio.ReadOnlyBufferException if this buffer is read-only
+     * @since 5.4
+     */
+    ByteBuf putLong(long b);
+
     /**
      * <p>Flips this buffer.  The limit is set to the current position and then the position is set to zero.  If the mark is defined then it
      * is discarded.</p>

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

@@ -97,6 +97,30 @@ public ByteBuf put(final byte b) {
         return this;
     }
 
+    @Override
+    public ByteBuf putInt(final int b) {
+        buf.putInt(b);
+        return this;
+    }
+
+    @Override
+    public ByteBuf putInt(final int index, final int b) {
+        buf.putInt(index, b);
+        return this;
+    }
+
+    @Override
+    public ByteBuf putDouble(final double b) {
+        buf.putDouble(b);
+        return this;
+    }
+
+    @Override
+    public ByteBuf putLong(final long b) {
+        buf.putLong(b);
+        return this;
+    }
+
     @Override
     public ByteBuf flip() {
         ((Buffer) buf).flip();
@@ -170,8 +194,13 @@ public ByteBuf get(final byte[] bytes, final int offset, final int length) {
 
     @Override
     public ByteBuf get(final int index, final byte[] bytes, final int offset, final int length) {
-        for (int i = 0; i < length; i++) {
-            bytes[offset + i] = buf.get(index + i);
+        if (buf.hasArray()) {
+            System.arraycopy(buf.array(), index, bytes, offset, length);
+        } else {
+            // Fallback to per-byte copying if no backing array is available.
+            for (int i = 0; i < length; i++) {
+                bytes[offset + i] = buf.get(index + i);
+            }
         }
         return this;
     }