diff --git a/test/hotspot/jtreg/compiler/debug/TestStress.java b/test/hotspot/jtreg/compiler/debug/TestStress.java index 2046488ac4006..f43818e8bd81a 100644 --- a/test/hotspot/jtreg/compiler/debug/TestStress.java +++ b/test/hotspot/jtreg/compiler/debug/TestStress.java @@ -77,7 +77,17 @@ static String macroEliminationTrace(int stressSeed) throws Exception { static void sum(int n) { int acc = 0; - for (int i = 0; i < n; i++) acc += i; + int[] arr1 = new int[n]; + int[] arr2 = new int[n]; + int[] arr3 = new int[n]; + int[] arr4 = new int[n]; + for (int i = 0; i < n; i++) { + acc += i; + arr1[i] = i; + arr2[i] = acc; + arr3[i] = i * n; + arr4[i] = acc * n; + } System.out.println(acc); } diff --git a/test/hotspot/jtreg/compiler/debug/TestStressDistinctSeed.java b/test/hotspot/jtreg/compiler/debug/TestStressDistinctSeed.java new file mode 100644 index 0000000000000..3b29daf2ce6fb --- /dev/null +++ b/test/hotspot/jtreg/compiler/debug/TestStressDistinctSeed.java @@ -0,0 +1,131 @@ +/* Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. +* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +* +* This code is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License version 2 only, as +* published by the Free Software Foundation. +* +* This code is distributed in the hope that it will be useful, but WITHOUT +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +* version 2 for more details (a copy is included in the LICENSE file that +* accompanied this code). +* +* You should have received a copy of the GNU General Public License version +* 2 along with this work; if not, write to the Free Software Foundation, +* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +* +* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +* or visit www.oracle.com if you need additional information or have any +* questions. +*/ + +package compiler.debug; + +import jdk.test.lib.process.OutputAnalyzer; +import jdk.test.lib.process.ProcessTools; +import jdk.test.lib.Asserts; +import java.util.Set; +import java.util.HashSet; +import java.util.Arrays; + +/* + * @test + * @key stress randomness + * @requires vm.debug == true & vm.compiler2.enabled & vm.flagless + * @summary Tests that stress compilations with the N different seeds yield different + * IGVN, CCP, macro elimination, and macro expansion traces. + * @library /test/lib / + * @run driver compiler.debug.TestStressDistinctSeed + */ + +public class TestStressDistinctSeed { + + private static int counter = 0; + + static String phaseTrace(String stressOption, String traceOption, + int stressSeed) throws Exception { + String className = TestStressDistinctSeed.class.getName(); + String[] procArgs = { + "-Xcomp", "-XX:-TieredCompilation", "-XX:-Inline", "-XX:+CICountNative", + "-XX:CompileOnly=" + className + "::sum", "-XX:" + traceOption, + "-XX:+" + stressOption, "-XX:StressSeed=" + stressSeed, + className, "5" }; + ProcessBuilder pb = ProcessTools.createLimitedTestJavaProcessBuilder(procArgs); + OutputAnalyzer out = new OutputAnalyzer(pb.start()); + out.shouldHaveExitValue(0); + return out.getStdout(); + } + + static String igvnTrace(int stressSeed) throws Exception { + return phaseTrace("StressIGVN", "+TraceIterativeGVN", stressSeed); + } + + static String ccpTrace(int stressSeed) throws Exception { + return phaseTrace("StressCCP", "+TracePhaseCCP", stressSeed); + } + + static String macroExpansionTrace(int stressSeed) throws Exception { + return phaseTrace("StressMacroExpansion", + "CompileCommand=PrintIdealPhase,*::*,AFTER_MACRO_EXPANSION_STEP", + stressSeed); + } + + static String macroEliminationTrace(int stressSeed) throws Exception { + return phaseTrace("StressMacroElimination", + "CompileCommand=PrintIdealPhase,*::*,AFTER_MACRO_ELIMINATION_STEP", + stressSeed); + } + + static void sum(int n) { + int[] arr1 = new int[n]; + for (int i = 0; i < n; i++) { + synchronized (TestStressDistinctSeed.class) { + counter += i; + arr1[i] = counter; + } + } + System.out.println(counter); + } + + public static void main(String[] args) throws Exception { + Set igvnTraceSet = new HashSet<>(); + Set ccpTraceSet = new HashSet<>(); + Set macroExpansionTraceSet = new HashSet<>(); + Set macroEliminationTraceSet = new HashSet<>(); + String igvnTraceOutput, ccpTraceOutput, macroExpansionTraceOutput, macroEliminationTraceOutput; + if (args.length == 0) { + for (int s = 0; s < 5; s++) { + igvnTraceOutput = igvnTrace(s); + ccpTraceOutput = ccpTrace(s); + macroExpansionTraceOutput = macroExpansionTrace(s); + macroEliminationTraceOutput = macroEliminationTrace(s); + // Test same seed produce same result to test that different traces come from different seed and + // not indeterminism with the test. + Asserts.assertEQ(igvnTraceOutput, igvnTrace(s), + "got different IGVN traces for the same seed"); + Asserts.assertEQ(ccpTraceOutput, ccpTrace(s), + "got different CCP traces for the same seed"); + Asserts.assertEQ(macroExpansionTraceOutput, macroExpansionTrace(s), + "got different macro expansion traces for the same seed"); + Asserts.assertEQ(macroEliminationTraceOutput, macroEliminationTrace(s), + "got different macro elimination traces for the same seed"); + + igvnTraceSet.add(igvnTraceOutput); + ccpTraceSet.add(ccpTraceOutput); + macroExpansionTraceSet.add(macroExpansionTraceOutput); + macroEliminationTraceSet.add(macroEliminationTraceOutput); + } + Asserts.assertGT(igvnTraceSet.size(), 1, + "got same IGVN traces for 5 different seeds"); + Asserts.assertGT(ccpTraceSet.size(), 1, + "got same CCP traces for 5 different seeds"); + Asserts.assertGT(macroExpansionTraceSet.size(), 1, + "got same macro expansion traces for 5 different seeds"); + Asserts.assertGT(macroEliminationTraceSet.size(), 1, + "got same macro elimination traces for 5 different seeds"); + } else if (args.length > 0) { + sum(Integer.parseInt(args[0])); + } + } +} \ No newline at end of file