Better benchmark and Stats infrastructure

 - Allow to specify the number of `#compilers` to run and the number of #runs
   per compiler.
 - Allow to specify with #wait-after a run after which we ask for a prompt. Useful
   for precise profiling.
 - Fix bug in Stats that prevented printing of detailed statistics

Author: odersky

compiler/src/dotty/tools/dotc/Bench.scala

@@ -14,24 +14,22 @@ import scala.annotation.internal.sharable
 object Bench extends Driver:
 
   @sharable private var numRuns = 1
-
-  private def ntimes(n: Int)(op: => Reporter): Reporter =
-    (0 until n).foldLeft(emptyReporter)((_, _) => op)
-
+  @sharable private var numCompilers = 1
+  @sharable private var waitAfter = -1
+  @sharable private var curCompiler = 0
   @sharable private var times: Array[Int] = _
 
   override def doCompile(compiler: Compiler, files: List[AbstractFile])(using Context): Reporter =
-    times = new Array[Int](numRuns)
     var reporter: Reporter = emptyReporter
     for i <- 0 until numRuns do
+      val curRun = curCompiler * numRuns + i
       val start = System.nanoTime()
       reporter = super.doCompile(compiler, files)
-      times(i) = ((System.nanoTime - start) / 1000000).toInt
-      println(s"time elapsed: ${times(i)}ms")
-      if ctx.settings.Xprompt.value then
+      times(curRun) = ((System.nanoTime - start) / 1000000).toInt
+      println(s"time elapsed: ${times(curRun)}ms")
+      if ctx.settings.Xprompt.value || waitAfter == curRun + 1 then
         print("hit <return> to continue >")
         System.in.nn.read()
-        println()
     reporter
 
   def extractNumArg(args: Array[String], name: String, default: Int = 1): (Int, Array[String]) = {
@@ -42,20 +40,26 @@ object Bench extends Driver:
 
   def reportTimes() =
     val best = times.sorted
-    val measured = numRuns / 3
+    val measured = numCompilers * numRuns / 3
     val avgBest = best.take(measured).sum / measured
     val avgLast = times.reverse.take(measured).sum / measured
-    println(s"best out of $numRuns runs: ${best(0)}")
+    println(s"best out of ${numCompilers * numRuns} runs: ${best(0)}")
     println(s"average out of best $measured: $avgBest")
     println(s"average out of last $measured: $avgLast")
 
-  override def process(args: Array[String], rootCtx: Context): Reporter =
+  override def process(args: Array[String]): Reporter =
     val (numCompilers, args1) = extractNumArg(args, "#compilers")
     val (numRuns, args2) = extractNumArg(args1, "#runs")
+    val (waitAfter, args3) = extractNumArg(args2, "#wait-after", -1)
+    this.numCompilers = numCompilers
     this.numRuns = numRuns
+    this.waitAfter = waitAfter
+    this.times = new Array[Int](numCompilers * numRuns)
     var reporter: Reporter = emptyReporter
-    for i <- 0 until numCompilers do
-      reporter = super.process(args2, rootCtx)
+    curCompiler = 0
+    while curCompiler < numCompilers do
+      reporter = super.process(args3)
+      curCompiler += 1
     reportTimes()
     reporter
 

compiler/src/dotty/tools/dotc/Driver.scala

@@ -171,7 +171,7 @@ class Driver {
    *  the other overloads without worrying about breaking compatibility
    *  with sbt.
    */
-  final def process(args: Array[String]): Reporter =
+  def process(args: Array[String]): Reporter =
     process(args, null: Reporter | Null, null: interfaces.CompilerCallback | Null)
 
   /** Entry point to the compiler using a custom `Context`.

compiler/src/dotty/tools/dotc/util/Stats.scala

@@ -55,15 +55,14 @@ import collection.mutable
   }
 
   def maybeMonitored[T](op: => T)(using Context): T =
-    if (ctx.settings.YdetailedStats.value && hits.nonEmpty) {
+    if ctx.settings.YdetailedStats.value then
       monitored = true
       try op
-      finally {
-        aggregate()
-        println()
-        println(hits.toList.sortBy(_._2).map{ case (x, y) => s"$x -> $y" } mkString "\n")
-        hits.clear()
-      }
-    }
+      finally
+        if hits.nonEmpty then
+          aggregate()
+          println()
+          println(hits.toList.sortBy(_._2).map{ case (x, y) => s"$x -> $y" } mkString "\n")
+          hits.clear()
     else op
 }