Refine statistics

 - new option -Ydetailed-stats provdies stats without starting
   a "heart-beat" thread.
 - track times of all phase groups under -Ydetailed-stats, even if
   -verbose if off.
 - better tracking of base types, which seem to be more prominent
   and expensive under new scheme.

Author: odersky

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

@@ -105,7 +105,7 @@ class Run(comp: Compiler, ictx: Context) {
     compileUnits()(ctx)
   }
 
-  protected def compileUnits()(implicit ctx: Context) = Stats.monitorHeartBeat {
+  protected def compileUnits()(implicit ctx: Context) = Stats.maybeMonitored {
     ctx.checkSingleThreaded()
 
     // If testing pickler, make sure to stop after pickling phase:
@@ -118,17 +118,18 @@ class Run(comp: Compiler, ictx: Context) {
     ctx.usePhases(phases)
     var lastPrintedTree: PrintedTree = NoPrintedTree
     for (phase <- ctx.allPhases)
-      if (phase.isRunnable) {
-        val start = System.currentTimeMillis
-        units = phase.runOn(units)
-        if (ctx.settings.Xprint.value.containsPhase(phase)) {
-          for (unit <- units) {
-            lastPrintedTree =
-              printTree(lastPrintedTree)(ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
+      if (phase.isRunnable)
+        Stats.trackTime(s"$phase ms ") {
+          val start = System.currentTimeMillis
+          units = phase.runOn(units)
+          if (ctx.settings.Xprint.value.containsPhase(phase)) {
+            for (unit <- units) {
+              lastPrintedTree =
+                printTree(lastPrintedTree)(ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
+            }
           }
+          ctx.informTime(s"$phase ", start)
         }
-        ctx.informTime(s"$phase ", start)
-      }
     if (!ctx.reporter.hasErrors) Rewrites.writeBack()
     for (unit <- units)
       Stats.record("retained typed trees at end", unit.tpdTree.treeSize)

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -87,7 +87,8 @@ class ScalaSettings extends Settings.SettingGroup {
   val YmethodInfer = BooleanSetting("-Yinfer-argument-types", "Infer types for arguments of overriden methods.")
   val YtraceContextCreation = BooleanSetting("-Ytrace-context-creation", "Store stack trace of context creations.")
   val YshowSuppressedErrors = BooleanSetting("-Yshow-suppressed-errors", "Also show follow-on errors and warnings that are normally supressed.")
-  val Yheartbeat = BooleanSetting("-Yheartbeat", "show heartbeat stack trace of compiler operations.")
+  val YdetailedStats = BooleanSetting("-Ydetailed-stats", "show detailed internal compiler stats (needs Stats.enabled to be set to true).")
+  val Yheartbeat = BooleanSetting("-Ydetailed-stats", "show heartbeat stack trace of compiler operations (needs Stats.enabled to be set to true).")
   val Yprintpos = BooleanSetting("-Yprintpos", "show tree positions.")
   val YnoDeepSubtypes = BooleanSetting("-Yno-deep-subtypes", "throw an exception on deep subtyping call stacks.")
   val YnoPatmatOpt = BooleanSetting("-Yno-patmat-opt", "disable all pattern matching optimizations.")

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -1638,7 +1638,10 @@ object SymDenotations {
       }
 
       def computeBaseTypeOf(tp: Type): Type = {
-        Stats.record("computeBaseTypeOf")
+        if (Stats.monitored) {
+          Stats.record("computeBaseType, total")
+          Stats.record(s"computeBaseType, ${tp.getClass}")
+        }
         if (symbol.isStatic && tp.derivesFrom(symbol) && symbol.typeParams.isEmpty)
           symbol.appliedRef
         else tp match {
@@ -1675,7 +1678,11 @@ object SymDenotations {
               if (basetp == null) {
                 btrCache.put(tp, NoPrefix)
                 basetp = computeBaseTypeOf(tp)
-                if (isCachable(tp, baseTypeCache)) btrCache.put(tp, basetp)
+                if (!basetp.exists) Stats.record("base type miss")
+                if (isCachable(tp, baseTypeCache)) {
+                  if (!basetp.exists) Stats.record("cached base type miss")
+                  btrCache.put(tp, basetp)
+                }
                 else btrCache.remove(tp)
               } else if (basetp == NoPrefix)
                 throw CyclicReference(this)

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

@@ -42,6 +42,16 @@ import collection.mutable
       finally stack = stack.tail
     } else op
 
+  @inline
+  def trackTime[T](fn: String)(op: => T) =
+    if (enabled) doTrackTime(fn)(op) else op
+
+  def doTrackTime[T](fn: String)(op: => T) =
+    if (monitored) {
+      val start = System.nanoTime
+      try op finally record(fn, ((System.nanoTime - start) / 1000).toInt)
+    } else op
+
   class HeartBeat extends Thread() {
     @volatile private[Stats] var continue = true
 
@@ -61,10 +71,10 @@ import collection.mutable
     }
   }
 
-  def monitorHeartBeat[T](op: => T)(implicit ctx: Context) = {
-    if (ctx.settings.Yheartbeat.value) {
-      var hb = new HeartBeat()
-      hb.start()
+  def maybeMonitored[T](op: => T)(implicit ctx: Context) = {
+    if (ctx.settings.YdetailedStats.value) {
+      val hb = new HeartBeat()
+      if (ctx.settings.Yheartbeat.value) hb.start()
       monitored = true
       try op
       finally {