Statistics improvements and bug fixes.

Added compile-time option hotEnabled to Statistics that can be used to count very high frequency methods with 0 overhead for the disabled case. Fixed problem with weak maps that caused some timers to be discarded prematurely before they could be printed. Fixed problem with accouning for stacked timers.

7 files changed, 149 insertions, 80 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index f7e00109ae..68782379a6 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -1125,7 +1125,7 @@ trait Implicits {
      *  such that some part of `tp` has C as one of its superclasses.
      */
     private def implicitsOfExpectedType: Infoss = {
-      Statistics.incCounter(implicitCacheHits)
+      Statistics.incCounter(implicitCacheAccs)
       implicitsCache get pt match {
         case Some(implicitInfoss) =>
           Statistics.incCounter(implicitCacheHits)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 69d3fd7f47..a92a9aa82e 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -4025,7 +4025,7 @@ trait Typers extends Modes with Adaptations with Tags {
           } else {
             context.enclMethod.returnsSeen = true
             val expr1: Tree = typed(expr, EXPRmode | BYVALmode | RETmode, restpt.tpe)
-            
+
             // Warn about returning a value if no value can be returned.
             if (restpt.tpe.typeSymbol == UnitClass) {
               // The typing in expr1 says expr is Unit (it has already been coerced if
@@ -5131,7 +5131,7 @@ trait Typers extends Modes with Adaptations with Tags {
       indentTyping()
 
       var alreadyTyped = false
-      val startByType = Statistics.pushTimerClass(byTypeNanos, tree.getClass)
+      val startByType = Statistics.pushTimer(byTypeStack, byTypeNanos(tree.getClass))
       Statistics.incCounter(visitsByType, tree.getClass)
       try {
         if (context.retyping &&
@@ -5187,7 +5187,7 @@ trait Typers extends Modes with Adaptations with Tags {
       }
       finally {
         deindentTyping()
-        Statistics.popTimerClass(byTypeNanos, startByType)
+        Statistics.popTimer(byTypeStack, startByType)
       }
     }
 
@@ -5375,10 +5375,11 @@ object TypersStats {
   val compoundBaseTypeSeqCount = Statistics.newSubCounter("  of which for compound types", baseTypeSeqCount)
   val typerefBaseTypeSeqCount = Statistics.newSubCounter("  of which for typerefs", baseTypeSeqCount)
   val singletonBaseTypeSeqCount = Statistics.newSubCounter("  of which for singletons", baseTypeSeqCount)
-  val failedSilentNanos   = Statistics.newSubTimer  ("time spent in failed", typerNanos)
-  val failedApplyNanos    = Statistics.newSubTimer  ("  failed apply", typerNanos)
-  val failedOpEqNanos     = Statistics.newSubTimer  ("  failed op=", typerNanos)
-  val isReferencedNanos   = Statistics.newSubTimer  ("time spent ref scanning", typerNanos)
-  val visitsByType        = Statistics.newByClass   ("#visits by tree node", "typer")(Statistics.newCounter(""))
-  val byTypeNanos         = Statistics.newByClassTimerStack("time spent by tree node", typerNanos)
+  val failedSilentNanos   = Statistics.newSubTimer("time spent in failed", typerNanos)
+  val failedApplyNanos    = Statistics.newSubTimer("  failed apply", typerNanos)
+  val failedOpEqNanos     = Statistics.newSubTimer("  failed op=", typerNanos)
+  val isReferencedNanos   = Statistics.newSubTimer("time spent ref scanning", typerNanos)
+  val visitsByType        = Statistics.newByClass("#visits by tree node", "typer")(Statistics.newCounter(""))
+  val byTypeNanos         = Statistics.newByClass("time spent by tree node", "typer")(Statistics.newStackableTimer("", typerNanos))
+  val byTypeStack         = Statistics.newTimerStack()
 }
diff --git a/src/msil/ch/epfl/lamp/compiler/msil/emit/ILGenerator.scala b/src/msil/ch/epfl/lamp/compiler/msil/emit/ILGenerator.scala
index 2223a6db0f..2aa9a99054 100644
--- a/src/msil/ch/epfl/lamp/compiler/msil/emit/ILGenerator.scala
+++ b/src/msil/ch/epfl/lamp/compiler/msil/emit/ILGenerator.scala
@@ -336,7 +336,6 @@ import ILGenerator._
         emitSpecialLabel(Label.Try)
         val endExc: Label = new Label.NormalLabel() // new Label(lastLabel) ???
         excStack.push(Label.Try, endExc)
-	return endExc
     }
 
     /** Begins a catch block. */
diff --git a/src/reflect/scala/reflect/internal/SymbolTable.scala b/src/reflect/scala/reflect/internal/SymbolTable.scala
index 18adab7c68..5ae8f22c64 100644
--- a/src/reflect/scala/reflect/internal/SymbolTable.scala
+++ b/src/reflect/scala/reflect/internal/SymbolTable.scala
@@ -129,11 +129,15 @@ abstract class SymbolTable extends makro.Universe
 
   // sigh, this has to be public or atPhase doesn't inline.
   var phStack: List[Phase] = Nil
-  private var ph: Phase = NoPhase
-  private var per = NoPeriod
+  private[this] var ph: Phase = NoPhase
+  private[this] var per = NoPeriod
 
   final def atPhaseStack: List[Phase] = phStack
-  final def phase: Phase = ph
+  final def phase: Phase = {
+    if (Statistics.hotEnabled)
+      Statistics.incCounter(SymbolTableStats.phaseCounter)
+    ph
+  }
 
   def atPhaseStackMessage = atPhaseStack match {
     case Nil    => ""
@@ -330,3 +334,7 @@ abstract class SymbolTable extends makro.Universe
    */
   def isCompilerUniverse = false
 }
+
+object SymbolTableStats {
+  val phaseCounter = Statistics.newCounter("#phase calls")
+}
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 4b0ceeb86b..a3893a0236 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -645,6 +645,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     }
 
     final def flags: Long = {
+      if (Statistics.hotEnabled) Statistics.incCounter(flagsCount)
       val fs = _rawflags & phase.flagMask
       (fs | ((fs & LateFlags) >>> LateShift)) & ~(fs >>> AntiShift)
     }
@@ -936,7 +937,11 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
 // ------ owner attribute --------------------------------------------------------------
 
-    def owner: Symbol = rawowner
+    def owner: Symbol = {
+      Statistics.incCounter(ownerCount)
+      rawowner
+    }
+
     // TODO - don't allow the owner to be changed without checking invariants, at least
     // when under some flag. Define per-phase invariants for owner/owned relationships,
     // e.g. after flatten all classes are owned by package classes, there are lots and
@@ -2324,7 +2329,10 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
     private[this] var _rawname: TermName = initName
     def rawname = _rawname
-    def name = _rawname
+    def name = {
+      Statistics.incCounter(nameCount)
+      _rawname
+    }
     def name_=(name: Name) {
       if (name != rawname) {
         log("Renaming %s %s %s to %s".format(shortSymbolClass, debugFlagString, rawname, name))
@@ -2493,11 +2501,13 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     override def companionClass =
       flatOwnerInfo.decl(name.toTypeName).suchThat(_ isCoDefinedWith this)
 
-    override def owner = (
+    override def owner = {
+      Statistics.incCounter(ownerCount)
       if (!isMethod && needsFlatClasses) rawowner.owner
       else rawowner
-    )
-    override def name: TermName = (
+    }
+    override def name: TermName = {
+      Statistics.incCounter(nameCount)
       if (!isMethod && needsFlatClasses) {
         if (flatname eq null)
           flatname = nme.flattenedName(rawowner.name, rawname)
@@ -2505,7 +2515,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
         flatname
       }
       else rawname
-    )
+    }
   }
   implicit val ModuleSymbolTag = ClassTag[ModuleSymbol](classOf[ModuleSymbol])
 
@@ -2576,7 +2586,10 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     // cloneSymbolImpl still abstract in TypeSymbol.
 
     def rawname = _rawname
-    def name = _rawname
+    def name = {
+      Statistics.incCounter(nameCount)
+      _rawname
+    }
     final def asNameType(n: Name) = n.toTypeName
 
     override def isNonClassType = true
@@ -2888,10 +2901,13 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       thisTypeCache
     }
 
-    override def owner: Symbol =
+    override def owner: Symbol = {
+      Statistics.incCounter(ownerCount)
       if (needsFlatClasses) rawowner.owner else rawowner
+    }
 
-    override def name: TypeName = (
+    override def name: TypeName = {
+      Statistics.incCounter(nameCount)
       if (needsFlatClasses) {
         if (flatname eq null)
           flatname = nme.flattenedName(rawowner.name, rawname).toTypeName
@@ -2899,7 +2915,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
         flatname
       }
       else rawname
-    )
+    }
 
     /** A symbol carrying the self type of the class as its type */
     override def thisSym: Symbol = thissym
@@ -3194,4 +3210,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 object SymbolsStats {
   val typeSymbolCount     = Statistics.newCounter("#type symbols")
   val classSymbolCount    = Statistics.newCounter("#class symbols")
+  val flagsCount          = Statistics.newCounter("#flags ops")
+  val ownerCount          = Statistics.newCounter("#owner ops")
+  val nameCount           = Statistics.newCounter("#name ops")
 }
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index d4b895bcb4..4cf2cceb81 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -679,7 +679,7 @@ trait Types extends api.Types { self: SymbolTable =>
       else {
 //        scala.tools.nsc.util.trace.when(pre.isInstanceOf[ExistentialType])("X "+this+".asSeenfrom("+pre+","+clazz+" = ") {
         Statistics.incCounter(asSeenFromCount)
-        val start = Statistics.startTimer(asSeenFromNanos)
+        val start = Statistics.pushTimer(typeOpsStack, asSeenFromNanos)
         val m = new AsSeenFromMap(pre.normalize, clazz)
         val tp = m apply this
         val tp1 = existentialAbstraction(m.capturedParams, tp)
@@ -687,7 +687,7 @@ trait Types extends api.Types { self: SymbolTable =>
           if (m.capturedSkolems.isEmpty) tp1
           else deriveType(m.capturedSkolems, _.cloneSymbol setFlag CAPTURED)(tp1)
 
-        Statistics.stopTimer(asSeenFromNanos, start)
+        Statistics.popTimer(typeOpsStack, start)
         result
       }
     }
@@ -826,12 +826,12 @@ trait Types extends api.Types { self: SymbolTable =>
 
     def stat_<:<(that: Type): Boolean = {
       Statistics.incCounter(subtypeCount)
-      val start = Statistics.startTimer(subtypeNanos)
+      val start = Statistics.pushTimer(typeOpsStack, subtypeNanos)
       val result =
         (this eq that) ||
         (if (explainSwitch) explain("<:", isSubType, this, that)
          else isSubType(this, that, AnyDepth))
-      Statistics.stopTimer(subtypeNanos, start)
+      Statistics.popTimer(typeOpsStack, start)
       result
     }
 
@@ -839,12 +839,12 @@ trait Types extends api.Types { self: SymbolTable =>
      */
     def weak_<:<(that: Type): Boolean = {
       Statistics.incCounter(subtypeCount)
-      val start = Statistics.startTimer(subtypeNanos)
+      val start = Statistics.pushTimer(typeOpsStack, subtypeNanos)
       val result =
         ((this eq that) ||
          (if (explainSwitch) explain("weak_<:", isWeakSubType, this, that)
           else isWeakSubType(this, that)))
-      Statistics.stopTimer(subtypeNanos, start)
+      Statistics.popTimer(typeOpsStack, start)
       result
     }
 
@@ -1018,7 +1018,7 @@ trait Types extends api.Types { self: SymbolTable =>
       val suspension: List[TypeVar] = if (this.isGround) null else suspendTypeVarsInType(this)
 
       Statistics.incCounter(findMemberCount)
-      val start = Statistics.startTimer(findMemberNanos)
+      val start = Statistics.pushTimer(typeOpsStack, findMemberNanos)
 
       //Console.println("find member " + name.decode + " in " + this + ":" + this.baseClasses)//DEBUG
       var members: Scope = null
@@ -1045,7 +1045,7 @@ trait Types extends api.Types { self: SymbolTable =>
                    !sym.isPrivateLocal ||
                    (bcs0.head.hasTransOwner(bcs.head)))) {
                 if (name.isTypeName || stableOnly && sym.isStable) {
-                  Statistics.stopTimer(findMemberNanos, start)
+                  Statistics.popTimer(typeOpsStack, start)
                   if (suspension ne null) suspension foreach (_.suspended = false)
                   return sym
                 } else if (member == NoSymbol) {
@@ -1091,7 +1091,7 @@ trait Types extends api.Types { self: SymbolTable =>
         } // while (!bcs.isEmpty)
         excluded = excludedFlags
       } // while (continue)
-      Statistics.stopTimer(findMemberNanos, start)
+      Statistics.popTimer(typeOpsStack, start)
       if (suspension ne null) suspension foreach (_.suspended = false)
       if (members eq null) {
         if (member == NoSymbol) Statistics.incCounter(noMemberCount)
@@ -1534,11 +1534,17 @@ trait Types extends api.Types { self: SymbolTable =>
           tpe.baseTypeSeqCache = bts lateMap paramToVar
         } else {
           Statistics.incCounter(compoundBaseTypeSeqCount)
-          tpe.baseTypeSeqCache = undetBaseTypeSeq
-          tpe.baseTypeSeqCache = if (tpe.typeSymbol.isRefinementClass)
-            tpe.memo(compoundBaseTypeSeq(tpe))(_.baseTypeSeq updateHead tpe.typeSymbol.tpe)
-          else
-            compoundBaseTypeSeq(tpe)
+          val start = Statistics.pushTimer(typeOpsStack, baseTypeSeqNanos)
+          try {
+            tpe.baseTypeSeqCache = undetBaseTypeSeq
+            tpe.baseTypeSeqCache =
+              if (tpe.typeSymbol.isRefinementClass)
+                tpe.memo(compoundBaseTypeSeq(tpe))(_.baseTypeSeq updateHead tpe.typeSymbol.tpe)
+              else
+                compoundBaseTypeSeq(tpe)
+          } finally {
+            Statistics.popTimer(typeOpsStack, start)
+          }
           // [Martin] suppressing memo-ization solves the problem with "same type after erasure" errors
           // when compiling with
           // scalac scala.collection.IterableViewLike.scala scala.collection.IterableLike.scala
@@ -2390,8 +2396,13 @@ trait Types extends api.Types { self: SymbolTable =>
       tpe.baseTypeSeqPeriod = currentPeriod
       if (!isValidForBaseClasses(period)) {
         Statistics.incCounter(typerefBaseTypeSeqCount)
-        tpe.baseTypeSeqCache = undetBaseTypeSeq
-        tpe.baseTypeSeqCache = tpe.baseTypeSeqImpl
+        val start = Statistics.pushTimer(typeOpsStack, baseTypeSeqNanos)
+        try {
+          tpe.baseTypeSeqCache = undetBaseTypeSeq
+          tpe.baseTypeSeqCache = tpe.baseTypeSeqImpl
+        } finally {
+          Statistics.popTimer(typeOpsStack, start)
+        }
       }
     }
     if (tpe.baseTypeSeqCache == undetBaseTypeSeq)
@@ -6306,13 +6317,13 @@ trait Types extends api.Types { self: SymbolTable =>
     case List(t) => t
     case _ =>
       Statistics.incCounter(lubCount)
-      val start = Statistics.startTimer(lubNanos)
+      val start = Statistics.pushTimer(typeOpsStack, lubNanos)
       try {
          lub(ts, lubDepth(ts))
       } finally {
         lubResults.clear()
         glbResults.clear()
-        Statistics.stopTimer(lubNanos, start)
+        Statistics.popTimer(typeOpsStack, start)
       }
   }
 
@@ -6454,13 +6465,13 @@ trait Types extends api.Types { self: SymbolTable =>
     case List(t) => t
     case ts0 =>
       Statistics.incCounter(lubCount)
-      val start = Statistics.startTimer(lubNanos)
+      val start = Statistics.pushTimer(typeOpsStack, lubNanos)
       try {
         glbNorm(ts0, lubDepth(ts0))
       } finally {
         lubResults.clear()
         glbResults.clear()
-        Statistics.stopTimer(lubNanos, start)
+        Statistics.popTimer(typeOpsStack, start)
      }
   }
 
@@ -6884,11 +6895,13 @@ object TypesStats {
   val noMemberCount       = Statistics.newSubCounter("  of which not found", findMemberCount)
   val multMemberCount     = Statistics.newSubCounter("  of which multiple overloaded", findMemberCount)
   val typerNanos          = Statistics.newTimer     ("time spent typechecking", "typer")
-  val lubNanos            = Statistics.newSubTimer  ("time spent in lubs", typerNanos)
-  val subtypeNanos        = Statistics.newSubTimer  ("time spent in <:<", typerNanos)
-  val findMemberNanos     = Statistics.newSubTimer  ("time spent in findmember", typerNanos)
-  val asSeenFromNanos     = Statistics.newSubTimer  ("time spent in asSeenFrom", typerNanos)
+  val lubNanos            = Statistics.newStackableTimer("time spent in lubs", typerNanos)
+  val subtypeNanos        = Statistics.newStackableTimer("time spent in <:<", typerNanos)
+  val findMemberNanos     = Statistics.newStackableTimer("time spent in findmember", typerNanos)
+  val asSeenFromNanos     = Statistics.newStackableTimer("time spent in asSeenFrom", typerNanos)
+  val baseTypeSeqNanos    = Statistics.newStackableTimer("time spent in baseTypeSeq", typerNanos)
   val compoundBaseTypeSeqCount = Statistics.newSubCounter("  of which for compound types", baseTypeSeqCount)
   val typerefBaseTypeSeqCount = Statistics.newSubCounter("  of which for typerefs", baseTypeSeqCount)
   val singletonBaseTypeSeqCount = Statistics.newSubCounter("  of which for singletons", baseTypeSeqCount)
+  val typeOpsStack = Statistics.newTimerStack()
 }
diff --git a/src/reflect/scala/reflect/internal/util/Statistics.scala b/src/reflect/scala/reflect/internal/util/Statistics.scala
index 57c9e98174..f69530c40d 100644
--- a/src/reflect/scala/reflect/internal/util/Statistics.scala
+++ b/src/reflect/scala/reflect/internal/util/Statistics.scala
@@ -4,6 +4,8 @@ import collection.mutable
 
 object Statistics {
 
+  type TimerSnapshot = (Long, Long)
+
   /** If enabled, increment counter by one */
   @inline final def incCounter(c: Counter) {
     if (_enabled && c != null) c.value += 1
@@ -30,20 +32,20 @@ object Statistics {
   }
 
   /** If enabled, start timer */
-  @inline final def startTimer(tm: Timer): (Long, Long) =
+  @inline final def startTimer(tm: Timer): TimerSnapshot =
     if (_enabled && tm != null) tm.start() else null
 
   /** If enabled, stop timer */
-  @inline final def stopTimer(tm: Timer, start: (Long, Long)) {
+  @inline final def stopTimer(tm: Timer, start: TimerSnapshot) {
     if (_enabled && tm != null) tm.stop(start)
   }
 
   /** If enabled, push and start a new timer in timer stack */
-  @inline final def pushTimerClass(timers: ByClassTimerStack, cls: Class[_]): (Long, Long) =
-    if (_enabled && timers != null) timers.push(cls) else null
+  @inline final def pushTimer(timers: TimerStack, timer: StackableTimer): TimerSnapshot =
+    if (_enabled && timers != null) timers.push(timer) else null
 
   /** If enabled, stop and pop timer from timer stack */
-  @inline final def popTimerClass(timers: ByClassTimerStack, prev: (Long, Long)) {
+  @inline final def popTimer(timers: TimerStack, prev: TimerSnapshot) {
     if (_enabled && timers != null) timers.pop(prev)
   }
 
@@ -73,6 +75,13 @@ object Statistics {
    */
   def newSubTimer(prefix: String, timer: Timer): Timer = new SubTimer(prefix, timer)
 
+  /** Create a new stackable that shows as `prefix` and is active
+   *  in the same phases as its base timer. Stackable timers are subtimers
+   *  that can be stacked ina timerstack, and that print aggregate, as well as specific
+   *  durations.
+   */
+  def newStackableTimer(prefix: String, timer: Timer): StackableTimer = new StackableTimer(prefix, timer)
+
   /** Create a new view that shows as `prefix` and is active in given phases.
    *  The view always reflects the current value of `quant` as a quantity.
    */
@@ -86,20 +95,27 @@ quant)
   /** Same as newQuantMap, where the key type is fixed to be Class[_] */
   def newByClass[V <% Ordered[V]](prefix: String, phases: String*)(initValue: => V): QuantMap[Class[_], V] = new QuantMap(prefix, phases, initValue)
 
-  /** Create a new timer stack map, indexed by Class[_]. */
-  def newByClassTimerStack(prefix: String, underlying: Timer) = new ByClassTimerStack(prefix, underlying)
+  /** Create a new timer stack */
+  def newTimerStack() = new TimerStack()
 
   def allQuantities: Iterable[Quantity] =
-    for ((q, _) <- qs if !q.isInstanceOf[SubQuantity];
+    for ((_, q) <- qs if q.underlying == q;
          r <- q :: q.children.toList if r.prefix.nonEmpty) yield r
 
   private def showPercent(x: Double, base: Double) =
     if (base == 0) "" else f" (${x / base * 100}%2.1f%)"
 
+  /** The base trait for quantities.
+   *  Quantities with non-empty prefix are printed in the statistics info.
+   */
   trait Quantity {
-    qs += (this -> ())
+    if (prefix.nonEmpty) {
+      val key = s"${if (underlying != this) underlying.prefix else ""}/$prefix"
+      qs(key) = this
+    }
     val prefix: String
     val phases: Seq[String]
+    def underlying: Quantity = this
     def showAt(phase: String) = phases.isEmpty || (phases contains phase)
     def line = f"$prefix%-30s: ${this}"
     val children = new mutable.ListBuffer[Quantity]
@@ -123,7 +139,7 @@ quant)
     override def toString = quant.toString
   }
 
-  private class RelCounter(prefix: String, val underlying: Counter) extends Counter(prefix, underlying.phases) with SubQuantity {
+  private class RelCounter(prefix: String, override val underlying: Counter) extends Counter(prefix, underlying.phases) with SubQuantity {
     override def toString =
       if (value == 0) "0"
       else {
@@ -142,26 +158,32 @@ quant)
       value + showPercent(value, underlying.value)
   }
 
-  class Timer(val prefix: String, val phases: Seq[String]) extends Quantity with Ordered[Timer] {
+  class Timer(val prefix: String, val phases: Seq[String]) extends Quantity {
     var nanos: Long = 0
     var timings = 0
-    def compare(that: Timer): Int =
-      if (this.nanos < that.nanos) -1
-      else if (this.nanos > that.nanos) 1
-      else 0
     def start() = {
       (nanos, System.nanoTime())
     }
-    def stop(prev: (Long, Long)) {
+    def stop(prev: TimerSnapshot) {
       val (nanos0, start) = prev
       nanos = nanos0 + System.nanoTime() - start
       timings += 1
     }
-    override def toString = s"$timings spans, ${nanos/1000}ms"
+    protected def show(ns: Long) = s"${ns/1000}ms"
+    override def toString = s"$timings spans, ${show(nanos)}"
   }
 
-  private class SubTimer(prefix: String, override val underlying: Timer) extends Timer(prefix, underlying.phases) with SubQuantity {
-    override def toString: String = super.toString + showPercent(nanos, underlying.nanos)
+  class SubTimer(prefix: String, override val underlying: Timer) extends Timer(prefix, underlying.phases) with SubQuantity {
+    override protected def show(ns: Long) = super.show(ns) + showPercent(ns, underlying.nanos)
+  }
+
+  class StackableTimer(prefix: String, underlying: Timer) extends SubTimer(prefix, underlying) with Ordered[StackableTimer] {
+    var specificNanos: Long = 0
+    def compare(that: StackableTimer): Int =
+      if (this.specificNanos < that.specificNanos) -1
+      else if (this.specificNanos > that.specificNanos) 1
+      else 0
+    override def toString = s"${super.toString} aggregate, ${show(specificNanos)} specific"
   }
 
   /** A mutable map quantity where missing elements are automatically inserted
@@ -183,23 +205,25 @@ quant)
       }.mkString(", ")
   }
 
-  /** A mutable map quantity that takes class keys to subtimer values, relative to
-   *  some `underlying` timer. In addition, class timers can be pushed and popped.
-   *  Pushing the timer for a class means stopping the currently active timer.
+  /** A stack of timers, all active, where a timer's specific "clock"
+   *  is stopped as long as it is buried by some other timer in the stack, but
+   *  its aggregate clock keeps on ticking.
    */
-  class ByClassTimerStack(prefix: String, val underlying: Timer)
-      extends QuantMap[Class[_], Timer](prefix, underlying.phases, new SubTimer("", underlying)) with SubQuantity {
-    private var elems: List[(Timer, Long)] = Nil
-    def push(cls: Class[_]): (Long, Long) = {
-      val topTimer = this(cls)
-      elems = (topTimer, 0L) :: elems
-      topTimer.start()
+  class TimerStack {
+    private var elems: List[(StackableTimer, Long)] = Nil
+    /** Start given timer and push it onto the stack */
+    def push(t: StackableTimer): TimerSnapshot = {
+      elems = (t, 0L) :: elems
+      t.start()
     }
-    def pop(prev: (Long, Long)) = {
+    /** Stop and pop top timer in stack
+     */
+    def pop(prev: TimerSnapshot) = {
       val (nanos0, start) = prev
       val duration = System.nanoTime() - start
       val (topTimer, nestedNanos) :: rest = elems
-      topTimer.nanos = nanos0 + duration - nestedNanos
+      topTimer.nanos = nanos0 + duration
+      topTimer.specificNanos += duration - nestedNanos
       topTimer.timings += 1
       elems = rest match {
         case (outerTimer, outerNested) :: elems1 =>
@@ -211,7 +235,7 @@ quant)
   }
 
   private var _enabled = false
-  private val qs = new mutable.WeakHashMap[Quantity, Unit]
+  private val qs = new mutable.HashMap[String, Quantity]
 
   def enabled = _enabled
   def enabled_=(cond: Boolean) = {
@@ -229,4 +253,9 @@ quant)
       _enabled = true
     }
   }
+
+  /** replace rhs with enabled and rebuild to also count tiny but super-hot methods
+   * such as phase, flags, owner, name.
+   */
+  final val hotEnabled = false
 }