8232365: Implementation for JEP 363: Remove the Concurrent Mark Sweep (CMS) Garbage Collector
Reviewed-by: kbarrett, tschatzl, erikj, coleenp, dholmes
/*
* Copyright (c) 2015, 2019, 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.
*/
package gc.arguments;
/*
* @test TestNewSizeFlags
* @key gc
* @bug 8025166
* @summary Verify that young gen size conforms values specified by NewSize, MaxNewSize and Xmn options
* @requires vm.gc != "Z" & vm.gc != "Shenandoah"
* @library /test/lib
* @library /
* @modules java.base/jdk.internal.misc
* java.management
* @build sun.hotspot.WhiteBox
* @run driver ClassFileInstaller sun.hotspot.WhiteBox
* @run driver/timeout=240 gc.arguments.TestNewSizeFlags
*/
import java.io.IOException;
import java.lang.management.MemoryUsage;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import jdk.test.lib.process.OutputAnalyzer;
import jdk.test.lib.process.ProcessTools;
import jdk.test.lib.Utils;
import sun.hotspot.WhiteBox;
public class TestNewSizeFlags {
public static final long M = 1024 * 1024;
public static void main(String args[]) throws Exception {
LinkedList<String> options = new LinkedList<>(
Arrays.asList(Utils.getFilteredTestJavaOpts("(-Xm[nsx][^ ]+)|"
+ "(-XX:(Max)?((New)|"
+ "(Heap))((Size)|"
+ "(Ratio))=[^ ]+)"))
);
// Test NewSize and MaxNewSize
testNewSizeFlags(20 * M, 10 * M, 30 * M, 40 * M, options, false);
testNewSizeFlags(10 * M, 20 * M, 30 * M, 80 * M, options, false);
testNewSizeFlags(-1, 20 * M, 30 * M, 40 * M, options, false);
testNewSizeFlags(10 * M, -1, 30 * M, 40 * M, options, false);
testNewSizeFlags(20 * M, 20 * M, 30 * M, 40 * M, options, false);
testNewSizeFlags(20 * M, 30 * M, 40 * M, 50 * M, options, false);
testNewSizeFlags(30 * M, 100 * M, 150 * M, 200 * M, options, false);
testNewSizeFlags(20 * M, 30 * M, 128 * M, 128 * M, options, false);
// Test -Xmn
testXmnFlags(0, 30 * M, 40 * M, options, true);
testXmnFlags(20 * M, 30 * M, 40 * M, options, false);
testXmnFlags(50 * M, 70 * M, 100 * M, options, false);
}
/**
* Verify that NewSize and MaxNewSize flags affect young gen size.
*
* @param newSize value of NewSize option, omitted if negative
* @param maxNewSize value of MaxNewSize option, omitted if negative
* @param heapSize value of HeapSize option
* @param maxHeapSize value of MaxHeapSize option
* @param options additional options for JVM
* @param failureExpected true if JVM should fail with passed heap size options
*/
public static void testNewSizeFlags(long newSize, long maxNewSize,
long heapSize, long maxHeapSize,
LinkedList<String> options,
boolean failureExpected) throws Exception {
long expectedNewSize = newSize;
long expectedMaxNewSize = (maxNewSize >= 0 ? Math.max(maxNewSize, newSize) : maxNewSize);
testVMOptions(newSize, maxNewSize,
heapSize, maxHeapSize,
expectedNewSize, expectedMaxNewSize,
options, failureExpected);
}
/**
* Verify that -Xmn flag affect young gen size.
*
* @param mnValue value of -Xmn option
* @param heapSize value of HeapSize option
* @param maxHeapSize value of MaxHeapSize option
* @param options additional options for JVM
* @param failureExpected true if JVM should fail with passed heap size options
*/
public static void testXmnFlags(long mnValue,
long heapSize, long maxHeapSize,
LinkedList<String> options,
boolean failureExpected) throws Exception {
LinkedList<String> newOptions = new LinkedList<>(options);
newOptions.add("-Xmn" + mnValue);
testVMOptions(-1, -1,
heapSize, maxHeapSize,
mnValue, mnValue,
newOptions, failureExpected);
}
/**
* Verify that NewSize and MaxNewSize flags affect young gen size.
*
* @param newSize value of NewSize option, omitted if negative
* @param maxNewSize value of MaxNewSize option, omitted if negative
* @param heapSize value of HeapSize option
* @param maxHeapSize value of MaxHeapSize option
* @param expectedNewSize expected initial young gen size
* @param expectedMaxNewSize expected max young gen size
* @param options additional options for JVM
* @param failureExpected true if JVM should fail with passed heap size options
*/
public static void testVMOptions(long newSize, long maxNewSize,
long heapSize, long maxHeapSize,
long expectedNewSize, long expectedMaxNewSize,
LinkedList<String> options, boolean failureExpected) throws Exception {
OutputAnalyzer analyzer = startVM(options, newSize, maxNewSize, heapSize, maxHeapSize, expectedNewSize, expectedMaxNewSize);
if (failureExpected) {
analyzer.shouldHaveExitValue(1);
analyzer.shouldMatch("(Error occurred during initialization of VM)|"
+ "(Error: Could not create the Java Virtual Machine.)");
} else {
analyzer.shouldHaveExitValue(0);
}
}
private static OutputAnalyzer startVM(LinkedList<String> options,
long newSize, long maxNewSize,
long heapSize, long maxHeapSize,
long expectedNewSize, long expectedMaxNewSize) throws Exception, IOException {
LinkedList<String> vmOptions = new LinkedList<>(options);
Collections.addAll(vmOptions,
"-Xbootclasspath/a:.",
"-XX:+UnlockDiagnosticVMOptions",
"-XX:+WhiteBoxAPI",
(newSize >= 0 ? "-XX:NewSize=" + newSize : ""),
(maxNewSize >= 0 ? "-XX:MaxNewSize=" + maxNewSize : ""),
"-Xmx" + maxHeapSize,
"-Xms" + heapSize,
"-XX:GCLockerEdenExpansionPercent=0",
"-XX:-UseLargePages",
NewSizeVerifier.class.getName(),
Long.toString(expectedNewSize),
Long.toString(expectedMaxNewSize),
Long.toString(heapSize),
Long.toString(maxHeapSize)
);
vmOptions.removeIf(String::isEmpty);
ProcessBuilder procBuilder = GCArguments.createJavaProcessBuilder(vmOptions.toArray(new String[vmOptions.size()]));
OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start());
return analyzer;
}
/**
* NewSizeVerifier checks that initial young gen size is equal to expected
* regardful to alignment and that young gen size will not be greater than
* expected max size.
* In order to verify that young gen size will not be greater then expected
* max size, NewSizeVerifier do some object allocation to force garbage
* collection and heap expansion.
*/
public static class NewSizeVerifier {
private static final WhiteBox WB = WhiteBox.getWhiteBox();
private static final GCTypes.YoungGCType YOUNG_GC_TYPE = GCTypes.YoungGCType.getYoungGCType();
private static final long HEAP_SPACE_ALIGNMENT = WB.getHeapSpaceAlignment();
private static final long HEAP_ALIGNMENT = WB.getHeapAlignment();
private static final long PS_VIRTUAL_SPACE_ALIGNMENT =
(YOUNG_GC_TYPE == GCTypes.YoungGCType.PSNew) ? WB.psVirtualSpaceAlignment() : 0;
public static final int ARRAY_LENGTH = 100;
public static final int CHUNK_SIZE = 1024;
public static final int MAX_ITERATIONS = 10;
public static byte garbage[][] = new byte[ARRAY_LENGTH][];
public static void main(String args[]) throws Exception {
if (args.length != 4) {
throw new IllegalArgumentException("Expected 4 args: <expectedNewSize> <expectedMaxNewSize> <initialHeapSize> <maxHeapSize>");
}
final long newSize = Long.valueOf(args[0]);
final long maxNewSize = Long.valueOf(args[1]);
final long initialHeapSize = Long.valueOf(args[2]);
final long maxHeapSize = Long.valueOf(args[3]);
// verify initial size
verifyNewSize(newSize, maxNewSize, initialHeapSize, maxHeapSize);
// force GC and verify that size is still correct
AllocationHelper allocator = new AllocationHelper(MAX_ITERATIONS, ARRAY_LENGTH, CHUNK_SIZE, () -> (verifyNewSize(newSize, maxNewSize, initialHeapSize, maxHeapSize)));
allocator.allocateMemoryAndVerifyNoOOME();
}
/**
* Verify that actual young gen size conforms NewSize and MaxNewSize values.
*/
public static Void verifyNewSize(long newSize, long maxNewSize,
long initialHeapSize, long maxHeapSize) {
long alignedNewSize = alignGenSize(newSize);
long alignedMaxNewSize = alignGenSize(maxNewSize);
long alignedXms = alignHeapSize(initialHeapSize);
long alignedXmx = alignHeapSize(maxHeapSize);
MemoryUsage youngGenUsage = getYoungGenUsage();
long initSize = youngGenUsage.getInit();
long commitedSize = youngGenUsage.getCommitted();
long maxSize = youngGenUsage.getMax();
if (newSize != -1) {
if (initSize < alignedNewSize) {
throw new RuntimeException("initial new size < NewSize value: "
+ initSize + " < " + alignedNewSize);
}
if (commitedSize < alignedNewSize) {
throw new RuntimeException("actual new size < NewSize value: "
+ commitedSize + " < " + alignedNewSize);
}
// for G1 max new size == committed new size
if (YOUNG_GC_TYPE != GCTypes.YoungGCType.G1
&& maxSize < alignedNewSize) {
throw new RuntimeException("max new size < NewSize value: "
+ maxSize + " < " + alignedNewSize);
}
}
if (maxNewSize != -1) {
if (initSize > alignedMaxNewSize) {
throw new RuntimeException("initial new size > MaxNewSize value: "
+ initSize + " > " + alignedMaxNewSize);
}
if (commitedSize > alignedMaxNewSize) {
throw new RuntimeException("actual new size > MaxNewSize value: "
+ commitedSize + " > " + alignedMaxNewSize);
}
if (alignedXms != alignedXmx) {
if (YOUNG_GC_TYPE != GCTypes.YoungGCType.G1
&& maxSize != alignedMaxNewSize) {
throw new RuntimeException("max new size != MaxNewSize value: "
+ maxSize + " != " + alignedMaxNewSize);
}
} else {
if (YOUNG_GC_TYPE != GCTypes.YoungGCType.G1
&& maxSize != alignedNewSize) {
throw new RuntimeException("max new size != NewSize for case InitialHeapSize == MaxHeapSize value: "
+ maxSize + " != " + alignedNewSize + " HeapSize == " + alignedXms);
}
}
}
return null;
}
/**
* Get young gen memory usage.
*
* For G1 it is EdenUsage + SurvivorUsage,
* for other GCs it is EdenUsage + 2 * SurvivorUsage.
* For G1 max value is just LONG_MAX.
* For all GCs used value is 0.
*/
private static MemoryUsage getYoungGenUsage() {
MemoryUsage edenUsage = HeapRegionUsageTool.getEdenUsage();
MemoryUsage survivorUsage = HeapRegionUsageTool.getSurvivorUsage();
long edenUsageInit = edenUsage.getInit();
long edenUsageCommited = edenUsage.getCommitted();
long survivorUsageInit = survivorUsage.getInit();
long survivorUsageCommited = survivorUsage.getCommitted();
if (YOUNG_GC_TYPE == GCTypes.YoungGCType.G1) {
return new MemoryUsage(edenUsageInit + survivorUsageInit, 0,
edenUsageCommited + survivorUsageCommited, Long.MAX_VALUE);
} else {
return new MemoryUsage(edenUsageInit + survivorUsageInit * 2, 0,
edenUsageCommited + survivorUsageCommited * 2,
edenUsage.getMax() + survivorUsage.getMax() * 2);
}
}
/**
* Align generation size regardful to used young GC.
*/
public static long alignGenSize(long value) {
switch (YOUNG_GC_TYPE) {
case DefNew:
return HeapRegionUsageTool.alignDown(value, HEAP_SPACE_ALIGNMENT);
case PSNew:
return HeapRegionUsageTool.alignUp(HeapRegionUsageTool.alignDown(value,
HEAP_SPACE_ALIGNMENT),
PS_VIRTUAL_SPACE_ALIGNMENT);
case G1:
return HeapRegionUsageTool.alignUp(value, WB.g1RegionSize());
default:
throw new RuntimeException("Unexpected young GC type");
}
}
/**
* Align heap size.
*/
public static long alignHeapSize(long value){
return HeapRegionUsageTool.alignUp(value,HEAP_ALIGNMENT);
}
}
}