Backport e5ce5c57c83972ff52758a804c942986cab74ca7 from JDK 26

ByteBuffer.allocateDirect initialization can result in large TTSP spikes

This backport adapts the JDK 26 improvement for ByteBuffer.allocateDirect
initialization to reduce TTSP spikes. Minor conflict in template resolved
manually to preserve 2023 copyright.

Author: Alaric McGregor

src/java.base/share/classes/java/nio/Bits.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -234,4 +234,28 @@ public long getMemoryUsed() {
     // of an element by element copy.  These numbers may change over time.
     static final int JNI_COPY_TO_ARRAY_THRESHOLD   = 6;
     static final int JNI_COPY_FROM_ARRAY_THRESHOLD = 6;
+
+    // Maximum number of bytes to set in one call to {@code Unsafe.setMemory}.
+    // This threshold allows safepoint polling during large memory operations.
+    static final long UNSAFE_SET_THRESHOLD = 1024 * 1024;
+
+    /**
+     * Sets a block of memory starting from a given address to a specified byte value.
+     *
+     * @param srcAddr
+     *        the starting memory address
+     * @param count
+     *        the number of bytes to set
+     * @param value
+     *        the byte value to set
+     */
+    static void setMemory(long srcAddr, long count, byte value) {
+        long offset = 0;
+        while (offset < count) {
+            long len = Math.min(UNSAFE_SET_THRESHOLD, count - offset);
+            UNSAFE.setMemory(srcAddr + offset, len, value);
+            offset += len;
+        }
+    }
+
 }

src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -31,7 +31,10 @@ import java.io.FileDescriptor;
 import java.lang.foreign.MemorySegment;
 import java.lang.ref.Reference;
 import java.util.Objects;
+import jdk.internal.foreign.AbstractMemorySegmentImpl;
 import jdk.internal.foreign.MemorySessionImpl;
+import jdk.internal.foreign.SegmentFactories;
+import jdk.internal.vm.annotation.ForceInline;
 import jdk.internal.misc.ScopedMemoryAccess.ScopedAccessError;
 import jdk.internal.misc.VM;
 import jdk.internal.ref.Cleaner;
@@ -56,14 +59,6 @@ class Direct$Type$Buffer$RW$$BO$
 {
 
 #if[rw]
-
-    // Cached unaligned-access capability
-    protected static final boolean UNALIGNED = Bits.unaligned();
-
-    // Base address, used in all indexing calculations
-    // NOTE: moved up to Buffer.java for speed in JNI GetDirectBufferAddress
-    //    protected long address;
-
     // An object attached to this buffer. If this buffer is a view of another
     // buffer then we use this field to keep a reference to that buffer to
     // ensure that its memory isn't freed before we are done with it.
@@ -74,6 +69,8 @@ class Direct$Type$Buffer$RW$$BO$
     }
 
 #if[byte]
