| /* |
| * Copyright (c) 2014, 2016, 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. |
| */ |
| |
| /* |
| * @test SegmentedCodeCacheDtraceTest |
| * @bug 8015774 |
| * @summary testing of dtrace for segmented code cache |
| * @requires os.family=="solaris" |
| * @modules java.base/jdk.internal.misc |
| * @library /test/lib / |
| * |
| * @build sun.hotspot.WhiteBox |
| * @run driver ClassFileInstaller sun.hotspot.WhiteBox |
| * sun.hotspot.WhiteBox$WhiteBoxPermission |
| * @run main/othervm/timeout=600 -Xbootclasspath/a:. |
| * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI |
| * compiler.codecache.dtrace.SegmentedCodeCacheDtraceTest |
| */ |
| |
| package compiler.codecache.dtrace; |
| |
| import compiler.testlibrary.CompilerUtils; |
| import jdk.test.lib.Asserts; |
| import jdk.test.lib.JDKToolFinder; |
| import jdk.test.lib.process.OutputAnalyzer; |
| import jdk.test.lib.Utils; |
| |
| import java.io.IOException; |
| import java.lang.reflect.Executable; |
| import java.nio.file.Files; |
| import java.nio.file.Paths; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Random; |
| import java.util.Set; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| import java.util.stream.Collectors; |
| |
| public class SegmentedCodeCacheDtraceTest { |
| |
| private static final String WORKER_CLASS_NAME |
| = SegmentedCodeCacheDtraceTestWorker.class.getName(); |
| private static final String JAVA_OPTS = " -XX:+DTraceMethodProbes " |
| + "-Xbootclasspath/a:" + System.getProperty("test.classes") + " " |
| + "-XX:+UnlockDiagnosticVMOptions " |
| + "-XX:+WhiteBoxAPI -XX:+SegmentedCodeCache " |
| + "-XX:CompileCommand=compileonly," |
| + WORKER_CLASS_NAME + "::* " |
| + " -classpath " + System.getProperty("test.class.path") + " " |
| + String.join(" ", Utils.getTestJavaOpts()); |
| private static final String DTRACE_SCRIPT |
| = "SegmentedCodeCacheDtraceTestScript.d"; |
| private static final List<Executable> MLIST = |
| SegmentedCodeCacheDtraceTestWorker.TESTED_METHODS_LIST; |
| private static final int WORKER_METHODS_COUNT = MLIST.size(); |
| |
| private void runTest(TestCombination tc) { |
| String params = MLIST.stream() |
| .map(Executable::getName) |
| .map(x -> tc.data.get(x).compileLevel + " " + tc.data.get(x).isInlined) |
| .collect(Collectors.joining(" ")); |
| DtraceRunner runner = new DtraceRunner(); |
| runner.runDtrace(JDKToolFinder.getTestJDKTool("java"), JAVA_OPTS, |
| WORKER_CLASS_NAME, params, Paths.get(System.getProperty("test.src"), |
| DTRACE_SCRIPT).toString(), |
| DtraceRunner.PERMIT_DESTRUCTIVE_ACTIONS_DTRACE_OPTION, |
| new SegmentedCodeCacheDtraceResultsAnalyzer()); |
| } |
| |
| private static TestCombination generateUniqueCombination( |
| int[] availableLevels, Set<TestCombination> combinations) { |
| int len = availableLevels.length; |
| /* first, check if we're out of combinations. */ |
| int maxCombinationsCount |
| = (1 << WORKER_METHODS_COUNT) |
| * (int) Math.pow(len, WORKER_METHODS_COUNT); |
| if (combinations.size() == maxCombinationsCount) { |
| return null; |
| } |
| Random r = Utils.getRandomInstance(); |
| while (combinations.size() < maxCombinationsCount) { |
| int levels[] = new int[WORKER_METHODS_COUNT]; |
| boolean inlines[] = new boolean[WORKER_METHODS_COUNT]; |
| for (int i = 0; i < WORKER_METHODS_COUNT; i++) { |
| levels[i] = availableLevels[r.nextInt(len)]; |
| inlines[i] = r.nextBoolean(); |
| } |
| TestCombination tc = new TestCombination(levels, inlines); |
| if (combinations.add(tc)) { |
| return tc; |
| } |
| } |
| return null; |
| } |
| |
| public static void main(String args[]) { |
| int iterations |
| = Integer.getInteger("jdk.test.lib.iterations", 1); |
| if (!DtraceRunner.dtraceAvailable()) { |
| System.out.println("INFO: There is no dtrace avaiable. Skipping."); |
| return; |
| } |
| int[] availableLevels = CompilerUtils.getAvailableCompilationLevels(); |
| // adding one more entry(zero) for interpeter |
| availableLevels |
| = Arrays.copyOf(availableLevels, availableLevels.length + 1); |
| Set<TestCombination> combinations = new HashSet<>(); |
| for (int i = 0; i < iterations; i++) { |
| TestCombination tc |
| = generateUniqueCombination(availableLevels, combinations); |
| if (tc == null) { |
| System.out.println("INFO: no more combinations available"); |
| return; |
| } else { |
| System.out.println("INFO: Running testcase for: " + tc); |
| new SegmentedCodeCacheDtraceTest().runTest(tc); |
| } |
| } |
| } |
| |
| private static class MethodData { |
| |
| public final int compileLevel; |
| public final boolean isInlined; |
| public final String name; |
| |
| public MethodData(String name, int compileLevel, boolean isInlined) { |
| this.name = name; |
| this.compileLevel = compileLevel; |
| this.isInlined = isInlined; |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (o == null || !(o instanceof MethodData)) { |
| return false; |
| } |
| MethodData md = (MethodData) o; |
| return md.compileLevel == compileLevel |
| && md.isInlined == isInlined |
| && md.name.equals(name); |
| } |
| |
| @Override |
| public int hashCode() { |
| return 100 * name.hashCode() + 10 * compileLevel + (isInlined ? 1 : 0); |
| } |
| |
| @Override |
| public String toString() { |
| return name + " " + compileLevel + " " + isInlined; |
| } |
| } |
| |
| private static class TestCombination { |
| |
| private final Map<String, MethodData> data; |
| |
| public TestCombination(int compLevels[], boolean inlines[]) { |
| Map<String, MethodData> d = new HashMap<>(); |
| for (int i = 0; i < MLIST.size(); i++) { |
| d.put(MLIST.get(i).getName(), new MethodData(MLIST.get(i).getName(), |
| compLevels[i], inlines[i])); |
| } |
| data = Collections.unmodifiableMap(d); |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (o == null || !(o instanceof TestCombination)) { |
| return false; |
| } |
| TestCombination second = (TestCombination) o; |
| return second.data.equals(data); |
| } |
| |
| @Override |
| public int hashCode() { |
| int sum = 0; |
| for (MethodData md : data.values()) { |
| sum += md.hashCode(); |
| } |
| return sum; |
| } |
| |
| private String getMethodDescString(MethodData md) { |
| return (md == null) |
| ? null |
| : String.format("Method %s compilation level %d and %s", |
| md.name, md.compileLevel, |
| md.isInlined ? "inlined" : "not inlined"); |
| } |
| |
| @Override |
| public String toString() { |
| return data.values().stream().map(m -> getMethodDescString(m)) |
| .collect(Collectors.joining(Utils.NEW_LINE, |
| "Combination: ", "")); |
| } |
| } |
| |
| private class SegmentedCodeCacheDtraceResultsAnalyzer |
| implements DtraceResultsAnalyzer { |
| |
| private static final int EXPECTED_MATCH_COUNT = 2; |
| |
| private final Pattern checkPattern; |
| |
| public SegmentedCodeCacheDtraceResultsAnalyzer() { |
| String workerClassRegExp = "\\s*" + WORKER_CLASS_NAME + "\\."; |
| String delimeter = "\\(\\)V\\*?" + workerClassRegExp; |
| String suffix = "test\\(\\)V\\*?" + workerClassRegExp |
| + "main\\(\\[Ljava\\/lang\\/String;\\)V"; |
| StringBuilder sb = new StringBuilder(workerClassRegExp); |
| // method order is important, so, going from list tail to head, |
| // accoring to call order representation in stacktrace |
| for (int i = MLIST.size() - 1; i > -1; i--) { |
| sb.append(MLIST.get(i).getName()).append(delimeter); |
| } |
| sb.append(suffix); |
| checkPattern = Pattern.compile(sb.toString()); |
| /* such pattern match should pass on a stacktrace like |
| CPU ID FUNCTION:NAME |
| 0 53573 __1cNSharedRuntimeTdtrace_method_entry6FpnKJavaThread_pnGMethod__i_:method-entry ustack: |
| |
| libjvm.so`__1cNSharedRuntimeTdtrace_method_entry6FpnKJavaThread_pnGMethod__i_+0x39c |
| SegmentedCodeCacheDtraceTestWorker.baz()V* |
| SegmentedCodeCacheDtraceTestWorker.bar()V |
| SegmentedCodeCacheDtraceTestWorker.foo()V* |
| SegmentedCodeCacheDtraceTestWorker.test()V |
| SegmentedCodeCacheDtraceTestWorker.main([Ljava/lang/String;)V |
| 0xffffffff6b0004b8 |
| libjvm.so`__1cJJavaCallsLcall_helper6FpnJJavaValue_pnMmethodHandle_pnRJavaCallArguments_pnGThread__v_+0x94c |
| libjvm.so`__1cRjni_invoke_static6FpnHJNIEnv__pnJJavaValue_pnI_jobject_nLJNICallType_pnK_jmethodID_pnSJNI_ArgumentPusher_pnGThread__v_+0xa64 |
| libjvm.so`jni_CallStaticVoidMethod+0x508 |
| libjli.so`JavaMain+0x584 |
| libc.so.1`_lwp_start |
| jstack: |
| |
| libjvm.so`__1cNSharedRuntimeTdtrace_method_entry6FpnKJavaThread_pnGMethod__i_+0x39c |
| SegmentedCodeCacheDtraceTestWorker.baz()V* |
| SegmentedCodeCacheDtraceTestWorker.bar()V |
| SegmentedCodeCacheDtraceTestWorker.foo()V* |
| SegmentedCodeCacheDtraceTestWorker.test()V |
| SegmentedCodeCacheDtraceTestWorker.main([Ljava/lang/String;)V |
| 0xffffffff6b0004b8 |
| libjvm.so`__1cJJavaCallsLcall_helper6FpnJJavaValue_pnMmethodHandle_pnRJavaCallArguments_pnGThread__v_+0x94c |
| libjvm.so`__1cRjni_invoke_static6FpnHJNIEnv__pnJJavaValue_pnI_jobject_nLJNICallType_pnK_jmethodID_pnSJNI_ArgumentPusher_pnGThread__v_+0xa64 |
| libjvm.so`jni_CallStaticVoidMethod+0x508 |
| libjli.so`JavaMain+0x584 |
| libc.so.1`_lwp_start |
| */ |
| } |
| |
| protected List<String> loadLog(String dtraceOutFile) throws IOException { |
| return Files.readAllLines(Paths.get(dtraceOutFile)); |
| } |
| |
| @Override |
| public void analyze(OutputAnalyzer oa, String dtraceOutFilePath) { |
| oa.shouldHaveExitValue(0); |
| List<String> dOut; |
| try { |
| dOut = loadLog(dtraceOutFilePath); |
| } catch (IOException e) { |
| throw new Error("Can't load log", e); |
| } |
| StringBuilder allDtraceOutput = new StringBuilder(); |
| for (String entry : dOut) { |
| allDtraceOutput.append(entry); |
| } |
| int matchCount = getMatchCount(allDtraceOutput.toString()); |
| Asserts.assertEQ(matchCount, EXPECTED_MATCH_COUNT, |
| "Unexpected output match amount. expected: " |
| + EXPECTED_MATCH_COUNT + " but found " + matchCount); |
| } |
| |
| protected int getMatchCount(String source) { |
| Matcher m = checkPattern.matcher(source); |
| int matchCount = 0; |
| while (m.find()) { |
| matchCount++; |
| } |
| return matchCount; |
| } |
| } |
| } |