/*
* 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 TestIHOPStatic
* @bug 8148397
* @summary Test checks concurrent cycle initiation which depends on IHOP value.
* @requires vm.gc.G1
* @requires !vm.flightRecorder
* @requires vm.opt.ExplicitGCInvokesConcurrent != true
* @library /test/lib /
* @modules java.base/jdk.internal.misc
* @modules java.management
* @run driver/timeout=240 gc.g1.ihop.TestIHOPStatic
*/
package gc.g1.ihop;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import jdk.test.lib.process.ProcessTools;
import jdk.test.lib.process.OutputAnalyzer;
import jdk.test.lib.Utils;
import gc.g1.ihop.lib.IhopUtils;
/**
* The test starts the AppIHOP multiple times varying setting of MaxHeapSize,
* IHOP and amount of memory to allocate. Then the test parses the GC log from
* the app to check that Concurrent Mark Cycle was initiated only if needed
* and at the right moment, defined by IHOP setting.
*/
public class TestIHOPStatic {
final static long YOUNG_SIZE = 8 * 1024 * 1024;
private final static String[] COMMON_OPTIONS = {
"-XX:+UseG1GC",
"-XX:G1HeapRegionSize=1m",
"-XX:-G1UseAdaptiveIHOP",
"-XX:NewSize=" + YOUNG_SIZE,
"-XX:MaxNewSize=" + YOUNG_SIZE,
"-Xlog:gc+ihop+ergo=debug,gc*=debug"
};
public static void main(String[] args) throws Throwable {
// Test case:
// IHOP value, heap occupancy, heap size, expectation of message
// Test cases for occupancy is greater than IHOP
runTest(30, 35, 64, true);
runTest(50, 55, 256, true);
runTest(60, 65, 64, true);
runTest(70, 75, 512, true);
// Test cases for big difference between occupancy and IHOP
runTest(30, 50, 256, true);
runTest(30, 70, 512, true);
runTest(50, 70, 256, true);
// Test cases for occupancy is less than IHOP
runTest(30, 25, 64, false);
runTest(50, 45, 256, false);
runTest(70, 65, 64, false);
runTest(70, 65, 512, false);
// Test cases for big difference between occupancy and IHOP
runTest(50, 30, 300, false);
runTest(70, 50, 160, false);
// Cases for 0 and 100 IHOP.
runTest(0, 50, 256, true);
runTest(0, 95, 512, true);
runTest(100, 20, 64, false);
runTest(100, 100, 512, false);
}
/**
* Runs the test case.
*
* @param ihop IHOP value
* @param pctToFill heap percentage to be filled
* @param heapSize heap size for test
* @param expectInitiationMessage
* true - concurrent cycle initiation message is expected
* false - message is not expected
*
* @throws Throwable
*/
private static void runTest(int ihop, long pctToFill, long heapSize, boolean expectInitiationMessage) throws Throwable {
System.out.println("");
System.out.println("IHOP test:");
System.out.println(" InitiatingHeapOccupancyPercent : " + ihop);
System.out.println(" Part of heap to fill (percentage) : " + pctToFill);
System.out.println(" MaxHeapSize : " + heapSize);
System.out.println(" Expect for concurrent cycle initiation message : " + expectInitiationMessage);
List<String> options = new ArrayList<>();
Collections.addAll(options, Utils.getTestJavaOpts());
Collections.addAll(options,
"-XX:InitiatingHeapOccupancyPercent=" + ihop,
"-Dmemory.fill=" + (heapSize * 1024 * 1024 * pctToFill / 100),
"-XX:MaxHeapSize=" + heapSize + "M",
"-XX:InitialHeapSize=" + heapSize + "M"
);
Collections.addAll(options, COMMON_OPTIONS);
options.add(AppIHOP.class.getName());
OutputAnalyzer out = ProcessTools.executeTestJvm(options.toArray(new String[options.size()]));
if (out.getExitValue() != 0) {
System.out.println(out.getOutput());
throw new RuntimeException("IhopTest failed with exit code " + out.getExitValue());
}
checkResult(out, expectInitiationMessage);
}
/**
* Checks execution results to ensure that concurrent cycle was initiated or
* was not.
*
* @param out
* @param expectInitiationMessage true - test expects for concurrent cycle initiation.
* false - test does not expect for concurrent cycle initiation
*/
private static void checkResult(OutputAnalyzer out, boolean expectInitiationMessage) {
// Find expected messages
List<String> logItems = IhopUtils.getErgoInitiationMessages(out);
// Concurrent cycle was not initiated but was expected.
if (logItems.isEmpty() && expectInitiationMessage) {
System.out.println(out.getOutput());
throw new RuntimeException("Concurrent cycle was not initiated.");
}
IhopUtils.checkIhopLogValues(out);
}
static class AppIHOP {
/**
* Simple class which fills part of memory and initiates GC.
* To be executed in separate VM.
* Expect next VM properties to be set:
* memory.fill - amount of garbage to be created.
*/
private static final long MEMORY_TO_FILL = Integer.getInteger("memory.fill");
private final static int CHUNK_SIZE = 10000;
public final static ArrayList<Object> STORAGE = new ArrayList<>();
public static void main(String[] args) throws InterruptedException {
// Calculate part of heap to be filled to achieve expected occupancy.
System.out.println("Mem to fill:" + MEMORY_TO_FILL);
if (MEMORY_TO_FILL <= 0) {
throw new RuntimeException("Wrong memory size: " + MEMORY_TO_FILL);
}
try {
createGarbage(MEMORY_TO_FILL);
} catch (OutOfMemoryError oome) {
return;
}
// Concurrent cycle initiation should start at end of Young GC cycle.
// Will fill entire young gen with garbage to guarantee that Young GC was initiated.
try {
createGarbage(TestIHOPStatic.YOUNG_SIZE);
} catch (OutOfMemoryError oome) {
}
}
private static void createGarbage(long memToFill) {
for (long i = 0; i < memToFill / CHUNK_SIZE; i++) {
STORAGE.add(new byte[CHUNK_SIZE]);
}
}
}
}