Add ExportImportResolutionBenchmark (#10043)

Vast majority of CPU time in ExportsResolution is spent in [BindingsMap.SymbolRestriction.optimize](https:/enso-org/enso/blob/9a373572470ed434fb7b99114553c411ad54718e/engine/runtime-compiler/src/main/scala/org/enso/compiler/phase/ExportsResolution.scala#L173). #10369 dealt with this. This PR only adds the `ExportImportResolutionBenchmark`.

# Important Notes
- Introduce new [ExportImportResolutionBenchmark](https:/enso-org/enso/blob/9e70f675d8c6d60b74733606b1c48f52e55da7ba/engine/runtime-benchmarks/src/main/java/org/enso/compiler/benchmarks/exportimport/ExportImportResolutionBenchmark.java) that measures the performance of import and export resolution only.
- Note that the already existing [ImportStandardLibrariesBenchmark](https:/enso-org/enso/blob/4d49b003752e8771e95d5ae379ce953c85ef020c/engine/runtime-benchmarks/src/main/java/org/enso/compiler/benchmarks/module/ImportStandardLibrariesBenchmark.java) is probably fine for the purpose, but I just wanted to be sure that **ONLY** the import/export resolution is measured and nothing else, so I have isolated that into a new benchmark.

build.sbt

@@ -2198,6 +2198,7 @@ lazy val `runtime-benchmarks` =
  )
  .dependsOn(`runtime-fat-jar`)
  .dependsOn(`benchmarks-common`)
+ .dependsOn(`test-utils`)
 
 lazy val `runtime-parser` =
  (project in file("engine/runtime-parser"))

docs/infrastructure/sbt.md

@@ -16,7 +16,6 @@ compilation. The build configuration is defined in
 <!-- MarkdownTOC levels="2,3" autolink="true" -->
 
 - [Incremental Compilation](#incremental-compilation)
-- [Bootstrapping](#bootstrapping)
 - [Compile Hooks](#compile-hooks)
 - [Helper Tasks](#helper-tasks)
  - [Graal and Flatc Version Check](#graal-and-flatc-version-check)

engine/runtime-benchmarks/src/main/java/org/enso/compiler/benchmarks/exportimport/ExportImportResolutionBenchmark.java

@@ -0,0 +1,152 @@
+package org.enso.compiler.benchmarks.exportimport;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import org.enso.common.CompilationStage;
+import org.enso.compiler.benchmarks.Utils;
+import org.enso.compiler.context.CompilerContext;
+import org.enso.compiler.phase.ImportResolver;
+import org.enso.compiler.phase.exports.ExportCycleException;
+import org.enso.compiler.phase.exports.ExportsResolution;
+import org.enso.interpreter.runtime.Module;
+import org.enso.pkg.QualifiedName;
+import org.enso.polyglot.RuntimeOptions;
+import org.enso.test.utils.ContextUtils;
+import org.enso.test.utils.ProjectUtils;
+import org.enso.test.utils.SourceModule;
+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.TearDown;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.BenchmarkParams;
+import org.openjdk.jmh.infra.Blackhole;
+import scala.jdk.javaapi.CollectionConverters;
+
+/**
+ * Benchmarks that measure performance of only {@link ImportResolver} and {@link ExportsResolution}.
+ */
+@BenchmarkMode(Mode.AverageTime)
+@Fork(1)
+@Warmup(iterations = 6)
+@Measurement(iterations = 4)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+public class ExportImportResolutionBenchmark {
+ private Path projDir;
+ private OutputStream out;
+ private Context ctx;
+ private ImportResolver importResolver;
+ private ExportsResolution exportsResolution;
+ private CompilerContext.Module mainModule;
+ private scala.collection.immutable.List<CompilerContext.Module> modulesToExportResolution;
+ private scala.collection.immutable.List<CompilerContext.Module> resolvedModules;
+
+ @Setup
+ public void setup(BenchmarkParams params) throws IOException {
+ this.out = new ByteArrayOutputStream();
+ var mainMod =
+ new SourceModule(
+ QualifiedName.fromString("Main"),
+ """
+ from Standard.Base import all
+ """);
+ this.projDir = Files.createTempDirectory("export-import-resolution-benchmark");
+ ProjectUtils.createProject("Proj", Set.of(mainMod), projDir);
+ // Create temp proj dir
+ this.ctx =
+ Utils.createDefaultContextBuilder()
+ .option(RuntimeOptions.PROJECT_ROOT, projDir.toAbsolutePath().toString())
+ .out(out)
+ .err(out)
+ .build();
+ var ensoCtx = ContextUtils.leakContext(ctx);
+ this.mainModule = ensoCtx.getPackageRepository().getLoadedModule("local.Proj.Main").get();
+ var mainRuntimeMod = Module.fromCompilerModule(mainModule);
+ assertThat(
+ "main module should not yet be compiled",
+ mainRuntimeMod.getCompilationStage().equals(CompilationStage.INITIAL));
+ this.importResolver = new ImportResolver(ensoCtx.getCompiler());
+ this.exportsResolution = new ExportsResolution(ensoCtx.getCompiler().context());
+ }
+
+ @TearDown
+ public void teardown(BenchmarkParams params) throws IOException {
+ if (!out.toString().isEmpty()) {
+ throw new AssertionError("Unexpected output (errors?) from the compiler: " + out.toString());
+ }
+ ProjectUtils.deleteRecursively(projDir);
+ ctx.close();
+
+ // It is expected that there are more than 20 modules in Standard.Base, and all of them
+ // should have been processed. Note that 20 is just a magic constant for sanity check.
+ assertThat(modulesToExportResolution.size() > 20);
+ var mods = CollectionConverters.asJava(modulesToExportResolution);
+ for (var mod : mods) {
+ var isImportResolved =
+ mod.getCompilationStage().isAtLeast(CompilationStage.AFTER_IMPORT_RESOLUTION);
+ assertThat(
+ "Module '" + mod.getName() + "' is not resolved after import resolution",
+ isImportResolved);
+ }
+
+ var benchName = params.getBenchmark();
+ if (benchName.contains("runImportExportResolution")) {
+ assertThat(resolvedModules.size() > 20);
+ for (var mod : CollectionConverters.asJava(resolvedModules)) {
+ var isExportResolved =
+ mod.getCompilationStage().isAtLeast(CompilationStage.AFTER_IMPORT_RESOLUTION);
+ assertThat(
+ "Module '" + mod.getName() + "' is not resolved after export resolution",
+ isExportResolved);
+ }
+ }
+ }
+
+ @Benchmark
+ public void importsResolution(Blackhole blackhole) {
+ var res = importResolver.mapImports(mainModule, false);
+ modulesToExportResolution = res._1;
+ blackhole.consume(res);
+ }
+
+ /**
+ * {@link ExportsResolution export resolver} needs to be run after the imports resolution, so in
+ * this benchmark, we run both import resolution and export resolution. In the other benchmark,
+ * only import resolution is run.
+ */
+ @Benchmark
+ public void importsAndExportsResolution(Blackhole blackhole) throws ExportCycleException {
+ var res = importResolver.mapImports(mainModule, false);
+ modulesToExportResolution = res._1;
+ resolvedModules = exportsResolution.run(modulesToExportResolution);
+ blackhole.consume(resolvedModules);
+ }
+
+ /**
+ * These utility methods are used because simple {@code assert} statement might not work -
+ * benchmarks are usually run without assertions enabled. This just makes sure that the given
+ * condition is checked and not ignored.
+ */
+ private static void assertThat(boolean condition) {
+ assertThat("", condition);
+ }
+
+ private static void assertThat(String msg, boolean condition) {
+ if (!condition) {
+ throw new AssertionError(msg);
+ }
+ }
+}