[GR-58163] Replay compilation.

PullRequest: graal/18820

Author: pecimuth

compiler/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 This changelog summarizes newly introduced optimizations and other compiler related changes.
 
+## GraalVM for JDK 26 (Internal Version 26.0.0)
+* (GR-58163): Added support for recording and replaying JIT compilations. The `-Djdk.graal.RecordForReplay=*` option
+  serializes all compilations matching the pattern to JSON files, which contain the results of JVMCI calls. The
+  recorded compilations can be replayed with the `mx replaycomp` command. Truffle compilations are currently not
+  supported. See `docs/ReplayCompilation.md` for details.
+
 ## GraalVM for JDK 25 (Internal Version 25.0.0)
 * (GR-60088): This PR adds the `org.graalvm.nativeimage.libgraal` SDK module. With this module, all logic for building
   libgraal has been moved into the compiler suite in a new `jdk.graal.compiler.libgraal` module

compiler/docs/ReplayCompilation.md

@@ -0,0 +1,100 @@
+# Replay Compilation
+
+The GraalVM compiler can record the inputs to a compilation task, serialize these inputs into a JSON file, and reproduce
+the compilation using the same inputs. Replay compilation is based on instrumenting the JVM Compiler Interface (JVMCI).
+Truffle compilations are currently not supported. It is not a goal to execute the replayed code.
+
+This file is a manual from the user's perspective. To learn how replay compilation is implemented, start by reading
+`ReplayCompilationSupport.java` and `CompilerInterfaceDeclarations.java`.
+
+## Example
+
+Recording is enabled with the option `-Djdk.graal.RecordForReplay=*`. The value is a method filter selecting the methods
+to be recorded. The syntax of method filters is explained `MethodFilter.java`.
+
+The below command records and serializes every compilation into `./replay-files/replaycomp/<compile-id>.json`.
+The directories are created if they do not exist.
+
+```shell
+mx benchmark renaissance:scrabble -- -Djdk.graal.RecordForReplay='*' -Djdk.graal.DumpPath=$PWD/replay-files -- -r 1
+```
+
+It is recommended to select specific methods rather than `*` to avoid slowing the compiler down and producing gigabytes
+of data. The compile speed overhead for recorded methods can be on the order of 10x. The size of a typical compilation
+unit is between 1 and 10 MB but compression saves 95% of space. Note that if the VM exits during an ongoing compilation,
+some of the JSON files may be incomplete.
+
+The `mx replaycomp` command finds all JSON replay files found in a given directory (and subdirectories) and invokes
+the replay compiler on each. The command also accepts a path to a single file.
+
+```shell
+mx replaycomp ./replay-files
+```
+
+## Debugging
+
+A replayed compilation can be debugged using a standard Java debugger (see `Debugging.md`).
+
+```shell
+mx -d replaycomp ./replay-files
+```
+
+## Record Crashed Compilations
+
+Using the `-Djdk.graal.CompilationFailureAction=Diagnose` option, the compiler retries and records crashed compilations.
+The command below exercises this behavior by forcing a crash. The JSON replay file can then be found in the `replaycomp`
+directory inside the diagnostic zip archive.
+
+```shell
+mx benchmark renaissance:scrabble -- -Djdk.graal.CompilationFailureAction=Diagnose -Djdk.graal.CrashAt=hashCode -- -r 1
+```
+
+It is possible to **not** record retried compilations with the option `-Djdk.graal.DiagnoseOptions=RecordForReplay=`.
+
+## Replay with JVM Arguments
+
+JVM arguments, including compiler options, can be passed directly to the `replaycomp` command.
+
+```shell
+mx replaycomp -Djdk.graal.Dump=:1 ./replay-files
+```
+
+Any `-ea`, `-esa`, and `-X` arguments from the command line are passed to the JVM as well.
+
+## Jargraal vs. Libgraal
+
+Both jargraal and libgraal compilations can be replayed on jargraal. When jargraal replays a libgraal compilation,
+it uses encoded snippets to match the behavior and compilations results of libgraal. It is also possible to replay
+libgraal compilations on libgraal. Replaying jargraal compilations on libgraal is not supported.
+
+It is necessary to explicitly enable the replay launcher entry point when building libgraal using the VM argument
+`-Ddebug.jdk.graal.enableReplayLauncher=true`.
+
+```shell
+EXTRA_IMAGE_BUILDER_ARGUMENTS=-Ddebug.jdk.graal.enableReplayLauncher=true mx --env libgraal build
+```
+
+When the `--libgraal` argument is passed to `mx replaycomp`, the previously built libgraal native library is loaded, and
+the native launcher is invoked instead of the Java launcher. With the below command, all replay related processing
+(including JSON parsing) is performed by libgraal code.
+
+```shell
+mx replaycomp --libgraal ./replay-files
+```
+
+## Replay Options
+
+`--compare-graphs=true` compares the final canonical graph of the replayed compilation to the recorded one, which is
+included in the JSON replay file. If there is a mismatch, the command exits with a non-zero status.
+
+```shell
+mx replaycomp --compare-graphs=true ./replay-files
+```
+
+If the replayed compilation diverges from the recorded one, the compiler may query JVMCI information that is not
+recorded in the JSON file. The default behavior is to return default values, which may not cause a compiler crash.
+The `-Djdk.graal.ReplayDivergenceIsFailure=true` argument prevents using default values and instead causes a crash.
+
+```shell
+mx replaycomp -Djdk.graal.ReplayDivergenceIsFailure=true ./replay-files
+```

