public static void main(String args[]) throws Exception {
is_64_bit_system = (Platform.is64bit());
OutputAnalyzer output;
whiteBox = WhiteBox.getWhiteBox();
// Grab my own PID
String pid = Integer.toString(ProcessTools.getProcessId());
ProcessBuilder pb = new ProcessBuilder();
AllocThread[] alloc_threads = new AllocThread[256];
ReleaseThread[] release_threads = new ReleaseThread[64];
int index;
// Create many allocation threads
for (index = 0; index < alloc_threads.length; index++) {
alloc_threads[index] = new AllocThread();
}
// Fewer release threads
for (index = 0; index < release_threads.length; index++) {
release_threads[index] = new ReleaseThread();
}
if (is_64_bit_system()) {
sleep_wait(2 * 60 * 1000);
} else {
sleep_wait(60 * 1000);
}
// pause the stress test
phase = TestPhase.pause;
while (pause_count.intValue() < alloc_threads.length + release_threads.length) {
sleep_wait(10);
}
long mallocd_total_in_KB = (mallocd_total + K / 2) / K;
// Now check if the result from NMT matches the total memory allocated.
String expected_test_summary =
"Test (reserved=" + mallocd_total_in_KB + "KB, committed=" + mallocd_total_in_KB + "KB)";
// Run 'jcmd <pid> VM.native_memory summary'
pb.command(new String[] {JDKToolFinder.getJDKTool("jcmd"), pid, "VM.native_memory", "summary"});
output = new OutputAnalyzer(pb.start());
output.shouldContain(expected_test_summary);
// Release all allocated memory
phase = TestPhase.release;
synchronized (mallocd_memory) {
mallocd_memory.notifyAll();
}
// Join all threads
for (index = 0; index < alloc_threads.length; index++) {
try {
alloc_threads[index].join();
} catch (InterruptedException e) {
}
}
for (index = 0; index < release_threads.length; index++) {
try {
release_threads[index].join();
} catch (InterruptedException e) {
}
}
// All test memory allocated should be released
output = new OutputAnalyzer(pb.start());
output.shouldNotContain("Test (reserved=");
// Verify that tracking level has not been downgraded
pb.command(
new String[] {JDKToolFinder.getJDKTool("jcmd"), pid, "VM.native_memory", "statistics"});
output = new OutputAnalyzer(pb.start());
output.shouldNotContain("Tracking level has been downgraded due to lack of resources");
}
static void analyzeOutputOn(ProcessBuilder pb) throws Exception {
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("<a 'java/lang/RuntimeException': Test exception 1 for logging>");
output.shouldContain(" thrown in interpreter method ");
output.shouldContain(") thrown in compiled method ");
output.shouldContain("Exception 2 caught.");
output.shouldHaveExitValue(0);
}
public static void main(String[] args) throws Exception {
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+PrintWarnings=8", "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("Improperly specified VM option 'PrintWarnings=8'");
output.shouldHaveExitValue(1);
pb = ProcessTools.createJavaProcessBuilder("-XX:-PrintWarnings=8", "-version");
output = new OutputAnalyzer(pb.start());
output.shouldContain("Improperly specified VM option 'PrintWarnings=8'");
output.shouldHaveExitValue(1);
}
public static void main(String args[]) throws Exception {
ArrayList<String> vmOpts = new ArrayList();
String testVmOptsStr = System.getProperty("test.java.opts");
if (!testVmOptsStr.isEmpty()) {
String[] testVmOpts = testVmOptsStr.split(" ");
Collections.addAll(vmOpts, testVmOpts);
}
Collections.addAll(
vmOpts,
new String[] {
"-XX:-UseTLAB", "-XX:+UnlockDiagnosticVMOptions", "-XX:+VerifyDuringStartup", "-version"
});
System.out.print("Testing:\n" + JDKToolFinder.getJDKTool("java"));
for (int i = 0; i < vmOpts.size(); i += 1) {
System.out.print(" " + vmOpts.get(i));
}
System.out.println();
ProcessBuilder pb =
ProcessTools.createJavaProcessBuilder(vmOpts.toArray(new String[vmOpts.size()]));
OutputAnalyzer output = new OutputAnalyzer(pb.start());
System.out.println("Output:\n" + output.getOutput());
output.shouldContain("[Verifying");
output.shouldHaveExitValue(0);
}
public static void main(String[] args) throws Exception {
ProcessBuilder pb =
ProcessTools.createJavaProcessBuilder("-XX:MaxMetaspaceSize=10m", "-Xshare:dump");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain(
"is not large enough.\nEither don't specify the -XX:MaxMetaspaceSize=<size>\nor increase the size to at least");
output.shouldHaveExitValue(2);
}
public static void main(String args[]) throws Exception {
if (!Platform.is64bit()) {
System.out.println(
"ReadFromNoaccessArea tests is useful only on 64bit architecture. Passing silently.");
return;
}
ProcessBuilder pb =
ProcessTools.createJavaProcessBuilder(
"-Xbootclasspath/a:.",
"-XX:+UnlockDiagnosticVMOptions",
"-XX:+WhiteBoxAPI",
"-XX:+UseCompressedOops",
"-XX:HeapBaseMinAddress=33G",
"-XX:-CreateCoredumpOnCrash",
"-Xmx32m",
DummyClassWithMainTryingToReadFromNoaccessArea.class.getName());
OutputAnalyzer output = new OutputAnalyzer(pb.start());
System.out.println("******* Printing stdout for analysis in case of failure *******");
System.out.println(output.getStdout());
System.out.println("******* Printing stderr for analysis in case of failure *******");
System.out.println(output.getStderr());
System.out.println("***************************************************************");
if (output.getStdout() != null
&& output.getStdout().contains("WB_ReadFromNoaccessArea method is useless")) {
// Test conditions broken. There is no protected page in ReservedHeapSpace in these
// circumstances. Silently passing test.
return;
}
if (Platform.isWindows()) {
output.shouldContain("EXCEPTION_ACCESS_VIOLATION");
} else if (Platform.isOSX()) {
output.shouldContain("SIGBUS");
} else {
output.shouldContain("SIGSEGV");
}
}
private static void verifySegmentedCodeCache(ProcessBuilder pb, boolean enabled)
throws Exception {
OutputAnalyzer out = new OutputAnalyzer(pb.start());
out.shouldHaveExitValue(0);
if (enabled) {
try {
// Non-nmethod code heap should be always available with the segmented code cache
out.shouldContain(NON_METHOD);
} catch (RuntimeException e) {
// Check if TieredCompilation is disabled (in a client VM)
if (!out.getOutput().contains("-XX:+TieredCompilation not supported in this VM")) {
// Code cache is not segmented
throw new RuntimeException("No code cache segmentation.");
}
}
} else {
out.shouldNotContain(NON_METHOD);
}
}
private static void outputShouldContain(String expectedString) {
output.shouldContain(expectedString);
}
public static void main(String[] args) throws Exception {
ProcessBuilder pb;
String filename = "./CDSCompressedKPtrsError.jsa";
if (Platform.is64bit()) {
pb =
ProcessTools.createJavaProcessBuilder(
"-XX:+UseCompressedOops",
"-XX:+UseCompressedClassPointers",
"-XX:+UnlockDiagnosticVMOptions",
"-XX:SharedArchiveFile=" + filename,
"-Xshare:dump");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
try {
output.shouldContain("Loading classes to share");
output.shouldHaveExitValue(0);
pb =
ProcessTools.createJavaProcessBuilder(
"-XX:-UseCompressedClassPointers",
"-XX:-UseCompressedOops",
"-XX:+UnlockDiagnosticVMOptions",
"-XX:SharedArchiveFile=" + filename,
"-Xshare:on",
"-version");
output = new OutputAnalyzer(pb.start());
output.shouldContain("Unable to use shared archive");
output.shouldHaveExitValue(0);
pb =
ProcessTools.createJavaProcessBuilder(
"-XX:-UseCompressedClassPointers",
"-XX:+UseCompressedOops",
"-XX:+UnlockDiagnosticVMOptions",
"-XX:SharedArchiveFile=" + filename,
"-Xshare:on",
"-version");
output = new OutputAnalyzer(pb.start());
output.shouldContain("Unable to use shared archive");
output.shouldHaveExitValue(0);
pb =
ProcessTools.createJavaProcessBuilder(
"-XX:+UseCompressedClassPointers",
"-XX:-UseCompressedOops",
"-XX:+UnlockDiagnosticVMOptions",
"-XX:SharedArchiveFile=" + filename,
"-Xshare:on",
"-version");
output = new OutputAnalyzer(pb.start());
output.shouldContain("Unable to use shared archive");
output.shouldHaveExitValue(0);
} catch (RuntimeException e) {
output.shouldContain("Unable to use shared archive");
output.shouldHaveExitValue(1);
}
// Test bad options with -Xshare:dump.
pb =
ProcessTools.createJavaProcessBuilder(
"-XX:-UseCompressedOops",
"-XX:+UseCompressedClassPointers",
"-XX:+UnlockDiagnosticVMOptions",
"-XX:SharedArchiveFile=./CDSCompressedKPtrsErrorBad1.jsa",
"-Xshare:dump");
output = new OutputAnalyzer(pb.start());
output.shouldContain("Cannot dump shared archive");
pb =
ProcessTools.createJavaProcessBuilder(
"-XX:+UseCompressedOops",
"-XX:-UseCompressedClassPointers",
"-XX:+UnlockDiagnosticVMOptions",
"-XX:SharedArchiveFile=./CDSCompressedKPtrsErrorBad2.jsa",
"-Xshare:dump");
output = new OutputAnalyzer(pb.start());
output.shouldContain("Cannot dump shared archive");
pb =
ProcessTools.createJavaProcessBuilder(
"-XX:-UseCompressedOops",
"-XX:-UseCompressedClassPointers",
"-XX:+UnlockDiagnosticVMOptions",
"-XX:SharedArchiveFile=./CDSCompressedKPtrsErrorBad3.jsa",
"-Xshare:dump");
output = new OutputAnalyzer(pb.start());
output.shouldContain("Cannot dump shared archive");
}
}
private static void failsWith(ProcessBuilder pb, String message) throws Exception {
OutputAnalyzer out = new OutputAnalyzer(pb.start());
out.shouldContain(message);
out.shouldHaveExitValue(1);
}
