[GR-47637] Implement Thread.onSpinWait intrinsic on AArch64.

PullRequest: graal/15136

Author: mur47x111

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/core/amd64/AMD64LIRGenerator.java

@@ -1012,6 +1012,11 @@ public void emitPause() {
         append(new AMD64PauseOp());
     }
 
+    @Override
+    public void emitSpinWait() {
+        append(new AMD64PauseOp());
+    }
+
     @Override
     public void emitHalt() {
         append(new AMD64HaltOp());

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/hotspot/GraalHotSpotVMConfig.java

@@ -137,6 +137,9 @@ private HotSpotGraalRuntime.HotSpotGC getSelectedGC() throws GraalError {
     public final boolean useFMAIntrinsics = getFlag("UseFMA", Boolean.class);
     public final int useAVX3Threshold = getFlag("AVX3Threshold", Integer.class, 4096, osArch.equals("amd64"));
 
+    public final String onSpinWaitInst = getFlag("OnSpinWaitInst", String.class, "none", osArch.equals("aarch64"));
+    public final int onSpinWaitInstCount = getFlag("OnSpinWaitInstCount", Integer.class, 0, osArch.equals("aarch64"));
+
     public final boolean preserveFramePointer = getFlag("PreserveFramePointer", Boolean.class);
 
     public final int diagnoseSyncOnValueBasedClasses = getFlag("DiagnoseSyncOnValueBasedClasses", Integer.class);

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/hotspot/aarch64/AArch64HotSpotLIRGenerator.java

@@ -34,12 +34,14 @@
 
 import java.util.Arrays;
 import java.util.EnumSet;
+import java.util.function.Consumer;
 import java.util.function.Function;
 
 import org.graalvm.compiler.asm.Label;
 import org.graalvm.compiler.asm.aarch64.AArch64Address;
 import org.graalvm.compiler.asm.aarch64.AArch64Assembler.ConditionFlag;
 import org.graalvm.compiler.asm.aarch64.AArch64Assembler.PrefetchMode;
+import org.graalvm.compiler.asm.aarch64.AArch64MacroAssembler;
 import org.graalvm.compiler.core.aarch64.AArch64ArithmeticLIRGenerator;
 import org.graalvm.compiler.core.aarch64.AArch64LIRGenerator;
 import org.graalvm.compiler.core.aarch64.AArch64LIRKindTool;
@@ -76,6 +78,7 @@
 import org.graalvm.compiler.lir.aarch64.AArch64PrefetchOp;
 import org.graalvm.compiler.lir.aarch64.AArch64RestoreRegistersOp;
 import org.graalvm.compiler.lir.aarch64.AArch64SaveRegistersOp;
+import org.graalvm.compiler.lir.aarch64.AArch64SpinWaitOp;
 import org.graalvm.compiler.lir.gen.BarrierSetLIRGenerator;
 import org.graalvm.compiler.lir.gen.LIRGenerationResult;
 import org.graalvm.compiler.lir.gen.MoveFactory;
@@ -468,6 +471,25 @@ public void emitZeroMemory(Value address, Value length, boolean isAligned) {
         emitZeroMemory(address, length, isAligned, useDcZva, zvaLength);
     }
 
+    private Consumer<AArch64MacroAssembler> onSpinWaitInst() {
+        return switch (config.onSpinWaitInst) {
+            case "nop" -> AArch64MacroAssembler::nop;
+            case "isb" -> AArch64MacroAssembler::isb;
+            case "yield" -> AArch64MacroAssembler::pause;
+            default -> throw GraalError.shouldNotReachHere("Unknown OnSpinWaitInst " + config.onSpinWaitInst);
+        };
+    }
+
+    @Override
+    public void emitSpinWait() {
+        if ("none".equals(config.onSpinWaitInst)) {
+            // do nothing
+        } else {
+            GraalError.guarantee(config.onSpinWaitInstCount > 0, "illegal onSpinWaitInstCount");
+            append(new AArch64SpinWaitOp(onSpinWaitInst(), config.onSpinWaitInstCount));
+        }
+    }
+
     @Override
     public int getArrayLengthOffset() {
         return config.arrayOopDescLengthOffset();

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/hotspot/meta/UnimplementedGraalIntrinsics.java

@@ -401,11 +401,6 @@ public UnimplementedGraalIntrinsics(GraalHotSpotVMConfig config, Architecture ar
             );
         }
 
-        if (arch instanceof AArch64) {
-            add(toBeInvestigated,
-                            "java/lang/Thread.onSpinWait()V");
-        }
-
         if (JAVA_SPEC >= 20) {
             // This reuses the intrinsic for java/lang/StringCoding.hasNegatives with minor changes
             add(toBeInvestigated,

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/lir/aarch64/AArch64SpinWaitOp.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package org.graalvm.compiler.lir.aarch64;
+
+import java.util.function.Consumer;
+
+import org.graalvm.compiler.asm.aarch64.AArch64MacroAssembler;
+import org.graalvm.compiler.debug.GraalError;
+import org.graalvm.compiler.lir.LIRInstructionClass;
+import org.graalvm.compiler.lir.Opcode;
+import org.graalvm.compiler.lir.SyncPort;
+import org.graalvm.compiler.lir.asm.CompilationResultBuilder;
+
+/**
+ * Emits spin wait instruction(s).
+ */
+// @formatter:off
+@SyncPort(from = "https://github.com/openjdk/jdk/blob/d7b941640638b35f9ac1ef11cd6bf6ccb795c29a/src/hotspot/cpu/aarch64/vm_version_aarch64.cpp#L52-L68",
+          sha1 = "92f81ed500658553a2ef2e7c48633094d95ba974")
+// @formatter:on
+@Opcode("SPIN_WAIT")
+public final class AArch64SpinWaitOp extends AArch64LIRInstruction {
+    public static final LIRInstructionClass<AArch64SpinWaitOp> TYPE = LIRInstructionClass.create(AArch64SpinWaitOp.class);
+
+    private final Consumer<AArch64MacroAssembler> instruction;
+    private final int count;
+
+    public AArch64SpinWaitOp(Consumer<AArch64MacroAssembler> instruction, int count) {
+        super(TYPE);
+
+        this.instruction = instruction;
+        this.count = count;
+        GraalError.guarantee(count > 0, "count should be positive");
+    }
+
+    @Override
+    public void emitCode(CompilationResultBuilder crb, AArch64MacroAssembler masm) {
+        for (int i = 0; i < count; i++) {
+            instruction.accept(masm);
+        }
+    }
+}

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/lir/gen/LIRGeneratorTool.java

@@ -528,6 +528,12 @@ default void emitSha256ImplCompress(Value buf, Value state) {
 
     void emitPause();
 
+    /**
+     * Perform no operation by default. See also {@link Thread#onSpinWait()}.
+     */
+    default void emitSpinWait() {
+    }
+
     void emitPrefetchAllocate(Value address);
 
     Value emitCompress(Value pointer, CompressEncoding encoding, boolean nonNull);

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/nodes/SpinWaitNode.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package org.graalvm.compiler.nodes;
+
+import static org.graalvm.compiler.nodeinfo.NodeCycles.CYCLES_IGNORED;
+
+import org.graalvm.compiler.core.common.type.StampFactory;
+import org.graalvm.compiler.graph.NodeClass;
+import org.graalvm.compiler.nodeinfo.NodeInfo;
+import org.graalvm.compiler.nodeinfo.NodeSize;
+import org.graalvm.compiler.nodes.spi.LIRLowerable;
+import org.graalvm.compiler.nodes.spi.NodeLIRBuilderTool;
+
+/**
+ * A node that results in a platform dependent spin_wait instruction being emitted.
+ */
+@NodeInfo(cycles = CYCLES_IGNORED, size = NodeSize.SIZE_1)
+public final class SpinWaitNode extends FixedWithNextNode implements LIRLowerable {
+
+    public static final NodeClass<SpinWaitNode> TYPE = NodeClass.create(SpinWaitNode.class);
+
+    public SpinWaitNode() {
+        super(TYPE, StampFactory.forVoid());
+    }
+
+    @Override
+    public void generate(NodeLIRBuilderTool gen) {
+        gen.getLIRGeneratorTool().emitSpinWait();
+    }
+}

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/replacements/StandardGraphBuilderPlugins.java

@@ -82,6 +82,7 @@
 import org.graalvm.compiler.nodes.NodeView;
 import org.graalvm.compiler.nodes.PiNode;
 import org.graalvm.compiler.nodes.ProfileData.BranchProbabilityData;
+import org.graalvm.compiler.nodes.SpinWaitNode;
 import org.graalvm.compiler.nodes.StateSplit;
 import org.graalvm.compiler.nodes.StructuredGraph;
 import org.graalvm.compiler.nodes.ValueNode;
@@ -2351,6 +2352,13 @@ private static boolean hasEnsureMaterializedForStackWalk() {
 
     private static void registerThreadPlugins(InvocationPlugins plugins, Replacements replacements) {
         Registration r = new Registration(plugins, Thread.class, replacements);
+        r.register(new InvocationPlugin("onSpinWait") {
+            @Override
+            public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) {
+                b.append(new SpinWaitNode());
+                return true;
+            }
+        });
         if (hasEnsureMaterializedForStackWalk()) {
             r.register(new InvocationPlugin("ensureMaterializedForStackWalk", Object.class) {
                 @Override

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/replacements/amd64/AMD64GraphBuilderPlugins.java

@@ -47,7 +47,6 @@
 import org.graalvm.compiler.nodes.ConstantNode;
 import org.graalvm.compiler.nodes.NamedLocationIdentity;
 import org.graalvm.compiler.nodes.NodeView;
-import org.graalvm.compiler.nodes.PauseNode;
 import org.graalvm.compiler.nodes.ValueNode;
 import org.graalvm.compiler.nodes.calc.AddNode;
 import org.graalvm.compiler.nodes.calc.CompressBitsNode;
@@ -115,7 +114,6 @@ public static void register(Plugins plugins, Replacements replacements, AMD64 ar
         invocationPlugins.defer(new Runnable() {
             @Override
             public void run() {
-                registerThreadPlugins(invocationPlugins, arch);
                 registerIntegerLongPlugins(invocationPlugins, JavaKind.Int, arch, replacements);
                 registerIntegerLongPlugins(invocationPlugins, JavaKind.Long, arch, replacements);
                 registerFloatDoublePlugins(invocationPlugins, JavaKind.Float, arch, replacements);
@@ -135,19 +133,6 @@ public void run() {
         });
     }
 
-    private static void registerThreadPlugins(InvocationPlugins plugins, AMD64 arch) {
-        // Pause instruction introduced with SSE2
-        assert (arch.getFeatures().contains(AMD64.CPUFeature.SSE2));
-        Registration r = new Registration(plugins, Thread.class);
-        r.register(new InvocationPlugin("onSpinWait") {
-            @Override
-            public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) {
-                b.append(new PauseNode());
-                return true;
-            }
-        });
-    }
-
     private static void registerIntegerLongPlugins(InvocationPlugins plugins, JavaKind kind, AMD64 arch, Replacements replacements) {
         Class<?> declaringClass = kind.toBoxedJavaClass();
         Class<?> type = kind.toJavaClass();