313 lines
12 KiB
Java
313 lines
12 KiB
Java
/*
|
|
* 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;
|
|
}
|
|
}
|
|
}
|