More idiomatic trace-profiler integraiton. Prevent malformed outputs by appending GC events after profiling is done.

Author: WojciechMazur

Diff for: compiler/src/dotty/tools/dotc/Run.scala

@@ -339,10 +339,9 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
         if phaseWillRun then
           Stats.trackTime(s"phase time ms/$phase") {
             val start = System.currentTimeMillis
-            val profileBefore = profiler.beforePhase(phase)
-            try units = phase.runOn(units)
-            catch case _: InterruptedException => cancelInterrupted()
-            profiler.afterPhase(phase, profileBefore)
+            profiler.onPhase(phase):
+              try units = phase.runOn(units)
+              catch case _: InterruptedException => cancelInterrupted()
             if (ctx.settings.Xprint.value.containsPhase(phase))
               for (unit <- units)
                 def printCtx(unit: CompilationUnit) = phase.printingContext(

Diff for: compiler/src/dotty/tools/dotc/core/Phases.scala

@@ -370,9 +370,8 @@ object Phases {
       // Test that we are in a state where we need to check if the phase should be skipped for a java file,
       // this prevents checking the expensive `unit.typedAsJava` unnecessarily.
       val doCheckJava = skipIfJava && !isAfterLastJavaPhase
-      for unit <- units do
+      for unit <- units do ctx.profiler.onUnit(this, unit):
         given unitCtx: Context = runCtx.fresh.setPhase(this.start).setCompilationUnit(unit).withRootImports
-        ctx.profiler.beforeUnit(this, unit)
         if ctx.run.enterUnit(unit) then
           try
             if doCheckJava && unit.typedAsJava then
@@ -382,9 +381,7 @@ object Phases {
           catch case ex: Throwable if !ctx.run.enrichedErrorMessage =>
             println(ctx.run.enrichErrorMessage(s"unhandled exception while running $phaseName on $unit"))
             throw ex
-          finally
-            ctx.profiler.afterUnit(this, unit)
-            ctx.run.advanceUnit()
+          finally ctx.run.advanceUnit()
           buf += unitCtx.compilationUnit
         end if
       end for

Diff for: compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala

@@ -333,18 +333,15 @@ abstract class SymbolLoader extends LazyType { self =>
     def description(using Context): String = s"proxy to ${self.description}"
   }
 
-  private inline def tryProfileCompletion[T](root: SymDenotation)(inline body: T)(using Context): T = {
-    if ctx.profiler eq null
-    then body
-    else
-      val sym = root.symbol
-      val associatedFile = root.symbol.associatedFile match
-        case file: AbstractFile => file
-        case _ => NoAbstractFile
-      ctx.profiler.onCompletion(sym, associatedFile)(body)
+  private inline def profileCompletion[T](root: SymDenotation)(inline body: T)(using Context): T = {
+    val sym = root.symbol
+    def associatedFile = root.symbol.associatedFile match
+      case file: AbstractFile => file
+      case _ => NoAbstractFile
+    ctx.profiler.onCompletion(sym, associatedFile)(body)
   }
 
-  override def complete(root: SymDenotation)(using Context): Unit = tryProfileCompletion(root) {
+  override def complete(root: SymDenotation)(using Context): Unit = profileCompletion(root) {
     def signalError(ex: Exception): Unit = {
       if (ctx.debug) ex.printStackTrace()
       val msg = ex.getMessage()
@@ -419,6 +416,7 @@ class ClassfileLoader(val classfile: AbstractFile) extends SymbolLoader {
 
   def compilationUnitInfo: CompilationUnitInfo | Null = CompilationUnitInfo(classfile)
 
+
   def description(using Context): String = "class file " + classfile.toString
 
   override def doComplete(root: SymDenotation)(using Context): Unit =

Diff for: compiler/src/dotty/tools/dotc/profile/ChromeTrace.scala

@@ -63,7 +63,7 @@ final class ChromeTrace(f: Path) extends Closeable {
     traceWriter.close()
   }
 
-  def traceDurationEvent(name: String, startNanos: Long, durationNanos: Long, tid: String = this.tid(), pidSuffix: String = ""): Unit = synchronized {
+  def traceDurationEvent(name: String, startNanos: Long, durationNanos: Long, tid: String = this.tid(), pidSuffix: String = ""): Unit = {
     val durationMicros = nanosToMicros(durationNanos)
     val startMicros = nanosToMicros(startNanos)
     objStart()
@@ -85,7 +85,7 @@ final class ChromeTrace(f: Path) extends Closeable {
       str2("pid", pid, "-", pidSuffix)
   }
 
-  def traceCounterEvent(name: String, counterName: String, count: Long, processWide: Boolean): Unit = synchronized {
+  def traceCounterEvent(name: String, counterName: String, count: Long, processWide: Boolean): Unit = {
     objStart()
     str("cat", "scalac")
     str("name", name)
@@ -104,7 +104,7 @@ final class ChromeTrace(f: Path) extends Closeable {
   def traceDurationEventStart(cat: String, name: String, colour: String = "", pidSuffix: String = tid()): Unit = traceDurationEventStartEnd(EventType.Start, cat, name, colour, pidSuffix)
   def traceDurationEventEnd(cat: String, name: String, colour: String = "", pidSuffix: String = tid()): Unit = traceDurationEventStartEnd(EventType.End, cat, name, colour, pidSuffix)
 
-  private def traceDurationEventStartEnd(eventType: String, cat: String, name: String, colour: String, pidSuffix: String = ""): Unit = synchronized {
+  private def traceDurationEventStartEnd(eventType: String, cat: String, name: String, colour: String, pidSuffix: String = ""): Unit = {
     objStart()
     str("cat", cat)
     str("name", name)