Invoke all Enso benchmarks via JMH

build.sbt

@@ -1769,6 +1769,120 @@ lazy val `distribution-manager` = project
   .dependsOn(pkg)
   .dependsOn(`logging-utils`)
 
+lazy val `bench-processor` = (project in file("lib/scala/bench-processor"))
+  .settings(
+    frgaalJavaCompilerSetting,
+    libraryDependencies ++= Seq(
+      "jakarta.xml.bind"    % "jakarta.xml.bind-api"     % jaxbVersion,
+      "com.sun.xml.bind"    % "jaxb-impl"                % jaxbVersion,
+      "org.openjdk.jmh"     % "jmh-core"                 % jmhVersion                % "provided",
+      "org.openjdk.jmh"     % "jmh-generator-annprocess" % jmhVersion                % "provided",
+      "org.netbeans.api"    % "org-openide-util-lookup"  % netbeansApiVersion        % "provided",
+      "org.graalvm.sdk"     % "graal-sdk"                % graalMavenPackagesVersion % "provided",
+      "junit"               % "junit"                    % junitVersion              % Test,
+      "com.github.sbt"      % "junit-interface"          % junitIfVersion            % Test,
+      "org.graalvm.truffle" % "truffle-api"              % graalMavenPackagesVersion % Test
+    ),
+    Compile / javacOptions := ((Compile / javacOptions).value ++
+    // Only run ServiceProvider processor and ignore those defined in META-INF, thus
+    // fixing incremental compilation setup
+    Seq(
+      "-processor",
+      "org.netbeans.modules.openide.util.ServiceProviderProcessor"
+    )),
+    commands += WithDebugCommand.withDebug,
+    (Test / fork) := true,
+    (Test / parallelExecution) := false,
+    (Test / javaOptions) ++= {
+      val runtimeJars =
+        (LocalProject("runtime") / Compile / fullClasspath).value
+      val jarsStr = runtimeJars.map(_.data).mkString(File.pathSeparator)
+      Seq(
+        s"-Dtruffle.class.path.append=${jarsStr}"
+      )
+    }
+  )
+  .dependsOn(`polyglot-api`)
+  .dependsOn(runtime)
+
+lazy val `std-benchmarks` = (project in file("std-bits/benchmarks"))
+  .settings(
+    frgaalJavaCompilerSetting,
+    libraryDependencies ++= jmh ++ Seq(
+      "org.openjdk.jmh"     % "jmh-core"                 % jmhVersion                % Benchmark,
+      "org.openjdk.jmh"     % "jmh-generator-annprocess" % jmhVersion                % Benchmark,
+      "org.graalvm.sdk"     % "graal-sdk"                % graalMavenPackagesVersion % "provided",
+      "org.graalvm.truffle" % "truffle-api"              % graalMavenPackagesVersion % Benchmark
+    ),
+    commands += WithDebugCommand.withDebug,
+    (Compile / logManager) :=
+      sbt.internal.util.CustomLogManager.excludeMsg(
+        "Could not determine source for class ",
+        Level.Warn
+      )
+  )
+  .configs(Benchmark)
+  .settings(
+    inConfig(Benchmark)(Defaults.testSettings)
+  )
+  .settings(
+    (Benchmark / parallelExecution) := false,
+    (Benchmark / run / fork) := true,
+    (Benchmark / run / connectInput) := true,
+    // Pass -Dtruffle.class.path.append to javac
+    (Benchmark / compile / javacOptions) ++= {
+      val runtimeClasspath =
+        (LocalProject("runtime") / Compile / fullClasspath).value
+      val runtimeInstrumentsClasspath =
+        (LocalProject(
+          "runtime-with-instruments"
+        ) / Compile / fullClasspath).value
+      val appendClasspath =
+        (runtimeClasspath ++ runtimeInstrumentsClasspath)
+          .map(_.data)
+          .mkString(File.pathSeparator)
+      Seq(
+        FrgaalJavaCompiler.noLimitModulesArg,
+        s"-J-Dtruffle.class.path.append=$appendClasspath"
+      )
+    },
+    (Benchmark / compile / javacOptions) ++= Seq(
+      "-s",
+      (Benchmark / sourceManaged).value.getAbsolutePath,
+      "-Xlint:unchecked"
+    ),
+    (Benchmark / run / javaOptions) ++= {
+      val runtimeClasspath =
+        (LocalProject("runtime") / Compile / fullClasspath).value
+      val runtimeInstrumentsClasspath =
+        (LocalProject(
+          "runtime-with-instruments"
+        ) / Compile / fullClasspath).value
+      val appendClasspath =
+        (runtimeClasspath ++ runtimeInstrumentsClasspath)
+          .map(_.data)
+          .mkString(File.pathSeparator)
+      Seq(
+        s"-Dtruffle.class.path.append=$appendClasspath"
+      )
+    }
+  )
+  .settings(
+    bench := (Benchmark / run).toTask("").tag(Exclusive).value,
+    benchOnly := Def.inputTaskDyn {
+      import complete.Parsers.spaceDelimited
+      val name = spaceDelimited("<name>").parsed match {
+        case List(name) => name
+        case _          => throw new IllegalArgumentException("Expected one argument.")
+      }
+      Def.task {
+        (Benchmark / run).toTask(" " + name).value
+      }
+    }.evaluated
+  )
+  .dependsOn(`bench-processor` % Benchmark)
+  .dependsOn(runtime % Benchmark)
+
 lazy val editions = project
   .in(file("lib/scala/editions"))
   .configs(Test)

