1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
/*
* Copyright (c) 2015, 2023, 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 TestMinAndInitialSurvivorRatioFlags
* @summary Verify that MinSurvivorRatio and InitialSurvivorRatio flags work
* @library /test/lib
* @library /
* @modules java.base/jdk.internal.misc
* java.management
* @build jdk.test.whitebox.WhiteBox
* @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
* @run driver/timeout=240 gc.arguments.TestMinAndInitialSurvivorRatioFlags
*/
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.Utils;
import jdk.test.whitebox.WhiteBox;
/* Test verifies that VM can start with any GC when MinSurvivorRatio and
* InitialSurvivorRatio flags passed and for Parallel GC it verifies that
* after start up survivor ratio equal to InitialSurvivorRatio value and
* that actual survivor ratio will never be less than MinSurvivorRatio.
*/
public class TestMinAndInitialSurvivorRatioFlags {
public static final long M = 1024 * 1024;
public static final long HEAP_SIZE = 200 * M;
public static final long NEW_SIZE = 100 * M;
public static void main(String args[]) throws Exception {
LinkedList<String> options = new LinkedList<>(
Arrays.asList(Utils.getFilteredTestJavaOpts("-XX:[^ ]*SurvivorRatio=[^ ]+"))
);
testSurvivorRatio(5, -1, -1, options, true);
testSurvivorRatio(10, -1, -1, options, true);
testSurvivorRatio(-1, 5, 3, options, true);
testSurvivorRatio(-1, 15, 3, options, true);
testSurvivorRatio(-1, 15, 3, options, false);
testSurvivorRatio(-1, 10, 10, options, true);
testSurvivorRatio(-1, 3, 15, options, true);
testSurvivorRatio(-1, 3, 15, options, false);
}
/**
* Test that MinSurvivorRatio and InitialSurvivorRatio flags work.
*
* @param survivorRatio value for -XX:SurvivorRatio option, omitted if negative
* @param initRatio value for -XX:InitialSurvivorRatio option, omitted if negative
* @param minRatio value for -XX:MinSurvivorRatio option, omitted if negative
* @param options additional options for VM
* @param useAdaptiveSizePolicy turn on or off UseAdaptiveSizePolicy option
*/
public static void testSurvivorRatio(int survivorRatio,
int initRatio,
int minRatio,
LinkedList<String> options,
boolean useAdaptiveSizePolicy) throws Exception {
LinkedList<String> vmOptions = new LinkedList<>(options);
Collections.addAll(vmOptions,
"-Xbootclasspath/a:.",
"-XX:+UnlockDiagnosticVMOptions",
"-XX:+WhiteBoxAPI",
"-XX:MaxNewSize=" + NEW_SIZE, "-XX:NewSize=" + NEW_SIZE,
"-Xmx" + HEAP_SIZE, "-Xms" + HEAP_SIZE,
(survivorRatio >= 0 ? "-XX:SurvivorRatio=" + survivorRatio : ""),
(initRatio >= 0 ? "-XX:InitialSurvivorRatio=" + initRatio : ""),
(minRatio >= 0 ? "-XX:MinSurvivorRatio=" + minRatio : ""),
(useAdaptiveSizePolicy ? "-XX:+UseAdaptiveSizePolicy" : "-XX:-UseAdaptiveSizePolicy"),
SurvivorRatioVerifier.class.getName(),
Integer.toString(survivorRatio),
Integer.toString(initRatio),
Integer.toString(minRatio),
Boolean.toString(useAdaptiveSizePolicy)
);
vmOptions.removeIf((String p) -> p.isEmpty());
OutputAnalyzer analyzer = GCArguments.executeLimitedTestJava(vmOptions);
analyzer.shouldHaveExitValue(0);
}
/**
* Class that verifies survivor ratio.
* Will be executed in tested VM. Checks initial size of eden and survivor paces with alignment.
*/
public static class SurvivorRatioVerifier {
public static WhiteBox wb = WhiteBox.getWhiteBox();
public static final int MAX_ITERATIONS = 10;
public static final int ARRAY_LENGTH = 10000;
public static final int CHUNK_SIZE = 10000;
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: <survivorRatio> <initRatio> <minRatio> <useAdaptiveSizePolicy>");
}
final int survivorRatio = Integer.valueOf(args[0]);
final int initRatio = Integer.valueOf(args[1]);
final int minRatio = Integer.valueOf(args[2]);
final boolean useAdaptiveSizePolicy = Boolean.valueOf(args[3]);
// we stop testing only here to ensure that JVM will accept
// both MinSurvivorRatio and InitialSurvivorRatio regardles to GC
if (GCTypes.YoungGCType.getYoungGCType() != GCTypes.YoungGCType.PSNew) {
System.out.println("Test is only applicable to Parallel GC");
return;
}
// verify initial survivor ratio
verifySurvivorRatio(survivorRatio, initRatio, minRatio, useAdaptiveSizePolicy, true);
// force GC
AllocationHelper allocator = new AllocationHelper(MAX_ITERATIONS, ARRAY_LENGTH, CHUNK_SIZE,
() -> (verifySurvivorRatio(survivorRatio, initRatio, minRatio, useAdaptiveSizePolicy, false)));
allocator.allocateMemoryAndVerify();
}
/**
* Verify actual survivor ratio.
*
* @param survivorRatio value of SurvivorRatio option, omitted if negative
* @param initRatio value of InitialSurvivorRatio option, omitted if negative
* @param minRatio value of MinSurvivorRatio option, omitted if negative
* @param useAdaptiveSizePolicy value of UseAdaptiveSizePolicy option
* @param verifyInitialRatio true if we are going to verify initial ratio
*/
public static Void verifySurvivorRatio(int survivorRatio,
int initRatio,
int minRatio,
boolean useAdaptiveSizePolicy,
boolean verifyInitialRatio) {
MemoryUsage edenUsage = HeapRegionUsageTool.getEdenUsage();
MemoryUsage survivorUsage = HeapRegionUsageTool.getSurvivorUsage();
long alignedNewSize = edenUsage.getMax() + 2 * survivorUsage.getMax();
long generationAlignment = wb.psHeapGenerationAlignment();
if (survivorRatio >= 0) {
// -XX:SurvivorRatio was passed to JVM, actual ratio should be SurvivorRatio + 2
long expectedSize = HeapRegionUsageTool.alignDown(alignedNewSize / (survivorRatio + 2),
generationAlignment);
if (survivorUsage.getCommitted() != expectedSize) {
throw new RuntimeException("Expected survivor size is: " + expectedSize
+ ", but observed size is: " + survivorUsage.getCommitted());
}
} else if (verifyInitialRatio || !useAdaptiveSizePolicy) {
// In case of initial ratio verification or disabled adaptive size policy
// ratio should be equal to InitialSurvivorRatio value
long expectedSize = HeapRegionUsageTool.alignDown(alignedNewSize / initRatio,
generationAlignment);
if (survivorUsage.getCommitted() != expectedSize) {
throw new RuntimeException("Expected survivor size is: " + expectedSize
+ ", but observed size is: " + survivorUsage.getCommitted());
}
} else {
// In any other case actual survivor ratio should not be lower than MinSurvivorRatio
// or is should be equal to InitialSurvivorRatio
long expectedMinSize = HeapRegionUsageTool.alignDown(alignedNewSize / minRatio,
generationAlignment);
long expectedInitSize = HeapRegionUsageTool.alignDown(alignedNewSize / initRatio,
generationAlignment);
if (survivorUsage.getCommitted() != expectedInitSize
&& survivorUsage.getCommitted() < expectedMinSize) {
throw new RuntimeException("Expected survivor size should be " + expectedMinSize
+ " or should be greater then " + expectedMinSize
+ ", but observer survivor size is " + survivorUsage.getCommitted());
}
}
return null;
}
}
}
|
