Collection tweaks

Author: odersky

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

@@ -178,8 +178,7 @@ class ScalaSettings extends Settings.SettingGroup {
 
   val YnoDecodeStacktraces: Setting[Boolean] = BooleanSetting("-Yno-decode-stacktraces", "Show raw StackOverflow stacktraces, instead of decoding them into triggering operations.")
 
-  val YinstrumentClosures: Setting[Boolean] = BooleanSetting("-Yinstrument-closures", "Add instrumentation code that counts closure creations.")
-  val YinstrumentAllocations: Setting[Boolean] = BooleanSetting("-Yinstrument-allocations", "Add instrumentation code that counts allocations.")
+  val Yinstrument: Setting[Boolean] = BooleanSetting("-Yinstrument", "Add instrumentation code that counts allocations and closure creations.")
 
   /** Dottydoc specific settings */
   val siteRoot: Setting[String] = StringSetting(

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

@@ -821,25 +821,13 @@ object Contexts {
 
     // Types state
     /** A table for hash consing unique types */
-    private[core] val uniques: util.HashSet[Type] = new util.HashSet[Type](Config.initialUniquesCapacity) {
-      override def hash(x: Type): Int = x.hash
-      override def isEqual(x: Type, y: Type) = x.eql(y)
-    }
+    private[core] val uniques: Uniques = Uniques()
 
     /** A table for hash consing unique applied types */
-    private[dotc] val uniqueAppliedTypes: AppliedUniques = new AppliedUniques
+    private[dotc] val uniqueAppliedTypes: AppliedUniques = AppliedUniques()
 
     /** A table for hash consing unique named types */
-    private[core] val uniqueNamedTypes: NamedTypeUniques = new NamedTypeUniques
-
-    private def uniqueSets = Map(
-        "uniques" -> uniques,
-        "uniqueAppliedTypes" -> uniqueAppliedTypes,
-        "uniqueNamedTypes" -> uniqueNamedTypes)
-
-    /** A map that associates label and size of all uniques sets */
-    def uniquesSizes: Map[String, (Int, Int, Int)] =
-      uniqueSets.transform((_, s) => (s.size, s.accesses, s.misses))
+    private[core] val uniqueNamedTypes: NamedTypeUniques = NamedTypeUniques()
 
     var emptyTypeBounds: TypeBounds = null
     var emptyWildcardBounds: WildcardType = null
@@ -895,15 +883,16 @@ object Contexts {
 
     private[dotc] var nameCharBuffer = new Array[Char](256)
 
-    def reset(): Unit = {
-      for ((_, set) <- uniqueSets) set.clear()
+    def reset(): Unit =
+      uniques.clear()
+      uniqueAppliedTypes.clear()
+      uniqueNamedTypes.clear()
       emptyTypeBounds = null
       emptyWildcardBounds = null
       errorTypeMsg.clear()
       sources.clear()
       sourceNamed.clear()
       comparers.clear()  // forces re-evaluation of top and bottom classes in TypeComparer
-    }
 
     // Test that access is single threaded
 

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

@@ -4,93 +4,71 @@ package core
 import Types._, Contexts._, util.Stats._, Hashable._, Names._
 import config.Config
 import Decorators._
-import util.HashSet
+import util.{HashSet, Stats}
+
+class Uniques extends HashSet[Type](Config.initialUniquesCapacity):
+  override def hash(x: Type): Int = x.hash
+  override def isEqual(x: Type, y: Type) = x.eql(y)
 
 /** Defines operation `unique` for hash-consing types.
  *  Also defines specialized hash sets for hash consing uniques of a specific type.
  *  All sets offer a `enterIfNew` method which checks whether a type
  *  with the given parts exists already and creates a new one if not.
  */
-object Uniques {
+object Uniques:
 
-  private def recordCaching(tp: Type): Unit = recordCaching(tp.hash, tp.getClass)
-  private def recordCaching(h: Int, clazz: Class[?]): Unit =
-    if (h == NotCached) {
-      record("uncached-types")
-      record(s"uncached: $clazz")
-    }
-    else {
-      record("cached-types")
-      record(s"cached: $clazz")
-    }
+  private inline def recordCaching(tp: Type): Unit = recordCaching(tp.hash, tp.getClass)
+  private inline def recordCaching(h: Int, clazz: Class[?]): Unit =
+    if monitored then
+      if h == NotCached then
+        record("uncached-types")
+        record(s"uncached: $clazz")
+      else
+        record("cached-types")
+        record(s"cached: $clazz")
 
-  def unique[T <: Type](tp: T)(using Context): T = {
-    if (monitored) recordCaching(tp)
-    if (tp.hash == NotCached) tp
-    else if (monitored) {
-      val size = ctx.uniques.size
-      val result = ctx.uniques.findEntryOrUpdate(tp).asInstanceOf[T]
-      if (ctx.uniques.size > size) record(s"fresh unique ${tp.getClass}")
-      result
-    }
-    else ctx.uniques.findEntryOrUpdate(tp).asInstanceOf[T]
-  }
-  /* !!! DEBUG
-  ensuring (
-    result => tp.toString == result.toString || {
-      println(s"cache mismatch; tp = $tp, cached = $result")
-      false
-    }
-  )
- */
+  def unique[T <: Type](tp: T)(using Context): T =
+    recordCaching(tp)
+    if tp.hash == NotCached then tp
+    else ctx.uniques.put(tp).asInstanceOf[T]
 
-  final class NamedTypeUniques extends HashSet[NamedType](Config.initialUniquesCapacity) with Hashable {
+  final class NamedTypeUniques extends HashSet[NamedType](Config.initialUniquesCapacity) with Hashable:
     override def hash(x: NamedType): Int = x.hash
 
-    private def findPrevious(h: Int, prefix: Type, designator: Designator): NamedType = {
-      var e = findEntryByHash(h)
-      while (e != null) {
-        if ((e.prefix eq prefix) && (e.designator eq designator)) return e
-        e = nextEntryByHash(h)
-      }
-      e
-    }
-
-    def enterIfNew(prefix: Type, designator: Designator, isTerm: Boolean)(using Context): NamedType = {
+    def enterIfNew(prefix: Type, designator: Designator, isTerm: Boolean)(using Context): NamedType =
       val h = doHash(null, designator, prefix)
-      if (monitored) recordCaching(h, classOf[NamedType])
+      if monitored then recordCaching(h, classOf[NamedType])
       def newType =
         if (isTerm) new CachedTermRef(prefix, designator, h)
         else new CachedTypeRef(prefix, designator, h)
-      if (h == NotCached) newType
-      else {
-        val r = findPrevious(h, prefix, designator)
-        if ((r ne null) && (r.isTerm == isTerm)) r else addEntryAfterScan(newType)
-      }
-    }
-  }
+      if h == NotCached then newType
+      else
+        Stats.record(statsItem("put"))
+        var idx = index(h)
+        var e = entryAt(idx)
+        while e != null do
+          if (e.prefix eq prefix) && (e.designator eq designator) && (e.isTerm == isTerm) then return e
+          idx = nextIndex(idx)
+          e = entryAt(idx)
+        addEntryAt(idx, newType)
+  end NamedTypeUniques
 
-  final class AppliedUniques extends HashSet[AppliedType](Config.initialUniquesCapacity) with Hashable {
+  final class AppliedUniques extends HashSet[AppliedType](Config.initialUniquesCapacity) with Hashable:
     override def hash(x: AppliedType): Int = x.hash
 
-    private def findPrevious(h: Int, tycon: Type, args: List[Type]): AppliedType = {
-      var e = findEntryByHash(h)
-      while (e != null) {
-        if ((e.tycon eq tycon) && e.args.eqElements(args)) return e
-        e = nextEntryByHash(h)
-      }
-      e
-    }
-
-    def enterIfNew(tycon: Type, args: List[Type]): AppliedType = {
+    def enterIfNew(tycon: Type, args: List[Type]): AppliedType =
       val h = doHash(null, tycon, args)
       def newType = new CachedAppliedType(tycon, args, h)
-      if (monitored) recordCaching(h, classOf[CachedAppliedType])
-      if (h == NotCached) newType
-      else {
-        val r = findPrevious(h, tycon, args)
-        if (r ne null) r else addEntryAfterScan(newType)
-      }
-    }
-  }
-}
+      if monitored then recordCaching(h, classOf[CachedAppliedType])
+      if h == NotCached then newType
+      else
+        Stats.record(statsItem("put"))
+        var idx = index(h)
+        var e = entryAt(idx)
+        while e != null do
+          if (e.tycon eq tycon) && e.args.eqElements(args) then return e
+          idx = nextIndex(idx)
+          e = entryAt(idx)
+        addEntryAt(idx, newType)
+  end AppliedUniques
+end Uniques

compiler/src/dotty/tools/dotc/transform/Instrumentation.scala

@@ -15,7 +15,7 @@ import Names._
 import Constants.Constant
 
 
-/** The phase is enabled if a -Yinstrument-... option is set.
+/** The phase is enabled if the -Yinstrument option is set.
  *  If enabled, it counts the number of closures or allocations for each source position.
  *  It does this by generating a call to dotty.tools.dotc.util.Stats.doRecord.
  */
@@ -25,13 +25,10 @@ class Instrumentation extends MiniPhase { thisPhase =>
   override def phaseName: String = "instrumentation"
 
   override def isEnabled(using Context) =
-    ctx.settings.YinstrumentClosures.value ||
-    ctx.settings.YinstrumentAllocations.value
+    ctx.settings.Yinstrument.value
 
   private val namesOfInterest = List(
-    "::", "+=", "toString", "newArray", "box", "toCharArray",
-    "map", "flatMap", "filter", "withFilter", "collect", "foldLeft", "foldRight", "take",
-    "reverse", "mapConserve", "mapconserve", "filterConserve", "zip")
+    "::", "+=", "lookup", "put", "-=")
   private var namesToRecord: Set[Name] = _
 
   private var consName: TermName = _

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

@@ -23,8 +23,7 @@ object GenericHashMap:
  *                           once the number of elements reaches the table's size.
  */
 abstract class GenericHashMap[Key <: AnyRef, Value >: Null <: AnyRef]
-    (protected val initialCapacity: Int = 8,
-     protected val capacityMultiple: Int = 3) extends MutableMap[Key, Value]:
+    (initialCapacity: Int = 8, capacityMultiple: Int = 3) extends MutableMap[Key, Value]:
   import GenericHashMap.DenseLimit
 
   protected var used: Int = _
@@ -61,12 +60,15 @@ abstract class GenericHashMap[Key <: AnyRef, Value >: Null <: AnyRef]
   private def index(x: Int): Int = x & (table.length - 2)
 
   private def firstIndex(key: Key) = if isDense then 0 else index(hash(key))
-  private def nextIndex(idx: Int) = index(idx + 2)
+  private def nextIndex(idx: Int) =
+    Stats.record(statsItem("miss"))
+    index(idx + 2)
 
   private def keyAt(idx: Int): Key = table(idx).asInstanceOf[Key]
   private def valueAt(idx: Int): Value = table(idx + 1).asInstanceOf[Value]
 
   def lookup(key: Key): Value =
+    Stats.record(statsItem("lookup"))
     var idx = firstIndex(key)
     var k = keyAt(idx)
     while k != null do
@@ -76,6 +78,7 @@ abstract class GenericHashMap[Key <: AnyRef, Value >: Null <: AnyRef]
     null
 
   def update(key: Key, value: Value): Unit =
+    Stats.record(statsItem("update"))
     var idx = firstIndex(key)
     var k = keyAt(idx)
     while k != null do
@@ -90,6 +93,7 @@ abstract class GenericHashMap[Key <: AnyRef, Value >: Null <: AnyRef]
     if used > limit then growTable()
 
   def remove(key: Key): Unit =
+    Stats.record(statsItem("remove"))
     var idx = firstIndex(key)
     var k = keyAt(idx)
     while k != null do
@@ -110,6 +114,7 @@ abstract class GenericHashMap[Key <: AnyRef, Value >: Null <: AnyRef]
       k = keyAt(idx)
 
   private def addOld(key: Key, value: AnyRef): Unit =
+    Stats.record(statsItem("re-enter"))
     var idx = firstIndex(key)
     var k = keyAt(idx)
     while k != null do
@@ -118,12 +123,7 @@ abstract class GenericHashMap[Key <: AnyRef, Value >: Null <: AnyRef]
     table(idx) = key
     table(idx + 1) = value
 
-  protected def growTable(): Unit =
-    val oldTable = table
-    val newLength =
-      if oldTable.length == DenseLimit then DenseLimit * 2 * roundToPower(capacityMultiple)
-      else table.length
-    allocate(newLength)
+  def copyFrom(oldTable: Array[AnyRef]): Unit =
     if isDense then
       Array.copy(oldTable, 0, table, 0, oldTable.length)
     else
@@ -133,11 +133,32 @@ abstract class GenericHashMap[Key <: AnyRef, Value >: Null <: AnyRef]
         if key != null then addOld(key, oldTable(idx + 1))
         idx += 2
 
-  def iterator: Iterator[(Key, Value)] =
-    for idx <- (0 until table.length by 2).iterator
-        if keyAt(idx) != null
-    yield (keyAt(idx), valueAt(idx))
+  protected def growTable(): Unit =
+    val oldTable = table
+    val newLength =
+      if oldTable.length == DenseLimit then DenseLimit * 2 * roundToPower(capacityMultiple)
+      else table.length
+    allocate(newLength)
+    copyFrom(oldTable)
+
+  private abstract class EntryIterator[T] extends Iterator[T]:
+    def entry(idx: Int): T
+    private var idx = 0
+    def hasNext =
+      while idx < table.length && table(idx) == null do idx += 2
+      idx < table.length
+    def next() =
+      require(hasNext)
+      try entry(idx) finally idx += 2
+
+  def iterator: Iterator[(Key, Value)] = new EntryIterator:
+    def entry(idx: Int) = (keyAt(idx), valueAt(idx))
 
   override def toString: String =
-    iterator.map((k, v) => s"$k -> $v").mkString("LinearTable(", ", ", ")")
+    iterator.map((k, v) => s"$k -> $v").mkString("HashMap(", ", ", ")")
+
+  protected def statsItem(op: String) =
+    val prefix = if isDense then "HashMap(dense)." else "HashMap."
+    val suffix = getClass.getSimpleName
+    s"$prefix$op $suffix"
 end GenericHashMap

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

@@ -8,13 +8,10 @@ class HashMap[Key <: AnyRef, Value >: Null <: AnyRef]
 extends GenericHashMap[Key, Value](initialCapacity, capacityMultiple):
   import GenericHashMap.DenseLimit
 
-  /** Hashcode, by default `System.identityHashCode`, but can be overriden */
   final def hash(x: Key): Int = x.hashCode
-
-  /** Equality, by default `eq`,  but can be overridden */
   final def isEqual(x: Key, y: Key): Boolean = x.equals(y)
 
-  // The following methdods are duplicated from GenericHashMap
+  // The following methods are duplicated from GenericHashMap
   // to avoid polymorphic dispatches
 
   /** Turn hashcode `x` into a table index */
@@ -27,6 +24,7 @@ extends GenericHashMap[Key, Value](initialCapacity, capacityMultiple):
   private def valueAt(idx: Int): Value = table(idx + 1).asInstanceOf[Value]
 
   override def lookup(key: Key): Value =
+    Stats.record(statsItem("lookup"))
     var idx = firstIndex(key)
     var k = keyAt(idx)
     while k != null do
@@ -36,6 +34,7 @@ extends GenericHashMap[Key, Value](initialCapacity, capacityMultiple):
     null
 
   override def update(key: Key, value: Value): Unit =
+    Stats.record(statsItem("update"))
     var idx = firstIndex(key)
     var k = keyAt(idx)
     while k != null do
@@ -48,4 +47,24 @@ extends GenericHashMap[Key, Value](initialCapacity, capacityMultiple):
     table(idx + 1) = value
     used += 1
     if used > limit then growTable()
+
+  private def addOld(key: Key, value: AnyRef): Unit =
+    Stats.record(statsItem("re-enter"))
+    var idx = firstIndex(key)
+    var k = keyAt(idx)
+    while k != null do
+      idx = nextIndex(idx)
+      k = keyAt(idx)
+    table(idx) = key
+    table(idx + 1) = value
+
+  override def copyFrom(oldTable: Array[AnyRef]): Unit =
+    if isDense then
+      Array.copy(oldTable, 0, table, 0, oldTable.length)
+    else
+      var idx = 0
+      while idx < oldTable.length do
+        val key = oldTable(idx).asInstanceOf[Key]
+        if key != null then addOld(key, oldTable(idx + 1))
+        idx += 2
 end HashMap