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