compiler/mx.compiler/mx_compiler.py

@@ -1571,6 +1571,41 @@ def profdiff(args):
     vm_args = ['-cp', cp, 'org.graalvm.profdiff.Profdiff'] + args
     return jdk.run_java(args=vm_args)
 
+def replaycomp_vm_args():
+    """Returns the VM arguments required to run the replay compilation launcher."""
+    vm_args = [
+        '-XX:-UseJVMCICompiler',
+        '--enable-native-access=org.graalvm.truffle',
+        '--add-exports=java.base/jdk.internal.module=ALL-UNNAMED',
+        '-Djdk.graal.CompilationFailureAction=Print'
+    ]
+    _, dists = mx.defaultDependencies(opt_limit_to_suite=True)
+    dists = [d for d in dists if d.isJARDistribution() and os.path.exists(d.classpath_repr(resolve=False))]
+    return mx.get_runtime_jvm_args(dists) + vm_args
+
+def replaycomp_main_class():
+    """Returns the main class name for the replay compilation launcher."""
+    return 'jdk.graal.compiler.hotspot.replaycomp.test.ReplayCompilationLauncher'
+
+def replaycomp(args):
+    """Runs the replay compilation launcher with the provided launcher and VM arguments."""
+    extra_vm_args = []
+    launcher_args = []
+    for arg in args:
+        vm_arg_prefixes = ['-X', '-D', '-ea', '-enableassertions', '-esa', '-enablesystemassertions']
+        if any(map(arg.startswith, vm_arg_prefixes)):
+            extra_vm_args.append(arg)
+        elif arg == '--libgraal':
+            jvmci_lib_path = os.path.join(mx.suite('sdk').get_output_root(platformDependent=True, jdkDependent=False),
+                                          mx.add_lib_suffix(mx.add_lib_prefix('jvmcicompiler')) + '.image')
+            extra_vm_args.extend([
+                '-XX:+UseJVMCINativeLibrary',
+                f'-XX:JVMCILibPath={jvmci_lib_path}'
+            ])
+        else:
+            launcher_args.append(arg)
+    return run_vm([*replaycomp_vm_args(), *extra_vm_args, replaycomp_main_class(), *launcher_args], nonZeroIsFatal=False)
+
 def igvutil(args):
     """various utilities to inspect and modify IGV graphs"""
     cp = mx.classpath('GRAAL_IGVUTIL', jdk=jdk)
@@ -1589,6 +1624,7 @@ def igvutil(args):
     'graaljdk-show': [print_graaljdk_config, '[options]'],
     'phaseplan-fuzz-jtt-tests': [phaseplan_fuzz_jtt_tests, "Runs JTT's unit tests with fuzzed phase plans."],
     'profdiff': [profdiff, '[options] proftool_output1 optimization_log1 proftool_output2 optimization_log2'],
+    'replaycomp': [replaycomp, ''],
     'igvutil': [igvutil, '[subcommand] [options]'],
 })
 

compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/LibGraalEntryPoints.java

@@ -31,6 +31,7 @@
 import java.io.PrintStream;
 import java.util.Arrays;
 import java.util.Map;
