Skip to content

Commit ed99977

Browse files
AlanBatemanAlanBateman
committedFeb 6, 2024
Test updates
1 parent 8c269a2 commit ed99977

File tree

2 files changed

+272
-73
lines changed

2 files changed

+272
-73
lines changed
 

‎test/jdk/java/lang/Thread/virtual/MonitorEnterExit.java

+105-73
Original file line numberDiff line numberDiff line change
@@ -24,32 +24,72 @@
2424
/*
2525
* @test id=default
2626
* @summary Test virtual thread with monitor enter/exit
27+
* @requires os.arch=="amd64" | os.arch=="x86_64" | os.arch=="aarch64"
2728
* @modules java.base/java.lang:+open
2829
* @library /test/lib
2930
* @run junit/othervm --enable-native-access=ALL-UNNAMED MonitorEnterExit
3031
*/
3132

3233
/*
33-
* @test id=Xint
34+
* @test id=default-LM_LEGACY
35+
* @requires os.arch=="amd64" | os.arch=="x86_64" | os.arch=="aarch64"
36+
* @modules java.base/java.lang:+open
37+
* @library /test/lib
38+
* @run junit/othervm -XX:LockingMode=1 --enable-native-access=ALL-UNNAMED MonitorEnterExit
39+
*/
40+
41+
/*
42+
* @test id=default-LM_LIGHTWEIGHT
43+
* @requires os.arch=="amd64" | os.arch=="x86_64" | os.arch=="aarch64"
44+
* @modules java.base/java.lang:+open
45+
* @library /test/lib
46+
* @run junit/othervm -XX:LockingMode=1 --enable-native-access=ALL-UNNAMED MonitorEnterExit
47+
*/
48+
49+
/*
50+
* @test id=Xint-LM_LEGACY
51+
* @requires os.arch=="amd64" | os.arch=="x86_64" | os.arch=="aarch64"
3452
* @modules java.base/java.lang:+open
3553
* @library /test/lib
3654
* @run junit/othervm -Xint -XX:LockingMode=1 --enable-native-access=ALL-UNNAMED MonitorEnterExit
55+
*/
56+
57+
/*
58+
* @test id=Xint-LM_LIGHTWEIGHT
59+
* @requires os.arch=="amd64" | os.arch=="x86_64" | os.arch=="aarch64"
60+
* @modules java.base/java.lang:+open
61+
* @library /test/lib
3762
* @run junit/othervm -Xint -XX:LockingMode=2 --enable-native-access=ALL-UNNAMED MonitorEnterExit
3863
*/
3964

4065
/*
41-
* @test id=TieredStopAtLevel1
66+
* @test id=Xcomp-TieredStopAtLevel1-LM_LEGACY
67+
* @requires os.arch=="amd64" | os.arch=="x86_64" | os.arch=="aarch64"
4268
* @modules java.base/java.lang:+open
4369
* @library /test/lib
4470
* @run junit/othervm -Xcomp -XX:TieredStopAtLevel=1 -XX:LockingMode=1 --enable-native-access=ALL-UNNAMED MonitorEnterExit
71+
*/
72+
73+
/*
74+
* @test id=Xcomp-TieredStopAtLevel1-LM_LIGHTWEIGHT
75+
* @modules java.base/java.lang:+open
76+
* @library /test/lib
4577
* @run junit/othervm -Xcomp -XX:TieredStopAtLevel=1 -XX:LockingMode=2 --enable-native-access=ALL-UNNAMED MonitorEnterExit
4678
*/
4779

4880
/*
49-
* @test id=noTieredCompilation
81+
* @test id=Xcomp-noTieredCompilation-LM_LEGACY
82+
* @requires os.arch=="amd64" | os.arch=="x86_64" | os.arch=="aarch64"
5083
* @modules java.base/java.lang:+open
5184
* @library /test/lib
5285
* @run junit/othervm -Xcomp -XX:-TieredCompilation -XX:LockingMode=1 --enable-native-access=ALL-UNNAMED MonitorEnterExit
86+
*/
87+
88+
/*
89+
* @test id=Xcomp-noTieredCompilation-LM_LIGHTWEIGHT
90+
* @requires os.arch=="amd64" | os.arch=="x86_64" | os.arch=="aarch64"
91+
* @modules java.base/java.lang:+open
92+
* @library /test/lib
5393
* @run junit/othervm -Xcomp -XX:-TieredCompilation -XX:LockingMode=2 --enable-native-access=ALL-UNNAMED MonitorEnterExit
5494
*/
5595

@@ -66,7 +106,6 @@
66106
import java.util.stream.IntStream;
67107
import java.util.stream.Stream;
68108

