fixed colours for implicits/macros

Author: retronym

src/compiler/scala/tools/nsc/profile/Profiler.scala

@@ -117,13 +117,13 @@ private [profile] object RealProfiler {
 }
 
 private [profile] class RealProfiler(reporter : ProfileReporter, val settings: Settings) extends Profiler with NotificationListener {
-
+  private val mainThread = Thread.currentThread()
   val tracePath = {
     if (settings.YprofileDestination.isSetByUser) new File(new java.io.File(settings.YprofileDestination.value)).changeExtension("trace").jfile.toPath
     else Files.createTempFile("scalac-", ".trace")
   }
   private val chromeTrace = new ChromeTrace(tracePath)
-  chromeTrace.traceAsyncEventStart("scalac", 0, "0")
+  chromeTrace.traceAsyncEventStart("scalac-" + mainThread.getId, mainThread.getId, "0")
 
   def completeBackground(threadRange: ProfileRange): Unit = {
     reporter.reportBackground(this, threadRange)
@@ -139,7 +139,6 @@ private [profile] class RealProfiler(reporter : ProfileReporter, val settings: S
 
   val active = RealProfiler.allPlugins map (_.generate(this, settings))
 
-  private val mainThread = Thread.currentThread()
 
   private[profile] def snapThread( idleTimeNanos:Long): ProfileSnap = {
     import RealProfiler._
@@ -180,7 +179,7 @@ private [profile] class RealProfiler(reporter : ProfileReporter, val settings: S
       val startNanos = gcEvent.endNanos - durationNanos
       chromeTrace.traceDurationEvent(gcEvent.name, startNanos, durationNanos, GcThreadId)
     }
-    chromeTrace.traceAsyncEventEnd("scalac", 0, "0")
+    chromeTrace.traceAsyncEventEnd("scalac-" + mainThread.getId, 0, "0")
 
     println("Trace file: " + tracePath)
     chromeTrace.close()
@@ -214,6 +213,21 @@ private [profile] class RealProfiler(reporter : ProfileReporter, val settings: S
     }
   }
 
+  override def beforePhase(phase: Phase): ProfileSnap = {
+    assert(mainThread eq Thread.currentThread())
+    chromeTrace.traceAsyncEventStart(phase.name, mainThread.getId, "0")
+    if (settings.YprofileRunGcBetweenPhases.containsPhase(phase))
+      doGC
+    if (settings.YprofileExternalTool.containsPhase(phase)) {
+      println("Profile hook start")
+      ExternalToolHook.before()
+    }
+    active foreach {_.beforePhase(phase)}
+    val snap = snapThread(0)
+    if (phase.prev eq null) baseline = snap
+    snap
+  }
+
   override def afterPhase(phase: Phase, snapBefore: ProfileSnap): Unit = {
     assert(mainThread eq Thread.currentThread())
     val initialSnap = snapThread(0)
@@ -226,21 +240,21 @@ private [profile] class RealProfiler(reporter : ProfileReporter, val settings: S
       doGC
       initialSnap.updateHeap(readHeapUsage())
     } else initialSnap
-    chromeTrace.traceAsyncEventEnd(phase.name, 0, "0")
+    chromeTrace.traceAsyncEventEnd(phase.name, mainThread.getId, "0")
 
     reporter.reportForeground(this, ProfileRange(snapBefore, finalSnap, phase, "", 0, Thread.currentThread))
   }
 
   override def beforeUnit(phase: Phase, file: AbstractFile): ProfileSnap = {
     assert(mainThread eq Thread.currentThread())
-    chromeTrace.traceAsyncEventStart(file.name, 0, "0")
+    chromeTrace.traceAsyncEventStart(file.name, mainThread.getId, "0")
     snapThread(0)
   }
 
   override def afterUnit(phase: Phase, file: AbstractFile, snapBefore: ProfileSnap): Unit = {
     assert(mainThread eq Thread.currentThread())
     val initialSnap = snapThread(0)
-    chromeTrace.traceAsyncEventEnd(file.name, 0, "0")
+    chromeTrace.traceAsyncEventEnd(file.name, mainThread.getId, "0")
     chromeTrace.traceCounterEvent("allocBytes", "allocBytes", initialSnap.allocatedBytes - this.baseline.allocatedBytes)
     chromeTrace.traceCounterEvent("heapBytes", "heapBytes", initialSnap.heapBytes - this.baseline.heapBytes)
     chromeTrace.traceCounterEvent("classesLoaded", "classesLoaded", initialSnap.totalClassesLoaded - this.baseline.totalClassesLoaded)
@@ -252,27 +266,11 @@ private [profile] class RealProfiler(reporter : ProfileReporter, val settings: S
 
   private var baseline: ProfileSnap = _
 
-  override def beforePhase(phase: Phase): ProfileSnap = {
-    assert(mainThread eq Thread.currentThread())
-    chromeTrace.traceAsyncEventStart(phase.name, 0, "0")
-    if (settings.YprofileRunGcBetweenPhases.containsPhase(phase))
-      doGC
-    if (settings.YprofileExternalTool.containsPhase(phase)) {
-      println("Profile hook start")
-      ExternalToolHook.before()
-    }
-    active foreach {_.beforePhase(phase)}
-    val snap = snapThread(0)
-    if (phase.prev eq null) baseline = snap
-    snap
-  }
-
   private val completingStack = new mutable.ArrayStack[Global#Symbol]
   private val stringsOf = (0 to 128).map(_.toString).toArray
   def intToString(i: Int) = if (i < 128) stringsOf(i) else i.toString
 
-  import scala.reflect.internal.util.ChromeTrace
-  private def traceId = if (completingStack.isEmpty) 0 else completingStack.top.id
+  private def traceId = if (completingStack.isEmpty) mainThread.getId else mainThread.getId << 32 | (completingStack.top.id.toLong & 0xffffffffL)
   override def beforeTypedImplDef(sym: Global#Symbol): Unit = {
     chromeTrace.traceAsyncEventStart(sym.rawname.toString, traceId, intToString(completingStack.length))
   }
@@ -281,23 +279,23 @@ private [profile] class RealProfiler(reporter : ProfileReporter, val settings: S
   }
 
   override def beforeImplicitSearch(pt: Global#Symbol): Unit = {
-    chromeTrace.traceAsyncEventStart("<implicit> " + pt.rawname, traceId, intToString(completingStack.length))
+    chromeTrace.traceAsyncEventStart("<implicit> " + pt.rawname, traceId, intToString(completingStack.length), colour = "yellow")
   }
 
   override def afterImplicitSearch(pt: Global#Symbol): Unit = {
-    chromeTrace.traceAsyncEventEnd("<implicit> " + pt.rawname, traceId, intToString(completingStack.length))
+    chromeTrace.traceAsyncEventEnd("<implicit> " + pt.rawname, traceId, intToString(completingStack.length), colour = "yellow")
   }
 
   override def beforeMacroExpansion(macroSym: Global#Symbol): Unit = {
-    chromeTrace.traceAsyncEventStart("<macro> " + macroSym.rawname, traceId, intToString(completingStack.length))
+    chromeTrace.traceAsyncEventStart("<macro> " + macroSym.rawname, traceId, intToString(completingStack.length), colour = "olive")
   }
 
   override def afterMacroExpansion(macroSym: Global#Symbol): Unit = {
-    chromeTrace.traceAsyncEventEnd("<macro> " + macroSym.rawname, traceId, intToString(completingStack.length))
+    chromeTrace.traceAsyncEventEnd("<macro> " + macroSym.rawname, traceId, intToString(completingStack.length), colour = "olive")
   }
 
   override def beforeCompletion(root: Global#Symbol): Unit = {
-    chromeTrace.traceAsyncEventStart("<wait>", traceId, intToString(completingStack.length))
+    chromeTrace.traceAsyncEventStart("<wait>", traceId, intToString(completingStack.length), colour = "thread_state_sleeping")
     completingStack.push(root)
     chromeTrace.traceAsyncEventStart("<completion>", traceId, intToString(completingStack.length))
     chromeTrace.traceAsyncEventStart(root.rawname.toString, traceId, intToString(completingStack.length))

src/reflect/scala/reflect/internal/util/ChromeTrace.scala

@@ -65,7 +65,7 @@ final class ChromeTrace(f: Path) extends Closeable {
     traceWriter.write("""", "pid": """")
     traceWriter.write("0")
     traceWriter.write("""", "tid": """")
-    traceWriter.write("0")
+    traceWriter.write(Thread.currentThread().getId.toString)
     traceWriter.write("""", "ts": """)
     traceWriter.write(microTime().toString)
     traceWriter.write(""", "args": {"""")
@@ -76,10 +76,10 @@ final class ChromeTrace(f: Path) extends Closeable {
     traceWriter.write("}\n")
   }
 
-  def traceAsyncEventStart(name: String, id: Int, threadIdSuffix: String): Unit = traceAsyncEvent(EventType.AsyncStart, name, id, threadIdSuffix)
-  def traceAsyncEventEnd(name: String, id: Int, threadIdSuffix: String): Unit = traceAsyncEvent(EventType.AsyncEnd, name, id, threadIdSuffix)
+  def traceAsyncEventStart(name: String, id: Long, threadIdSuffix: String, colour: String = ""): Unit = traceAsyncEvent(EventType.AsyncStart, name, id, threadIdSuffix, colour)
+  def traceAsyncEventEnd(name: String, id: Long, threadIdSuffix: String, colour: String = ""): Unit = traceAsyncEvent(EventType.AsyncEnd, name, id, threadIdSuffix, colour)
 
-  private def traceAsyncEvent(eventType: String, name: String, id: Int, threadIdSuffix: String): Unit = {
+  private def traceAsyncEvent(eventType: String, name: String, id: Long, threadIdSuffix: String, colour: String): Unit = {
     commaIfFirst()
     traceWriter.write("""{"cat": "scalac", "name": """")
     traceWriter.write(name)
@@ -95,6 +95,11 @@ final class ChromeTrace(f: Path) extends Closeable {
     traceWriter.write(threadIdSuffix)
     traceWriter.write("""", "ts": """)
     traceWriter.write(microTime().toString)
+    if (colour != "") {
+      traceWriter.write(""", "cname": """")
+      traceWriter.write(colour)
+      traceWriter.write("\"")
+    }
     traceWriter.write("}\n")
   }