Add AnnotationsMappingBenchmark

Author: mbovel

bench-micro/scripts/compare.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+
+name=$1
+commit_1=$2
+commit_2=$3
+runs=2
+
+if [ -z "$name" ] || [ -z "$commit_1" ] || [ -z "$commit_2" ]; then
+    echo "Usage: $0 <benchmark-name> <commit-1> <commit-2>"
+    exit 1
+fi
+
+run_benchmark() {
+    jvm=$1
+    jvm_coursier_id=$2
+    run=$3
+    hash=$4
+    json_file=../../results/$hash-$name-$jvm-$run.json
+    txt_file=../../results/$hash-$name-$jvm-$run.txt
+    echo "Running $name benchmark with JVM $jvm at commit $hash, run $run out of $runs"
+    git checkout $hash
+    git clean -fdx
+    eval "$(coursier java --jvm "$jvm_coursier_id" --env)"
+    rm -rf "$json_file" "$stdout_file" .bloop .sbt .bsp .metals target
+    sbt "clean; scala3-bench-micro / Jmh / run -rf JSON -rff $json_file -o $txt_file $name"
+}
+
+read -p "WARNING: This script will brutally reset your Dotty repo (git clean -fdx). Type 'y' to continue." -n 1 -r
+echo    # new line
+if [[ ! $REPLY =~ ^[Yy]$ ]]; then exit 1; fi
+
+read -p "This script should be run form the Dotty root repository. Type 'y' to continue." -n 1 -r
+echo    # new line
+if [[ ! $REPLY =~ ^[Yy]$ ]]; then exit 1; fi
+
+read -p "This script will create an empty directory <dotty>/../results to store results. Type 'y' to continue." -n 1 -r
+echo    # new line
+if [[ ! $REPLY =~ ^[Yy]$ ]]; then exit 1; fi
+
+mkdir ../results
+
+for run in $(seq 1 $runs); do
+    for hash in $commit_1 $commit_2; do
+        run_benchmark openjdk "adoptium:1.17.0.11" $run $hash
+        run_benchmark graal "graalvm-java17:22.3.3" $run $hash
+    done
+done

bench-micro/src/main/scala/dotty/tools/benchmarks/AnnotationsMappingBenchmark.scala

@@ -0,0 +1,74 @@
+package dotty.tools.benchmarks
+
+import org.openjdk.jmh.annotations.{Benchmark, BenchmarkMode, Fork, Level, Measurement, Mode as JMHMode, Param, Scope, Setup, State, Warmup}
+import java.util.concurrent.TimeUnit.SECONDS
+
+import dotty.tools.dotc.{Driver, Run, Compiler}
+import dotty.tools.dotc.ast.{tpd, TreeTypeMap}, tpd.{Apply, Block, Tree, TreeAccumulator, TypeApply}
+import dotty.tools.dotc.core.Annotations.{Annotation, ConcreteAnnotation, EmptyAnnotation}
+import dotty.tools.dotc.core.Contexts.{ContextBase, Context, ctx, withMode}
+import dotty.tools.dotc.core.Mode
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.core.Symbols.{defn, mapSymbols, Symbol}
+import dotty.tools.dotc.core.Types.{AnnotatedType, NoType, SkolemType, TermRef, Type, TypeMap}
+import dotty.tools.dotc.parsing.Parser
+import dotty.tools.dotc.typer.TyperPhase
+
+/** Benchmark to compare different ways to map concrete annotations.
+  *
+  * The main performance bottleneck there is the mapping of the annotation's
+  * inner tree of; a `TreeTypeMap` is much slower than a `TypeMap`.
+  *
+  * Run with: scala3-bench-micro / Jmh / run AnnotationsMappingBenchmark
+  */
+@Fork(value = 4)
+@Warmup(iterations = 4, time = 1, timeUnit = SECONDS)
+@Measurement(iterations = 4, time = 1, timeUnit = SECONDS)
+@BenchmarkMode(Array(JMHMode.Throughput))
+@State(Scope.Thread)
+class AnnotationsMappingBenchmark:
+  var tp: Type = null
+  var specialIntTp: Type = null
+  var context: Context = null
+  var typeFunction: Context ?=> Type => Type = null
+  var typeMap: TypeMap = null
+
+  @Param(Array("v1", "v2", "v3", "v4"))
+  var valName: String = null
+
+  @Param(Array("id", "mapInts"))
+  var typeFunctionName: String = null
+
+  @Setup(Level.Iteration)
+  def setup(): Unit =
+    val testPhase =
+      new Phase:
+        final override def phaseName = "testPhase"
+        final override def run(using ctx: Context): Unit =
+          val pkg = ctx.compilationUnit.tpdTree.symbol
+          tp = pkg.requiredClass("Test").requiredValueRef(valName).underlying
+          specialIntTp = pkg.requiredClass("Test").requiredType("SpecialInt").typeRef
+          context = ctx
+
+    val compiler =
+      new Compiler:
+        private final val baseCompiler = new Compiler()
+        final override def phases = List(List(Parser()), List(TyperPhase()), List(testPhase))
+
+    val driver =
+      new Driver:
+        final override def newCompiler(using Context): Compiler = compiler
+
+    driver.process(Array("-classpath", System.getProperty("BENCH_CLASS_PATH"), "tests/someAnnotatedTypes.scala"))
+
+    typeFunction =
+      typeFunctionName match
+        case "id"      => tp => tp
+        case "mapInts" => tp => (if tp frozen_=:= defn.IntType then specialIntTp else tp)
+        case _         => throw new IllegalArgumentException(s"Unknown type function: $typeFunctionName")
+
+    typeMap =
+      new TypeMap(using context):
+        final override def apply(tp: Type): Type = typeFunction(mapOver(tp))
+
+  @Benchmark def applyTypeMap() = typeMap.apply(tp)

bench-micro/tests/someAnnotatedTypes.scala

@@ -0,0 +1,28 @@
+class Test:
+  class FlagAnnot extends annotation.StaticAnnotation
+  class StringAnnot(val s: String) extends annotation.StaticAnnotation
+  class LambdaAnnot(val f: Int => Boolean) extends annotation.StaticAnnotation
+
+  type SpecialInt <: Int
+
+  val v1: Int @FlagAnnot = 42
+
+  val v2: Int @StringAnnot("hello") = 42
+
+  val v3: Int @LambdaAnnot(it => it == 42) = 42
+
+  val v4: Int @LambdaAnnot(it => {
+    def g(x: Int, y: Int) = x - y + 5
+    g(it, 7) * 2 == 80
+  }) = 42
+
+  /*val v5: Int @LambdaAnnot(it => {
+    class Foo(x: Int):
+      def xPlus10 = x + 10
+      def xPlus20 = x + 20
+      def xPlus(y: Int) = x + y
+    val foo = Foo(it)
+    foo.xPlus10 - foo.xPlus20 + foo.xPlus(30) == 62
+  }) = 42*/
+
+  def main(args: Array[String]): Unit = ???