moved Graal options to jdk.graal prefix

Author: dougxc

compiler/CHANGELOG.md

@@ -3,6 +3,8 @@
 This changelog summarizes newly introduced optimizations and other compiler related changes.
 
 ## GraalVM for JDK 22 (Internal Version 24.0.0)
+* (GR-49960): The Graal options now use the `jdk.graal.` prefix (e.g. `-Djdk.graal.PrintCompilation=true`).
+  The legacy `graal.` prefix is deprecated but still supported (e.g. `-Dgraal.PrintCompilation=true`).
 * (GR-49610): The Graal module has been renamed from `jdk.internal.vm.compiler` to `jdk.graal.compiler`.
   Likewise, the compiler packages moved into the `jdk.graal.compiler` namespace.
   These renamings were done in preparation for [Project Galahad](https://openjdk.org/projects/galahad/).

compiler/README.md

@@ -101,7 +101,7 @@ You should wait for the GUI to appear before running the second command.
 
 ```bash
 $ $GRAALVM_EE_HOME/bin/idealgraphvisualizer &
-mx unittest -Dgraal.Dump BC_athrow0
+mx unittest -Djdk.graal.Dump BC_athrow0
 ```
 
 If you added `-XX:+UseJVMCICompiler` as described above, you will see IR for compilations requested by the VM itself in addition to compilations requested by the unit test.
@@ -122,7 +122,7 @@ complicate fine tuning options such as `-Xmx` and `-Xms` which now need to take
 heap usage of the compiler into account. Secondly, the compiler will initially be executed
 in the interpreter and only get faster over time as its hot methods are JIT
 compiled. This is mitigated to some degree by forcing the GraalVM compiler
-to only be compiled by C1 (i.e., `-Dgraal.CompileGraalWithC1Only=true`) but this comes at the cost
+to only be compiled by C1 (i.e., `-Djdk.graal.CompileGraalWithC1Only=true`) but this comes at the cost
 of slower compilation speed.
 
 To address these issues, the GraalVM compiler can be deployed as a native shared library. The shared

compiler/ci/ci_common/compiler-common.libsonnet

@@ -74,7 +74,7 @@
       "--jvm=${JVM}",
       "--jvm-config=${JVM_CONFIG}",
       "-XX:+PrintConcurrentLocks",
-      "-Dgraal.CompilationFailureAction=Diagnose",
+      "-Djdk.graal.CompilationFailureAction=Diagnose",
       "-XX:+CITime"] +
       self.min_heap_size +
       self.max_heap_size,

compiler/ci/ci_common/gate.jsonnet

@@ -42,7 +42,7 @@
          "--kill-with-sigquit",
          "gate",
          "--strict-mode",
