< prev index next > test/jdk/com/sun/jdi/EATests.java
Print this page
* -XX:+WhiteBoxAPI
* -Xbatch
* -XX:-DoEscapeAnalysis -XX:-EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks
* -XX:+IgnoreUnrecognizedVMOptions -XX:+DeoptimizeObjectsALot
*
+ * @bug 8324881
+ * @comment Regression test for using the wrong thread when logging during re-locking from deoptimization.
+ *
+ * @comment DiagnoseSyncOnValueBasedClasses=2 will cause logging when locking on \@ValueBased objects.
+ * @run driver EATests
+ * -XX:+UnlockDiagnosticVMOptions
+ * -Xms256m -Xmx256m
+ * -Xbootclasspath/a:.
+ * -XX:CompileCommand=dontinline,*::dontinline_*
+ * -XX:+WhiteBoxAPI
+ * -Xbatch
+ * -XX:+DoEscapeAnalysis -XX:+EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks
+ * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=1
+ * -XX:DiagnoseSyncOnValueBasedClasses=2
+ *
+ * @comment Re-lock may inflate monitors when re-locking, which cause monitorinflation trace logging.
+ * @run driver EATests
+ * -XX:+UnlockDiagnosticVMOptions
+ * -Xms256m -Xmx256m
+ * -Xbootclasspath/a:.
+ * -XX:CompileCommand=dontinline,*::dontinline_*
+ * -XX:+WhiteBoxAPI
+ * -Xbatch
+ * -XX:+DoEscapeAnalysis -XX:+EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks
+ * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=2
+ * -Xlog:monitorinflation=trace:file=monitorinflation.log
+ *
+ * @comment Re-lock may race with deflation.
+ * @run driver EATests
+ * -XX:+UnlockDiagnosticVMOptions
+ * -Xms256m -Xmx256m
+ * -Xbootclasspath/a:.
+ * -XX:CompileCommand=dontinline,*::dontinline_*
+ * -XX:+WhiteBoxAPI
+ * -Xbatch
+ * -XX:+DoEscapeAnalysis -XX:+EliminateAllocations -XX:+EliminateLocks -XX:+EliminateNestedLocks
+ * -XX:+UnlockExperimentalVMOptions -XX:LockingMode=0
+ * -XX:GuaranteedAsyncDeflationInterval=1000
*/
+
/**
* @test
* @bug 8227745
*
* @summary This is another configuration of EATests.java to test Graal. Some testcases are expected
new EARelockingSimpleTarget() .run();
new EARelockingSimpleWithAccessInOtherThreadTarget() .run();
new EARelockingRecursiveTarget() .run();
new EARelockingNestedInflatedTarget() .run();
new EARelockingNestedInflated_02Target() .run();
+ new EARelockingNestedInflated_03Target() .run();
new EARelockingArgEscapeLWLockedInCalleeFrameTarget() .run();
new EARelockingArgEscapeLWLockedInCalleeFrame_2Target() .run();
new EARelockingArgEscapeLWLockedInCalleeFrameNoRecursiveTarget() .run();
new EAGetOwnedMonitorsTarget() .run();
new EAEntryCountTarget() .run();
new EARelockingObjectCurrentlyWaitingOnTarget() .run();
+ new EARelockingValueBasedTarget() .run();
// Test cases that require deoptimization even though neither
// locks nor allocations are eliminated at the point where
// escape state is changed.
new EADeoptFrameAfterReadLocalObject_01Target() .run();
new EARelockingSimple() .run(this);
new EARelockingSimpleWithAccessInOtherThread() .run(this);
new EARelockingRecursive() .run(this);
new EARelockingNestedInflated() .run(this);
new EARelockingNestedInflated_02() .run(this);
+ new EARelockingNestedInflated_03() .run(this);
new EARelockingArgEscapeLWLockedInCalleeFrame() .run(this);
new EARelockingArgEscapeLWLockedInCalleeFrame_2() .run(this);
new EARelockingArgEscapeLWLockedInCalleeFrameNoRecursive() .run(this);
new EAGetOwnedMonitors() .run(this);
new EAEntryCount() .run(this);
new EARelockingObjectCurrentlyWaitingOn() .run(this);
+ new EARelockingValueBased() .run(this);
// Test cases that require deoptimization even though neither
// locks nor allocations are eliminated at the point where
// escape state is changed.
new EADeoptFrameAfterReadLocalObject_01() .run(this);
}
}
/////////////////////////////////////////////////////////////////////////////
+ /**
+ * Like {@link EARelockingNestedInflated_02} with the difference that the
+ * inflation of the lock happens because of contention.
+ */
+ class EARelockingNestedInflated_03 extends EATestCaseBaseDebugger {
+
+ public void runTestCase() throws Exception {
+ BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V");
+ printStack(bpe.thread());
+ @SuppressWarnings("unused")
+ ObjectReference o = getLocalRef(bpe.thread().frame(2), XYVAL_NAME, "l1");
+ }
+ }
+
+ class EARelockingNestedInflated_03Target extends EATestCaseBaseTarget {
+
+ public XYVal lockInflatedByContention;
+ public boolean doLockNow;
+ public EATestCaseBaseTarget testCase;
+
+ @Override
+ public void setUp() {
+ super.setUp();
+ testMethodDepth = 2;
+ lockInflatedByContention = new XYVal(1, 1);
+ testCase = this;
+ }
+
+ @Override
+ public void warmupDone() {
+ super.warmupDone();
+ // Use new lock. lockInflatedByContention might have been inflated because of recursion.
+ lockInflatedByContention = new XYVal(1, 1);
+ // Start thread that tries to enter lockInflatedByContention while the main thread owns it -> inflation
+ TestScaffold.newThread(() -> {
+ while (true) {
+ synchronized (testCase) {
+ try {
+ if (doLockNow) {
+ doLockNow = false; // reset for main thread
+ testCase.notify();
+ break;
+ }
+ testCase.wait();
+ } catch (InterruptedException e) { /* ignored */ }
+ }
+ }
+ synchronized (lockInflatedByContention) { // will block and trigger inflation
+ msg(Thread.currentThread().getName() + ": acquired lockInflatedByContention");
+ }
+ }, testCaseName + ": Lock Contender (test thread)").start();
+ }
+
+ public void dontinline_testMethod() {
+ @SuppressWarnings("unused")
+ XYVal xy = new XYVal(1, 1); // scalar replaced
+ XYVal l1 = lockInflatedByContention; // read by debugger
+ synchronized (l1) {
+ testMethod_inlined(l1);
+ }
+ }
+
+ public void testMethod_inlined(XYVal l2) {
+ synchronized (l2) { // eliminated nested locking
+ dontinline_notifyOtherThread();
+ dontinline_brkpt();
+ }
+ }
+
+ public void dontinline_notifyOtherThread() {
+ if (!warmupDone) {
+ return;
+ }
+ synchronized (testCase) {
+ doLockNow = true;
+ testCase.notify();
+ // wait for other thread to reset doLockNow again
+ while (doLockNow) {
+ try {
+ testCase.wait();
+ } catch (InterruptedException e) { /* ignored */ }
+ }
+ }
+ }
+ }
+
+ /////////////////////////////////////////////////////////////////////////////
+
/**
* Checks if an eliminated lock of an ArgEscape object l1 can be relocked if
* l1 is locked in a callee frame.
*/
class EARelockingArgEscapeLWLockedInCalleeFrame extends EATestCaseBaseDebugger {
l2.wait();
}
}
}
+
+ /////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * Test relocking eliminated @ValueBased object.
+ */
+ class EARelockingValueBased extends EATestCaseBaseDebugger {
+
+ public void runTestCase() throws Exception {
+ BreakpointEvent bpe = resumeTo(TARGET_TESTCASE_BASE_NAME, "dontinline_brkpt", "()V");
+ printStack(bpe.thread());
+ @SuppressWarnings("unused")
+ ObjectReference o = getLocalRef(bpe.thread().frame(1), Integer.class.getName(), "l1");
+ }
+ }
+
+ class EARelockingValueBasedTarget extends EATestCaseBaseTarget {
+
+ public void dontinline_testMethod() {
+ Integer l1 = new Integer(255);
+ synchronized (l1) {
+ dontinline_brkpt();
+ }
+ }
+ }
+
/////////////////////////////////////////////////////////////////////////////
//
// Test cases that require deoptimization even though neither locks
// nor allocations are eliminated at the point where escape state is changed.
//
< prev index next >