[GR-69649] Inline primitive constant operands in Bytecode DSL interpreters.

PullRequest: graal/22279

Author: DSouzaM

truffle/CHANGELOG.md

@@ -23,6 +23,7 @@ This changelog summarizes major changes between Truffle versions relevant to lan
 * GR-8251: Pending steps are no longer removed when no debugging action is prepared on a `SuspendedEvent`. In practice, this means that the lifecycle of steps is now independent of breakpoint hits.
 * 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-69649: Bytecode DSL now encodes primitive constant operands directly in the bytecode, reducing memory indirections in the interpreter. This optimization is enabled by default; you can configure it with `@GenerateBytecode(inlinePrimitiveConstants = true)`.
 
 ## 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.test/src/com/oracle/truffle/api/bytecode/test/ConstantOperandTest.java

@@ -652,6 +652,40 @@ public void testImplicitTagInstrumentation() {
         });
     }
 
+    @Test
+    public void testYieldQuickeningRegressionTest() {
+        /*
+         * Regression test for a quickening bug. The yield's childBci calculation did not account
+         * for tag.resume instructions, and under the right circumstances, the parent operation
+         * would "quicken" an instruction operand, leading to unexpected results.
+         */
+        runInstrumentationTest((context, instrumenter) -> {
+            BytecodeRootNodes<ComplexCustomYieldTestRootNode> nodes = ComplexCustomYieldTestRootNodeGen.create(BytecodeDSLTestLanguage.REF.get(null), BytecodeConfig.DEFAULT, b -> {
+                b.beginRoot();
+                b.emitLoadConstant(42);
+                b.beginReturn();
+                b.beginAddConstantsYield(1);
+                b.emitLoadArgument(0);
+                b.endAddConstantsYield(1);
+                b.endReturn();
+                b.endRoot();
+            });
+            ComplexCustomYieldTestRootNode root = nodes.getNode(0);
+            root.getBytecodeNode().setUncachedThreshold(0);
+            List<Object> yieldValues = new ArrayList<>();
+            AtomicInteger resumeCount = new AtomicInteger();
+            instrumenter.attachExecutionEventFactory(SourceSectionFilter.newBuilder().tagIs(StatementTag.class).build(), createFactory(yieldValues, resumeCount));
+
+            ContinuationResult cont = (ContinuationResult) root.getCallTarget().call(0);
+            assertEquals(2, cont.getResult());
+            assertEquals(123, cont.continueWith(123));
+
+            cont = (ContinuationResult) root.getCallTarget().call(0);
+            assertEquals(2, cont.getResult());
+            assertEquals(123, cont.continueWith(123));
+        });
+    }
+
     private static void runInstrumentationTest(BiConsumer<Context, Instrumenter> test) {
         Context context = Context.create(BytecodeDSLTestLanguage.ID);
         try {

truffle/src/com.oracle.truffle.api.bytecode.test/src/com/oracle/truffle/api/bytecode/test/CustomYieldTest.java

@@ -317,6 +317,7 @@ meth public abstract !hasdefault boolean enableSpecializationIntrospection()
 meth public abstract !hasdefault boolean enableTagInstrumentation()
 meth public abstract !hasdefault boolean enableUncachedInterpreter()
 meth public abstract !hasdefault boolean enableYield()
+meth public abstract !hasdefault boolean inlinePrimitiveConstants()
 meth public abstract !hasdefault boolean storeBytecodeIndexInFrame()
 meth public abstract !hasdefault java.lang.Class<?> tagTreeNodeLibrary()
 meth public abstract !hasdefault java.lang.Class<?>[] boxingEliminationTypes()

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

@@ -469,6 +469,16 @@
      */
     Class<?>[] boxingEliminationTypes() default {};
 
+    /**
+     * Whether constant operands of primitive type should be encoded directly in the bytecode.
+     * Inlining can reduce the number of memory reads required to access constants.
+     * <p>
+     * Currently, inlining is only supported for {@link ConstantOperand}s.
+     *
+     * @since 25.1
+     */
+    boolean inlinePrimitiveConstants() default true;
+
     /**
      * Whether to generate introspection data for specializations. The data is accessible using
      * {@link com.oracle.truffle.api.bytecode.Instruction.Argument#getSpecializationInfo()}.

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

@@ -44,6 +44,7 @@
 import java.io.IOException;
 
 import com.oracle.truffle.api.bytecode.BytecodeRootNode;
+import com.oracle.truffle.api.bytecode.GenerateBytecode;
 
 /**
  * Represents a class that can serialize constants in a bytecode interpreter.
@@ -71,13 +72,14 @@
  * A serializer is responsible for encoding:
  * <ul>
  * <li>objects used as constants in the bytecode (e.g., objects passed to {@code emitLoadConstant}
- * or constant operands)</li>
+ * or constant operands, except primitive ones that are
+ * {@link GenerateBytecode#inlinePrimitiveConstants inlined})</li>
  * <li>objects stored in non-{@code transient} fields of the root node</li>
  * <li>{@link com.oracle.truffle.api.source.Source} objects passed in builder calls (i.e., sources
  * passed to {@code beginSource})</li>
  * </ul>
  *
- * @see com.oracle.truffle.api.bytecode.GenerateBytecode#enableSerialization
+ * @see GenerateBytecode#enableSerialization
  * @since 24.2
  */
 @FunctionalInterface

truffle/src/com.oracle.truffle.api.bytecode/src/com/oracle/truffle/api/bytecode/serialization/BytecodeSerializer.java

@@ -56,6 +56,7 @@
 import com.oracle.truffle.dsl.processor.TruffleTypes;
 import com.oracle.truffle.dsl.processor.bytecode.generator.BytecodeRootNodeElement.InterpreterTier;
 import com.oracle.truffle.dsl.processor.bytecode.model.BytecodeDSLModel;
+import com.oracle.truffle.dsl.processor.bytecode.model.ConstantOperandModel;
 import com.oracle.truffle.dsl.processor.bytecode.model.InstructionModel;
 import com.oracle.truffle.dsl.processor.bytecode.model.InstructionModel.ImmediateKind;
 import com.oracle.truffle.dsl.processor.bytecode.model.InstructionModel.InstructionImmediate;
@@ -163,10 +164,12 @@ public void beforeCallSpecialization(FlatNodeGenFactory nodeFactory, CodeTreeBui
     private boolean buildChildExecution(CodeTreeBuilder b, FrameState frameState, String frame, int specializationIndex) {
         int operandIndex = specializationIndex;
         if (operandIndex < instruction.signature.constantOperandsBeforeCount) {
-            TypeMirror constantOperandType = instruction.operation.constantOperands.before().get(operandIndex).type();
-            List<InstructionImmediate> imms = instruction.getImmediates(ImmediateKind.CONSTANT);
-            InstructionImmediate imm = imms.get(operandIndex);
-            b.tree(readConstFastPath(imm, constantOperandType));
+            ConstantOperandModel constantOperand = instruction.operation.constantOperands.before().get(operandIndex);
+            InstructionImmediate imm = instruction.constantOperandImmediates.get(constantOperand);
+            if (imm == null) {
+                throw new AssertionError("Could not find an immediate for constant operand " + constantOperand + " on instruction " + instruction);
+            }
+            b.tree(rootNode.readConstantImmediate("$bc", "$bci", "$bytecode", imm, constantOperand.type()));
             return false;
         }
         operandIndex -= instruction.signature.constantOperandsBeforeCount;
@@ -236,20 +239,18 @@ private boolean buildChildExecution(CodeTreeBuilder b, FrameState frameState, St
 
         int constantOperandAfterCount = instruction.signature.constantOperandsAfterCount;
         if (operandIndex < constantOperandAfterCount) {
-            TypeMirror constantOperandType = instruction.operation.constantOperands.after().get(operandIndex).type();
-            List<InstructionImmediate> imms = instruction.getImmediates(ImmediateKind.CONSTANT);
-            InstructionImmediate imm = imms.get(instruction.signature.constantOperandsBeforeCount + operandIndex);
-            b.tree(rootNode.readConstFastPath(readImmediate("$bc", "$bci", imm), "$bytecode.constants", constantOperandType));
+            ConstantOperandModel constantOperand = instruction.operation.constantOperands.after().get(operandIndex);
+            InstructionImmediate imm = instruction.constantOperandImmediates.get(constantOperand);
+            if (imm == null) {
+                throw new AssertionError("Could not find an immediate for constant operand " + constantOperand + " on instruction " + instruction);
+            }
+            b.tree(rootNode.readConstantImmediate("$bc", "$bci", "$bytecode", imm, constantOperand.type()));
             return false;
         }
 
         throw new AssertionError("index=" + specializationIndex + ", signature=" + instruction.signature);
     }
 
-    private CodeTree readConstFastPath(InstructionImmediate imm, TypeMirror immediateType) {
-        return rootNode.readConstFastPath(readImmediate("$bc", "$bci", imm), "$bytecode.constants", immediateType);
-    }
-
     public CodeExecutableElement getQuickenMethod() {
         return quickenMethod;
     }
@@ -307,7 +308,7 @@ public CodeTree bindExpressionValue(FrameState frameState, Variable variable) {
                 return CodeTreeBuilder.singleString("$bci");
             case BytecodeDSLParser.SYMBOL_CONTINUATION_ROOT:
                 InstructionImmediate continuationIndex = instruction.getImmediates(ImmediateKind.CONSTANT).getLast();
-                return CodeTreeBuilder.createBuilder().tree(readConstFastPath(continuationIndex, rootNode.getContinuationRootNodeImpl().asType())).build();
+                return CodeTreeBuilder.createBuilder().tree(rootNode.readConstantImmediate("$bc", "$bci", "$bytecode", continuationIndex, rootNode.getContinuationRootNodeImpl().asType())).build();
             default:
                 return NodeGeneratorPlugs.super.bindExpressionValue(frameState, variable);