8294437: java/nio/channels/FileChannel tests slow on Windows

Reviewed-by: alanb, bpb

Author: djelinski

test/jdk/java/nio/channels/FileChannel/FileChannelUtils.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2022, 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
+ * 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.
+ */
+
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static java.nio.file.StandardOpenOption.*;
+
+/**
+ * Common library for various test file utility functions.
+ */
+public final class FileChannelUtils {
+
+    public static Path createSparseTempFile(String prefix, String suffix) throws IOException {
+        Path file = Files.createTempFile(prefix, suffix);
+        Files.delete(file); // need CREATE_NEW to make the file sparse
+
+        FileChannel fc = FileChannel.open(file, CREATE_NEW, SPARSE, WRITE);
+        fc.close();
+        return file;
+    }
+}

test/jdk/java/nio/channels/FileChannel/LargeMapTest.java

@@ -21,14 +21,18 @@
  * questions.
  */
 
+import jdk.test.lib.RandomFactory;
+
 import java.lang.foreign.MemorySegment;
 import java.lang.foreign.MemorySession;
 
-import java.io.File;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;
 import java.nio.file.Path;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+
 import static java.nio.file.StandardOpenOption.*;
 
 /*
@@ -38,42 +42,46 @@
  * @summary Ensure that memory mapping beyond 32-bit range does not cause an
  *          EXCEPTION_ACCESS_VIOLATION.
  * @requires vm.bits == 64
- * @run main/othervm/timeout=240 LargeMapTest
+ * @library /test/lib
+ * @build jdk.test.lib.RandomFactory FileChannelUtils
+ * @run main/othervm LargeMapTest
+ * @key randomness
  */
 public class LargeMapTest {
-    private static final String FILE = "test.dat";
-    private static final long LENGTH = 8000000000L;
-    private static final long OFFSET = 3704800000L;
-    private static final int  BUFSIZ = 100000;
+    private static final long LENGTH = (1L << 32) + 512;
+    private static final int  EXTRA  = 1024;
+    private static final long BASE   = LENGTH - EXTRA;
+    private static final Random GEN  = RandomFactory.getRandom();
 
     public static void main(String[] args) throws IOException {
         System.out.println(System.getProperty("sun.arch.data.model"));
         System.out.println(System.getProperty("os.arch"));
         System.out.println(System.getProperty("java.version"));
 
-        Path p = Path.of(FILE);
+        System.out.println("  Writing large file...");
+        long t0 = System.nanoTime();
+        Path p = FileChannelUtils.createSparseTempFile("test", ".dat");
         p.toFile().deleteOnExit();
-        try (FileChannel fc = FileChannel.open(p, CREATE, WRITE)) {
-            fc.position(LENGTH - 1);
-            fc.write(ByteBuffer.wrap(new byte[] {27}));
+        ByteBuffer bb;
+        try (FileChannel fc = FileChannel.open(p, WRITE)) {
+            fc.position(BASE);
+            byte[] b = new byte[EXTRA];
+            GEN.nextBytes(b);
+            bb = ByteBuffer.wrap(b);
+            fc.write(bb);
+            long t1 = System.nanoTime();
+            System.out.printf("  Wrote large file in %d ns (%d ms) %n",
+                    t1 - t0, TimeUnit.NANOSECONDS.toMillis(t1 - t0));
         }
+        bb.rewind();
 
-        long offset = OFFSET;
-        ByteBuffer bb = ByteBuffer.allocateDirect(BUFSIZ);
-
-        try (FileChannel fc = FileChannel.open(p, READ, WRITE);) {
-            MemorySegment mbb = MemorySegment.ofBuffer(bb);
+        try (FileChannel fc = FileChannel.open(p, READ, WRITE)) {
             MemorySegment mappedMemorySegment =
                 fc.map(FileChannel.MapMode.READ_WRITE, 0, p.toFile().length(),
                        MemorySession.openImplicit());
-
-            final int interval = BUFSIZ*1000;
-            while (offset < LENGTH) {
-                if (offset % interval == 0)
-                    System.out.println("offset: " + offset);
-                MemorySegment target = mappedMemorySegment.asSlice(offset, BUFSIZ);
-                offset = offset + BUFSIZ;
-                target.copyFrom(mbb);
+            MemorySegment target = mappedMemorySegment.asSlice(BASE, EXTRA);
+            if (!target.asByteBuffer().equals(bb)) {
+                throw new RuntimeException("Expected buffers to be equal");
             }
         }
     }

test/jdk/java/nio/channels/FileChannel/MapTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2022, 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
@@ -36,6 +36,7 @@
 import static java.nio.file.StandardOpenOption.*;
 import static java.nio.charset.StandardCharsets.*;
 import java.util.Random;
+import java.util.concurrent.TimeUnit;
 
 
 /**
@@ -56,21 +57,42 @@ public class MapTest {
     public static void main(String[] args) throws Exception {
         blah = File.createTempFile("blah", null);
         blah.deleteOnExit();
+        long t0 = System.nanoTime();
         initTestFile(blah);
+        long t1 = System.nanoTime();
+        out.printf("Test file %s initialized in %d ns (%d ms) %n",
+                blah, t1 - t0, TimeUnit.NANOSECONDS.toMillis(t1 - t0));
+        t0 = t1;
         try {
-            out.println("Test file " + blah + " initialized");
             testZero();
-            out.println("Zero size: OK");
+            t1 = System.nanoTime();
+            out.printf("Zero size: done in %d ns (%d ms) %n",
+                    t1 - t0, TimeUnit.NANOSECONDS.toMillis(t1 - t0));
+            t0 = t1;
             testRead();
-            out.println("Read: OK");
+            t1 = System.nanoTime();
+            out.printf("Read: done in %d ns (%d ms) %n",
+                    t1 - t0, TimeUnit.NANOSECONDS.toMillis(t1 - t0));
+            t0 = t1;
             testWrite();
-            out.println("Write: OK");
+            t1 = System.nanoTime();
+            out.printf("Write: done in %d ns (%d ms) %n",
+                    t1 - t0, TimeUnit.NANOSECONDS.toMillis(t1 - t0));
+            t0 = t1;
             testHighOffset();
-            out.println("High offset: OK");
+            t1 = System.nanoTime();
+            out.printf("High offset: done in %d ns (%d ms) %n",
+                    t1 - t0, TimeUnit.NANOSECONDS.toMillis(t1 - t0));
+            t0 = t1;
             testForce();
-            out.println("Force: OK");
+            t1 = System.nanoTime();
+            out.printf("Force: done in %d ns (%d ms) %n",
+                    t1 - t0, TimeUnit.NANOSECONDS.toMillis(t1 - t0));
+            t0 = t1;
             testExceptions();
-            out.println("Exceptions: OK");
+            t1 = System.nanoTime();
+            out.printf("Exceptions: done in %d ns (%d ms) %n",
+                    t1 - t0, TimeUnit.NANOSECONDS.toMillis(t1 - t0));
         } finally {
             blah.delete();
         }
@@ -195,44 +217,42 @@ private static void testHighOffset() throws Exception {
      * the data exercising various valid and invalid writeback ranges.
      */
     private static void testForce() throws Exception {
-        for (int x=0; x<50; x++) {
-            try (RandomAccessFile raf = new RandomAccessFile(blah, "rw")) {
-                FileChannel fc = raf.getChannel();
-                final int BLOCK_SIZE = 64;
-                final int BLOCK_COUNT = (4096 * 2)/ BLOCK_SIZE;
-                int offset = 0;
-                MappedByteBuffer b = fc.map(MapMode.READ_WRITE,
-                                            0, BLOCK_SIZE * (BLOCK_COUNT + 1));
-
-                for (int blocks = 0; blocks < BLOCK_COUNT; blocks++) {
-                    for (int i = 0; i < BLOCK_SIZE; i++) {
-                        b.put(offset + i, (byte)('0' + i));
-                    }
-                    b.force(offset, BLOCK_SIZE);
-                    offset += BLOCK_SIZE;
+        try (RandomAccessFile raf = new RandomAccessFile(blah, "rw")) {
+            FileChannel fc = raf.getChannel();
+            final int BLOCK_SIZE = 64;
+            final int BLOCK_COUNT = (4096 * 2)/ BLOCK_SIZE;
+            int offset = 0;
+            MappedByteBuffer b = fc.map(MapMode.READ_WRITE,
+                                        0, BLOCK_SIZE * (BLOCK_COUNT + 1));
+
+            for (int blocks = 0; blocks < BLOCK_COUNT; blocks++) {
+                for (int i = 0; i < BLOCK_SIZE; i++) {
+                    b.put(offset + i, (byte)('0' + i));
                 }
+                b.force(offset, BLOCK_SIZE);
+                offset += BLOCK_SIZE;
+            }
 
-                Exception exc = null;
-                try {
-                    // start and end are out of range
-                    b.force(offset + BLOCK_SIZE, BLOCK_SIZE);
-                } catch (IndexOutOfBoundsException e) {
-                    exc = e;
-                }
-                if (exc == null) {
-                    throw new RuntimeException("expected Exception for force beyond buffer extent");
-                }
+            Exception exc = null;
+            try {
+                // start and end are out of range
+                b.force(offset + BLOCK_SIZE, BLOCK_SIZE);
+            } catch (IndexOutOfBoundsException e) {
+                exc = e;
+            }
+            if (exc == null) {
+                throw new RuntimeException("expected Exception for force beyond buffer extent");
+            }
 
-                exc = null;
-                try {
-                    // start is in range but end is out of range
-                    b.force(offset, 2 * BLOCK_SIZE);
-                } catch (IndexOutOfBoundsException e) {
-                    exc = e;
-                }
-                if (exc == null) {
-                    throw new RuntimeException("expected Exception for force beyond write limit");
-                }
+            exc = null;
+            try {
+                // start is in range but end is out of range
+                b.force(offset, 2 * BLOCK_SIZE);
+            } catch (IndexOutOfBoundsException e) {
+                exc = e;
+            }
+            if (exc == null) {
+                throw new RuntimeException("expected Exception for force beyond write limit");
             }
         }
     }