docs/CONTRIBUTING.md

@@ -387,6 +387,7 @@ the following flags:
   allow for manual analysis and discovery of optimisation failures.
 - `--showCompilations`: Prints the truffle compilation trace information.
 - `--printAssembly`: Prints the assembly output from the HotSpot JIT tier.
+- `--debugger`: Launches the JVM with the remote debugger enabled.
 
 For more information on this sbt command, please see
 [WithDebugCommand.scala](../project/WithDebugCommand.scala).
@@ -756,7 +757,8 @@ interface of the runner prints all server options when you execute it with
 Below are options uses by the Language Server:
 
 - `--server`: Runs the Language Server
-- `--root-id <uuid>`: Content root id.
+- `--root-id <uuid>`: Content root id. The Language Server chooses one randomly,
+  so can pass any valid UUID.
 - `--path <path>`: Path to the content root.
 - `--interface <interface>`: Interface for processing all incoming connections.
   Default value is 127.0.0.1

docs/debugger/README.md

@@ -8,96 +8,14 @@ order: 0
 
 # Enso Debugger
 
-The Enso Debugger allows amongst other things, to execute arbitrary expressions
-in a given execution context - this is used to implement a debugging REPL. The
-REPL can be launched when triggering a breakpoint in the code.
-
-This folder contains all documentation pertaining to the REPL and the debugger,
-which is broken up as follows:
-
-- [**The Enso Debugger Protocol:**](./protocol.md) The protocol for the Debugger
-
-# Chrome Developer Tools Debugger
-
-As a well written citizen of the [GraalVM](http://graalvm.org) project the Enso
-language can be used with existing tools available for the overall platform. One
-of them is
-[Chrome Debugger](https://www.graalvm.org/22.1/tools/chrome-debugger/) and Enso
-language is fully integrated with it. Launch the `bin/enso` executable with
-additional `--inspect` option and debug your Enso programs in _Chrome Developer
-Tools_.
-
-```bash
-enso$ ./built-distribution/enso-engine-*/enso-*/bin/enso --inspect --run ./test/Tests/src/Data/Numbers_Spec.enso
-Debugger listening on ws://127.0.0.1:9229/Wugyrg9
-For help, see: https://www.graalvm.org/tools/chrome-debugger
-E.g. in Chrome open: devtools://devtools/bundled/js_app.html?ws=127.0.0.1:9229/Wugyrg9
-```
-
-copy the printed URL into chrome browser and you should see:
-
-![Chrome Debugger](https://user-images.githubusercontent.com/26887752/209614265-684f530e-cf7e-45d5-9450-7ea1e4f65986.png)
-
-Step in, step over, set breakpoints, watch values of the variables as well as
-evaluate arbitrary expressions in the console. Note that as of December 2022,
-with GraalVM 22.3.0, there is a well-known
-[bug in Truffle](https://github.com/oracle/graal/issues/5513) that causes
-`NullPointerException` when a host object gets into the chrome inspector. There
-is a workaround for that, but it may not work in certain situations. Therefore,
-if you encounter `NullPointerException` thrown from
-
-```
-at org.graalvm.truffle/com.oracle.truffle.polyglot.PolyglotContextImpl.getContext(PolyglotContextImpl.java:685)
-```
-
-simply ignore it. It will be handled within the debugger and should not affect
-the rest of the environment.
-
-# Debugging Enso and Java Code at Once
-
-Enso libraries are written in a mixture of Enso code and Java libraries.
-Debugging both sides (the Java as well as Enso code) is possible with a decent
-IDE.
-
-Get [NetBeans](http://netbeans.apache.org) version 13 or newer or
-[VS Code with Apache Language Server extension](https://cwiki.apache.org/confluence/display/NETBEANS/Apache+NetBeans+Extension+for+Visual+Studio+Code)
-and _start listening on port 5005_ with _Debug/Attach Debugger_ or by specifying
-following debug configuration in VSCode:
-
-```json
-{
-  "name": "Listen to 5005",
-  "type": "java+",
-  "request": "attach",
-  "listen": "true",
-  "hostName": "localhost",
-  "port": "5005"
-}
-```
-
-Then it is just about executing following Sbt command which builds CLI version
-of the engine, launches it in debug mode and passes all other arguments to the
-started process:
-
-```bash
-sbt:enso> runEngineDistribution --debug --run ./test/Tests/src/Data/Numbers_Spec.enso
-```
-
-Alternatively you can pass in special JVM arguments when launching the
-`bin/enso` launcher:
-
-```bash
-enso$ JAVA_OPTS=-agentlib:jdwp=transport=dt_socket,server=n,address=5005 ./built-distribution/enso-engine-*/enso-*/bin/enso --run ./test/Tests/src/Data/Numbers_Spec.enso
-```
-
-As soon as the debuggee connects and the Enso language starts - choose the
-_Toggle Pause in GraalVM Script_ button in the toolbar:
-
-![NetBeans Debugger](https://user-images.githubusercontent.com/26887752/209614191-b0513635-819b-4c64-a6f9-9823b90a1513.png)
-
-and your execution shall stop on the next `.enso` line of code. This mode allows
-to debug both - the Enso code as well as Java code. The stack traces shows a
-mixture of Java and Enso stack frames by default. Right-clicking on the thread
-allows one to switch to plain Java view (with a way more stack frames) and back.
-Analyzing low level details as well as Enso developer point of view shall be
-simple with such tool.
+This folder contains all documentation pertaining to the debugging facilities
+used by Enso, broken up as follows:
+
+- [**The Enso Debugger Protocol:**](./protocol.md) The protocol for the REPL
+  Debugger.
+- [**Chrome devtools debugger:**](./chrome-devtools.md) A guide how to debug
+  Enso code using Chrome devtools.
+- [**Debugging Enso and Java code at once:**](./mixed-debugging.md) A
+  step-by-step guide how to debug both Enso and Java code in a single debugger.
+- [**Debugging Engine (Runtime) only Java code:**](./runtime-debugging.md) A
+  guide how to debug the internal Engine Java code.

docs/debugger/chrome-devtools.md

@@ -0,0 +1,41 @@
+# Chrome Developer Tools Debugger
+
+As a well written citizen of the [GraalVM](http://graalvm.org) project the Enso
+language can be used with existing tools available for the overall platform. One
+of them is
+[Chrome Debugger](https://www.graalvm.org/22.1/tools/chrome-debugger/) and Enso
+language is fully integrated with it. Launch the `bin/enso` executable with
+additional `--inspect` option and debug your Enso programs in _Chrome Developer
+Tools_.
+
+```bash
+enso$ ./built-distribution/enso-engine-*/enso-*/bin/enso --inspect --run ./test/Tests/src/Data/Numbers_Spec.enso
+Debugger listening on ws://127.0.0.1:9229/Wugyrg9
+For help, see: https://www.graalvm.org/tools/chrome-debugger
+E.g. in Chrome open: devtools://devtools/bundled/js_app.html?ws=127.0.0.1:9229/Wugyrg9
+```
+
+copy the printed URL into chrome browser and you should see:
+
+![Chrome Debugger](https://user-images.githubusercontent.com/26887752/209614265-684f530e-cf7e-45d5-9450-7ea1e4f65986.png)
+
+Step in, step over, set breakpoints, watch values of the variables as well as
+evaluate arbitrary expressions in the console. Note that as of December 2022,
+with GraalVM 22.3.0, there is a well-known
+[bug in Truffle](https://github.com/oracle/graal/issues/5513) that causes
+`NullPointerException` when a host object gets into the chrome inspector. There
+is a workaround for that, but it may not work in certain situations. Therefore,
+if you encounter `NullPointerException` thrown from
+
+```
+at org.graalvm.truffle/com.oracle.truffle.polyglot.PolyglotContextImpl.getContext(PolyglotContextImpl.java:685)
+```
+
+simply ignore it. It will be handled within the debugger and should not affect
+the rest of the environment.
+
+## Tips and tricks
+
+- Use `env JAVA_OPTS=-Dpolyglot.inspect.Path=enso_debug` to set the chrome to
+  use a fixed URL. In this case the URL is
+  `devtools://devtools/bundled/js_app.html?ws=127.0.0.1:9229/enso_debug`

docs/debugger/mixed-debugging.md

@@ -0,0 +1,48 @@
+# Debugging Enso and Java Code at Once
+
+Enso libraries are written in a mixture of Enso code and Java libraries.
+Debugging both sides (the Java as well as Enso code) is possible with a decent
+IDE.
+
+Get [NetBeans](http://netbeans.apache.org) version 13 or newer or
+[VS Code with Apache Language Server extension](https://cwiki.apache.org/confluence/display/NETBEANS/Apache+NetBeans+Extension+for+Visual+Studio+Code)
+and _start listening on port 5005_ with _Debug/Attach Debugger_ or by specifying
+following debug configuration in VSCode:
+
+```json
+{
+  "name": "Listen to 5005",
+  "type": "java+",
+  "request": "attach",
+  "listen": "true",
+  "hostName": "localhost",
+  "port": "5005"
+}
+```
+
+Then it is just about executing following Sbt command which builds CLI version
+of the engine, launches it in debug mode and passes all other arguments to the
+started process:
+
+```bash
+sbt:enso> runEngineDistribution --debug --run ./test/Tests/src/Data/Numbers_Spec.enso
+```
+
+Alternatively you can pass in special JVM arguments when launching the
+`bin/enso` launcher:
+
+```bash
+enso$ JAVA_OPTS=-agentlib:jdwp=transport=dt_socket,server=n,address=5005 ./built-distribution/enso-engine-*/enso-*/bin/enso --run ./test/Tests/src/Data/Numbers_Spec.enso
+```
+
+As soon as the debuggee connects and the Enso language starts - choose the
+_Toggle Pause in GraalVM Script_ button in the toolbar:
+
+![NetBeans Debugger](https://user-images.githubusercontent.com/26887752/209614191-b0513635-819b-4c64-a6f9-9823b90a1513.png)
+
+and your execution shall stop on the next `.enso` line of code. This mode allows
+to debug both - the Enso code as well as Java code. The stack traces shows a
+mixture of Java and Enso stack frames by default. Right-clicking on the thread
+allows one to switch to plain Java view (with a way more stack frames) and back.
+Analyzing low level details as well as Enso developer point of view shall be
+simple with such tool.