56 __ByValue final class MyValue {
57 final int x;
58 final long y;
59 final double z;
60
61 private MyValue(int x, long y, double z) {
62 this.x = x;
63 this.y = y;
64 this.z = z;
65 }
66
67 @DontInline
68 public static MyValue createDontInline(int x, long y, double z) {
69 return __Make MyValue(x, y, z);
70 }
71
72 @ForceInline
73 public static MyValue createInline(int x, long y, double z) {
74 return __Make MyValue(x, y, z);
75 }
76 }
77
78 public class ValueTypeTestBench {
79 // Print ideal graph after execution of each test
80 private static final boolean PRINT_GRAPH = true;
81
82 // ========== Test definitions ==========
83
84 // Receive value type through call to interpreter
85 @Test(failOn = ALLOC + STORE)
86 public double test1() {
87 MyValue v = MyValue.createDontInline(rI, rL, rD);
88 return v.x + v.y + v.z;
89 }
90
91 @DontCompile
92 public void test1_verifier(boolean warmup) {
93 double result = test1();
94 Asserts.assertEQ(result, rI + rL + rD);
95 }
298 MyValue v = MyValue.createDontInline(rI, rL, rD);
299 double result = 42;
300 for (int i = 0; i < 1000; ++i) {
301 if (b) {
302 result += v.x;
303 } else {
304 // Uncommon trap referencing v. Should not allocate
305 // but just pass the existing oop to the uncommon trap.
306 result = sumValue(v);
307 }
308 }
309 return result;
310 }
311
312 @DontCompile
313 public void test13_verifier(boolean warmup) {
314 double result = test13(warmup);
315 Asserts.assertEQ(result, warmup ? 42 + (1000*(double)rI) : (rI + rL + rD));
316 }
317
318
319 // ========== Helper methods ==========
320
321 @DontCompile
322 public double sumValue(MyValue v) {
323 return v.x + v.y + v.z;
324 }
325
326 // ========== Test infrastructure ==========
327
328 private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
329 private static final int COMP_LEVEL_ANY = -1;
330 private static final int COMP_LEVEL_FULL_OPTIMIZATION = 4;
331 private static final Hashtable<String, Method> tests = new Hashtable<String, Method>();
332 private static final int WARMUP = 10;
333
334 // Regular expressions used to match nodes in the PrintIdeal output
335 private static final String START = "(\\d+\\t(.*";
336 private static final String MID = ".*)+\\t===.*";
337 private static final String END = ")|";
|
56 __ByValue final class MyValue {
57 final int x;
58 final long y;
59 final double z;
60
61 private MyValue(int x, long y, double z) {
62 this.x = x;
63 this.y = y;
64 this.z = z;
65 }
66
67 @DontInline
68 public static MyValue createDontInline(int x, long y, double z) {
69 return __Make MyValue(x, y, z);
70 }
71
72 @ForceInline
73 public static MyValue createInline(int x, long y, double z) {
74 return __Make MyValue(x, y, z);
75 }
76
77 @DontInline
78 public String toStringDontInline() {
79 return "MyValue: x=" + x + " y=" + y + " z=" + z;
80 }
81
82 @ForceInline
83 public String toStringInline() {
84 return "MyValue: x=" + x + " y=" + y + " z=" + z;
85 }
86 }
87
88 public class ValueTypeTestBench {
89 // Print ideal graph after execution of each test
90 private static final boolean PRINT_GRAPH = true;
91
92 // ========== Test definitions ==========
93
94 // Receive value type through call to interpreter
95 @Test(failOn = ALLOC + STORE)
96 public double test1() {
97 MyValue v = MyValue.createDontInline(rI, rL, rD);
98 return v.x + v.y + v.z;
99 }
100
101 @DontCompile
102 public void test1_verifier(boolean warmup) {
103 double result = test1();
104 Asserts.assertEQ(result, rI + rL + rD);
105 }
308 MyValue v = MyValue.createDontInline(rI, rL, rD);
309 double result = 42;
310 for (int i = 0; i < 1000; ++i) {
311 if (b) {
312 result += v.x;
313 } else {
314 // Uncommon trap referencing v. Should not allocate
315 // but just pass the existing oop to the uncommon trap.
316 result = sumValue(v);
317 }
318 }
319 return result;
320 }
321
322 @DontCompile
323 public void test13_verifier(boolean warmup) {
324 double result = test13(warmup);
325 Asserts.assertEQ(result, warmup ? 42 + (1000*(double)rI) : (rI + rL + rD));
326 }
327
328 // Create a value type in a non-inlined method and then call a
329 // non-inlined method on that value type.
330 @Test(failOn = (ALLOC + STORE))
331 public String test14() {
332 MyValue v = MyValue.createDontInline(32, 64L, 128.0);
333 String s = v.toStringDontInline();
334 return s;
335 }
336
337 @DontCompile
338 public void test14_verifier(boolean b) {
339 String s = test14();
340 System.out.println("Result is: " + s);
341 }
342
343 // Create a value type in an inlined method and then call a
344 // non-inlined method on that value type.
345 @Test(match = {ALLOC}, matchCount = {1})
346 public String test15() {
347 MyValue v = MyValue.createInline(65, 129L, 257.0);
348 String s = v.toStringDontInline();
349 return s;
350 }
351
352 @DontCompile
353 public void test15_verifier(boolean b) {
354 String s = test15();
355 System.out.println("Result is: " + s);
356 }
357
358 // Create a value type in a non-inlined method and then call an
359 // inlined method on that value type. Allocations are due to building
360 // String objects and not due to allocating value types.
361 @Test(match = {ALLOC}, matchCount = {2})
362 public String test16() {
363 MyValue v = MyValue.createDontInline(130, 258L, 514.0);
364 String s = v.toStringInline();
365 return s;
366 }
367
368 @DontCompile
369 public void test16_verifier(boolean b) {
370 String s = test16();
371 System.out.println("Result is: " + s);
372 }
373
374 // Create a value type in an inlined method and then call an
375 // inlined method on that value type.
376 @Test(match = {ALLOC}, matchCount = {2})
377 public String test17() {
378 MyValue v = MyValue.createInline(259, 515L, 1027.0);
379 String s = v.toStringInline();
380 return s;
381 }
382
383 @DontCompile
384 public void test17_verifier(boolean b) {
385 String s = test17();
386 System.out.println("Result is: " + s);
387 }
388
389 // ========== Helper methods ==========
390
391 @DontCompile
392 public double sumValue(MyValue v) {
393 return v.x + v.y + v.z;
394 }
395
396 // ========== Test infrastructure ==========
397
398 private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
399 private static final int COMP_LEVEL_ANY = -1;
400 private static final int COMP_LEVEL_FULL_OPTIMIZATION = 4;
401 private static final Hashtable<String, Method> tests = new Hashtable<String, Method>();
402 private static final int WARMUP = 10;
403
404 // Regular expressions used to match nodes in the PrintIdeal output
405 private static final String START = "(\\d+\\t(.*";
406 private static final String MID = ".*)+\\t===.*";
407 private static final String END = ")|";
|