8344577: Virtual thread tests are timing out on some macOS systems

8344143: Test jdk/java/lang/Thread/virtual/stress/GetStackTraceALotWhenPinned.java timed out on  macosx-x64

Reviewed-by: mbaesken
Backport-of: a032de2904baf83143415858ed7191549c659035

Author: RealCLanger

test/jdk/java/lang/Thread/virtual/stress/GetStackTraceALotWhenPinned.java

@@ -36,12 +36,13 @@
  * @requires vm.debug == true
  * @modules java.base/java.lang:+open
  * @library /test/lib
- * @run main/othervm/timeout=300 GetStackTraceALotWhenPinned 200000
+ * @run main/othervm/timeout=300 GetStackTraceALotWhenPinned 50000
  */
 
 import java.time.Instant;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.locks.LockSupport;
+import jdk.test.lib.Platform;
 import jdk.test.lib.thread.VThreadRunner;
 import jdk.test.lib.thread.VThreadPinner;
 
@@ -53,7 +54,15 @@ public static void main(String[] args) throws Exception {
             VThreadRunner.ensureParallelism(2);
         }
 
-        int iterations = Integer.parseInt(args[0]);
+        int iterations;
+        int value = Integer.parseInt(args[0]);
+        if (Platform.isOSX() && Platform.isX64()) {
+            // reduced iterations on macosx-x64
+            iterations = Math.max(value / 4, 1);
+        } else {
+            iterations = value;
+        }
+
         var barrier = new Barrier(2);
 
         // Start a virtual thread that loops doing Thread.yield and parking while pinned.
@@ -78,18 +87,23 @@ public static void main(String[] args) throws Exception {
             }
         });
 
-        long lastTimestamp = System.currentTimeMillis();
-        for (int i = 0; i < iterations; i++) {
+        long lastTime = System.nanoTime();
+        for (int i = 1; i <= iterations; i++) {
             // wait for virtual thread to arrive
             barrier.await();
 
             thread.getStackTrace();
             LockSupport.unpark(thread);
 
-            long currentTime = System.currentTimeMillis();
-            if ((currentTime - lastTimestamp) > 500) {
-                System.out.format("%s %d remaining ...%n", Instant.now(), (iterations - i));
-                lastTimestamp = currentTime;
+            long currentTime = System.nanoTime();
+            if (i == iterations || ((currentTime - lastTime) > 1_000_000_000L)) {
+                System.out.format("%s => %d of %d%n", Instant.now(), i, iterations);
+                lastTime = currentTime;
+            }
+
+            if (Thread.currentThread().isInterrupted()) {
+                // fail quickly if interrupted by jtreg
+                throw new RuntimeException("interrupted");
             }
         }
     }

test/jdk/java/lang/Thread/virtual/stress/ParkALot.java

@@ -25,38 +25,54 @@
  * @test
  * @summary Stress test parking and unparking
  * @requires vm.debug != true
- * @run main/othervm ParkALot 500000
+ * @library /test/lib
+ * @run main/othervm/timeout=300 ParkALot 300000
  */
 
 /*
  * @test
  * @requires vm.debug == true
- * @run main/othervm ParkALot 100000
+ * @library /test/lib
+ * @run main/othervm/timeout=300 ParkALot 100000
  */
 
 import java.time.Instant;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.locks.LockSupport;
+import jdk.test.lib.Platform;
 
 public class ParkALot {
-    private static final int ITERATIONS = 1_000_000;
 
-    public static void main(String[] args) {
+    public static void main(String[] args) throws Exception {
         int iterations;
-        if (args.length > 0) {
-            iterations = Integer.parseInt(args[0]);
+        int value = Integer.parseInt(args[0]);
+        if (Platform.isOSX() && Platform.isX64()) {
+            // reduced iterations on macosx-x64
+            iterations = Math.max(value / 4, 1);
         } else {
-            iterations = ITERATIONS;
+            iterations = value;
         }
 
         int maxThreads = Math.clamp(Runtime.getRuntime().availableProcessors() / 2, 1, 4);
         for (int nthreads = 1; nthreads <= maxThreads; nthreads++) {
             System.out.format("%s %d thread(s) ...%n", Instant.now(), nthreads);
             ThreadFactory factory = Thread.ofPlatform().factory();
             try (var executor = Executors.newThreadPerTaskExecutor(factory)) {
+                var totalIterations = new AtomicInteger();
                 for (int i = 0; i < nthreads; i++) {
-                    executor.submit(() -> parkALot(iterations));
+                    executor.submit(() -> parkALot(iterations, totalIterations::incrementAndGet));
+                }
+
+                // shutdown, await for all threads to finish with progress output
+                executor.shutdown();
+                boolean terminated = false;
+                while (!terminated) {
+                    terminated = executor.awaitTermination(1, TimeUnit.SECONDS);
+                    System.out.format("%s => %d of %d%n",
+                            Instant.now(), totalIterations.get(), iterations * nthreads);
                 }
             }
             System.out.format("%s %d thread(s) done%n", Instant.now(), nthreads);
@@ -66,8 +82,10 @@ public static void main(String[] args) {
     /**
      * Creates a virtual thread that alternates between untimed and timed parking.
      * A platform thread spins unparking the virtual thread.
+     * @param iterations number of iterations
+     * @param afterIteration the task to run after each iteration
      */
-    private static void parkALot(int iterations) {
+    private static void parkALot(int iterations, Runnable afterIteration) {
         Thread vthread = Thread.ofVirtual().start(() -> {
             int i = 0;
             boolean timed = false;
@@ -80,6 +98,7 @@ private static void parkALot(int iterations) {
                     timed = true;
                 }
                 i++;
+                afterIteration.run();
             }
         });
 

test/jdk/java/lang/Thread/virtual/stress/SleepALot.java

@@ -25,7 +25,7 @@
  * @test
  * @summary Stress test Thread.sleep
  * @requires vm.debug != true & vm.continuations
- * @run main/othervm SleepALot 500000
+ * @run main SleepALot 500000
  */
 
 /*