Add cache for class bytes

Author: mbovel

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

@@ -17,12 +17,14 @@ object CacheStores:
     def classPaths: Cache[AbstractFile, ClassPath]
     def files: Cache[TermName, AbstractFile]
     def sources: Cache[AbstractFile, SourceFile]
+    def classBytes: Cache[AbstractFile, Array[Byte]]
 
     override def toString: String =
       s"""CacheStore(
          |  classPaths = $classPaths,
          |  files = $files,
          |  sources = $sources
+         |  classBytes = $classBytes
          |)""".stripMargin
 
   /** Default, per-run cache store implementation. */
@@ -47,3 +49,9 @@ object CacheStores:
      *  `ContextBase.sources`. See also `Context.getSource`.
      */
     val sources = NoopCache()
+
+    /** By default, we do not cache class bytes across runs. */
+    val classBytes = NoopCache()
+
+    /** By default, we do not cache tasty loaders. */
+    val tastyLoaders = NoopCache()

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

@@ -22,8 +22,23 @@ object Caches:
    *    the type of cached values
    */
   trait Cache[K, V]:
+
+    /** Get the value associated with `key` from the cache, or compute it using
+     *  the by-name parameter `value`.
+     *
+     *  The value is cached iff `mightContain(key) == true`.
+     */
     def apply(key: K, value: => V): V
+
+    /** Check whether the cache might contain a value for `key`.
+     *
+     *  `true` means that the cache will cache the value for `key` if requested
+     *  via [[apply]], not that it has already cached it.
+     */
+    def mightContain(key: K): Boolean
+
     def stats(): CacheStats
+
     override def toString: String =
       s"${this.getClass.getSimpleName}(stats() = ${stats()})"
 
@@ -42,6 +57,9 @@ object Caches:
       total += 1
       value
 
+    def mightContain(key: K): Boolean =
+      false
+
     def stats(): CacheStats =
       CacheStats(total, misses = 0, uncached = total)
 
@@ -73,6 +91,9 @@ object Caches:
               map.put(key, (stamp, v))
               v
 
+    def mightContain(key: K): Boolean =
+      getStamp(key).isDefined
+
     def stats(): CacheStats =
       CacheStats(total, misses, uncached)
 
@@ -103,6 +124,9 @@ object Caches:
                 (stamp, value)
           )._2
 
+    def mightContain(key: K): Boolean =
+      getStamp(key).isDefined
+
     def stats(): CacheStats =
       CacheStats(total.longValue(), misses.longValue(), uncached.longValue())
 
@@ -123,27 +147,36 @@ object Caches:
   final class FileBasedCache[V]() extends Cache[AbstractFile, V]:
     private case class FileStamp(lastModified: FileTime, fileKey: Object)
 
-    private def getFileStamp(abstractFile: AbstractFile): Option[FileStamp] =
+    private def getPath(abstractFile: AbstractFile): Option[Path] =
       abstractFile.underlyingSource match
         case Some(underlyingSource) if underlyingSource ne abstractFile =>
-          getFileStamp(underlyingSource)
+          getPath(underlyingSource)
         case _ =>
-          val javaFile = abstractFile.file
-          if javaFile == null then
-            None
-          else
-            val attrs = Files.readAttributes(javaFile.toPath, classOf[BasicFileAttributes])
-            val lastModified = attrs.lastModifiedTime()
-            // This can be `null` on some platforms, but that's okay, we just use
-            // the last modified timestamp as our stamp in that case.
-            val fileKey = attrs.fileKey()
-            Some(FileStamp(lastModified, fileKey))
+          val javaPath = abstractFile.jpath
+          if javaPath != null then Some(javaPath) else None
+
+    private def getFileStamp(abstractFile: AbstractFile): Option[FileStamp] =
+      getPath(abstractFile) match
+        case Some(path) =>
+          val attrs = Files.readAttributes(path, classOf[BasicFileAttributes])
+          val lastModified = attrs.lastModifiedTime()
+          // This can be `null` on some platforms, but that's okay, we just use
+          // the last modified timestamp as our stamp in that case.
+          val fileKey = attrs.fileKey()
+          Some(FileStamp(lastModified, fileKey))
+        case None =>
+          None
 
     private val underlying = SynchronizedMapCache[AbstractFile, FileStamp, V](getFileStamp)
 
     def apply(key: AbstractFile, value: => V): V =
       underlying(key, value)
 
+    def mightContain(key: AbstractFile): Boolean =
+      // We just check that a path exists here to avoi IO. `getFileStamp` will
+      // return `None` iff `getPath` returns `None`.
+      getPath(key).isDefined
+
     def stats(): CacheStats =
       underlying.stats()
 
@@ -176,5 +209,8 @@ object Caches:
         uncached = baseStats.uncached + uncached.longValue()
       )
 
+    def mightContain(key: K): Boolean =
+      shouldCache(key) && underlying.mightContain(key)
+
     override def toString: String =
       s"FilteringCache(${underlying.toString}, uncached = ${uncached.longValue()})"

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -294,8 +294,17 @@ class ClassfileParser(
   private def mismatchError(className: SimpleName) =
     throw new IOException(s"class file '${classfile.canonicalPath}' has location not matching its contents: contains class $className")
 
-  def run()(using Context): Option[Embedded] = try ctx.base.reusableDataReader.withInstance { reader =>
-    implicit val reader2 = reader.reset(classfile)
+  def run()(using Context): Option[Embedded] =
+    if ctx.cacheStore.classBytes.mightContain(classfile) then
+      val bytes = ctx.cacheStore.classBytes(classfile, classfile.toByteArray)
+      given DataReader = AbstractFileReader(bytes)
+      runWithReader()
+    else
+      ctx.base.reusableDataReader.withInstance: reader =>
+        given DataReader = reader.reset(classfile)
+        runWithReader()
+
+  private def runWithReader()(using Context, DataReader): Option[Embedded] = try {
     report.debuglog("[class] >> " + classRoot.fullName)
     classfileVersion = parseHeader(classfile)
     this.pool = new ConstantPool

compiler/test/dotty/tools/TestCacheStore.scala

@@ -8,6 +8,7 @@ object TestCacheStore extends CacheStore:
   /** Use the default global classpath cache. */
   val classPaths = DefaultCacheStore.classPaths
 
+  /** Standard library sources directory */
   private val stdLibDir = "library/src"
 
   /** Cache files across runs, without invalidation. */
@@ -20,3 +21,13 @@ object TestCacheStore extends CacheStore:
    *  a test run.
    */
   val sources = FilteringCache(SynchronizedMapCache(), _.canonicalPath.startsWith(stdLibDir))
+
+  /** Test output directory */
+  private val outDir = "out"
+
+  /** Cache class bytes across runs, except for classes in the `out` directory.
+   *
+   *  Classes in the `out` directory are generated during tests, so we do not
+   *  want to cache them.
+   */
+  val classBytes = FilteringCache(SynchronizedMapCache(), !_.canonicalPath.startsWith(outDir))