Implement threaded-switch for the bytecode DSL; Add more bytecode interpreter benchmarks for threaded-switch.

Author: chumer

truffle/CHANGELOG.md

@@ -24,6 +24,7 @@ This changelog summarizes major changes between Truffle versions relevant to lan
 * GR-8251: `DebuggerSession.resumeThread(Thread)` no longer cancels ongoing step operations. Stepping is now independent of other debugger actions to enhance flexibility.
 * GR-61293: Bytecode DSL: Specialization state is now inlined into the bytecode array, which reduces memory footprint and interpreter execution time.
 * GR-68993: Added `HostCompilerDirectives.markThreadedSwitch(int)` to mark a switch statement within a loop as a candidate for threaded switch optimization.
+* GR-68993: Bytecode DSL: All bytecode interpreters are now using the threaded switch optimization by default. This new optimization can be configured using `@GenerateBytecode(enableThreadedSwitch=true|false)`.
 
 ## Version 25.0
 * GR-31495 Added ability to specify language and instrument specific options using `Source.Builder.option(String, String)`. Languages may describe available source options by implementing `TruffleLanguage.getSourceOptionDescriptors()` and `TruffleInstrument.getSourceOptionDescriptors()` respectively.

truffle/src/com.oracle.truffle.api.bytecode/snapshot.sigtest

@@ -315,6 +315,7 @@ meth public abstract !hasdefault boolean enableRootTagging()
 meth public abstract !hasdefault boolean enableSerialization()
 meth public abstract !hasdefault boolean enableSpecializationIntrospection()
 meth public abstract !hasdefault boolean enableTagInstrumentation()
+meth public abstract !hasdefault boolean enableThreadedSwitch()
 meth public abstract !hasdefault boolean enableUncachedInterpreter()
 meth public abstract !hasdefault boolean enableYield()
 meth public abstract !hasdefault boolean storeBytecodeIndexInFrame()

truffle/src/com.oracle.truffle.api.bytecode/src/com/oracle/truffle/api/bytecode/GenerateBytecode.java

@@ -46,6 +46,7 @@
 import java.lang.annotation.Target;
 
 import com.oracle.truffle.api.CompilerAsserts;
+import com.oracle.truffle.api.HostCompilerDirectives;
 import com.oracle.truffle.api.TruffleLanguage;
 import com.oracle.truffle.api.bytecode.debug.BytecodeDebugListener;
 import com.oracle.truffle.api.frame.Frame;
@@ -542,4 +543,23 @@
      */
     boolean additionalAssertions() default false;
 
+    /**
+     * Enables the use of the {@link HostCompilerDirectives#markThreadedSwitch(int) threaded switch}
+     * for the generated bytecode switch.
+     * <p>
+     * The threaded-switch mechanism reduces dispatch overhead for large or frequently executed
+     * bytecode switches, improving interpreter performance. Disabling it forces a traditional
+     * (non-threaded) switch implementation, which can be useful for benchmarking or debugging but
+     * is generally slower.
+     * <p>
+     * This option is enabled by default. It is not recommended to disable the threaded switch in
+     * production, as doing so may significantly reduce performance without improving stability. On
+     * JVMs that do not support {@link HostCompilerDirectives#markThreadedSwitch(int)} this flag has
+     * no effect.
+     *
+     * @see HostCompilerDirectives#markThreadedSwitch(int)
+     * @since 26.0
+     */
+    boolean enableThreadedSwitch() default true;
+
 }

truffle/src/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/bytecode/generator/BytecodeRootNodeElement.java

@@ -14511,7 +14511,17 @@ private List<CodeExecutableElement> createContinueAt() {
             }
 
             b.startTryBlock();
-            b.startSwitch().tree(op).end().startBlock();
+            b.startSwitch();
+
+            if (model.enableThreadedSwitch) {
+                b.startStaticCall(types.HostCompilerDirectives, "markThreadedSwitch");
+            }
+            b.tree(op);
+            if (model.enableThreadedSwitch) {
+                b.end();
+            }
+
+            b.end().startBlock();
 
             List<InstructionModel> topLevelInstructions = instructionPartitions.get(0);
             Map<Boolean, List<InstructionModel>> groupedInstructions = topLevelInstructions.stream().collect(deterministicGroupingBy((i) -> isForceCached(tier, i)));

truffle/src/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/bytecode/model/BytecodeDSLModel.java

