Adapt polybench to use --prebuilt-vm flag

Author: DSouzaM

truffle/mx.truffle/mx_polybench/command.py

@@ -368,10 +368,17 @@ class PolybenchRunSpecification(NamedTuple):
     def is_native(self) -> bool:
         return VMFeature.NATIVE in self.vm_features
 
-    def jvm_name(self) -> str:
-        return "native-image-java-home" if self.is_native() else "java-home"
+    def jvm_and_config(self) -> Tuple[str, str]:
+        if self.is_native():
+            # The VM config misses the 'ce'/'ee' suffix. The PolybenchBenchmarkSuite
+            # patches this in the output data.
+            return "native-image", self._native_vm_config()
+        else:
+            # The vanilla configuration does not inject any additional VM arguments.
+            # The PolybenchBenchmarkSuite overwrites this config in the output data.
+            return "server", "vanilla"
 
-    def jvm_config(self) -> str:
+    def _native_vm_config(self) -> str:
         features = []
         if VMFeature.G1GC in self.vm_features:
             features.append("g1gc")
@@ -387,10 +394,11 @@ def _run_specification(
     reuse_disk_images: bool = False,
 ):
     pattern = _parse_mx_benchmark_pattern(spec.pattern, pattern_is_glob)
+    jvm_name, jvm_config = spec.jvm_and_config()
     mx_benchmark_args = (
         [f"polybench:{pattern}"]
         + spec.arguments.mx_benchmark_args
-        + ["--", f"--jvm={spec.jvm_name()}", f"--jvm-config={spec.jvm_config()}"]
+        + ["--", f"--jvm={jvm_name}", f"--jvm-config={jvm_config}", "--prebuilt-vm"]
         + spec.arguments.vm_args
         + ["--"]
         + spec.arguments.polybench_args

truffle/mx.truffle/mx_polybench/model.py

@@ -461,11 +461,48 @@ def createCommandLineArgs(self, benchmarks, bmSuiteArgs):
         return vm_args + [PolybenchBenchmarkSuite.POLYBENCH_MAIN] + polybench_args
 
     def runAndReturnStdOut(self, benchmarks, bmSuiteArgs):
-        """Delegates to the super implementation then injects engine.config into every datapoint."""
         ret_code, out, dims = super().runAndReturnStdOut(benchmarks, bmSuiteArgs)
-        dims["engine.config"] = self._get_mode(bmSuiteArgs)
+        host_vm_config = self._infer_host_vm_config(bmSuiteArgs, dims)
+        guest_vm, guest_vm_config = self._infer_guest_vm_info(benchmarks, bmSuiteArgs)
+        dims.update(
+            {
+                "host-vm-config": host_vm_config,
+                "guest-vm": guest_vm,
+                "guest-vm-config": guest_vm_config,
+            }
+        )
         return ret_code, out, dims
 
+    def _infer_host_vm_config(self, bm_suite_args, dims):
+        edition = dims.get("platform.graalvm-edition", "unknown").lower()
+        if edition not in ["ce", "ee"] or not dims.get("platform.prebuilt-vm", False):
+            raise ValueError(f"Polybench should only run with a prebuilt GraalVM. Dimensions found: {dims}")
+
+        if self.is_native_mode(bm_suite_args):
+            # patch ce/ee suffix
+            existing_config = dims["host-vm-config"]
+            existing_edition = existing_config.split("-")[-1]
+            if existing_edition in ["ce", "ee"]:
+                assert (
+                    existing_edition == edition
+                ), f"Existing host-vm-config {existing_config} conflicts with GraalVM edition {edition}"
+                return existing_config
+            return dims["host-vm-config"] + "-" + edition
+        else:
+            # assume config used when building a GraalVM distribution
+            return "graal-enterprise-libgraal-pgo" if edition == "ee" else "graal-core-libgraal"
+
+    def _infer_guest_vm_info(self, benchmarks, bm_suite_args) -> Tuple[str, str]:
+        resolved_benchmark = self._resolve_current_benchmark(benchmarks)
+        guest_vm = "-".join(sorted(resolved_benchmark.suite.languages))
+        if "--engine.Compilation=false" in self.runArgs(
+            bm_suite_args
+        ) or "-Dpolyglot.engine.Compilation=false" in self.vmArgs(bm_suite_args):
+            guest_vm_config = "interpreter"
+        else:
+            guest_vm_config = "default"
+        return guest_vm, guest_vm_config
+
     def rules(self, output, benchmarks, bmSuiteArgs):
         metric_name = PolybenchBenchmarkSuite._get_metric_name(output)
         if metric_name is None:
@@ -586,14 +623,6 @@ def _get_metric_name(bench_output) -> Optional[str]:
             )
             return metric_name
 
-    def _get_mode(self, bmSuiteArgs):
-        """Determines the "mode" to report in benchmark data points."""
-        if "--engine.Compilation=false" in self.runArgs(
-            bmSuiteArgs
-        ) or "-Dpolyglot.engine.Compilation=false" in self.vmArgs(bmSuiteArgs):
-            return "interpreter"
-        return "standard"
-
 
 class ExcludeWarmupRule(mx_benchmark.StdOutRule):
     """Rule that behaves as the StdOutRule, but skips input until a certain pattern."""