8274112: (fc) Tune FileChannel.transferTo()

Reviewed-by: alanb, lancea, rriggs

src/java.base/share/classes/sun/nio/ch/FileChannelImpl.java

@@ -574,6 +574,10 @@ public class FileChannelImpl
         }
     }
 
+    // Size threshold above which to use a mapped buffer;
+    // transferToArbitraryChannel() is faster for smaller transfers
+    private static final long TRUSTED_TRANSFER_THRESHOLD = 16L*1024L;
+
     // Maximum size to map when using a mapped buffer
     private static final long MAPPED_TRANSFER_SIZE = 8L*1024L*1024L;
 
@@ -581,6 +585,9 @@ public class FileChannelImpl
                                           WritableByteChannel target)
         throws IOException
     {
+        if (count < TRUSTED_TRANSFER_THRESHOLD)
+            return IOStatus.UNSUPPORTED_CASE;
+
         boolean isSelChImpl = (target instanceof SelChImpl);
         if (!((target instanceof FileChannelImpl) || isSelChImpl))
             return IOStatus.UNSUPPORTED;
@@ -1372,9 +1379,10 @@ public class FileChannelImpl
     // Removes an existing mapping
     private static native int unmap0(long address, long length);
 
-    // Transfers from src to dst, or returns -2 if kernel can't do that
+    // Transfers from src to dst, or returns IOStatus.UNSUPPORTED (-4) or
-    private native long transferTo0(FileDescriptor src, long position,
+    // IOStatus.UNSUPPORTED_CASE (-6) if the kernel does not support it
-                                    long count, FileDescriptor dst);
+    private static native long transferTo0(FileDescriptor src, long position,
+                                           long count, FileDescriptor dst);
 
     // Retrieves the maximum size of a transfer
     private static native int maxDirectTransferSize0();

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 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
@@ -22,25 +22,47 @@
  */
 
 /* @test
- * @bug 4652496
+ * @bug 4652496 8274112
  * @summary Test transferTo with different target channels
+ * @library /test/lib
+ * @build jdk.test.lib.RandomFactory
  * @run main TransferToChannel
  * @run main/othervm -Djdk.nio.enableFastFileTransfer TransferToChannel
+ * @key randomness
  */
 
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;
 import java.nio.channels.WritableByteChannel;
-import java.nio.ByteBuffer;
+import java.nio.file.Files;
-import java.io.*;
+import java.util.Arrays;
 import java.util.Random;
+import jdk.test.lib.RandomFactory;
 
 public class TransferToChannel {
 
-    static File file;
+    private static final Random RAND = RandomFactory.getRandom();
-    static File outFile;
+
-    static FileChannel in;
+    // Chunk size should be larger than FileChannelImpl.TRANSFER_SIZE (8192)
-    // Chunk size should be larger than FileChannelImpl.TRANSFER_SIZE for good test
+    // for a good test
-    static int CHUNK_SIZE = 1024 * 9;
+    private static final int CHUNK_SIZE = 9*1024;
+
+    // File size should be a value much larger than CHUNK_SIZE
+    private static final int FILE_SIZE = 1000*1024;
+
+    // The minimum direct transfer size should be less than the file size
+    // but still substantial
+    private static final int MIN_DIRECT_TRANSFER_SIZE = FILE_SIZE/2;
+
+    private static File file;
+    private static File outFile;
+    private static FileChannel in;
 
     public static void main(String[] args) throws Exception {
         file = File.createTempFile("readingin", null);
@@ -52,52 +74,60 @@ public class TransferToChannel {
         in = fis.getChannel();
         test1();
         test2();
+        test3();
         in.close();
         file.delete();
         outFile.delete();
     }
 
-    static void test1() throws Exception {
+    private static void test1() throws Exception {
         for (int i=0; i<10; i++) {
             transferFileToUserChannel();
             System.gc();
-            System.err.println("Transferred file...");
+            System.err.println("Transferred file to user channel...");
         }
     }
 
-    static void test2() throws Exception {
+    private static void test2() throws Exception {
         for (int i=0; i<10; i++) {
             transferFileToTrustedChannel();
             System.gc();
-            System.err.println("Transferred file...");
+            System.err.println("Transferred file to trusted channel...");
         }
     }
 
-    static void transferFileToUserChannel() throws Exception {
+    private static void test3() throws Exception {
+        for (int i=0; i<10; i++) {
+            transferFileDirectly();
+            System.gc();
+            System.err.println("Transferred file directly...");
+        }
+    }
+
+    private static void transferFileToUserChannel() throws Exception {
         long remainingBytes = in.size();
         long size = remainingBytes;
         WritableByteChannel wbc = new WritableByteChannel() {
-                Random rand = new Random(0);
+            Random rand = new Random(0);
-                public int write(ByteBuffer src) throws IOException {
+            public int write(ByteBuffer src) throws IOException {
-                    int read = src.remaining();
+                int read = src.remaining();
-                    byte[] incoming = new byte[read];
+                byte[] incoming = new byte[read];
-                    src.get(incoming);
+                src.get(incoming);
-                    checkData(incoming, read);
+                checkData(incoming, read);
-                    return read == 0 ? -1 : read;
+                return read == 0 ? -1 : read;
-                }
+            }
-                public boolean isOpen() {
+            public boolean isOpen() {
-                    return true;
+                return true;
-                }
+            }
-                public void close() throws IOException {
+            public void close() throws IOException {
-                }
+            }
-                void checkData(byte[] incoming, int size) {
+            void checkData(byte[] incoming, int size) {
-                    byte[] expected = new byte[size];
+                byte[] expected = new byte[size];
-                    rand.nextBytes(expected);
+                rand.nextBytes(expected);
-                    for (int i=0; i<size; i++)
+                if (!Arrays.equals(incoming, expected))
-                        if (incoming[i] != expected[i])
+                    throw new RuntimeException("Data corrupted");
-                            throw new RuntimeException("Data corrupted");
+            }
-                }
+        };
-            };
         while (remainingBytes > 0) {
             long bytesTransferred = in.transferTo(size - remainingBytes,
                               Math.min(CHUNK_SIZE, remainingBytes), wbc);
@@ -108,7 +138,7 @@ public class TransferToChannel {
         }
     }
 
-    static void transferFileToTrustedChannel() throws Exception {
+    private static void transferFileToTrustedChannel() throws Exception {
         long remainingBytes = in.size();
         long size = remainingBytes;
         FileOutputStream fos = new FileOutputStream(outFile);
@@ -124,14 +154,44 @@ public class TransferToChannel {
         out.close();
     }
 
-    static void generateBigFile(File file) throws Exception {
+    private static void transferFileDirectly() throws Exception {
+        outFile.delete();
+        final long size = in.size();
+        final long position = RAND.nextInt((int)size - MIN_DIRECT_TRANSFER_SIZE);
+        try (FileOutputStream fos = new FileOutputStream(outFile);
+             FileChannel out = fos.getChannel()) {
+
+            assert out.position() == 0;
+            long pos = position;
+            while (pos < size) {
+                long bytesTransferred = in.transferTo(pos, Long.MAX_VALUE, out);
+                if (bytesTransferred >= 0)
+                    pos += bytesTransferred;
+                else {
+                    throw new Exception("transfer failed at " + pos +
+                        " / " + size);
+                }
+            }
+        }
+
+        byte[] expected = Files.readAllBytes(file.toPath());
+        byte[] actual = Files.readAllBytes(outFile.toPath());
+        if (!Arrays.equals(expected, (int)position, (int)size,
+                           actual, 0, (int)(size - position)))
+            throw new Exception("Actual bytes do not match expected bytes");
+    }
+
+    private static void generateBigFile(File file) throws Exception {
         OutputStream out = new BufferedOutputStream(
                            new FileOutputStream(file));
         byte[] randomBytes = new byte[1024];
         Random rand = new Random(0);
-        for (int i = 0; i < 1000; i++) {
+        int numWritten = 0;
+        while (numWritten < FILE_SIZE) {
+            int nwrite = Math.min(randomBytes.length, FILE_SIZE - numWritten);
             rand.nextBytes(randomBytes);
-            out.write(randomBytes);
+            out.write(randomBytes, 0, nwrite);
+            numWritten += nwrite;
         }
         out.flush();
         out.close();

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 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
@@ -432,10 +432,16 @@ public class Transfers {
         int pos = (int)seed & 0xfff;
         fc.position(pos);
 
-        int n = (int)fc.transferTo(off, len, tgt.channel());
+        long position = off;
-        if (n != len)
+        long count = len;
-            throw new Failure("Incorrect transfer length: " + n
+        while (count > 0) {
-                              + " (expected " + len + ")");
+            long n = (int)fc.transferTo(position, count, tgt.channel());
+            if (n < 0 || n > count)
+                throw new Failure("Incorrect transfer length n = : " + n
+                                  + " (expected 0 <= n <= " + len + ")");
+            position += n;
+            count -= n;
+        }
 
         // Check that source wasn't changed
         if (fc.position() != pos)