+import java.util.function.BooleanSupplier;
 
 import org.graalvm.collections.EconomicMap;
 import org.graalvm.jniutils.JNI.JNIEnv;
@@ -45,12 +46,15 @@
 
 import jdk.graal.compiler.debug.GlobalMetrics;
 import jdk.graal.compiler.debug.GraalError;
+import jdk.graal.compiler.debug.TTY;
 import jdk.graal.compiler.hotspot.CompilationContext;
 import jdk.graal.compiler.hotspot.CompilationTask;
 import jdk.graal.compiler.hotspot.HotSpotGraalCompiler;
 import jdk.graal.compiler.hotspot.HotSpotGraalRuntime;
 import jdk.graal.compiler.hotspot.HotSpotGraalServices;
 import jdk.graal.compiler.hotspot.ProfileReplaySupport;
+import jdk.graal.compiler.hotspot.replaycomp.ReplayCompilationRunner;
+import jdk.graal.compiler.hotspot.replaycomp.ReplayCompilationSupport;
 import jdk.graal.compiler.options.OptionDescriptors;
 import jdk.graal.compiler.options.OptionKey;
 import jdk.graal.compiler.options.OptionValues;
@@ -288,4 +292,44 @@ private static long hashConstantOopFields(JNIEnv jniEnv,
             return 0;
         }
     }
+
+    /**
+     * Runs the replay compilation launcher in libgraal with the provided command-line arguments.
+     *
+     * @param argBuffer a native buffer containing a zero-terminated UTF-8 string of
+     *            {@code '\n'}-separated arguments for the replay compilation launcher
+     * @return the exit status of the replay compilation launcher
+     */
+    @SuppressWarnings({"unused", "try"})
+    @CEntryPoint(name = "Java_jdk_graal_compiler_hotspot_replaycomp_test_ReplayCompilationLauncher_runInLibgraal", include = LibGraalReplayLauncherEnabled.class)
+    private static int replayCompilation(JNIEnv jniEnv,
+                    PointerBase jclass,
+                    @IsolateThreadContext long isolateThread,
+                    long argBuffer) {
+        try (JNIMethodScope scope = new JNIMethodScope("replayCompilation", jniEnv)) {
+            String argString = CTypeConversion.utf8ToJavaString(Word.pointer(argBuffer));
+            String[] args;
+            if (argString.isEmpty()) {
+                args = new String[0];
+            } else {
+                args = argString.split("\n");
+            }
+            return ReplayCompilationRunner.run(args, TTY.out().out()).getStatus();
+        } catch (Throwable t) {
+            JNIExceptionWrapper.throwInHotSpot(jniEnv, t);
+            return ReplayCompilationRunner.ExitStatus.Failure.getStatus();
+        } finally {
+            LibGraalSupportImpl.doReferenceHandling();
+        }
+    }
+
+    /**
+     * Controls whether the replay launcher entry point should be included in libgraal.
+     */
+    private static final class LibGraalReplayLauncherEnabled implements BooleanSupplier {
+        @Override
+        public boolean getAsBoolean() {
+            return new LibGraalFeature.IsEnabled().getAsBoolean() && ReplayCompilationSupport.ENABLE_REPLAY_LAUNCHER;
+        }
+    }
 }

compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/LibGraalFeature.java

@@ -44,6 +44,7 @@
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
+import jdk.graal.compiler.serviceprovider.GraalServices;
 import org.graalvm.collections.EconomicMap;
 import org.graalvm.jniutils.NativeBridgeSupport;
 import org.graalvm.nativeimage.ImageInfo;
@@ -315,7 +316,11 @@ public void accept(DuringAnalysisAccess duringAnalysisAccess) {
 
     private void registerHostedOnlyElements(BeforeAnalysisAccess access, AnnotatedElement... elements) {
         for (AnnotatedElement element : elements) {
-            if (element.getAnnotation(HostedOnly.class) != null) {
+            HostedOnly annotation = element.getAnnotation(HostedOnly.class);
+            if (annotation == null) {
+                continue;
+            }
+            if (annotation.unlessTrue().isEmpty() || !Boolean.parseBoolean(GraalServices.getSavedProperty(annotation.unlessTrue()))) {
                 access.registerReachabilityHandler(new HostedOnlyElementCallback(element, reachedHostedOnlyElements), element);
             }
         }