Invoke all Enso benchmarks via JMH

engine/runtime/src/bench/java/org/enso/interpreter/bench/benchmarks/meso/VectorOperations.java

@@ -0,0 +1,58 @@
+package org.enso.interpreter.bench.benchmarks.meso;
+
+import java.io.ByteArrayOutputStream;
+import java.nio.file.Paths;
+import java.util.concurrent.TimeUnit;
+import org.enso.compiler.core.IR;
+import org.enso.compiler.core.IR$;
+import org.graalvm.polyglot.Context;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.BenchmarkParams;
+import org.openjdk.jmh.infra.Blackhole;
+
+@BenchmarkMode(Mode.AverageTime)
+@Fork(1)
+@Warmup(iterations = 3)
+@Measurement(iterations = 5)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+public class VectorOperations {
+
+  @Setup
+  public void initializeBenchmark(BenchmarkParams params) throws Exception {
+    var ctx = Context.newBuilder()
+        .allowExperimentalOptions(true)
+        .allowIO(true)
+        .allowAllAccess(true)
+        .logHandler(new ByteArrayOutputStream())
+        .option(
+            "enso.languageHomeOverride",
+            Paths.get("../../distribution/component").toFile().getAbsolutePath()
+        ).build();
+
+    String benchMeasureRedef = """
+        type Bench
+            measure : Any -> Text -> Integer -> Integer -> Nothing
+            measure ~act label iter_size num_iters =
+                ...
+        """;
+  }
+
+  private void collectBenchMeasureMethodCalls() {
+    new IR.Error.ImportExport.ModuleDoesNotExist("bla");
+  }
+
+  @Benchmark
+  public void benchmark(Blackhole blackhole) {
+
+  }
+}

engine/runtime/src/bench/resources/org.enso.interpreter.bench.benchmarks.meso/Vector_Operations.enso

@@ -0,0 +1,46 @@
+from Standard.Base import all
+import Standard.Base.Runtime.State
+import Standard.Base
+
+from Standard.Test import Bench
+
+import project.Vector.Utils
+
+polyglot java import java.util.Random as Java_Random
+
+## Bench Utilities ============================================================
+
+vector_size = 1000000
+iter_size = 100
+num_iterations = 10
+
+# The Benchmarks ==============================================================
+
+bench =
+    random_vec = Utils.make_random_vec vector_size
+    random_vec_2 = Utils.make_random_vec 100000
+    random_gen = Java_Random.new 123456
+
+    Bench.measure (Base.Vector.new vector_size i->i) "New Vector" iter_size num_iterations
+    Bench.measure (Base.Vector.new vector_size _->42) "New Constant" iter_size num_iterations
+    Bench.measure (Base.Vector.new vector_size _->random_gen.nextLong) "New Random" iter_size num_iterations
+    Bench.measure (Base.Vector.fill vector_size 42) "Fill Constant" iter_size num_iterations
+    Bench.measure (Base.Vector.fill vector_size random_gen.nextLong) "Fill Random (constant)" iter_size num_iterations
+    Bench.measure (random_vec + [1]) "Append Single" iter_size num_iterations
+    Bench.measure (random_vec + random_vec_2) "Append Large" iter_size num_iterations
+    Bench.measure (random_vec.reduce (+)) "Sum" iter_size num_iterations
+    Bench.measure ((random_vec.drop (First 20)).reduce (+)) "Drop First 20 and Sum" iter_size num_iterations
+    Bench.measure ((random_vec.drop (Last 20)).reduce (+)) "Drop Last 20 and Sum" iter_size num_iterations
+    Bench.measure (random_vec.filter (x -> x % 3 == 1)) "Filter" iter_size num_iterations
+    Bench.measure (random_vec.filter_with_index (i-> x-> (i+x) % 3 == 1)) "Filter With Index" iter_size num_iterations
+
+    Bench.measure (random_vec . map (x -> x +  random_gen.nextLong) . filter (x -> x % 3 == 1)) "Map & Filter" iter_size num_iterations
+    Bench.measure (random_vec.partition (x -> x % 3 == 1)) "Partition" iter_size num_iterations
+    Bench.measure (random_vec.partition_with_index (i-> x-> (i+x) % 3 == 1)) "Partition With Index" iter_size num_iterations
+
+    stateful_fun x =
+       s = State.get Number
+       State.put s+x
+    Bench.measure (State.run Number 0 <| random_vec.each stateful_fun) "Each" iter_size num_iterations
+
+main = bench

engine/runtime/src/bench/scala/org/enso/interpreter/bench/IRUtils.scala

@@ -0,0 +1,46 @@
+package org.enso.interpreter.bench
+
+import org.enso.compiler.core.IR
+
+object IRUtils {
+  private def collectBenchCalls(ir: IR.Module): List[BenchCall] = {
+    val methods = ir.bindings.collect { case m : IR.Module.Scope.Definition.Method => m }
+
+    for (method <- methods) {
+      method.body.preorder.flatMap(ir => {
+        ir match {
+          case application: IR.Application.Prefix =>
+            application.function match {
+              case IR.Name.Literal("measure", true, _, _, _) =>
+                application.arguments.head match {
+                  case IR.CallArgument.Specified(_, value, _, _, _) =>
+                    value match {
+                      case IR.Name.Literal("Bench", _, _, _, _) =>
+                        Some(new BenchCall(application))
+                      case _ => None
+                    }
+                }
+              case _ => None
+            }
+        }
+      })
+    }
+
+  }
+
+  private class BenchCall(
+    val call: IR.Application.Prefix
+  ) {
+    val args: List[IR.CallArgument.Specified] = call.arguments.collect { case s : IR.CallArgument.Specified => s }
+    val location: IR.IdentifiedLocation = call.location.get
+    assert(args.length == 5)
+    assert(args.head.value.asInstanceOf[IR.Name.Literal].name == "Bench")
+    val action: IR.Expression = args(1).value
+    val title: String = {
+      args(2).value match {
+        case lit: IR.Literal.Text => lit.text
+        case unexpected => throw new IllegalStateException(s"Unexpected bench title IR: ${unexpected}")
+      }
+    }
+  }
+}