-         "--extra-vm-argument=-Dgraal.DumpOnError=true -Dgraal.PrintGraphFile=true -Dgraal.PrintBackendCFG=true" +
+         "--extra-vm-argument=-Djdk.graal.DumpOnError=true -Djdk.graal.PrintGraphFile=true -Djdk.graal.PrintBackendCFG=true" +
            (if extra_vm_args == "" then "" else " " + extra_vm_args)
       ] + (if extra_unittest_args != "" then [
         "--extra-unittest-argument=" + extra_unittest_args,
@@ -102,9 +102,9 @@
 
   test_javabase:: s.base("build,javabasetest"),
   test_jtt_phaseplan_fuzzing:: s.base("build,phaseplan-fuzz-jtt-tests"),
-  test_vec16:: s.base(extra_vm_args="-Dgraal.DetailedAsserts=true -XX:MaxVectorSize=16"),
-  test_avx0:: s.base(extra_vm_args="-Dgraal.ForceAdversarialLayout=true", jvm_config_suffix="-avx0"),
-  test_avx1:: s.base(extra_vm_args="-Dgraal.ForceAdversarialLayout=true", jvm_config_suffix="-avx1"),
+  test_vec16:: s.base(extra_vm_args="-Djdk.graal.DetailedAsserts=true -XX:MaxVectorSize=16"),
+  test_avx0:: s.base(extra_vm_args="-Djdk.graal.ForceAdversarialLayout=true", jvm_config_suffix="-avx0"),
+  test_avx1:: s.base(extra_vm_args="-Djdk.graal.ForceAdversarialLayout=true", jvm_config_suffix="-avx1"),
 
   # Runs truffle tests in a mode similar to HotSpot's -Xcomp option
   # (i.e. compile immediately without background compilation).
@@ -143,7 +143,7 @@
   ctw:: s.base("build,ctw", no_warning_as_error=true),
   ctw_zgc:: s.base("build,ctw", no_warning_as_error=true, extra_vm_args="-XX:+UseZGC"),
 
-  ctw_economy:: s.base("build,ctweconomy", extra_vm_args="-Dgraal.CompilerConfiguration=economy"),
+  ctw_economy:: s.base("build,ctweconomy", extra_vm_args="-Djdk.graal.CompilerConfiguration=economy"),
   ctw_phaseplan_fuzzing:: s.base("build,ctwphaseplanfuzzing"),
 
   # Runs some benchmarks as tests
@@ -154,7 +154,7 @@
   bootstrap_lite:: s.base("build,bootstraplite", no_warning_as_error=true),
   bootstrap_full:: s.base("build,bootstrapfullverify", no_warning_as_error=true),
   bootstrap_full_zgc:: s.base("build,bootstrapfullverify", no_warning_as_error=true, extra_vm_args="-XX:+UseZGC"),
-  bootstrap_economy:: s.base("build,bootstrapeconomy", no_warning_as_error=true, extra_vm_args="-Dgraal.CompilerConfiguration=economy"),
+  bootstrap_economy:: s.base("build,bootstrapeconomy", no_warning_as_error=true, extra_vm_args="-Djdk.graal.CompilerConfiguration=economy"),
 
   style:: c.deps.eclipse + c.deps.jdt + s.base("style,fullbuild,javadoc"),
 

compiler/docs/CompilationPlanFuzzing.md

@@ -145,7 +145,7 @@ It is possible to fix some parameters of the creation of fuzzed compilation plan
   * `mx phaseplan-fuzz-jtt-tests HP_life`
   * `mx gate --extra-unittest-argument='HP_life' --tags phaseplan-fuzz-jtt-tests`
 - If you want to use the phases of a specific compiler configuration and respect its requirements, you should use:
-  * `-Dgraal.CompilerConfiguration=<config>`
+  * `-Djdk.graal.CompilerConfiguration=<config>`
 
 #### Load a phase plan
 You can load a phase plan (one created by a fuzzed compilation plan or any other phase plan serialized using the `PhasePlanSerializer`) using the command:
@@ -169,5 +169,5 @@ These commands will make each thread create a new fuzzed compilation plan for ea
 #### Load a phase plan
 It is possible to load a phase plan (one created by a fuzzed compilation plan or any other phase plan serialized using the `PhasePlanSerializer`) and use it for the compilation of a method by using the command:
 ```
-mx gate --extra-vm-argument='-DCompileTheWorld.LoadPhasePlan=/path/to/phaseplan' --extra-vm-argument='-DCompileTheWorld.MethodFilter=<methodName>' --extra-vm-argument='-Dgraal.CompilerConfiguration=<config>' --tags ctw
+mx gate --extra-vm-argument='-DCompileTheWorld.LoadPhasePlan=/path/to/phaseplan' --extra-vm-argument='-DCompileTheWorld.MethodFilter=<methodName>' --extra-vm-argument='-Djdk.graal.CompilerConfiguration=<config>' --tags ctw
 ```

compiler/docs/Debugging.md

@@ -53,12 +53,12 @@ try (Scope s = debug.scope("CodeInstall", method)) {
 ```
 
 The `debug.log` statement will send output to the console if `CodeInstall` is matched by the
-`-Dgraal.Log` option. The matching logic for this option is implemented in
+`-Djdk.graal.Log` option. The matching logic for this option is implemented in
 [DebugFilter](../src/jdk.graal.compiler/src/jdk/graal/compiler/debug/DebugFilter.java)
 and documented in the
 [Dump help message](../src/jdk.graal.compiler/src/jdk/graal/compiler/debug/doc-files/DumpHelp.txt). As
-mentioned in the javadoc, the same matching logic also applies to the `-Dgraal.Dump`,
-`-Dgraal.Time`, `-Dgraal.Count` and `-Dgraal.TrackMemUse` options.
+mentioned in the javadoc, the same matching logic also applies to the `-Djdk.graal.Dump`,
+`-Djdk.graal.Time`, `-Djdk.graal.Count` and `-Djdk.graal.TrackMemUse` options.
 
 Since `DebugContext` objects are thread local, they need to be passed around as parameters.  For
 convenience, they may be available from objects such as a `Graph` or a `Node` but care needs to be
@@ -78,9 +78,9 @@ obtained with `-XX:+JVMCIPrintProperties`.
 The compiler supports metrics in the form of counters, timers and memory trackers.
 Each metric has a unique name. Metrics are collected per-compilation.
 At shutdown, they are aggregated across all compilations and reported to the console.
-This ouput can be redirected to a file via the `-Dgraal.AggregatedMetricsFile` option.
+This ouput can be redirected to a file via the `-Djdk.graal.AggregatedMetricsFile` option.
 
-To list the per-compilation metrics, use the `-Dgraal.MetricsFile` option. If not specified,
+To list the per-compilation metrics, use the `-Djdk.graal.MetricsFile` option. If not specified,
 per-compilation metrics are not reported.
 
 Metrics are represented in the code via fields or variables of type `CounterKey`, `TimerKey` or `MemUseTrackerKey`.
@@ -136,11 +136,11 @@ CompilationMemory_Accm=100000 bytes
 CompilationMemory_Flat=1000 bytes
 ```
 
-For both the `-Dgraal.AggregatedMetricsFile` and the `-Dgraal.MetricsFile` option, the output format
+For both the `-Djdk.graal.AggregatedMetricsFile` and the `-Djdk.graal.MetricsFile` option, the output format
 is determined by the file name suffix. A `.csv` suffix produces a semi-colon separated format that
 is amenable to automatic data processing.
 
-The columns in the `-Dgraal.MetricsFile` CSV output are:
+The columns in the `-Djdk.graal.MetricsFile` CSV output are:
 * **compilable**: A textual label such as the fully qualified name of the method being compiled.
 For Truffle compilations, this will be a name describing the guest language function/method being compiled.
 * **compilable_identity**: The identity hash code of the **compilable**. This is useful when the
@@ -156,7 +156,7 @@ but its identity will.
 * **metric_value**: The metric value being reported.
 * **metric_unit**: The unit of measurement for the value being reported. This will be the empty string for a counter.
 
-Example `-Dgraal.MetricsFile` output:
+Example `-Djdk.graal.MetricsFile` output:
 ```
 java.lang.String.hashCode()int;1272077530;0;HotSpotCompilation-95;PhaseNodes_PhaseSuite;1
 java.lang.String.hashCode()int;1272077530;0;HotSpotCompilation-95;PhaseNodes_GraphBuilderPhase;1
@@ -167,12 +167,12 @@ java.lang.String.hashCode()int;1272077530;0;HotSpotCompilation-95;PhaseTime_Grap
 java.lang.String.hashCode()int;1272077530;0;HotSpotCompilation-95;PhaseTime_GraphBuilderPhase_Flat;27724000
 ```
 
-The columns in the `-Dgraal.AggregatedMetricsFile` CSV output are:
+The columns in the `-Djdk.graal.AggregatedMetricsFile` CSV output are:
 * **metric_name**: The name of the metric being reported.
 * **metric_value**: The metric value being reported.
 * **metric_unit**: The unit of measurement for the value being reported. This will be the empty string for a counter.
 
-Example `-Dgraal.AggregatedMetricsFile` output:
+Example `-Djdk.graal.AggregatedMetricsFile` output:
 ```
 AllocationsRemoved;6446;
 BackEnd_Accm;7931303;us
@@ -183,30 +183,30 @@ LIRPhaseMemUse_AllocationStage_Accm;499763160;bytes
 LIRPhaseMemUse_AllocationStage_Flat;17354112;bytes
 ```
 
-Note that `-Dgraal.MetricsFile` produces per-compilation output, not per-method output.
+Note that `-Djdk.graal.MetricsFile` produces per-compilation output, not per-method output.
 If a method is compiled multiple times, post-processing of the CSV output will be required
 to obtain per-method metric values.
 
 ## Method filtering
 
-Specifying one of the debug scope options (i.e., `-Dgraal.Log`, `-Dgraal.Dump`, `-Dgraal.Count`,
-`-Dgraal.Time`, or `-Dgraal.TrackMemUse`) can generate a lot of output. Typically, you are only
+Specifying one of the debug scope options (i.e., `-Djdk.graal.Log`, `-Djdk.graal.Dump`, `-Djdk.graal.Count`,
+`-Djdk.graal.Time`, or `-Djdk.graal.TrackMemUse`) can generate a lot of output. Typically, you are only
 interesting in compiler output related to a single or few methods. In this case, use the
-`-Dgraal.MethodFilter` option to specify a method filter. The matching logic for this option is
+`-Djdk.graal.MethodFilter` option to specify a method filter. The matching logic for this option is
 described in
 [MethodFilter](../src/jdk.graal.compiler/src/jdk/graal/compiler/debug/MethodFilter.java#L33-L92)
 and documented in the
 [MethodFilter help message](../src/jdk.graal.compiler/src/jdk/graal/compiler/debug/doc-files/MethodFilterHelp.txt).
 
 ## Metric filtering
 
-Alternatively, you may only want to see certain metrics. The `-Dgraal.Timers`, `-Dgraal.Counters`
-and `-Dgraal.MemUseTrackers` exist for this purpose.  These options take a comma separated list of
+Alternatively, you may only want to see certain metrics. The `-Djdk.graal.Timers`, `-Djdk.graal.Counters`
+and `-Djdk.graal.MemUseTrackers` exist for this purpose.  These options take a comma separated list of
 metrics names. Only the named metrics will be activated and reported. To see the available metric
-names, specify `-Dgraal.ListMetrics=true`. At VM shutdown this option lists all the metrics that
+names, specify `-Djdk.graal.ListMetrics=true`. At VM shutdown this option lists all the metrics that
 were encountered during the VM execution. It does not list metrics registered on non-executed paths
 since metric registration is lazy.  For example, to see all the metrics available in a boot strap:
-``` mx vm -XX:+UseJVMCICompiler -XX:+BootstrapJVMCI -Dgraal.ListMetrics=true -version ```
+``` mx vm -XX:+UseJVMCICompiler -XX:+BootstrapJVMCI -Djdk.graal.ListMetrics=true -version ```
 
 ## Dumping
 
@@ -218,19 +218,19 @@ visualizations of certain compiler data structures. Currently, there is support
   [Ideal Graph Visualizer (IGV)](../../docs/tools/ideal-graph-visualizer.md), and
 * LIR register allocation and generated code to the [C1Visualizer](https://github.com/zakkak/c1visualizer)
 
-Dumping is enabled via the `-Dgraal.Dump` option. The dump handler for generating C1Visualizer
-output will also generate output for LIR graphs if the `-Dgraal.PrintBackendCFG=true` option is specified
-(in addition to the `-Dgraal.Dump` option).
+Dumping is enabled via the `-Djdk.graal.Dump` option. The dump handler for generating C1Visualizer
+output will also generate output for LIR graphs if the `-Djdk.graal.PrintBackendCFG=true` option is specified
+(in addition to the `-Djdk.graal.Dump` option).
 
-By default, `-Dgraal.Dump` output is written to the local file system in a directory determined
-by the `-Dgraal.DumpPath` option (default is `$CWD/graal_dumps`). You can send dumps directly to
-the IGV over a network socket with the `-Dgraal.PrintGraph=Network` option. The `-Dgraal.PrintGraphHost`
-and `-Dgraal.PrintGraphPort` options determine where the dumps are sent. By default, they are
+By default, `-Djdk.graal.Dump` output is written to the local file system in a directory determined
+by the `-Djdk.graal.DumpPath` option (default is `$CWD/graal_dumps`). You can send dumps directly to
+the IGV over a network socket with the `-Djdk.graal.PrintGraph=Network` option. The `-Djdk.graal.PrintGraphHost`
+and `-Djdk.graal.PrintGraphPort` options determine where the dumps are sent. By default, they are
 sent to _127.0.0.1:4445_ and IGV listens on port 4445 by default.
 
 By default, the graph dumping code dumps every graph at a particular level even if the graph hasn't
 changed since the previous dump.  Internally the compiler tracks when changes are made to the edges
-of the graph and setting the flag `-Dgraal.PrintUnmodifiedGraphs=false` will cause it to elide graph
+of the graph and setting the flag `-Djdk.graal.PrintUnmodifiedGraphs=false` will cause it to elide graph
 dumps when no edges have changed since the previous dump.  This can greatly reduce the number of
 graphs dumped at high dump levels, though the resulting output can be a little harder to understand
 without the context of the other graph names.
@@ -243,15 +243,15 @@ The IGV can be launched with `mx igv` and the C1Visualizer can be launched via `
 
 Various other VM options are of interest to see activity related to compilation:
 
-- `-XX:+PrintCompilation` or `-Dgraal.PrintCompilation=true` for notification and brief info about each compilation
+- `-XX:+PrintCompilation` or `-Djdk.graal.PrintCompilation=true` for notification and brief info about each compilation
 - `-XX:+TraceDeoptimization` can be useful to see if excessive compilation is occurring
 
 ## Examples
 #### Inspecting the compilation of a single method
 
 To see the compiler data structures used while compiling `Node.updateUsages`, use the following command:
 ```
-> mx vm -XX:+UseJVMCICompiler -XX:+BootstrapJVMCI -XX:-TieredCompilation -Dgraal.Dump= -Dgraal.MethodFilter=Node.updateUsages -version
+> mx vm -XX:+UseJVMCICompiler -XX:+BootstrapJVMCI -XX:-TieredCompilation -Djdk.graal.Dump= -Djdk.graal.MethodFilter=Node.updateUsages -version
 Bootstrapping JVMCI....Dumping debug output in /Users/dsimon/graal/graal/compiler/dumps/1497910458736
 ................................................ in 38177 ms (compiled 5206 methods)
 java version "1.8.0_212"
@@ -262,12 +262,12 @@ dumps/1497910458736/HotSpotCompilation-539[jdk.graal.compiler.graph.Node.updateU
 dumps/1497910458736/HotSpotCompilation-539[jdk.graal.compiler.graph.Node.updateUsages(Node, Node)].cfg
 ```
 
-As you become familiar with the scope names used in the compiler, you can refine the `-Dgraal.Dump` option
+As you become familiar with the scope names used in the compiler, you can refine the `-Djdk.graal.Dump` option
 to limit the amount of dump output generated. For example, the `"CodeGen"` and `"CodeInstall"`
 scopes are active during code generation and installation respectively. To see the machine code (in
 the C1Visualizer) produced during these scopes:
 ```
- mx vm -Dgraal.Dump=CodeGen,CodeInstall -Dgraal.MethodFilter=NodeClass.get -version
+ mx vm -Djdk.graal.Dump=CodeGen,CodeInstall -Djdk.graal.MethodFilter=NodeClass.get -version
 ```
 You will notice that no IGV output is generated by this command.
 

compiler/docs/JMH.md

@@ -23,7 +23,7 @@ If you want to run a Truffle JMH benchmark, try:
 
 ```
 cd compiler
-mx benchmark truffle:JMH_1_21 -- -Dgraal.CompileGraalWithC1Only=false -- BenchmarkName
+mx benchmark truffle:JMH_1_21 -- -Djdk.graal.CompileGraalWithC1Only=false -- BenchmarkName
 ```
 
 If you do not know or want to learn more, continue reading.