Run position pickling in a separate task

Run position pickling and byte array assembly in a separate task

Author: odersky

compiler/src/dotty/tools/backend/jvm/GenBCode.scala

@@ -235,15 +235,15 @@ class GenBCodePipeline(val int: DottyBackendInterface)(using Context) extends BC
             if (!ctx.settings.YemitTastyInClass.value) {
               val outTastyFile = getFileForClassfile(outF, store.name, ".tasty")
               val outstream = new DataOutputStream(outTastyFile.bufferedOutput)
-              try outstream.write(binary)
+              try outstream.write(binary())
               catch case ex: ClosedByInterruptException =>
                 try
                   outTastyFile.delete() // don't leave an empty or half-written tastyfile around after an interrupt
                 catch case _: Throwable =>
                 throw ex
               finally outstream.close()
 
-              val uuid = new TastyHeaderUnpickler(binary).readHeader()
+              val uuid = new TastyHeaderUnpickler(binary()).readHeader()
               val lo = uuid.getMostSignificantBits
               val hi = uuid.getLeastSignificantBits
 
@@ -257,7 +257,7 @@ class GenBCodePipeline(val int: DottyBackendInterface)(using Context) extends BC
               // Create an empty file to signal that a tasty section exist in the corresponding .class
               // This is much cheaper and simpler to check than doing classfile parsing
               getFileForClassfile(outF, store.name, ".hasTasty")
-              binary
+              binary()
             }
           val dataAttr = createJAttribute(nme.TASTYATTR.mangledString, tasty, 0, tasty.length)
           store.visitAttribute(dataAttr)

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -30,7 +30,7 @@ class CompilationUnit protected (val source: SourceFile) {
   var sourceVersion: Option[SourceVersion] = None
 
   /** Pickled TASTY binaries, indexed by class. */
-  var pickled: Map[ClassSymbol, Array[Byte]] = Map()
+  var pickled: Map[ClassSymbol, () => Array[Byte]] = Map()
 
   /** The fresh name creator for the current unit.
    *  FIXME(#7661): This is not fine-grained enough to enable reproducible builds,

compiler/src/dotty/tools/dotc/decompiler/DecompilationPrinter.scala

@@ -39,7 +39,7 @@ class DecompilationPrinter extends Phase {
   private def printToOutput(out: PrintStream)(using Context): Unit = {
     val unit = ctx.compilationUnit
     if (ctx.settings.printTasty.value)
-      println(new TastyPrinter(unit.pickled.head._2).printContents())
+      println(new TastyPrinter(unit.pickled.head._2()).printContents())
     else {
       val unitFile = unit.source.toString.replace("\\", "/").replace(".class", ".tasty")
       out.println(s"/** Decompiled from $unitFile */")

compiler/src/dotty/tools/dotc/decompiler/IDEDecompilerDriver.scala

@@ -35,7 +35,7 @@ class IDEDecompilerDriver(val settings: List[String]) extends dotc.Driver {
       val unit = ctx.run.units.head
 
       val decompiled = ReflectionImpl.showTree(unit.tpdTree)
-      val tree = new TastyHTMLPrinter(unit.pickled.head._2).printContents()
+      val tree = new TastyHTMLPrinter(unit.pickled.head._2()).printContents()
 
       reporter.removeBufferedMessages.foreach(message => System.err.println(message))
       (tree, decompiled)

compiler/src/dotty/tools/dotc/fromtasty/ReadTasty.scala

@@ -40,7 +40,7 @@ class ReadTasty extends Phase {
               if (cls.rootTree.isEmpty) None
               else {
                 val unit = CompilationUnit(cls, cls.rootTree, forceTrees = true)
-                unit.pickled += (cls -> unpickler.unpickler.bytes)
+                unit.pickled += (cls -> (() => unpickler.unpickler.bytes))
                 Some(unit)
               }
             case tree: Tree[?] =>

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

@@ -13,6 +13,7 @@ import Symbols._
 import Flags.Module
 import reporting.ThrowingReporter
 import collection.mutable
+import scala.concurrent.ExecutionContext.global
 
 object Pickler {
   val name: String = "pickler"
@@ -45,6 +46,42 @@ class Pickler extends Phase {
     clss.filterNot(companionModuleClasses.contains)
   }
 
+  class PickleCompleter:
+    private var pickled: Array[Byte] = null
+
+    def complete(pickler: TastyPickler, cls: ClassSymbol, tree: Tree)(using Context): Unit =
+      val treePkl = pickler.treePkl
+      if tree.span.exists then
+        new PositionPickler(pickler, treePkl.buf.addrOfTree).picklePositions(tree :: Nil)
+
+      if !ctx.settings.YdropComments.value then
+        new CommentPickler(pickler, treePkl.buf.addrOfTree).pickleComment(tree)
+
+      val pickled = pickler.assembleParts()
+
+      def rawBytes = // not needed right now, but useful to print raw format.
+        pickled.iterator.grouped(10).toList.zipWithIndex.map {
+          case (row, i) => s"${i}0: ${row.mkString(" ")}"
+        }
+
+      synchronized {
+        this.pickled = pickled
+        // println(i"rawBytes = \n$rawBytes%\n%") // DEBUG
+        if pickling ne noPrinter then
+          pickling.synchronized {
+            println(i"**** pickled info of $cls")
+            println(new TastyPrinter(pickled).printContents())
+          }
+        notifyAll()
+      }
+    end complete
+
+    def bytes: Array[Byte] = synchronized {
+      if pickled == null then wait()
+      pickled
+    }
+  end PickleCompleter
+
   override def run(using Context): Unit = {
     val unit = ctx.compilationUnit
     pickling.println(i"unpickling in run ${ctx.runId}")
@@ -55,35 +92,20 @@ class Pickler extends Phase {
     }
     {
       val pickler = new TastyPickler(cls)
-      if (ctx.settings.YtestPickler.value) {
+      if ctx.settings.YtestPickler.value then
         beforePickling(cls) = tree.show
         picklers(cls) = pickler
-      }
       val treePkl = pickler.treePkl
       treePkl.pickle(tree :: Nil)
       treePkl.compactify()
       pickler.addrOfTree = treePkl.buf.addrOfTree
       pickler.addrOfSym = treePkl.addrOfSym
-      if (tree.span.exists)
-        new PositionPickler(pickler, treePkl.buf.addrOfTree).picklePositions(tree :: Nil)
-
-      if (!ctx.settings.YdropComments.value)
-        new CommentPickler(pickler, treePkl.buf.addrOfTree).pickleComment(tree)
-
-      // other pickle sections go here.
-      val pickled = pickler.assembleParts()
-      unit.pickled += (cls -> pickled)
-
-      def rawBytes = // not needed right now, but useful to print raw format.
-        pickled.iterator.grouped(10).toList.zipWithIndex.map {
-          case (row, i) => s"${i}0: ${row.mkString(" ")}"
-        }
-
-      // println(i"rawBytes = \n$rawBytes%\n%") // DEBUG
-      if (pickling ne noPrinter) {
-        println(i"**** pickled info of $cls")
-        println(new TastyPrinter(pickled).printContents())
-      }
+      val completer = PickleCompleter()
+      if ctx.settings.YtestPickler.value then
+        completer.complete(pickler, cls, tree)
+      else
+        global.execute(() => completer.complete(pickler, cls, tree))
+      unit.pickled += (cls -> (() => completer.bytes))
     }
   }