36 import jdk.test.lib.process.ProcessTools;
37 import jdk.test.lib.process.OutputAnalyzer;
38 import jtreg.SkippedException;
39
40 public class CompressedClassPointers {
41
42 static final String logging_option = "-Xlog:gc+metaspace=trace,cds=trace";
43
44 // Returns true if we are to test the narrow klass base; we only do this on
45 // platforms where we can be reasonably shure that we get reproducable placement).
46 static boolean testNarrowKlassBase() {
47 if (Platform.isWindows()) {
48 return false;
49 }
50 return true;
51
52 }
53
54 // CDS off, small heap, ccs size default (1G)
55 // A small heap should allow us to place the ccs within the lower 32G and thus allow zero based encoding.
56 public static void smallHeapTest() throws Exception {
57 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
58 "-XX:+UnlockDiagnosticVMOptions",
59 "-XX:SharedBaseAddress=8g",
60 "-Xmx128m",
61 logging_option,
62 "-Xshare:off",
63 "-XX:+VerifyBeforeGC", "-version");
64 OutputAnalyzer output = new OutputAnalyzer(pb.start());
65 if (testNarrowKlassBase()) {
66 output.shouldContain("Narrow klass base: 0x0000000000000000");
67 }
68 output.shouldHaveExitValue(0);
69 }
70
71 // CDS off, small heap, ccs size explicitely set to 1G
72 // A small heap should allow us to place the ccs within the lower 32G and thus allow zero based encoding.
73 public static void smallHeapTestWith1G() throws Exception {
74 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
75 "-XX:+UnlockDiagnosticVMOptions",
76 "-XX:CompressedClassSpaceSize=1g",
77 "-Xmx128m",
78 logging_option,
79 "-Xshare:off",
80 "-XX:+VerifyBeforeGC", "-version");
81 OutputAnalyzer output = new OutputAnalyzer(pb.start());
82 if (testNarrowKlassBase()) {
83 output.shouldContain("Narrow klass base: 0x0000000000000000, Narrow klass shift: 3");
84 }
85 output.shouldHaveExitValue(0);
86 }
87
88 // CDS off, a very large heap, ccs size left to 1G default.
89 // We expect the ccs to be mapped somewhere far beyond the heap, such that it is not possible
90 // to use zero based encoding.
91 public static void largeHeapTest() throws Exception {
92 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
93 "-XX:+UnlockDiagnosticVMOptions",
94 "-XX:+UnlockExperimentalVMOptions",
95 "-Xmx30g",
96 logging_option,
97 "-Xshare:off",
98 "-XX:+VerifyBeforeGC", "-version");
99 OutputAnalyzer output = new OutputAnalyzer(pb.start());
100 if (testNarrowKlassBase() && !Platform.isPPC() && !Platform.isOSX()) {
101 // PPC: in most cases the heap cannot be placed below 32g so there
102 // is room for ccs and narrow klass base will be 0x0. Exception:
103 // Linux 4.1.42 or earlier (see ELF_ET_DYN_BASE in JDK-8244847).
104 // For simplicity we exclude PPC.
105 // OSX: similar.
106 output.shouldNotContain("Narrow klass base: 0x0000000000000000");
107 output.shouldContain("Narrow klass shift: 0");
108 }
109 output.shouldHaveExitValue(0);
110 }
111
112 // Settings as in largeHeapTest() except for max heap size. We make max heap
113 // size even larger such that it cannot fit into lower 32G but not too large
114 // for compressed oops.
115 // We expect a zerobased ccs.
116 public static void largeHeapAbove32GTest() throws Exception {
117 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
118 "-XX:+UnlockDiagnosticVMOptions",
119 "-XX:+UnlockExperimentalVMOptions",
120 "-Xmx31g",
121 logging_option,
122 "-Xshare:off",
123 "-XX:+VerifyBeforeGC", "-version");
124 OutputAnalyzer output = new OutputAnalyzer(pb.start());
125 if (testNarrowKlassBase()) {
126 if (!(Platform.isAArch64() && Platform.isOSX())) { // see JDK-8262895
127 output.shouldContain("Narrow klass base: 0x0000000000000000");
128 if (!Platform.isAArch64() && !Platform.isOSX()) {
129 output.shouldContain("Narrow klass shift: 0");
130 }
131 }
132 }
133 output.shouldHaveExitValue(0);
134 }
135
136 // Using large paged heap, metaspace uses small pages.
137 public static void largePagesForHeapTest() throws Exception {
138 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
139 "-XX:+UnlockDiagnosticVMOptions",
140 "-Xmx128m",
141 "-XX:+UseLargePages",
142 logging_option,
143 "-XX:+VerifyBeforeGC", "-version");
144 OutputAnalyzer output = new OutputAnalyzer(pb.start());
145 if (testNarrowKlassBase()) {
146 output.shouldContain("Narrow klass base:");
147 }
148 output.shouldHaveExitValue(0);
149 }
150
151 public static void heapBaseMinAddressTest() throws Exception {
152 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
153 "-XX:HeapBaseMinAddress=1m",
154 "-Xlog:gc+heap+coops=debug",
155 "-version");
156 OutputAnalyzer output = new OutputAnalyzer(pb.start());
177 output.shouldHaveExitValue(0);
178
179 pb = ProcessTools.createJavaProcessBuilder(
180 "-XX:+UnlockDiagnosticVMOptions",
181 "-XX:SharedArchiveFile=./CompressedClassPointers.jsa",
182 "-Xmx128m",
183 "-XX:SharedBaseAddress=8g",
184 "-Xlog:gc+heap+coops=debug",
185 "-Xshare:on",
186 "-version");
187 output = new OutputAnalyzer(pb.start());
188 output.shouldContain("sharing");
189 output.shouldHaveExitValue(0);
190
191 } catch (RuntimeException e) {
192 output.shouldContain("Unable to use shared archive");
193 output.shouldHaveExitValue(1);
194 }
195 }
196
197 public static void smallHeapTestNoCoop() throws Exception {
198 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
199 "-XX:-UseCompressedOops",
200 "-XX:+UseCompressedClassPointers",
201 "-XX:+UnlockDiagnosticVMOptions",
202 "-XX:SharedBaseAddress=8g",
203 "-Xmx128m",
204 "-Xlog:gc+metaspace=trace",
205 "-Xshare:off",
206 "-Xlog:cds=trace",
207 "-XX:+VerifyBeforeGC", "-version");
208 OutputAnalyzer output = new OutputAnalyzer(pb.start());
209 output.shouldContain("Narrow klass base: 0x0000000000000000");
210 output.shouldHaveExitValue(0);
211 }
212
213 public static void smallHeapTestWith1GNoCoop() throws Exception {
214 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
215 "-XX:-UseCompressedOops",
216 "-XX:+UseCompressedClassPointers",
217 "-XX:+UnlockDiagnosticVMOptions",
218 "-XX:CompressedClassSpaceSize=1g",
219 "-Xmx128m",
220 "-Xlog:gc+metaspace=trace",
221 "-Xshare:off",
222 "-Xlog:cds=trace",
223 "-XX:+VerifyBeforeGC", "-version");
224 OutputAnalyzer output = new OutputAnalyzer(pb.start());
225 output.shouldContain("Narrow klass base: 0x0000000000000000");
226 if (!Platform.isAArch64() && !Platform.isPPC()) {
227 // Currently relax this test for Aarch64 and ppc.
228 output.shouldContain("Narrow klass shift: 0");
229 }
230 output.shouldHaveExitValue(0);
231 }
232
233 public static void largeHeapTestNoCoop() throws Exception {
234 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
235 "-XX:-UseCompressedOops",
236 "-XX:+UseCompressedClassPointers",
237 "-XX:+UnlockDiagnosticVMOptions",
238 "-XX:+UnlockExperimentalVMOptions",
239 "-Xmx30g",
240 "-Xlog:gc+metaspace=trace",
241 "-Xshare:off",
242 "-Xlog:cds=trace",
243 "-XX:+VerifyBeforeGC", "-version");
244 OutputAnalyzer output = new OutputAnalyzer(pb.start());
245 output.shouldContain("Narrow klass base: 0x0000000000000000");
246 if (!Platform.isAArch64() && !Platform.isPPC()) {
247 // Currently relax this test for Aarch64 and ppc.
248 output.shouldContain("Narrow klass shift: 0");
249 }
250 output.shouldHaveExitValue(0);
251 }
252
253 public static void largePagesTestNoCoop() throws Exception {
254 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
255 "-XX:-UseCompressedOops",
256 "-XX:+UseCompressedClassPointers",
257 "-XX:+UnlockDiagnosticVMOptions",
258 "-Xmx128m",
259 "-XX:+UseLargePages",
260 "-Xlog:gc+metaspace=trace",
261 "-XX:+VerifyBeforeGC", "-version");
262 OutputAnalyzer output = new OutputAnalyzer(pb.start());
263 output.shouldContain("Narrow klass base:");
264 output.shouldHaveExitValue(0);
265 }
266
267 public static void heapBaseMinAddressTestNoCoop() throws Exception {
268 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
269 "-XX:-UseCompressedOops",
270 "-XX:+UseCompressedClassPointers",
271 "-XX:HeapBaseMinAddress=1m",
300 "-XX:-UseCompressedOops",
301 "-XX:+UseCompressedClassPointers",
302 "-XX:+UnlockDiagnosticVMOptions",
303 "-XX:SharedArchiveFile=./CompressedClassPointers.jsa",
304 "-Xmx128m",
305 "-XX:SharedBaseAddress=8g",
306 "-Xlog:gc+heap+coops=debug",
307 "-Xshare:on",
308 "-version");
309 output = new OutputAnalyzer(pb.start());
310 output.shouldContain("sharing");
311 output.shouldHaveExitValue(0);
312
313 } catch (RuntimeException e) {
314 output.shouldContain("Unable to use shared archive");
315 output.shouldHaveExitValue(1);
316 }
317 }
318
319 public static void main(String[] args) throws Exception {
320 smallHeapTest();
321 smallHeapTestWith1G();
322 largeHeapTest();
323 largeHeapAbove32GTest();
324 largePagesForHeapTest();
325 heapBaseMinAddressTest();
326 sharingTest();
327
328 if (!Platform.isOSX()) {
329 // Testing compressed class pointers without compressed oops.
330 // This is only possible if the platform supports it. Notably,
331 // on macOS, when compressed oops is disabled and the heap is
332 // given an arbitrary address, that address occasionally collides
333 // with where we would ideally have placed the compressed class
334 // space. Therefore, macOS is omitted for now.
335 smallHeapTestNoCoop();
336 smallHeapTestWith1GNoCoop();
337 largeHeapTestNoCoop();
338 largePagesTestNoCoop();
339 heapBaseMinAddressTestNoCoop();
340 sharingTestNoCoop();
341 }
342 }
343 }
|
36 import jdk.test.lib.process.ProcessTools;
37 import jdk.test.lib.process.OutputAnalyzer;
38 import jtreg.SkippedException;
39
40 public class CompressedClassPointers {
41
42 static final String logging_option = "-Xlog:gc+metaspace=trace,cds=trace";
43
44 // Returns true if we are to test the narrow klass base; we only do this on
45 // platforms where we can be reasonably shure that we get reproducable placement).
46 static boolean testNarrowKlassBase() {
47 if (Platform.isWindows()) {
48 return false;
49 }
50 return true;
51
52 }
53
54 // CDS off, small heap, ccs size default (1G)
55 // A small heap should allow us to place the ccs within the lower 32G and thus allow zero based encoding.
56 /* Lilliput: cannot work due to drastically reduced narrow klass pointer range (atm 2g and that may get
57 smaller still). There is an argument for improving CDS/CCS reservation and make it more likely to run
58 zero-based, but that logic has to be rethought.
59 public static void smallHeapTest() throws Exception {
60 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
61 "-XX:+UnlockDiagnosticVMOptions",
62 "-XX:SharedBaseAddress=8g",
63 "-Xmx128m",
64 logging_option,
65 "-Xshare:off",
66 "-XX:+VerifyBeforeGC", "-version");
67 OutputAnalyzer output = new OutputAnalyzer(pb.start());
68 if (testNarrowKlassBase()) {
69 output.shouldContain("Narrow klass base: 0x0000000000000000");
70 }
71 output.shouldHaveExitValue(0);
72 }
73 */
74
75 // CDS off, small heap, ccs size explicitely set to 1G
76 // A small heap should allow us to place the ccs within the lower 32G and thus allow zero based encoding.
77 /* Lilliput: See comment above.
78 public static void smallHeapTestWith1G() throws Exception {
79 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
80 "-XX:+UnlockDiagnosticVMOptions",
81 "-XX:CompressedClassSpaceSize=1g",
82 "-Xmx128m",
83 logging_option,
84 "-Xshare:off",
85 "-XX:+VerifyBeforeGC", "-version");
86 OutputAnalyzer output = new OutputAnalyzer(pb.start());
87 if (testNarrowKlassBase()) {
88 output.shouldContain("Narrow klass base: 0x0000000000000000, Narrow klass shift: 3");
89 }
90 output.shouldHaveExitValue(0);
91 }
92 */
93
94 // CDS off, a very large heap, ccs size left to 1G default.
95 // We expect the ccs to be mapped somewhere far beyond the heap, such that it is not possible
96 // to use zero based encoding.
97 /* Lilliput: I am not sure what the point of this test CCS reservation is independent from
98 heap. See below the desparate attempts to predict heap reservation on PPC. Why do we even care?
99 public static void largeHeapTest() throws Exception {
100 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
101 "-XX:+UnlockDiagnosticVMOptions",
102 "-XX:+UnlockExperimentalVMOptions",
103 "-Xmx30g",
104 logging_option,
105 "-Xshare:off",
106 "-XX:+VerifyBeforeGC", "-version");
107 OutputAnalyzer output = new OutputAnalyzer(pb.start());
108 if (testNarrowKlassBase() && !Platform.isPPC() && !Platform.isOSX()) {
109 // PPC: in most cases the heap cannot be placed below 32g so there
110 // is room for ccs and narrow klass base will be 0x0. Exception:
111 // Linux 4.1.42 or earlier (see ELF_ET_DYN_BASE in JDK-8244847).
112 // For simplicity we exclude PPC.
113 // OSX: similar.
114 output.shouldNotContain("Narrow klass base: 0x0000000000000000");
115 output.shouldContain("Narrow klass shift: 0");
116 }
117 output.shouldHaveExitValue(0);
118 }
119 */
120
121 // Settings as in largeHeapTest() except for max heap size. We make max heap
122 // size even larger such that it cannot fit into lower 32G but not too large
123 // for compressed oops.
124 // We expect a zerobased ccs.
125 /* Lilliput: narrow klass pointer range drastically reduced. See comments under smallHeapTest().
126 public static void largeHeapAbove32GTest() throws Exception {
127 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
128 "-XX:+UnlockDiagnosticVMOptions",
129 "-XX:+UnlockExperimentalVMOptions",
130 "-Xmx31g",
131 logging_option,
132 "-Xshare:off",
133 "-XX:+VerifyBeforeGC", "-version");
134 OutputAnalyzer output = new OutputAnalyzer(pb.start());
135 if (testNarrowKlassBase()) {
136 if (!(Platform.isAArch64() && Platform.isOSX())) { // see JDK-8262895
137 output.shouldContain("Narrow klass base: 0x0000000000000000");
138 if (!Platform.isAArch64() && !Platform.isOSX()) {
139 output.shouldContain("Narrow klass shift: 0");
140 }
141 }
142 }
143 output.shouldHaveExitValue(0);
144 }
145 */
146
147 // Using large paged heap, metaspace uses small pages.
148 /* Lilliput: not sure what the point of this test is. The ability to have a class space if heap uses
149 large pages? Why would that be a problem? Kept alive for now since it makes no problems even with
150 smaller class pointers.
151 */
152 public static void largePagesForHeapTest() throws Exception {
153 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
154 "-XX:+UnlockDiagnosticVMOptions",
155 "-Xmx128m",
156 "-XX:+UseLargePages",
157 logging_option,
158 "-XX:+VerifyBeforeGC", "-version");
159 OutputAnalyzer output = new OutputAnalyzer(pb.start());
160 if (testNarrowKlassBase()) {
161 output.shouldContain("Narrow klass base:");
162 }
163 output.shouldHaveExitValue(0);
164 }
165
166 public static void heapBaseMinAddressTest() throws Exception {
167 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
168 "-XX:HeapBaseMinAddress=1m",
169 "-Xlog:gc+heap+coops=debug",
170 "-version");
171 OutputAnalyzer output = new OutputAnalyzer(pb.start());
192 output.shouldHaveExitValue(0);
193
194 pb = ProcessTools.createJavaProcessBuilder(
195 "-XX:+UnlockDiagnosticVMOptions",
196 "-XX:SharedArchiveFile=./CompressedClassPointers.jsa",
197 "-Xmx128m",
198 "-XX:SharedBaseAddress=8g",
199 "-Xlog:gc+heap+coops=debug",
200 "-Xshare:on",
201 "-version");
202 output = new OutputAnalyzer(pb.start());
203 output.shouldContain("sharing");
204 output.shouldHaveExitValue(0);
205
206 } catch (RuntimeException e) {
207 output.shouldContain("Unable to use shared archive");
208 output.shouldHaveExitValue(1);
209 }
210 }
211
212 /* Lilliput: narrow klass pointer range drastically reduced. See comments under smallHeapTest().
213 public static void smallHeapTestNoCoop() throws Exception {
214 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
215 "-XX:-UseCompressedOops",
216 "-XX:+UseCompressedClassPointers",
217 "-XX:+UnlockDiagnosticVMOptions",
218 "-XX:SharedBaseAddress=8g",
219 "-Xmx128m",
220 "-Xlog:gc+metaspace=trace",
221 "-Xshare:off",
222 "-Xlog:cds=trace",
223 "-XX:+VerifyBeforeGC", "-version");
224 OutputAnalyzer output = new OutputAnalyzer(pb.start());
225 output.shouldContain("Narrow klass base: 0x0000000000000000");
226 output.shouldHaveExitValue(0);
227 }
228 */
229
230 /* Lilliput: narrow klass pointer range drastically reduced. See comments under smallHeapTest().
231 public static void smallHeapTestWith1GNoCoop() throws Exception {
232 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
233 "-XX:-UseCompressedOops",
234 "-XX:+UseCompressedClassPointers",
235 "-XX:+UnlockDiagnosticVMOptions",
236 "-XX:CompressedClassSpaceSize=1g",
237 "-Xmx128m",
238 "-Xlog:gc+metaspace=trace",
239 "-Xshare:off",
240 "-Xlog:cds=trace",
241 "-XX:+VerifyBeforeGC", "-version");
242 OutputAnalyzer output = new OutputAnalyzer(pb.start());
243 output.shouldContain("Narrow klass base: 0x0000000000000000");
244 if (!Platform.isAArch64() && !Platform.isPPC()) {
245 // Currently relax this test for Aarch64 and ppc.
246 output.shouldContain("Narrow klass shift: 0");
247 }
248 output.shouldHaveExitValue(0);
249 }
250 */
251
252 /* Lilliput: narrow klass pointer range drastically reduced. See comments under smallHeapTest().
253 public static void largeHeapTestNoCoop() throws Exception {
254 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
255 "-XX:-UseCompressedOops",
256 "-XX:+UseCompressedClassPointers",
257 "-XX:+UnlockDiagnosticVMOptions",
258 "-XX:+UnlockExperimentalVMOptions",
259 "-Xmx30g",
260 "-Xlog:gc+metaspace=trace",
261 "-Xshare:off",
262 "-Xlog:cds=trace",
263 "-XX:+VerifyBeforeGC", "-version");
264 OutputAnalyzer output = new OutputAnalyzer(pb.start());
265 output.shouldContain("Narrow klass base: 0x0000000000000000");
266 if (!Platform.isAArch64() && !Platform.isPPC()) {
267 // Currently relax this test for Aarch64 and ppc.
268 output.shouldContain("Narrow klass shift: 0");
269 }
270 output.shouldHaveExitValue(0);
271 }
272 */
273
274 public static void largePagesTestNoCoop() throws Exception {
275 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
276 "-XX:-UseCompressedOops",
277 "-XX:+UseCompressedClassPointers",
278 "-XX:+UnlockDiagnosticVMOptions",
279 "-Xmx128m",
280 "-XX:+UseLargePages",
281 "-Xlog:gc+metaspace=trace",
282 "-XX:+VerifyBeforeGC", "-version");
283 OutputAnalyzer output = new OutputAnalyzer(pb.start());
284 output.shouldContain("Narrow klass base:");
285 output.shouldHaveExitValue(0);
286 }
287
288 public static void heapBaseMinAddressTestNoCoop() throws Exception {
289 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
290 "-XX:-UseCompressedOops",
291 "-XX:+UseCompressedClassPointers",
292 "-XX:HeapBaseMinAddress=1m",
321 "-XX:-UseCompressedOops",
322 "-XX:+UseCompressedClassPointers",
323 "-XX:+UnlockDiagnosticVMOptions",
324 "-XX:SharedArchiveFile=./CompressedClassPointers.jsa",
325 "-Xmx128m",
326 "-XX:SharedBaseAddress=8g",
327 "-Xlog:gc+heap+coops=debug",
328 "-Xshare:on",
329 "-version");
330 output = new OutputAnalyzer(pb.start());
331 output.shouldContain("sharing");
332 output.shouldHaveExitValue(0);
333
334 } catch (RuntimeException e) {
335 output.shouldContain("Unable to use shared archive");
336 output.shouldHaveExitValue(1);
337 }
338 }
339
340 public static void main(String[] args) throws Exception {
341 // smallHeapTest();
342 // smallHeapTestWith1G();
343 // largeHeapTest();
344 // largeHeapAbove32GTest();
345 largePagesForHeapTest();
346 heapBaseMinAddressTest();
347 sharingTest();
348
349 if (!Platform.isOSX()) {
350 // Testing compressed class pointers without compressed oops.
351 // This is only possible if the platform supports it. Notably,
352 // on macOS, when compressed oops is disabled and the heap is
353 // given an arbitrary address, that address occasionally collides
354 // with where we would ideally have placed the compressed class
355 // space. Therefore, macOS is omitted for now.
356 // smallHeapTestNoCoop();
357 // smallHeapTestWith1GNoCoop();
358 // largeHeapTestNoCoop();
359 largePagesTestNoCoop();
360 heapBaseMinAddressTestNoCoop();
361 sharingTestNoCoop();
362 }
363 }
364 }
|