Mercurial > hg > truffle

comparison test/gc/arguments/TestUseCompressedOopsErgoTools.java @ 12233:40136aa2cdb1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8010722: assert: failed: heap size is too big for compressed oops Summary: Use conservative assumptions of required alignment for the various garbage collector components into account when determining the maximum heap size that supports compressed oops. Using this conservative value avoids several circular dependencies in the calculation. Reviewed-by: stefank, dholmes
author tschatzl
date Wed, 11 Sep 2013 16:25:02 +0200
parents
children 2f426063daea
comparison
equal deleted inserted replaced
12230:040895ec3920 12233:40136aa2cdb1
1 /*
2 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 import sun.management.ManagementFactoryHelper;
25 import com.sun.management.HotSpotDiagnosticMXBean;
26 import com.sun.management.VMOption;
27
28 import java.util.regex.Matcher;
29 import java.util.regex.Pattern;
30 import java.util.ArrayList;
31 import java.util.Arrays;
32
33 import com.oracle.java.testlibrary.*;
34 import sun.hotspot.WhiteBox;
35
36 class DetermineMaxHeapForCompressedOops {
37 public static void main(String[] args) throws Exception {
38 WhiteBox wb = WhiteBox.getWhiteBox();
39 System.out.print(wb.getCompressedOopsMaxHeapSize());
40 }
41 }
42
43 class TestUseCompressedOopsErgoTools {
44
45 private static long getClassMetaspaceSize() {
46 HotSpotDiagnosticMXBean diagnostic = ManagementFactoryHelper.getDiagnosticMXBean();
47
48 VMOption option = diagnostic.getVMOption("ClassMetaspaceSize");
49 return Long.parseLong(option.getValue());
50 }
51
52
53 public static long getMaxHeapForCompressedOops(String[] vmargs) throws Exception {
54 OutputAnalyzer output = runWhiteBoxTest(vmargs, DetermineMaxHeapForCompressedOops.class.getName(), new String[] {}, false);
55 return Long.parseLong(output.getStdout());
56 }
57
58 public static boolean is64bitVM() {
59 String val = System.getProperty("sun.arch.data.model");
60 if (val == null) {
61 throw new RuntimeException("Could not read sun.arch.data.model");
62 }
63 if (val.equals("64")) {
64 return true;
65 } else if (val.equals("32")) {
66 return false;
67 }
68 throw new RuntimeException("Unexpected value " + val + " of sun.arch.data.model");
69 }
70
71 /**
72 * Executes a new VM process with the given class and parameters.
73 * @param vmargs Arguments to the VM to run
74 * @param classname Name of the class to run
75 * @param arguments Arguments to the class
76 * @param useTestDotJavaDotOpts Use test.java.opts as part of the VM argument string
77 * @return The OutputAnalyzer with the results for the invocation.
78 */
79 public static OutputAnalyzer runWhiteBoxTest(String[] vmargs, String classname, String[] arguments, boolean useTestDotJavaDotOpts) throws Exception {
80 ArrayList<String> finalargs = new ArrayList<String>();
81
82 String[] whiteboxOpts = new String[] {
83 "-Xbootclasspath/a:.",
84 "-XX:+UnlockDiagnosticVMOptions", "-XX:+WhiteBoxAPI",
85 "-cp", System.getProperty("java.class.path"),
86 };
87
88 if (useTestDotJavaDotOpts) {
89 // System.getProperty("test.java.opts") is '' if no options is set,
90 // we need to skip such a result
91 String[] externalVMOpts = new String[0];
92 if (System.getProperty("test.java.opts") != null && System.getProperty("test.java.opts").length() != 0) {
93 externalVMOpts = System.getProperty("test.java.opts").split(" ");
94 }
95 finalargs.addAll(Arrays.asList(externalVMOpts));
96 }
97
98 finalargs.addAll(Arrays.asList(vmargs));
99 finalargs.addAll(Arrays.asList(whiteboxOpts));
100 finalargs.add(classname);
101 finalargs.addAll(Arrays.asList(arguments));
102
103 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(finalargs.toArray(new String[0]));
104 OutputAnalyzer output = new OutputAnalyzer(pb.start());
105 output.shouldHaveExitValue(0);
106 return output;
107 }
108
109 private static String[] join(String[] part1, String part2) {
110 ArrayList<String> result = new ArrayList<String>();
111 result.addAll(Arrays.asList(part1));
112 result.add(part2);
113 return result.toArray(new String[0]);
114 }
115
116 public static void checkCompressedOopsErgo(String[] gcflags) throws Exception {
117 long maxHeapForCompressedOops = getMaxHeapForCompressedOops(gcflags);
118
119 checkUseCompressedOops(gcflags, maxHeapForCompressedOops, true);
120 checkUseCompressedOops(gcflags, maxHeapForCompressedOops - 1, true);
121 checkUseCompressedOops(gcflags, maxHeapForCompressedOops + 1, false);
122
123 // the use of HeapBaseMinAddress should not change the outcome
124 checkUseCompressedOops(join(gcflags, "-XX:HeapBaseMinAddress=32G"), maxHeapForCompressedOops, true);
125 checkUseCompressedOops(join(gcflags, "-XX:HeapBaseMinAddress=32G"), maxHeapForCompressedOops - 1, true);
126 checkUseCompressedOops(join(gcflags, "-XX:HeapBaseMinAddress=32G"), maxHeapForCompressedOops + 1, false);
127
128 // use a different object alignment
129 maxHeapForCompressedOops = getMaxHeapForCompressedOops(join(gcflags, "-XX:ObjectAlignmentInBytes=16"));
130
131 checkUseCompressedOops(join(gcflags, "-XX:ObjectAlignmentInBytes=16"), maxHeapForCompressedOops, true);
132 checkUseCompressedOops(join(gcflags, "-XX:ObjectAlignmentInBytes=16"), maxHeapForCompressedOops - 1, true);
133 checkUseCompressedOops(join(gcflags, "-XX:ObjectAlignmentInBytes=16"), maxHeapForCompressedOops + 1, false);
134
135 // use a different ClassMetaspaceSize
136 String classMetaspaceSizeArg = "-XX:ClassMetaspaceSize=" + 2 * getClassMetaspaceSize();
137 maxHeapForCompressedOops = getMaxHeapForCompressedOops(join(gcflags, classMetaspaceSizeArg));
138
139 checkUseCompressedOops(join(gcflags, classMetaspaceSizeArg), maxHeapForCompressedOops, true);
140 checkUseCompressedOops(join(gcflags, classMetaspaceSizeArg), maxHeapForCompressedOops - 1, true);
141 checkUseCompressedOops(join(gcflags, classMetaspaceSizeArg), maxHeapForCompressedOops + 1, false);
142 }
143
144 private static void checkUseCompressedOops(String[] args, long heapsize, boolean expectUseCompressedOops) throws Exception {
145 ArrayList<String> finalargs = new ArrayList<String>();
146 finalargs.addAll(Arrays.asList(args));
147 finalargs.add("-Xmx" + heapsize);
148 finalargs.add("-XX:+PrintFlagsFinal");
149 finalargs.add("-version");
150
151 String output = expectValid(finalargs.toArray(new String[0]));
152
153 boolean actualUseCompressedOops = getFlagBoolValue(" UseCompressedOops", output);
154
155 if (expectUseCompressedOops != actualUseCompressedOops) {
156 throw new RuntimeException("Expected use of compressed oops: " + expectUseCompressedOops + " but was: " + actualUseCompressedOops);
157 }
158 }
159
160 private static boolean getFlagBoolValue(String flag, String where) {
161 Matcher m = Pattern.compile(flag + "\\s+:?= (true|false)").matcher(where);
162 if (!m.find()) {
163 throw new RuntimeException("Could not find value for flag " + flag + " in output string");
164 }
165 String match = m.group(1).equals("true");
166 }
167
168 private static String expect(String[] flags, boolean hasWarning, boolean hasError, int errorcode) throws Exception {
169 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(flags);
170 OutputAnalyzer output = new OutputAnalyzer(pb.start());
171 output.shouldHaveExitValue(errorcode);
172 return output.getStdout();
173 }
174
175 private static String expectValid(String[] flags) throws Exception {
176 return expect(flags, false, false, 0);
177 }
178 }
179