Add ExportImportResolutionBenchmark

build.sbt

@@ -2195,6 +2195,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);
+ }
+ }
+}