Cache standard library sources during compilation tests

Author: mbovel

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

@@ -20,7 +20,7 @@ object Caches:
       s"${this.getClass.getSimpleName}(stats() = ${stats()})"
 
   /** Statistics about a cache */
-  final class CacheStats(total: Long, misses: Long, uncached: Long):
+  final case class CacheStats(total: Long, misses: Long, uncached: Long):
     val hits: Long = total - misses - uncached
 
     override def toString: String =
@@ -37,6 +37,9 @@ object Caches:
     def stats(): CacheStats =
       CacheStats(total, misses = 0, uncached = total)
 
+  /** Default value for stamp function that indicates no stamping. */
+  private def noStamp[K](key: K): Option[Unit] = Some(())
+
   /** A thread-unsafe cache implementation based on a mutable [[Map]].
    *
    *  Entries are not evicted.
@@ -47,7 +50,7 @@ object Caches:
    *    `Some(stamp)`, the stamp is used to validate cached entries: cache
    *    values are only reused if the stamp matches the cached stamp.
    */
-  final class MapCache[K, S, V](getStamp: K => Option[S]) extends Cache[K, V]:
+  final class MapCache[K, S, V](getStamp: K => Option[S] = noStamp) extends Cache[K, V]:
     private val map = Map.empty[K, (S, V)]
     private var total = 0L
     private var misses = 0L
@@ -76,7 +79,7 @@ object Caches:
    *
    *  Entries are not evicted.
    */
-  final class SynchronizedMapCache[K, S, V](getStamp: K => Option[S]) extends Cache[K, V]:
+  final class SynchronizedMapCache[K, S, V](getStamp: K => Option[S] = noStamp) extends Cache[K, V]:
     private val map = ConcurrentHashMap[K, (S, V)]()
     private val total = LongAdder()
     private val misses = LongAdder()
@@ -146,4 +149,31 @@ object Caches:
     override def toString: String =
       s"FileBasedCache(${underlying.toString})"
 
+  /** Filtering cache wrapper that only caches values whose key satisfies a
+   *  given predicate.
+   *
+   *  @param underlying
+   *    Underlying cache
+   *  @param shouldCache
+   *    Should the value associated with the given key should be cached?
+   */
+  final class FilteringCache[K, V](underlying: Cache[K, V], shouldCache: K => Boolean) extends Cache[K, V]:
+    private val uncached = LongAdder()
 
+    def apply(key: K, value: => V): V =
+      if shouldCache(key) then
+        underlying(key, value)
+      else
+        uncached.increment()
+        value
+
+    def stats(): CacheStats =
+      val baseStats = underlying.stats()
+      CacheStats(
+        total = baseStats.total + uncached.longValue(),
+        misses = baseStats.misses,
+        uncached = baseStats.uncached + uncached.longValue()
+      )
+
+    override def toString: String =
+      s"FilteringCache(${underlying.toString}, uncached = ${uncached.longValue()})"

compiler/test/dotty/tools/TestCacheStore.scala

@@ -0,0 +1,22 @@
+package dotty.tools
+
+import dotty.tools.dotc.core.Caches.{FilteringCache, SynchronizedMapCache}
+import dotty.tools.dotc.core.CacheStores.{CacheStore, DefaultCacheStore}
+import dotty.tools.io.AbstractFile
+
+object TestCacheStore extends CacheStore:
+  /** Use the default global classpath cache. */
+  val classPaths = DefaultCacheStore.classPaths
+
+  private val stdLibDir = "library/src"
+
+  /** Cache files across runs, without invalidation. */
+  val files = FilteringCache(SynchronizedMapCache(), _.startsWith((stdLibDir)))
+
+  /** Cache source files across runs, without invalidation.
+   *
+   *  We use a [[SynchronizedMapCache]] and not a [[FileBasedCache]] here
+   *  because we assume that source files in `library/src` do not change during
+   *  a test run.
+   */
+  val sources = FilteringCache(SynchronizedMapCache(), _.canonicalPath.startsWith(stdLibDir))

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -19,6 +19,7 @@ import TestSources.sources
 import reporting.TestReporter
 import vulpix._
 import dotty.tools.dotc.config.ScalaSettings
+import dotty.tools.dotc.core.CacheStores.DefaultCacheStore
 
 class CompilationTests {
   import ParallelTesting._
@@ -406,6 +407,7 @@ object CompilationTests extends ParallelTesting {
 
   implicit val summaryReport: SummaryReporting = new SummaryReport
   @AfterClass def tearDown(): Unit = {
+    println(s"Cache statistics: $TestCacheStore")
     super.cleanup()
     summaryReport.echoSummary()
   }

compiler/test/dotty/tools/vulpix/ParallelTesting.scala

@@ -63,6 +63,14 @@ trait ParallelTesting extends RunnerOrchestration:
 
   protected def testPlatform: TestPlatform = TestPlatform.JVM
 
+  private def setupTestContext(initCtx: FreshContext): FreshContext =
+    initCtx.setCacheStore(TestCacheStore)
+    initCtx
+
+  private class TestDriver extends Driver:
+    override protected def initCtx =
+      setupTestContext(super.initCtx.fresh)
+
   /** A test source whose files or directory of files is to be compiled
    *  in a specific way defined by the `Test`
    */
@@ -533,8 +541,8 @@ trait ParallelTesting extends RunnerOrchestration:
       val reporter = mkReporter
 
       val driver =
-        if (times == 1) new Driver
-        else new Driver {
+        if (times == 1) TestDriver()
+        else new TestDriver() {
           private def ntimes(n: Int)(op: Int => Reporter): Reporter =
             (1 to n).foldLeft(emptyReporter) ((_, i) => op(i))
 
@@ -686,7 +694,7 @@ trait ParallelTesting extends RunnerOrchestration:
       val classes = flattenFiles(targetDir).filter(isBestEffortTastyFile).map(_.toString)
       val flags = flags0 `and` "-from-tasty" `and` "-Ywith-best-effort-tasty"
       val reporter = mkReporter
-      val driver = new Driver
+      val driver = TestDriver()
 
       driver.process(flags.all ++ classes, reporter = reporter)
 
@@ -698,7 +706,7 @@ trait ParallelTesting extends RunnerOrchestration:
         .and("-Ywith-best-effort-tasty")
         .and("-d", targetDir.getPath)
       val reporter = mkReporter
-      val driver = new Driver
+      val driver = TestDriver()
 
       val args = Array("-classpath", flags.defaultClassPath + JFile.pathSeparator + bestEffortDir.toString) ++ flags.options
 
@@ -716,7 +724,7 @@ trait ParallelTesting extends RunnerOrchestration:
 
       val reporter = mkReporter
 
-      val driver = new Driver
+      val driver = TestDriver()
 
       driver.process(flags.all ++ classes, reporter = reporter)