Merge pull request #113 from retronym/asyncMulti

Author: retronym

README.md

@@ -132,9 +132,18 @@ for merges and sets of commits that we're backtesting (UI on https://scala-ci.ty
 
 ### Collecting profiling data
 
-```
-sbt> .../jmh:run Benchmark -prof jmh.extras.JFR // Java Flight Recorder
-```
+#### Async Profiler
+
+  - [Install](https://github.com/jvm-profiling-tools/async-profiler/releases) async-profiler 2.x.
+  - export `ASYNC_PROFILER_DIR=/path/to/async-profiler` (the directory containing `build`)
+  - Create a JFR profile and flamegraphs with CPU or allocation tracing: `{profAsyncCpu, profAsyncAlloc} hot -psource=scala -f1`
+  - Create a combined JFR profile with CPU and allocation tracing: `profAsyncCpuAlloc hot -psource=scala -f1`
+     - This can be converted to flamegraphs with the converter provided by async-profiler: `java -cp converter.jar jfr2flame`
+       or by using the convenience sbt command `sbt jfr2flame`.
+
+#### Java Flight Recorder
+
+ - `profJfr hot -psource=scala -f1`
 
 ### Using GraalVM
 

build.sbt

@@ -100,7 +100,7 @@ addCommandAlias("cold", "compilation/jmh:run ColdScalacBenchmark -foe true")
 commands ++= build.Profiler.commands
 
 // duplicated in project/build.sbt
-val jmhV = System.getProperty("jmh.version", "1.30")
+val jmhV = System.getProperty("jmh.version", "1.31")
 
 def addJmh(project: Project): Project = {
   // IntelliJ SBT project import doesn't like sbt-jmh's default setup, which results the prod and test

compilation/src/main/scala/scala/tools/nsc/ScalacBenchmark.scala

@@ -47,8 +47,9 @@ class ScalacBenchmark extends BenchmarkDriver {
   @Param(value = Array(""))
   var extraArgs: String = _
 
-  @Param(value = Array("../corpus"))
-  var corpusPath: String = "../corpus"
+  final val DefaultCorpusPath = ""
+  @Param(value = Array(DefaultCorpusPath))
+  var corpusPath: String = DefaultCorpusPath
 
   // This parameter is set by ScalacBenchmarkRunner / UploadingRunner based on the Scala version.
   // When running the benchmark directly the "latest" symlink is used.
@@ -93,7 +94,7 @@ class ScalacBenchmark extends BenchmarkDriver {
     BenchmarkUtils.deleteRecursive(tempDir.toPath)
   }
 
-  def corpusSourcePath: Path = Paths.get(s"$corpusPath/$source/$corpusVersion")
+  def corpusSourcePath: Path = Paths.get(s"${if (corpusPath == DefaultCorpusPath) "../corpus" else corpusPath}/$source/$corpusVersion")
 
   @Setup(Level.Trial) def initDepsClasspath(): Unit = {
     val classPath = BenchmarkUtils.initDeps(corpusSourcePath)

project/Profilers.scala

@@ -1,25 +1,58 @@
 package build
 
+import sbt.Keys.scalaInstance
+
 import java.io.File
 import sbt._
 import sbt.complete.DefaultParsers.OptSpace
 import sbt.complete.Parser
+import sbt.internal.inc.classpath.ClasspathUtilities
+
+import java.util.stream.Collectors
 
 abstract class Profiler(val name: String) {
   def command(outDir: File): String
   val flameGraphOpts = s"--minwidth,1,--colors,java,--cp,--width,1800"
 }
 object Profiler {
-  def all = List(basic, jfr, asyncAlloc, asyncCpu, asyncWall, perfNorm)
+  def all = List(basic, jfr, asyncAlloc, asyncCpu, asyncCpuAlloc, asyncWall, perfNorm)
 
   def commands = Profiler.all.map { prof => Command.arb(profParser("prof" + prof.toString.capitalize))(commandImpl(List(prof))) } :+
-    Command.arb(profParser("prof"))(commandImpl(Profiler.all))
+    Command.arb(profParser("prof"))(commandImpl(Profiler.all)) :+ jfr2flameCommand
 
   def profParser(name: String)(s: State): Parser[String] = {
     import Parser._
     token(name ~> OptSpace) flatMap { _ => matched(s.combinedParser)} map (_.trim)
   }
 
+  def jfr2flameCommand = Command.command("jfr2flame") { state =>
+    import java.nio.file._
+    import scala.collection.JavaConverters._
+    val jfrFiles: List[Path] = Files.walk(Paths.get(System.getProperty("user.dir"))).iterator.asScala.filter(x => x.toString.endsWith(".jfr")).toList
+    for (jfrFile <- jfrFiles) {
+      val converterJar = file(System.getenv("ASYNC_PROFILER_DIR")) / "build" / "converter.jar"
+      val (_, si) = Project.extract(state).runTask(scalaInstance, state)
+      val run = new Run(cp => ClasspathUtilities.makeLoader(cp, si), trapExit = true)
+      def jfr2flame(forward: Boolean, event: String): Unit = {
+        val jfrFileNameString = jfrFile.toAbsolutePath.toString
+        val flameFileName = jfrFileNameString.replaceAll(""".jfr$""", s"${if (event == "cpu") "" else "-" + event}-${if (forward) "forward" else "reverse"}.html")
+        val directionOpts = if (forward) Nil else List("--reverse")
+        val eventOpts = if (event == "cpu") Nil else List("--" + event)
+        val flameOpts = List("--minwidth", "0.2")
+        run.run("jfr2flame", converterJar :: Nil, eventOpts ++ flameOpts ++ directionOpts ++ List(jfrFileNameString, flameFileName), state.log).get
+      }
+      for (forward <- List(true, false)) {
+        jfr2flame(forward, "cpu")
+        jfr2flame(forward, "alloc")
+      }
+    }
+    state
+  }
+  def jfr2flameParser(name: String)(s: State): Parser[String] = {
+    import Parser._
+    token("jfr2flame" ~> OptSpace) flatMap { _ => matched(s.combinedParser)} map (_.trim)
+  }
+
   def commandImpl(profs: List[Profiler]) = (s: State, line: String) => {
     val commands: List[String] = profs.flatMap { (prof: Profiler) =>
       val outDir = file(s"target/profile-${prof.name}")
@@ -37,16 +70,30 @@ case object basic extends Profiler("basic") {
 case object jfr extends Profiler("jfr") {
   def command(outDir: File): String = s"""-jvmArgs -XX:+UnlockCommercialFeatures -prof "jfr:dir=${outDir.getAbsolutePath};stackDepth=1024;postProcessor=scala.bench.JfrToFlamegraph;verbose=true" """
 }
-sealed abstract class async(event: String) extends Profiler("async-" + event) {
-  val framebuf = 33554432
+sealed abstract class async(event: String, secondaryAlloc: Boolean = false) extends Profiler("async-" + event + (if (secondaryAlloc) "-alloc" else "")) {
+  require(event != "alloc" || !secondaryAlloc)
   def command(outDir: File): String = {
-    val r = s"""-prof "async:dir=${outDir.getAbsolutePath};libPath=${System.getenv("ASYNC_PROFILER_DIR")}/build/libasyncProfiler.so;minwidth=1;width=1800;verbose=true;event=$event;filter=${event == "wall"};flat=40;trace=10;framebuf=${framebuf};output=flamegraph,jfr,text" """
+    val opts = collection.mutable.ListBuffer[String]()
+    val doFlame = !secondaryAlloc
+    opts ++= List(s"dir=${outDir.getAbsolutePath}", s"libPath=${System.getenv("ASYNC_PROFILER_DIR")}/build/libasyncProfiler.so", "verbose=true")
+    opts += s"event=${event}"
+    if (doFlame) {
+      opts ++= List("output=flamegraph", "minwidth=1","width=1800", s"filter=${event == "wall"}")
+    }
+    if (secondaryAlloc) {
+      opts += "alloc"
+      opts += "output=jfr"
+    } else {
+      opts ++= List("flat=40", "traces=10", "output=text")
+    }
+    val r = s"""-prof "async:${opts.mkString(";")}" """
     println(r)
     r
   }
 }
 case object asyncCpu extends async("cpu")
 case object asyncAlloc extends async("alloc")
+case object asyncCpuAlloc extends async("cpu", true)
 case object asyncWall extends async("wall")
 case object perfNorm extends Profiler("perfNorm") {
   def command(outDir: File): String = "-prof perfnorm"

project/build.sbt

@@ -1,4 +1,4 @@
-val jmhV = System.getProperty("jmh.version", "1.30")  // duplicated in build.sbt
+val jmhV = System.getProperty("jmh.version", "1.31")  // duplicated in build.sbt
 
 libraryDependencies ++= List(
   "org.openjdk.jmh"     % "jmh-core"                 % jmhV,