Add logging and timing randomization

Author: odersky

tests/run/suspend-strawman-2/Async.scala

@@ -65,6 +65,7 @@ object Async:
 
   end Impl
 
+  /** An implementation of Async that blocks the running thread when waiting */
   private class Blocking(val scheduler: Scheduler = Scheduler) extends Async:
 
     def root = Cancellable.empty
@@ -73,19 +74,21 @@ object Async:
 
     private var hasResumed = false
 
-    def await[T](src: Source[T]): T = synchronized:
-      src.poll() match
-        case Some(x) => x
-        case None =>
-          var result: Option[T] = None
-          src.onComplete: x =>
-            synchronized:
-              result = Some(x)
-              notify()
-            true
+    def await[T](src: Source[T]): T =
+      src.poll().getOrElse:
+        var result: Option[T] = None
+        src.onComplete: x =>
+          synchronized:
+            result = Some(x)
+            notify()
+          true
+        synchronized:
           while result.isEmpty do wait()
           result.get
 
+  /** Execute asynchronous computation `body` on currently running thread.
+   *  The thread will suspend when the computation waits.
+   */
   def blocking[T](body: Async ?=> T, scheduler: Scheduler = Scheduler): T =
     body(using Blocking())
 

tests/run/suspend-strawman-2/Test.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 import concurrent.*
 import fiberRuntime.boundary.setName
 

tests/run/suspend-strawman-2/fiberRuntime.scala

@@ -1,5 +1,19 @@
 package fiberRuntime
 
+object util:
+  inline val logging = false
+  inline def log(inline msg: String) =
+    if logging then println(msg)
+
+  private val rand = new java.util.Random
+
+  def sleepABit() =
+    Thread.sleep(rand.nextInt(100))
+
+  val threadName = new ThreadLocal[String]
+end util
+import util.*
+
 /** A delimited contination, which can be invoked with `resume` */
 class Suspension:
   private var hasResumed = false
@@ -8,22 +22,31 @@ class Suspension:
     notify()
   def suspend(): Unit = synchronized:
     if !hasResumed then
+      log(s"suspended ${threadName.get()}")
       wait()
 
 def suspend[T, R](body: Suspension => Unit): Unit =
+  sleepABit()
+  log(s"suspending ${threadName.get()}")
   val susp = Suspension()
   body(susp)
+  sleepABit()
   susp.suspend()
 
 object boundary:
   final class Label[-T]()
 
-  def setName(name: String) = ()
+  def setName(name: String) =
+    log(s"started $name, ${Thread.currentThread.getId()}")
+    sleepABit()
+    threadName.set(name)
 
   def apply[T](body: Label[T] ?=> Unit): Unit =
     new Thread:
       override def run() =
-        body(using Label[T]())
+        sleepABit()
+        try body(using Label[T]())
+        finally log(s"finished ${threadName.get()} ${Thread.currentThread.getId()}")
     .start()