1/* 2 * Copyright (c) 2015, 2016, 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/* 25 * @test 26 * @bug 8072016 27 * @summary Infinite deoptimization/recompilation cycles in case of arraycopy with tightly coupled allocation 28 * @requires vm.flavor == "server" & !vm.emulatedClient 29 * @library /test/lib / 30 * @modules java.base/jdk.internal.misc 31 * java.management 32 * 33 * @build sun.hotspot.WhiteBox 34 * @run driver ClassFileInstaller sun.hotspot.WhiteBox sun.hotspot.WhiteBox$WhiteBoxPermission 35 * @run main/othervm -Xmixed -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI 36 * -XX:-BackgroundCompilation -XX:-UseOnStackReplacement -XX:TypeProfileLevel=020 37 * compiler.arraycopy.TestArrayCopyNoInitDeopt 38 */ 39 40package compiler.arraycopy; 41 42import compiler.whitebox.CompilerWhiteBoxTest; 43import jdk.test.lib.Platform; 44import sun.hotspot.WhiteBox; 45 46import java.lang.reflect.Method; 47 48public class TestArrayCopyNoInitDeopt { 49 50 public static int[] m1(Object src) { 51 if (src == null) return null; 52 int[] dest = new int[10]; 53 try { 54 System.arraycopy(src, 0, dest, 0, 10); 55 } catch (ArrayStoreException npe) { 56 } 57 return dest; 58 } 59 60 static Object m2_src(Object src) { 61 return src; 62 } 63 64 public static int[] m2(Object src) { 65 if (src == null) return null; 66 src = m2_src(src); 67 int[] dest = new int[10]; 68 try { 69 System.arraycopy(src, 0, dest, 0, 10); 70 } catch (ArrayStoreException npe) { 71 } 72 return dest; 73 } 74 75 private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox(); 76 private static final int TIERED_STOP_AT_LEVEL = WHITE_BOX.getIntxVMFlag("TieredStopAtLevel").intValue(); 77 78 static boolean deoptimize(Method method, Object src_obj) throws Exception { 79 for (int i = 0; i < 10; i++) { 80 method.invoke(null, src_obj); 81 if (!WHITE_BOX.isMethodCompiled(method)) { 82 return true; 83 } 84 } 85 return false; 86 } 87 88 static public void main(String[] args) throws Exception { 89 if (!Platform.isServer() || Platform.isEmulatedClient()) { 90 throw new Error("TESTBUG: Not server mode"); 91 } 92 // Only execute if C2 is available 93 if (TIERED_STOP_AT_LEVEL == CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION) { 94 int[] src = new int[10]; 95 Object src_obj = new Object(); 96 Method method_m1 = TestArrayCopyNoInitDeopt.class.getMethod("m1", Object.class); 97 Method method_m2 = TestArrayCopyNoInitDeopt.class.getMethod("m2", Object.class); 98 99 // Warm up 100 for (int i = 0; i < 20000; i++) { 101 m1(src); 102 } 103 104 // And make sure m1 is compiled by C2 105 WHITE_BOX.enqueueMethodForCompilation(method_m1, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION); 106 107 if (!WHITE_BOX.isMethodCompiled(method_m1)) { 108 throw new RuntimeException("m1 not compiled"); 109 } 110 111 // should deoptimize for type check 112 if (!deoptimize(method_m1, src_obj)) { 113 throw new RuntimeException("m1 not deoptimized"); 114 } 115 116 WHITE_BOX.enqueueMethodForCompilation(method_m1, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION); 117 118 if (!WHITE_BOX.isMethodCompiled(method_m1)) { 119 throw new RuntimeException("m1 not recompiled"); 120 } 121 122 if (deoptimize(method_m1, src_obj)) { 123 throw new RuntimeException("m1 deoptimized again"); 124 } 125 126 if (WHITE_BOX.getUintxVMFlag("TypeProfileLevel") == 20) { 127 // Same test as above but with speculative types 128 129 // Warm up & make sure we collect type profiling 130 for (int i = 0; i < 20000; i++) { 131 m2(src); 132 } 133 134 // And make sure m2 is compiled by C2 135 WHITE_BOX.enqueueMethodForCompilation(method_m2, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION); 136 137 if (!WHITE_BOX.isMethodCompiled(method_m2)) { 138 throw new RuntimeException("m2 not compiled"); 139 } 140 141 // should deoptimize for speculative type check 142 if (!deoptimize(method_m2, src_obj)) { 143 throw new RuntimeException("m2 not deoptimized"); 144 } 145 146 WHITE_BOX.enqueueMethodForCompilation(method_m2, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION); 147 148 if (!WHITE_BOX.isMethodCompiled(method_m2)) { 149 throw new RuntimeException("m2 not recompiled"); 150 } 151 152 // should deoptimize for actual type check 153 if (!deoptimize(method_m2, src_obj)) { 154 throw new RuntimeException("m2 not deoptimized"); 155 } 156 157 WHITE_BOX.enqueueMethodForCompilation(method_m2, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION); 158 159 if (!WHITE_BOX.isMethodCompiled(method_m2)) { 160 throw new RuntimeException("m2 not recompiled"); 161 } 162 163 if (deoptimize(method_m2, src_obj)) { 164 throw new RuntimeException("m2 deoptimized again"); 165 } 166 } 167 } 168 } 169} 170