/*
* Copyright (c) 2013, 2018, 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
* @modules java.base/jdk.internal.misc
* @key stress gc
*
* @summary converted from VM Testbase gc/memory/Nio.
* VM Testbase keywords: [gc, stress, stressopt, monitoring]
*
* @library /vmTestbase
* /test/lib
* @run driver jdk.test.lib.FileInstaller . .
* @run main/othervm -XX:MaxDirectMemorySize=50M gc.memory.Nio.Nio
*/
package gc.memory.Nio;
import java.lang.management.ManagementFactory;
import java.nio.ByteBuffer;
import jdk.internal.misc.VM;
import com.sun.management.HotSpotDiagnosticMXBean;
import java.io.File;
import java.io.IOException;
/**
* Test that uses java.nio.ByteBuffer to allocate native memory.
* The test allocates all the memory available and checks that
* further attempts to allocate more more will fail.
* Test also checks that allocating native memory doesn't affect heap.
* Test also cheks that GC can find unused native memory.
*
* @summary Checks that nio.ByteBuffer allocates native memory and doesn't affect heap.
* @run main/othervm -XX:MaxDirectMemorySize=50M gc.memory.Nio.Nio
*/
public class Nio {
static final int MAX_SIZE = (int)VM.maxDirectMemory();
public static void main(String[] args) {
System.exit(new Nio().run() + 95 /*STATUS_BASE*/);
}
public Nio() {
}
public int run() {
// Step0: init
gc();
long usedHeap_0 = getUsedHeap();
long usedNonHeap_0 = getUsedNonHeap();
// Step1: allocate the all available direct memory
// no OOME, no heap memory should be used
System.out.println("Allocating all the direct memory: " + MAX_SIZE);
ByteBuffer bb;
try {
bb = ByteBuffer.allocateDirect((int)MAX_SIZE);
System.out.println("... success");
} catch (OutOfMemoryError oom) {
throw new Fault("Unexpected OOME during the first allocation " + oom);
}
long usedHeap_1 = getUsedHeap();
long usedNonHeap_1 = getUsedNonHeap();
checkHeapIsNotAffected(usedHeap_0, usedHeap_1, usedNonHeap_0, usedNonHeap_1);
// Step2: invoke GC, it shouldn't help.
System.out.println("Doing gc");
gc();
// Step3: allocate 1 byte in the direct memory
// OOM is expected
try {
System.out.println("Allocating 1 byte");
ByteBuffer.allocateDirect(1);
throw new Fault("No OOM, but we already allocated all the memory");
} catch (OutOfMemoryError oom) {
System.out.println("Expected OOM " + oom);
}
// Step4: read and write into allocated memory
double d0 = -3.1415;
float f0 = 41234.6f;
bb.putDouble(MAX_SIZE/2, d0);
bb.putFloat(MAX_SIZE - 17, f0);
double d1 = bb.getDouble(MAX_SIZE/2);
float f1 = bb.getFloat(MAX_SIZE - 17);
System.out.println("put: " + d0 + ", " + f0);
System.out.println("got: " + d1 + ", " + f1);
if (d0 != d1 || f0 != f1) {
throw new Fault("read/write to buffer check failed");
}
// Step5:
// clean the buffer, use gc, try to allocate again
// no OOM is expected
bb = null;
gc();
try {
System.out.println("Allocating 10 bytes");
ByteBuffer.allocateDirect(10);
} catch (OutOfMemoryError oom) {
throw new Fault("Nop, OOM is unexpected again: " + oom);
}
System.out.println("The long quest has done! Congratulations");
return 0;
}
public static void gc() {
System.gc();
try {
Thread.currentThread().sleep(200);
} catch (Exception ignore) {
}
}
/**
* @return the size of used heap
*/
public static long getUsedHeap() {
return ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
}
/**
* @return the size of used non heap
*/
public static long getUsedNonHeap() {
return ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage().getUsed();
}
/**
* Check that heap and non-heap memory have NOT changed significantly.
* Throws a Fault if check failed.
*
* @param h_before used heap before
* @param h_after used heap after
* @param nh_before used non heap before
* @param nh_after used non heap after
*/
void checkHeapIsNotAffected(long h_before, long h_after, long nh_before, long nh_after) {
if (h_after - h_before > MAX_SIZE * 0.75) {
System.err.println("Used heap before: " + h_before);
System.err.println("Used heap after : " + h_after);
dumpHeap();
String failed = "Allocating direct memory should not eat the heap!"
+ " Heap dumped to heapDump.hprof file.";
throw new Fault(failed);
}
if (nh_after - nh_before > MAX_SIZE * 0.75) {
System.err.println("Used heap before: " + nh_before);
System.err.println("Used heap after : " + nh_after);
dumpHeap();
throw new Fault("Allocating direct memory should not eat non the heap!");
}
}
/**
* Try to make heap dump
*/
void dumpHeap() {
HotSpotDiagnosticMXBean mxBean = ManagementFactory
.getPlatformMXBean(HotSpotDiagnosticMXBean.class);
try {
System.out.println("Try to dump heap to heapDump.hprof file..");
mxBean.dumpHeap("heapDump.hprof", false);
System.out.println("Done");
} catch (IOException e) {
System.out.println("Failed to dump heap");
e.printStackTrace();
}
}
/**
* RuntimeException signaling a test failure.
*/
public static class Fault extends RuntimeException {
public Fault(String message) {
super(message);
}
}
}