+    // Cached unaligned-access capability
+    static final boolean UNALIGNED = Bits.unaligned();
 
     private record Deallocator(long address, long size, int capacity) implements Runnable {
         private Deallocator {
@@ -117,7 +114,7 @@ class Direct$Type$Buffer$RW$$BO$
             Bits.unreserveMemory(size, cap);
             throw x;
         }
-        UNSAFE.setMemory(base, size, (byte) 0);
+        Bits.setMemory(base, size, (byte) 0);
         if (pa && (base % ps != 0)) {
             // Round up to page boundary
             address = base + ps - (base & (ps - 1));
@@ -162,9 +159,10 @@ class Direct$Type$Buffer$RW$$BO$
     }
 
     // Invoked only by JNI: NewDirectByteBuffer(void*, long)
+    // and JavaNioAccess.newDirectByteBuffer(int).
     // The long-valued capacity is restricted to int range.
     //
-    private Direct$Type$Buffer(long addr, long cap) {
+    Direct$Type$Buffer(long addr, long cap) {
         super(-1, 0, checkCapacity(cap), (int)cap, null);
         address = addr;
         cleaner = null;
@@ -534,6 +532,24 @@ class Direct$Type$Buffer$RW$$BO$
     }
 #end[char]
 
+#if[byte]
+    @ForceInline
+    @Override
+    int scaleShifts() {
+        return 0;
+    }
+
+    @ForceInline
+    @Override
+    AbstractMemorySegmentImpl heapSegment(Object base,
+                                          long offset,
+                                          long length,
+                                          boolean readOnly,
+                                          MemorySessionImpl bufferScope) {
+        // Direct buffers are not backed by an array.
+        throw new UnsupportedOperationException();
+    }
+#end[byte]
 
 #if[byte]
     // #BIN

test/jdk/java/nio/Buffer/AllocateDirectInit.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2007, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -23,29 +23,60 @@
 
 /**
  * @test
- * @bug 4490253 6535542
+ * @bug 4490253 6535542 8357959
+ * @key randomness
+ * @library /test/lib
+ * @build jdk.test.lib.RandomFactory
  * @summary Verify that newly allocated direct buffers are initialized.
+ * @run main/othervm AllocateDirectInit
  */
 
 import java.nio.ByteBuffer;
+import java.util.Random;
+
+import jdk.test.lib.RandomFactory;
 
 public class AllocateDirectInit {
+    private static final int MAX_BIN_LIMIT = 16 * 1024 * 1024;
+    private static final int MAX_DEC_LIMIT = 10 * 1000 * 1000;
+    private static final int TRIES_PER_LIMIT = 1024;
+
+    private static final Random RND = RandomFactory.getRandom();
+
     public static void main(String [] args){
-        for (int i = 0; i < 1024; i++) {
-            ByteBuffer bb = ByteBuffer.allocateDirect(1024);
-//          printByteBuffer(bb);
-            for (bb.position(0); bb.position() < bb.limit(); ) {
-                if ((bb.get() & 0xff) != 0)
-                    throw new RuntimeException("uninitialized buffer, position = "
-                                               + bb.position());
+        // Try power of two limits
+        for (int limit = 1; limit < MAX_BIN_LIMIT; limit *= 2) {
+            check(ByteBuffer.allocateDirect(limit - 1));
+            check(ByteBuffer.allocateDirect(limit));
+            check(ByteBuffer.allocateDirect(limit + 1));
+        }
+
+        // Try power of ten limits
+        for (int limit = 1; limit < MAX_DEC_LIMIT; limit *= 10) {
+            check(ByteBuffer.allocateDirect(limit - 1));
+            check(ByteBuffer.allocateDirect(limit));
+            check(ByteBuffer.allocateDirect(limit + 1));
+        }
+
+        // Try random sizes within power of two limits
+        for (int limit = 1; limit < MAX_BIN_LIMIT; limit *= 2) {
+            for (int t = 0; t < TRIES_PER_LIMIT; t++) {
+                check(ByteBuffer.allocateDirect(RND.nextInt(limit)));
             }
         }
     }
 
-    private static void printByteBuffer(ByteBuffer bb) {
-        System.out.print("byte [");
-        for (bb.position(0); bb.position() < bb.limit(); )
-            System.out.print(" " + Integer.toHexString(bb.get() & 0xff));
-        System.out.println(" ]");
+    private static void check(ByteBuffer bb) {
+        while (bb.hasRemaining()) {
+            if (bb.get() != 0) {
+                int mismatchPos = bb.position();
+                System.out.print("byte [");
+                for (bb.position(0); bb.position() < bb.limit(); ) {
+                    System.out.print(" " + Integer.toHexString(bb.get() & 0xff));
+                }
+                System.out.println(" ]");
+                throw new RuntimeException("uninitialized buffer, position = " + mismatchPos);
+            }
+        }
     }
 }

test/micro/org/openjdk/bench/java/nio/DirectByteBufferAlloc.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+package org.openjdk.bench.java.nio;
+
+
+import java.nio.ByteBuffer;
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Thread)
+@Warmup(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS)
+@Measurement(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS)
+@Fork(3)
+public class DirectByteBufferAlloc {
+
+    @Param({
+            "128", // 128 bytes
+            "1024", // 1KB
+            "1048576", // 1 MB
+            "16777216" // 16MB
+    })
+    public int bytes;
+
+    @Benchmark
+    public ByteBuffer allocateDirectBuffer() {
+        return ByteBuffer.allocateDirect(bytes);
+    }
+}