69-
import jdk.test.lib.Platform;
70109
import jdk.test.lib.thread.VThreadRunner;
71110
import jdk.test.lib.thread.VThreadPinner;
72111

@@ -98,6 +137,22 @@ void testEnterNoContention() throws Exception {
98137
});
99138
}
100139

140+
/**
141+
* Test monitor enter with contention, monitor is held by platform thread.
142+
*/
143+
@Test
144+
void testEnterWhenHeldByPlatformThread() throws Exception {
145+
testEnterWithContention();
146+
}
147+
148+
/**
149+
* Test monitor enter with contention, monitor is held by virtual thread.
150+
*/
151+
@Test
152+
void testEnterWhenHeldByVirtualThread() throws Exception {
153+
VThreadRunner.run(this::testEnterWithContention);
154+
}
155+
101156
/**
102157
* Test monitor enter with contention, monitor will be held by caller thread.
103158
*/
@@ -129,22 +184,6 @@ private void testEnterWithContention() throws Exception {
129184
assertTrue(entered.get());
130185
}
131186

132-
/**
133-
* Test monitor enter with contention, monitor is held by platform thread.
134-
*/
135-
@Test
136-
void testEnterWhenHeldByPlatformThread() throws Exception {
137-
testEnterWithContention();
138-
}
139-
140-
/**
141-
* Test monitor enter with contention, monitor is held by virtual thread.
142-
*/
143-
@Test
144-
void testEnterWhenHeldByVirtualThread() throws Exception {
145-
VThreadRunner.run(this::testEnterWithContention);
146-
}
147-
148187
/**
149188
* Test monitor reenter.
150189
*/
@@ -171,7 +210,6 @@ private void testReenter(Object lock, int depth) {
171210
* Test monitor reenter when there are other threads blocked trying to enter.
172211
*/
173212
@Test
174-
// @EnabledIf("platformIsX64")
175213
void testReenterWithContention() throws Exception {
176214
var lock = new Object();
177215
VThreadRunner.run(() -> {
@@ -248,6 +286,28 @@ void testReenterWhenPinned() throws Exception {
248286
});
249287
}
250288

289+
/**
290+
* Test contended monitor enter when pinned. Monitor is held by platform thread.
291+
*/
292+
@Test
293+
void testContendedEnterWhenPinnedHeldByPlatformThread() throws Exception {
294+
testEnterWithContentionWhenPinned();
295+
}
296+
297+
/**
298+
* Test contended monitor enter when pinned. Monitor is held by virtual thread.
299+
*/
300+
@Test
301+
void testContendedEnterWhenPinnedHeldByVirtualThread() throws Exception {
302+
// need at least two carrier threads
303+
int previousParallelism = VThreadRunner.ensureParallelism(2);
304+
try {
305+
VThreadRunner.run(this::testEnterWithContentionWhenPinned);
306+
} finally {
307+
VThreadRunner.setParallelism(previousParallelism);
308+
}
309+
}
310+
251311
/**
252312
* Test contended monitor enter when pinned, monitor will be held by caller thread.
253313
*/
@@ -276,33 +336,10 @@ private void testEnterWithContentionWhenPinned() throws Exception {
276336
assertTrue(entered.get());
277337
}
278338

279-
/**
280-
* Test contended monitor enter when pinned. Monitor is held by platform thread.
281-
*/
282-
@Test
283-
void testContendedEnterWhenPinnedHeldByPlatformThread() throws Exception {
284-
testEnterWithContentionWhenPinned();
285-
}
286-
287-
/**
288-
* Test contended monitor enter when pinned. Monitor is held by virtual thread.
289-
*/
290-
@Test
291-
void testContendedEnterWhenPinnedHeldByVirtualThread() throws Exception {
292-
// need at least two carrier threads
293-
int previousParallelism = VThreadRunner.ensureParallelism(2);
294-
try {
295-
VThreadRunner.run(this::testEnterWithContentionWhenPinned);
296-
} finally {
297-
VThreadRunner.setParallelism(previousParallelism);
298-
}
299-
}
300-
301339
/**
302340
* Test that parking while holding a monitor releases the carrier.
303341
*/
304342
@ParameterizedTest
305-
// @EnabledIf("platformIsX64")
306343
@ValueSource(booleans = { true, false })
307344
void testReleaseWhenParked(boolean reenter) throws Exception {
308345
assumeTrue(ThreadBuilders.supportsCustomScheduler(), "No support for custom schedulers");
@@ -349,7 +386,6 @@ void testReleaseWhenParked(boolean reenter) throws Exception {
349386
* Test that blocking waiting to enter a monitor releases the carrier.
350387
*/
351388
@Test
352-
// @EnabledIf("platformIsX64")
353389
void testReleaseWhenBlocked() throws Exception {
354390
assumeTrue(ThreadBuilders.supportsCustomScheduler(), "No support for custom schedulers");
355391
try (ExecutorService scheduler = Executors.newFixedThreadPool(1)) {
@@ -389,10 +425,9 @@ void testReleaseWhenBlocked() throws Exception {
389425
/**
390426
* Test lots of virtual threads parked while holding a monitor. If the number of
391427
* virtual threads exceeds the number of carrier threads then this test will hang if
392-
* carriers aren't released.
428+
* parking doesn't release the carrier.
393429
*/
394430
@Test
395-
// @EnabledIf("platformIsX64")
396431
void testManyParkedThreads() throws Exception {
397432
Thread[] vthreads = new Thread[MAX_VTHREAD_COUNT];
398433
var done = new AtomicBoolean();
@@ -428,7 +463,6 @@ void testManyParkedThreads() throws Exception {
428463
* carriers aren't released.
429464
*/
430465
@Test
431-
// @EnabledIf("platformIsX64")
432466
void testManyBlockedThreads() throws Exception {
433467
Thread[] vthreads = new Thread[MAX_VTHREAD_COUNT];
434468
var lock = new Object();
@@ -484,13 +518,15 @@ synchronized void increment() {
484518
var threads = new Thread[nThreads];
485519
int index = 0;
486520
for (int i = 0; i < nPlatformThreads; i++) {
487-
threads[index] = Thread.ofPlatform().unstarted(counter::increment);
488-
threads[index].setName("platform-" + index);
521+
threads[index] = Thread.ofPlatform()
522+
.name("platform-" + index)
523+
.unstarted(counter::increment);
489524
index++;
490525
}
491526
for (int i = 0; i < nVirtualThreads; i++) {
492-
threads[index] = Thread.ofVirtual().unstarted(counter::increment);
493-
threads[index].setName("virtual-" + index);
527+
threads[index] = Thread.ofVirtual()
528+
.name("virtual-" + index)
529+
.unstarted(counter::increment);
494530
index++;
495531
}
496532
// start all threads
@@ -504,6 +540,23 @@ synchronized void increment() {
504540
assertEquals(nThreads, counter.count);
505541
}
506542

543+
/**
544+
* Test unblocking a virtual thread waiting to enter a monitor held by a platform thread.
545+
*/
546+
@RepeatedTest(20)
547+
void testUnblockingByPlatformThread() throws Exception {
548+
testUnblocking();
549+
}
550+
551+
/**
552+
* Test unblocking a virtual thread waiting to enter a monitor held by another
553+
* virtual thread.
554+
*/
555+
@RepeatedTest(20)
556+
void testUnblockingByVirtualThread() throws Exception {
557+
VThreadRunner.run(this::testUnblocking);
558+
}
559+
507560
/**
508561
* Test unblocking a virtual thread waiting to enter a monitor, monitor will be
509562
* initially be held by caller thread.
@@ -540,23 +593,6 @@ private void testUnblocking() throws Exception {
540593
assertTrue(entered.get());
541594
}
542595

543-
/**
544-
* Test unblocking a virtual thread waiting to enter a monitor held by a platform thread.
545-
*/
546-
@RepeatedTest(20)
547-
void testUnblockingByPlatformThread() throws Exception {
548-
testUnblocking();
549-
}
550-
551-
/**
552-
* Test unblocking a virtual thread waiting to enter a monitor held by another
553-
* virtual thread.
554-
*/
555-
@RepeatedTest(20)
556-
void testUnblockingByVirtualThread() throws Exception {
557-
VThreadRunner.run(this::testUnblocking);
558-
}
559-
560596
/**
561597
* Test that unblocking a virtual thread waiting to enter a monitor does not consume
562598
* the thread's parking permit.
@@ -624,8 +660,4 @@ private void await(Thread thread, Thread.State expectedState) throws Interrupted
624660
state = thread.getState();
625661
}
626662
}
627-
628-
static boolean platformIsX64() {
629-
return Platform.isX64();
630-
}
631663
}

‎test/jdk/java/lang/Thread/virtual/stress/LotsOfMonitors.java

+167
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,167 @@
1+
/*
2+
* Copyright (c) 2024, 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+
* @summary Test virtual thread entering a lot of monitors, both with and without contention
27+
* @requires os.arch=="amd64" | os.arch=="x86_64" | os.arch=="aarch64"
28+
* @library /test/lib
29+
* @run junit LotsOfMonitors
30+
*/
31+
32+
import java.util.ArrayList;
33+
import java.util.List;
34+
import java.util.concurrent.CountDownLatch;
35+
import java.util.concurrent.ThreadLocalRandom;
36+
37+
import jdk.test.lib.thread.VThreadRunner;
38+
import org.junit.jupiter.api.Test;
39+
import org.junit.jupiter.api.condition.*;
40+
import static org.junit.jupiter.api.Assertions.*;
41+
42+
class LotsOfMonitors {
43+
44+
/**
45+
* Test entering lots of monitors with no contention.
46+
*/
47+
@Test
48+
void testEnterNoContention() throws Exception {
49+
VThreadRunner.run(() -> {
50+
testEnter(List.of(), 16); // creates 65535 monitors
51+
});
52+
}
53+
54+
/**
55+
* Enter the monitor for a new object, then reenter a monitor that is already held.
56+
*/
57+
private void testEnter(List<Object> ownedMonitors, int remaining) {
58+
if (remaining > 0) {
59+
var lock = new Object();
60+
assertFalse(Thread.holdsLock(lock));
61+
62+
synchronized (lock) {
63+
assertTrue(Thread.holdsLock(lock));
64+
65+
// new list of owned monitors
66+
var monitors = concat(ownedMonitors, lock);
67+
testEnter(monitors, remaining - 1);
68+
69+
// reenter a monitor that is already owned
70+
int index = ThreadLocalRandom.current().nextInt(monitors.size());
71+
var otherLock = monitors.get(index);
72+
assertTrue(Thread.holdsLock(otherLock));
73+
synchronized (otherLock) {
74+
testEnter(monitors, remaining - 1);
75+
}
76+
}
77+
78+
assertFalse(Thread.holdsLock(lock));
79+
}
80+
}
81+
82+
/**
83+
* Test entering lots of monitors with contention.
84+
*/
85+
@Test
86+
void testEnterWithContention() throws Exception {
87+
final int MAX_MONITORS = 1024;
88+
89+
VThreadRunner.run(() -> {
90+
var threads = new ArrayList<Thread>();
91+
testEnter(MAX_MONITORS, threads);
92+
assertEquals(MAX_MONITORS, threads.size());
93+
94+
// wait for threads to terminate
95+
for (Thread vthread : threads) {
96+
vthread.join();
97+
}
98+
});
99+
}
100+
101+
/**
102+
* Enter the monitor for a new object, racing with another thread that attempts to
103+
* enter around the same time.
104+
*/
105+
private void testEnter(int remaining, List<Thread> threads) throws Exception {
106+
if (remaining > 0) {
107+
var lock = new Object();
108+
assertFalse(Thread.holdsLock(lock));
109+
110+
// start thread to enter monitor for brief period, then enters again when signalled
111+
var started = new CountDownLatch(1);
112+
var signal = new CountDownLatch(1);
113+
var thread = Thread.ofVirtual().start(() -> {
114+
started.countDown();
115+
// enter, may be contended
116+
synchronized (lock) {
117+
Thread.onSpinWait();
118+
}
119+
// wait to be signalled
120+
try {
121+
signal.await();
122+
} catch (InterruptedException e) {
123+
}
124+
// enter again
125+
synchronized (lock) {
126+
// do nothing
127+
}
128+
});
129+
threads.add(thread);
130+
131+
// wait for thread to start, then enter monitor (may be contended)
132+
started.await();
133+
synchronized (lock) {
134+
assertTrue(Thread.holdsLock(lock));
135+
136+
// signal thread to enter monitor again, it should block
137+
signal.countDown();
138+
await(thread, Thread.State.BLOCKED);
139+
testEnter(remaining -1, threads);
140+
}
141+
142+
assertFalse(Thread.holdsLock(lock));
143+
}
144+
}
145+
146+
147+
/**
148+
* Waits for the given thread to reach a given state.
149+
*/
150+
private void await(Thread thread, Thread.State expectedState) {
151+
Thread.State state = thread.getState();
152+
while (state != expectedState) {
153+
assertTrue(state != Thread.State.TERMINATED, "Thread has terminated");
154+
Thread.yield();
155+
state = thread.getState();
156+
}
157+
}
158+
159+
/**
160+
* Adds an element to a list, returning a new list.
161+
*/
162+
private <T> List<T> concat(List<T> list, T object) {
163+
var newList = new ArrayList<>(list);
164+
newList.add(object);
165+
return newList;
166+
}
167+
}

0 commit comments

Comments
 (0)
Please sign in to comment.