@@ -130,6 +130,7 @@ public BytecodeDSLModel(ProcessorContext context, TypeElement templateType, Anno
     public boolean enableRootTagging;
     public boolean enableRootBodyTagging;
     public boolean enableBlockScoping;
+    public boolean enableThreadedSwitch;
     public String defaultLocalValue;
     public DSLExpression defaultLocalValueExpression;
     public String variadicStackLimit;

truffle/src/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/bytecode/parser/BytecodeDSLParser.java

@@ -248,6 +248,7 @@ private void parseBytecodeDSLModel(TypeElement typeElement, BytecodeDSLModel mod
         model.bytecodeDebugListener = (!enableBytecodeDebugListener || types.BytecodeDebugListener == null) ? false : ElementUtils.isAssignable(typeElement.asType(), types.BytecodeDebugListener);
         model.additionalAssertions = TruffleProcessorOptions.additionalAssertions(processingEnv) ||
                         ElementUtils.getAnnotationValue(Boolean.class, generateBytecodeMirror, "additionalAssertions", true);
+        model.enableThreadedSwitch = ElementUtils.getAnnotationValue(Boolean.class, generateBytecodeMirror, "enableThreadedSwitch");
 
         BytecodeDSLBuiltins.addBuiltins(model, types, context);
 

truffle/src/org.graalvm.truffle.benchmark/src/org/graalvm/truffle/benchmark/bytecode_dsl/BytecodeDSLBenchmarkRootNode.java

@@ -52,10 +52,16 @@
 import com.oracle.truffle.api.nodes.RootNode;
 
 @GenerateBytecodeTestVariants({
-                @Variant(suffix = "NoOpts", configuration = @GenerateBytecode(languageClass = BenchmarkLanguage.class, enableTagInstrumentation = true, enableYield = true)),
-                @Variant(suffix = "Uncached", configuration = @GenerateBytecode(languageClass = BenchmarkLanguage.class, enableTagInstrumentation = true, enableYield = true, enableUncachedInterpreter = true)),
-                @Variant(suffix = "AllOpts", configuration = @GenerateBytecode(languageClass = BenchmarkLanguage.class, enableTagInstrumentation = true, enableYield = true, enableUncachedInterpreter = true, boxingEliminationTypes = {
-                                int.class, boolean.class}))
+                @Variant(suffix = "NoOpts", configuration = @GenerateBytecode(languageClass = BenchmarkLanguage.class, //
+                                enableThreadedSwitch = false, enableTagInstrumentation = true, enableYield = true)),
+                @Variant(suffix = "Uncached", configuration = @GenerateBytecode(languageClass = BenchmarkLanguage.class, //
+                                enableThreadedSwitch = true, enableTagInstrumentation = true, enableYield = true, enableUncachedInterpreter = true)),
+                @Variant(suffix = "AllOpts", configuration = @GenerateBytecode(languageClass = BenchmarkLanguage.class, //
+                                enableThreadedSwitch = false, enableTagInstrumentation = true, enableYield = true, enableUncachedInterpreter = true, boxingEliminationTypes = {
+                                                int.class, boolean.class})),
+                @Variant(suffix = "ThreadedAllOpts", configuration = @GenerateBytecode(languageClass = BenchmarkLanguage.class, //
+                                enableThreadedSwitch = true, enableTagInstrumentation = true, enableYield = true, enableUncachedInterpreter = true, boxingEliminationTypes = {
+                                                int.class, boolean.class}))
 })
 public abstract class BytecodeDSLBenchmarkRootNode extends RootNode implements BytecodeRootNode {
 

truffle/src/org.graalvm.truffle.benchmark/src/org/graalvm/truffle/benchmark/bytecode_dsl/SimpleBytecodeBenchmark.java

@@ -47,6 +47,7 @@
 import org.graalvm.truffle.benchmark.bytecode_dsl.manual.Builder;
 import org.graalvm.truffle.benchmark.bytecode_dsl.manual.BytecodeInterpreterAllOpts;
 import org.graalvm.truffle.benchmark.bytecode_dsl.manual.BytecodeInterpreterNoOpts;
+import org.graalvm.truffle.benchmark.bytecode_dsl.manual.BytecodeInterpreterThreadedAllOpts;
 import org.graalvm.truffle.benchmark.bytecode_dsl.specs.BenchmarkSpec;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.Level;
@@ -88,6 +89,7 @@ public void setup(BenchmarkParams params) {
         callTarget = switch (benchMethod) {
             case "bytecodeDSLNoOpts" -> createBytecodeDSLNodes(BytecodeDSLBenchmarkRootNodeNoOpts.class, null, benchmarkSpec::parseBytecodeDSL).getNodes().getLast().getCallTarget();
             case "bytecodeDSLAllOpts" -> createBytecodeDSLNodes(BytecodeDSLBenchmarkRootNodeAllOpts.class, null, benchmarkSpec::parseBytecodeDSL).getNodes().getLast().getCallTarget();
+            case "bytecodeDSLThreadedAllOpts" -> createBytecodeDSLNodes(BytecodeDSLBenchmarkRootNodeThreadedAllOpts.class, null, benchmarkSpec::parseBytecodeDSL).getNodes().getLast().getCallTarget();
             case "bytecodeDSLUncached" -> {
                 var node = createBytecodeDSLNodes(BytecodeDSLBenchmarkRootNodeUncached.class, null, benchmarkSpec::parseBytecodeDSL).getNodes().getLast();
                 node.getBytecodeNode().setUncachedThreshold(Integer.MIN_VALUE);
@@ -103,6 +105,11 @@ public void setup(BenchmarkParams params) {
                 benchmarkSpec.parseBytecode(builder);
                 yield createBytecodeNodes(BytecodeInterpreterAllOpts.class, null, builder).getCallTarget();
             }
+            case "manualThreadedAllOpts" -> {
+                var builder = Builder.newBuilder();
+                benchmarkSpec.parseBytecode(builder);
+                yield createBytecodeNodes(BytecodeInterpreterThreadedAllOpts.class, null, builder).getCallTarget();
+            }
             case "ast" -> benchmarkSpec.parseAST(null);
             default -> throw new AssertionError("Unexpected benchmark method " + benchMethod);
         };
@@ -138,6 +145,11 @@ public void bytecodeDSLUncached() {
         benchmark(callTarget);
     }
 
+    @Benchmark
+    public void bytecodeDSLThreadedAllOpts() {
+        benchmark(callTarget);
+    }
+
     @Benchmark
     public void manualNoOpts() {
         benchmark(callTarget);
@@ -148,6 +160,11 @@ public void manualAllOpts() {
         benchmark(callTarget);
     }
 
+    @Benchmark
+    public void manualThreadedAllOpts() {
+        benchmark(callTarget);
+    }
+
     @Benchmark
     public void ast() {
         benchmark(callTarget);