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 id=default 26 * @summary Tests for object monitors that have been useful to find bugs 27 * @library /test/lib 28 * @requires vm.continuations & vm.opt.LockingMode != 1 29 * @modules java.base/java.lang:+open 30 * @run junit/othervm MiscMonitorTests 31 */ 32 33 /* 34 * @test id=Xint 35 * @library /test/lib 36 * @requires vm.continuations & vm.opt.LockingMode != 1 37 * @modules java.base/java.lang:+open 38 * @run junit/othervm -Xint MiscMonitorTests 39 */ 40 41 /* 42 * @test id=Xcomp 43 * @library /test/lib 44 * @requires vm.continuations & vm.opt.LockingMode != 1 45 * @modules java.base/java.lang:+open 46 * @run junit/othervm -Xcomp MiscMonitorTests 47 */ 48 49 /* 50 * @test id=Xcomp-TieredStopAtLevel3 51 * @library /test/lib 52 * @requires vm.continuations & vm.opt.LockingMode != 1 53 * @modules java.base/java.lang:+open 54 * @run junit/othervm -Xcomp -XX:TieredStopAtLevel=3 MiscMonitorTests 55 */ 56 57 /* 58 * @test id=Xcomp-noTieredCompilation 59 * @summary Test virtual threads using synchronized 60 * @library /test/lib 61 * @requires vm.continuations & vm.opt.LockingMode != 1 62 * @modules java.base/java.lang:+open 63 * @run junit/othervm -Xcomp -XX:-TieredCompilation MiscMonitorTests 64 */ 65 66 /* 67 * @test id=gc 68 * @requires vm.debug == true & vm.continuations & vm.opt.LockingMode != 1 69 * @library /test/lib 70 * @modules java.base/java.lang:+open 71 * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:+FullGCALot -XX:FullGCALotInterval=1000 MiscMonitorTests 72 */ 73 74 import java.util.concurrent.atomic.AtomicInteger; 75 import java.util.concurrent.*; 76 import java.util.ArrayList; 77 import java.util.List; 78 79 import jdk.test.lib.thread.VThreadScheduler; 80 import org.junit.jupiter.api.Test; 81 import static org.junit.jupiter.api.Assertions.*; 82 83 class MiscMonitorTests { 84 static final int CARRIER_COUNT = Runtime.getRuntime().availableProcessors(); 85 86 /** 87 * Test that yielding while holding monitors releases carrier. 88 */ 89 @Test 90 void testReleaseOnYield() throws Exception { 91 try (var test = new TestReleaseOnYield()) { 92 test.runTest(); 93 } 94 } 95 96 private static class TestReleaseOnYield extends TestBase { 97 final Object lock = new Object(); 98 volatile boolean finish; 99 volatile int counter; 100 101 @Override 102 void runTest() throws Exception { 103 int vthreadCount = CARRIER_COUNT; 104 105 startVThreads(() -> foo(), vthreadCount, "Batch1"); 106 sleep(500); // Give time for threads to reach Thread.yield 107 startVThreads(() -> bar(), vthreadCount, "Batch2"); 108 109 while (counter != vthreadCount) { 110 Thread.onSpinWait(); 111 } 112 finish = true; 113 joinVThreads(); 114 } 115 116 void foo() { 117 Object lock = new Object(); 118 synchronized (lock) { 119 while (!finish) { 120 Thread.yield(); 121 } 122 } 123 System.err.println("Exiting foo from thread " + Thread.currentThread().getName()); 124 } 125 126 void bar() { 127 synchronized (lock) { 128 counter++; 129 } 130 System.err.println("Exiting bar from thread " + Thread.currentThread().getName()); 131 } 132 } 133 134 /** 135 * Test yielding while holding monitors with recursive locking releases carrier. 136 */ 137 @Test 138 void testReleaseOnYieldRecursive() throws Exception { 139 try (var test = new TestReleaseOnYieldRecursive()) { 140 test.runTest(); 141 } 142 } 143 144 private static class TestReleaseOnYieldRecursive extends TestBase { 145 final Object lock = new Object(); 146 volatile boolean finish; 147 volatile int counter; 148 149 @Override 150 void runTest() throws Exception { 151 int vthreadCount = CARRIER_COUNT; 152 153 startVThreads(() -> foo(), vthreadCount, "Batch1"); 154 sleep(500); // Give time for threads to reach Thread.yield 155 startVThreads(() -> bar(), vthreadCount, "Batch2"); 156 157 while (counter != 2 * vthreadCount) { 158 Thread.onSpinWait(); 159 } 160 finish = true; 161 joinVThreads(); 162 } 163 164 void foo() { 165 Object lock = new Object(); 166 synchronized (lock) { 167 while (!finish) { 168 Thread.yield(); 169 } 170 } 171 System.err.println("Exiting foo from thread " + Thread.currentThread().getName()); 172 } 173 174 void bar() { 175 synchronized (lock) { 176 counter++; 177 } 178 recursive(10); 179 System.err.println("Exiting bar from thread " + Thread.currentThread().getName()); 180 }; 181 182 void recursive(int count) { 183 synchronized (Thread.currentThread()) { 184 if (count > 0) { 185 recursive(count - 1); 186 } else { 187 synchronized (lock) { 188 counter++; 189 Thread.yield(); 190 } 191 } 192 } 193 } 194 } 195 196 /** 197 * Test that contention on monitorenter releases carrier. 198 */ 199 @Test 200 void testReleaseOnContention() throws Exception { 201 try (var test = new TestReleaseOnContention()) { 202 test.runTest(); 203 } 204 } 205 206 private static class TestReleaseOnContention extends TestBase { 207 final Object lock = new Object(); 208 volatile boolean finish; 209 volatile int counter; 210 211 @Override 212 void runTest() throws Exception { 213 int vthreadCount = CARRIER_COUNT * 8; 214 215 startVThreads(() -> foo(), vthreadCount, "VThread"); 216 sleep(500); // Give time for threads to reach synchronized (lock) 217 218 finish = true; 219 joinVThreads(); 220 } 221 222 void foo() { 223 synchronized (lock) { 224 while (!finish) { 225 Thread.yield(); 226 } 227 } 228 System.err.println("Exiting foo from thread " + Thread.currentThread().getName()); 229 } 230 } 231 232 /** 233 * Test contention on monitorenter with extra monitors on stack shared by all threads. 234 */ 235 @Test 236 void testContentionMultipleMonitors() throws Exception { 237 try (var test = new TestContentionMultipleMonitors()) { 238 test.runTest(); 239 } 240 } 241 242 private static class TestContentionMultipleMonitors extends TestBase { 243 static int MONITOR_COUNT = 12; 244 final Object[] lockArray = new Object[MONITOR_COUNT]; 245 final AtomicInteger workerCount = new AtomicInteger(0); 246 volatile boolean finish; 247 248 @Override 249 void runTest() throws Exception { 250 int vthreadCount = CARRIER_COUNT * 8; 251 for (int i = 0; i < MONITOR_COUNT; i++) { 252 lockArray[i] = new Object(); 253 } 254 255 startVThreads(() -> foo(), vthreadCount, "VThread"); 256 257 sleep(5000); 258 finish = true; 259 joinVThreads(); 260 assertEquals(vthreadCount, workerCount.get()); 261 } 262 263 void foo() { 264 while (!finish) { 265 int lockNumber = ThreadLocalRandom.current().nextInt(0, MONITOR_COUNT - 1); 266 synchronized (lockArray[lockNumber]) { 267 recursive1(lockNumber, lockNumber); 268 } 269 } 270 workerCount.getAndIncrement(); 271 System.err.println("Exiting foo from thread " + Thread.currentThread().getName()); 272 } 273 274 public void recursive1(int depth, int lockNumber) { 275 if (depth > 0) { 276 recursive1(depth - 1, lockNumber); 277 } else { 278 if (Math.random() < 0.5) { 279 Thread.yield(); 280 } 281 recursive2(lockNumber); 282 } 283 } 284 285 public void recursive2(int lockNumber) { 286 if (lockNumber + 2 <= MONITOR_COUNT - 1) { 287 lockNumber += 2; 288 synchronized (lockArray[lockNumber]) { 289 Thread.yield(); 290 recursive2(lockNumber); 291 } 292 } 293 } 294 } 295 296 /** 297 * Test contention on monitorenter with extra monitors on stack both local only and shared by all threads. 298 */ 299 @Test 300 void testContentionMultipleMonitors2() throws Exception { 301 try (var test = new TestContentionMultipleMonitors2()) { 302 test.runTest(); 303 } 304 } 305 306 private static class TestContentionMultipleMonitors2 extends TestBase { 307 int MONITOR_COUNT = 12; 308 final Object[] lockArray = new Object[MONITOR_COUNT]; 309 final AtomicInteger workerCount = new AtomicInteger(0); 310 volatile boolean finish; 311 312 @Override 313 void runTest() throws Exception { 314 int vthreadCount = CARRIER_COUNT * 8; 315 for (int i = 0; i < MONITOR_COUNT; i++) { 316 lockArray[i] = new Object(); 317 } 318 319 startVThreads(() -> foo(), vthreadCount, "VThread"); 320 321 sleep(5000); 322 finish = true; 323 joinVThreads(); 324 assertEquals(vthreadCount, workerCount.get()); 325 } 326 327 void foo() { 328 Object[] myLockArray = new Object[MONITOR_COUNT]; 329 for (int i = 0; i < MONITOR_COUNT; i++) { 330 myLockArray[i] = new Object(); 331 } 332 333 while (!finish) { 334 int lockNumber = ThreadLocalRandom.current().nextInt(0, MONITOR_COUNT - 1); 335 synchronized (myLockArray[lockNumber]) { 336 synchronized (lockArray[lockNumber]) { 337 recursive1(lockNumber, lockNumber, myLockArray); 338 } 339 } 340 } 341 workerCount.getAndIncrement(); 342 System.err.println("Exiting foo from thread " + Thread.currentThread().getName()); 343 } 344 345 public void recursive1(int depth, int lockNumber, Object[] myLockArray) { 346 if (depth > 0) { 347 recursive1(depth - 1, lockNumber, myLockArray); 348 } else { 349 if (Math.random() < 0.5) { 350 Thread.yield(); 351 } 352 recursive2(lockNumber, myLockArray); 353 } 354 } 355 356 public void recursive2(int lockNumber, Object[] myLockArray) { 357 if (lockNumber + 2 <= MONITOR_COUNT - 1) { 358 lockNumber += 2; 359 synchronized (myLockArray[lockNumber]) { 360 if (Math.random() < 0.5) { 361 Thread.yield(); 362 } 363 synchronized (lockArray[lockNumber]) { 364 Thread.yield(); 365 recursive2(lockNumber, myLockArray); 366 } 367 } 368 } 369 } 370 } 371 372 373 /** 374 * Test contention on monitorenter with synchronized methods. 375 */ 376 @Test 377 void testContentionWithSyncMethods() throws Exception { 378 try (var test = new TestContentionWithSyncMethods()) { 379 test.runTest(); 380 } 381 } 382 383 private static class TestContentionWithSyncMethods extends TestBase { 384 static final int MONITOR_COUNT = 12; 385 final Object[] lockArray = new Object[MONITOR_COUNT]; 386 final AtomicInteger workerCount = new AtomicInteger(0); 387 volatile boolean finish; 388 389 @Override 390 void runTest() throws Exception { 391 int vthreadCount = CARRIER_COUNT * 8; 392 for (int i = 0; i < MONITOR_COUNT; i++) { 393 lockArray[i] = new Object(); 394 } 395 396 startVThreads(() -> foo(), vthreadCount, "VThread"); 397 398 sleep(5000); 399 finish = true; 400 joinVThreads(); 401 assertEquals(vthreadCount, workerCount.get()); 402 } 403 404 void foo() { 405 Object myLock = new Object(); 406 407 while (!finish) { 408 int lockNumber = ThreadLocalRandom.current().nextInt(0, MONITOR_COUNT - 1); 409 synchronized (myLock) { 410 synchronized (lockArray[lockNumber]) { 411 recursive(lockNumber, myLock); 412 } 413 } 414 } 415 workerCount.getAndIncrement(); 416 System.err.println("Exiting foo from thread " + Thread.currentThread().getName()); 417 }; 418 419 synchronized void recursive(int depth, Object myLock) { 420 if (depth > 0) { 421 recursive(depth - 1, myLock); 422 } else { 423 if (Math.random() < 0.5) { 424 Thread.yield(); 425 } else { 426 synchronized (myLock) { 427 Thread.yield(); 428 } 429 } 430 } 431 } 432 } 433 434 /** 435 * Test wait/notify mechanism. 436 */ 437 @Test 438 void waitNotifyTest() throws Exception { 439 int threadCount = 1000; 440 int waitTime = 50; 441 Thread[] vthread = new Thread[threadCount]; 442 long start = System.currentTimeMillis(); 443 444 while (System.currentTimeMillis() - start < 5000) { 445 CountDownLatch latchStart = new CountDownLatch(threadCount); 446 CountDownLatch latchFinish = new CountDownLatch(threadCount); 447 Object object = new Object(); 448 449 for (int i = 0; i < threadCount; i++) { 450 vthread[i] = Thread.ofVirtual().start(() -> { 451 synchronized (object) { 452 try { 453 latchStart.countDown(); 454 object.wait(waitTime); 455 } catch (InterruptedException e) { 456 //do nothing; 457 } 458 } 459 latchFinish.countDown(); 460 }); 461 } 462 463 try { 464 latchStart.await(); 465 synchronized (object) { 466 object.notifyAll(); 467 } 468 latchFinish.await(); 469 for (int i = 0; i < threadCount; i++) { 470 vthread[i].join(); 471 } 472 } catch (InterruptedException e) { 473 //do nothing; 474 } 475 } 476 } 477 478 private static abstract class TestBase implements AutoCloseable { 479 final ExecutorService scheduler = Executors.newFixedThreadPool(CARRIER_COUNT); 480 final List<Thread[]> vthreadList = new ArrayList<>(); 481 482 abstract void runTest() throws Exception; 483 484 void startVThreads(Runnable r, int count, String name) { 485 Thread vthreads[] = new Thread[count]; 486 for (int i = 0; i < count; i++) { 487 vthreads[i] = VThreadScheduler.virtualThreadBuilder(scheduler).name(name + "-" + i).start(r); 488 } 489 vthreadList.add(vthreads); 490 } 491 492 void joinVThreads() throws Exception { 493 for (Thread[] vthreads : vthreadList) { 494 for (Thread vthread : vthreads) { 495 vthread.join(); 496 } 497 } 498 } 499 500 void sleep(long ms) throws Exception { 501 Thread.sleep(ms); 502 } 503 504 @Override 505 public void close() { 506 scheduler.close(); 507 } 508 } 509 }