summaryrefslogtreecommitdiff
path: root/src/compiler/scala/reflect/internal/SymbolTable.scala
diff options
context:
space:
mode:
authorPaul Phillips <paulp@improving.org>2011-07-14 01:27:04 +0000
committerPaul Phillips <paulp@improving.org>2011-07-14 01:27:04 +0000
commit733669230a470b60c2ecc92c666f0871cecf22ef (patch)
tree70ee5f0e49e348e317bfd9db5d2230b433dada31 /src/compiler/scala/reflect/internal/SymbolTable.scala
parent5e49b4181976f20d28625008a775223dbf8e7f6e (diff)
downloadscala-733669230a470b60c2ecc92c666f0871cecf22ef.tar.gz
scala-733669230a470b60c2ecc92c666f0871cecf22ef.tar.bz2
scala-733669230a470b60c2ecc92c666f0871cecf22ef.zip
Adding some Sets/Maps to perRunCaches, and elim...
Adding some Sets/Maps to perRunCaches, and eliminating ambiguously named imports. Did a tour of the compiler adding a few longer-lived mutable structures to the per-run cache clearing mechanism. Some of these were not a big threat, but there is (almost) literally no cost to tracking them and the fewer mutable structures which are created "lone wolf style" the easier it is to spot the one playing by his own rules. While I was at it I followed through on long held ambition to eliminate the importing of highly ambiguous names like "Map" and "HashSet" from the mutable and immutable packages. I didn't quite manage elimination but it's pretty close. Something potentially as pernicious which I didn't do much about is this import: import scala.collection._ Imagine coming across that one on lines 407 and 474 of a 1271 file. That's not cool. Some poor future programmer will be on line 1100 and use "Map[A, B]" in some function and only after the product has shipped will it be discovered that the signature is wrong and the rocket will now be crashing into the mountainside straightaway. No review.
Diffstat (limited to 'src/compiler/scala/reflect/internal/SymbolTable.scala')
-rw-r--r--src/compiler/scala/reflect/internal/SymbolTable.scala27
1 files changed, 25 insertions, 2 deletions
diff --git a/src/compiler/scala/reflect/internal/SymbolTable.scala b/src/compiler/scala/reflect/internal/SymbolTable.scala
index ca2b5867ce..32fa88ac15 100644
--- a/src/compiler/scala/reflect/internal/SymbolTable.scala
+++ b/src/compiler/scala/reflect/internal/SymbolTable.scala
@@ -116,6 +116,9 @@ abstract class SymbolTable extends api.Universe
object perRunCaches {
import java.lang.ref.WeakReference
+ import scala.tools.util.Signallable
+ import scala.runtime.ScalaRunTime.stringOf
+
// We can allow ourselves a structural type, these methods
// amount to a few calls per run at most. This does suggest
@@ -128,6 +131,25 @@ abstract class SymbolTable extends api.Universe
// letting us know when a cache is really out of commission.
private val caches = mutable.HashSet[WeakReference[Clearable]]()
+ private def dumpCaches() {
+ println(caches.size + " structures are in perRunCaches.")
+ caches.zipWithIndex foreach { case (ref, index) =>
+ val cache = ref.get()
+ println("(" + index + ")" + (
+ if (cache == null) " has been collected."
+ else " has " + cache.size + " entries:\n" + stringOf(cache)
+ ))
+ }
+ }
+ if (settings.debug.value) {
+ println(Signallable("dump compiler caches")(dumpCaches()))
+ }
+
+ def recordCache[T <: Clearable](cache: T): T = {
+ caches += new WeakReference(cache)
+ cache
+ }
+
def clearAll() = {
if (settings.debug.value) {
val size = caches flatMap (ref => Option(ref.get)) map (_.size) sum;
@@ -142,8 +164,9 @@ abstract class SymbolTable extends api.Universe
}
}
- def newMap[K, V]() = { val m = mutable.HashMap[K, V]() ; caches += new WeakReference(m) ; m }
- def newSet[K]() = { val s = mutable.HashSet[K]() ; caches += new WeakReference(s) ; s }
+ def newWeakMap[K, V]() = recordCache(mutable.WeakHashMap[K, V]())
+ def newMap[K, V]() = recordCache(mutable.HashMap[K, V]())
+ def newSet[K]() = recordCache(mutable.HashSet[K]())
}
/** Break into repl debugger if assertion is true. */