/*
* Copyright (c) 2016, 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.
*/
/* @test
* @ignore This test has huge disk space requirements
* @bug 8168628
* @summary Test extending files to very large sizes without hitting a SIGBUS
* @requires (os.family == "linux")
* @run main/othervm/timeout=600 -Xms4g -Xmx4g FileExtensionAndMap
* @run main/othervm/timeout=600 -Xms4g -Xmx4g FileExtensionAndMap true
*/
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Semaphore;
import java.util.stream.IntStream;
public class FileExtensionAndMap {
private static final ExecutorService CACHED_EXECUTORSERVICE =
Executors.newCachedThreadPool();
private static final String TMPDIR = System.getProperty("test.dir", ".");
private static boolean useRaf = false;
public static void main(String args[]) throws Exception {
if (args.length > 2) {
throw new IllegalArgumentException
("Arguments: [true|false [targetFolder]]");
}
String defaultFolder = TMPDIR + File.separator + "target";
if (args.length > 0) {
useRaf = Boolean.valueOf(args[0]);
if (args.length > 1) {
defaultFolder = args[1];
}
}
final String targetFolder = defaultFolder;
Path p = Paths.get(targetFolder);
boolean targetExists = Files.exists(p);
if (!targetExists) {
Files.createDirectory(p);
}
System.out.printf("Using RandomAccessFile: %s; target folder: %s%n",
useRaf, targetFolder);
ForkJoinPool fjPool = new ForkJoinPool(3);
fjPool.submit(() -> {
IntStream.range(0, 20).parallel().forEach((index) -> {
String fileName = "testBigFile_" + index + ".dat";
Path source = null;
Path target = null;
try {
source = Paths.get(TMPDIR, fileName);
testCreateBigFile(source);
target = Paths.get(targetFolder, fileName);
testFileCopy(source, target);
} catch (Throwable th) {
System.err.println("Error copying file with fileName: "
+ fileName + " : " + th.getMessage());
th.printStackTrace(System.err);
} finally {
try {
if (source != null) {
Files.deleteIfExists(source);
}
} catch (Throwable ignored) {
}
try {
if (target != null) {
Files.deleteIfExists(target);
}
} catch (Throwable ignored) {
}
}
});
}).join();
if (!targetExists) {
Files.delete(p);
}
}
private static void testFileCopy(Path source, Path target)
throws IOException {
Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
System.out.println("Finished copying file with fileName: "
+ source.getFileName());
}
private static void testCreateBigFile(Path segmentFile)
throws IOException {
final Semaphore concurrencySemaphore = new Semaphore(5);
long fileSize = 3L * 1024L * 1024L * 1024L;
int blockSize = 10 * 1024 * 1024;
int loopCount = (int) Math.floorDiv(fileSize, blockSize);
String fileName = segmentFile.getFileName().toString();
if (useRaf) {
try (RandomAccessFile raf
= new RandomAccessFile(segmentFile.toFile(), "rw")) {
raf.setLength(fileSize);
try (FileChannel fc = raf.getChannel()) {
for (int i = 0; i < loopCount; i++) {
final long startPosition = 1L * blockSize * i;
concurrencySemaphore.acquireUninterruptibly();
CACHED_EXECUTORSERVICE.submit(() -> {
writeTemplateData(fileName, fc, startPosition,
blockSize, concurrencySemaphore);
});
}
} finally {
concurrencySemaphore.acquireUninterruptibly(5);
}
}
} else {
Path file = Files.createFile(segmentFile);
try (FileChannel fc = FileChannel.open(file,
StandardOpenOption.READ, StandardOpenOption.WRITE)) {
for (int i = 0; i < loopCount; i++) {
final long startPosition = 1L * blockSize * i;
concurrencySemaphore.acquireUninterruptibly();
CACHED_EXECUTORSERVICE.submit(() -> {
writeTemplateData(fileName, fc, startPosition,
blockSize, concurrencySemaphore);
});
}
}
}
}
private static void writeTemplateData(String fileName,
FileChannel fc, long startPosition, int blockSize,
Semaphore concurrencySemaphore) {
try {
byte[] EMPTY_RECORD = new byte[blockSize / 256];
MappedByteBuffer mappedByteBuffer = fc.map(MapMode.READ_WRITE,
startPosition, blockSize);
IntStream.range(0, 256).forEach((recordIndex) -> {
try {
mappedByteBuffer.position((int) (recordIndex *
EMPTY_RECORD.length));
mappedByteBuffer.put(EMPTY_RECORD, 0, EMPTY_RECORD.length);
} catch (Throwable th) {
System.err.println
("Error in FileExtensionAndMap.writeTemplateData empty record for fileName: "
+ fileName + ", startPosition: " + startPosition + ", recordIndex: "
+ recordIndex + " : " + th.getMessage());
th.printStackTrace(System.err);
}
});
mappedByteBuffer.force();
} catch (Throwable th) {
if (!(th instanceof ClosedChannelException)) {
System.err.println
("Error in FileExtensionAndMap.writeTemplateData empty record for fileName: "
+ fileName + ", startPosition: " + startPosition + " : "
+ th.getMessage());
th.printStackTrace(System.err);
}
} finally {
concurrencySemaphore.release();
}
}
}