[GR-60584] [GR-64433] [GR-67907] Move polybench to truffle and unchain it.

PullRequest: graal/19818

Author: DSouzaM

vm/benchmarks/interpreter/java/DeltaBlue/DeltaBlue.java renamed to espresso/benchmarks/interpreter/DeltaBlue/DeltaBlue.java

@@ -36,7 +36,7 @@
 import mx_subst
 import mx_util
 import mx_gate
-import mx_espresso_benchmarks  # pylint: disable=unused-import
+import mx_espresso_benchmarks
 import mx_sdk_vm
 import mx_sdk_vm_impl
 from mx_gate import Task, add_gate_runner
@@ -99,7 +99,7 @@ def _espresso_standalone_command(args, with_sulong=False, allow_jacoco=True, jdk
     )
 
 def javavm_deps():
-    result = [espresso_resources_suite() + ':ESPRESSO_RUNTIME_RESOURCES']
+    result = [espresso_runtime_resources_distribution()]
     if mx.suite('truffle-enterprise', fatalIfMissing=False):
         result.append('truffle-enterprise:TRUFFLE_ENTERPRISE')
     if mx.suite('regex', fatalIfMissing=False):
@@ -212,6 +212,8 @@ def _run_verify_imports(s):
     # Find invalid files
     invalid_files = []
     for project in s.projects:
+        if getattr(project, "skipVerifyImports", False):
+            continue
         output_root = project.get_output_root()
         for src_dir in project.source_dirs():
             if src_dir.startswith(output_root):
@@ -581,6 +583,8 @@ def mx_register_dynamic_suite_constituents(register_project, register_distributi
         community_dist_name=f'GRAALVM_ESPRESSO_COMMUNITY_JAVA{java_home_dep.major_version}{dist_suffix}',
         enterprise_dist_name=f'GRAALVM_ESPRESSO_JAVA{java_home_dep.major_version}{dist_suffix}'))
 
+    mx_espresso_benchmarks.mx_register_dynamic_suite_constituents(register_project, register_distribution)
+
 
 def espresso_resources_suite(java_home_dep=None):
     # Espresso resources are in the CE/EE suite depending on espresso java home type
@@ -592,6 +596,10 @@ def espresso_resources_suite(java_home_dep=None):
         return 'espresso'
 
 
+def espresso_runtime_resources_distribution(java_home_dep=None):
+    return espresso_resources_suite(java_home_dep=java_home_dep) + ':ESPRESSO_RUNTIME_RESOURCES'
+
+
 def register_espresso_runtime_resources(register_project, register_distribution, suite):
     if espresso_resources_suite() != suite.name:
         return

vm/benchmarks/interpreter/java/Fibonacci/Fibonacci.java renamed to espresso/benchmarks/interpreter/Fibonacci/Fibonacci.java

@@ -20,19 +20,108 @@
 # or visit www.oracle.com if you need additional information or have any
 # questions.
 #
+import os
 import re
 from abc import ABCMeta, abstractmethod
 
 import mx
 import mx_benchmark
 import mx_espresso
+import mx_jardistribution
+import mx_polybench
 
 from mx_benchmark import GuestVm, JavaVm, OutputCapturingJavaVm
 from mx_sdk_benchmark import _daCapoScalaConfig
 
 _suite = mx.suite('espresso')
 
 
+def mx_register_dynamic_suite_constituents(register_project, register_distribution):
+    benchmark_dist = _suite.dependency("ESPRESSO_POLYBENCH_BENCHMARKS")
+    polybench_benchmarks = os.path.join(_suite.dir, 'benchmarks', 'interpreter')
+    for f in os.listdir(polybench_benchmarks):
+        if os.path.isdir(os.path.join(polybench_benchmarks, f)) and not f.startswith("."):
+            main_class = os.path.basename(f)
+            simple_name = main_class.split(".")[-1]
+
+            project_name = 'benchmarks.interpreter.espresso.' + simple_name.lower()
+            register_project(mx.JavaProject(
+                suite=_suite,
+                subDir=None,
+                srcDirs=[os.path.join(_suite.dir, 'benchmarks', 'interpreter', main_class)],
+                deps=[],
+                name=project_name,
+                d=os.path.join(_suite.dir, 'benchmarks', 'interpreter', main_class),
+                javaCompliance='11+',
+                workingSets=None,
+                testProject=True,
+                eclipseformat=False,
+                skipVerifyImports=True,
+                # javac and JDT both produce warnings on these sources. suppress javac warnings and avoid JDT.
+                forceJavac=True,
+                checkstyleProj=project_name,
+                **{
+                    "javac.lint.overrides": "none",
+                }
+            ))
+
+            dist_name = 'ESPRESSO_POLYBENCH_BENCHMARK_' + simple_name.upper()
+            jar_dist = mx_jardistribution.JARDistribution(
+                suite=_suite,
+                subDir=None,
+                srcDirs=[''],
+                sourcesPath=None,
+                deps=[project_name],
+                mainClass=main_class,
+                name=dist_name,
+                path='',
+                platformDependent=False,
+                distDependencies=[],
+                javaCompliance='11+',
+                excludedLibs=[],
+                workingSets=None,
+                theLicense=None,
+                testDistribution=True,
+                maven=False,
+            )
+            register_distribution(jar_dist)
+
+            benchmark_dist.layout[f'./interpreter/{simple_name}.jar'] = [
+                f'dependency:{dist_name}/*.jar']
+            benchmark_dist.buildDependencies.append(dist_name)
+
+    espresso_runtime_resources_distribution = mx_espresso.espresso_runtime_resources_distribution()
+    mx_polybench.register_polybench_language(mx_suite=_suite, language="espresso",
+                                             distributions=["ESPRESSO", "ESPRESSO_LIBS_RESOURCES",
+                                                            espresso_runtime_resources_distribution, "truffle:TRUFFLE_NFI_LIBFFI"])
+
+    def espresso_polybench_runner(polybench_run: mx_polybench.PolybenchRunFunction, tags) -> None:
+        if "gate" in tags:
+            polybench_run(["--jvm", "interpreter/*.jar", "--experimental-options", "--engine.Compilation=false", "-w", "1", "-i", "1"])
+            polybench_run(["--native", "interpreter/*.jar", "--experimental-options", "--engine.Compilation=false", "-w", "1", "-i", "1"])
+        if "benchmark" in tags:
+            polybench_run(["--jvm", "interpreter/*.jar", "--experimental-options", "--engine.Compilation=false"])
+            polybench_run(["--native", "interpreter/*.jar", "--experimental-options", "--engine.Compilation=false"])
+            polybench_run(["--jvm", "interpreter/*.jar"])
+            polybench_run(["--native", "interpreter/*.jar"])
+            polybench_run(["--jvm", "interpreter/*.jar", "--metric=metaspace-memory"])
+            polybench_run(["--jvm", "interpreter/*.jar", "--metric=application-memory"])
+            polybench_run(["--jvm", "interpreter/*.jar", "--metric=allocated-bytes", "-w", "40", "-i", "10", "--experimental-options", "--engine.Compilation=false"])
+            polybench_run(["--native", "interpreter/*.jar", "--metric=allocated-bytes", "-w", "40", "-i", "10", "--experimental-options", "--engine.Compilation=false"])
+            polybench_run(["--jvm", "interpreter/*.jar", "--metric=allocated-bytes", "-w", "40", "-i", "10"])
+            polybench_run(["--native", "interpreter/*.jar", "--metric=allocated-bytes", "-w", "40", "-i", "10"])
+        if "instructions" in tags:
+            assert mx_polybench.is_enterprise()
+            fork_count_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "polybench-fork-counts.json")
+            polybench_run(["--native", "interpreter/*.jar", "--metric=instructions", "--experimental-options", "--engine.Compilation=false",
+                           "--mx-benchmark-args", "--fork-count-file", fork_count_file])
+
+    mx_polybench.register_polybench_benchmark_suite(mx_suite=_suite, name="espresso", languages=["espresso"],
+                                                    benchmark_distribution=benchmark_dist.name,
+                                                    benchmark_file_filter=".*jar", runner=espresso_polybench_runner,
+                                                    tags={"gate", "benchmark", "instructions"})
+
+
 class EspressoStandaloneVm(OutputCapturingJavaVm, metaclass=ABCMeta):
     def __init__(self, config_name, options):
         super().__init__()

vm/benchmarks/interpreter/java/Richards/Richards.java renamed to espresso/benchmarks/interpreter/Richards/Richards.java

@@ -0,0 +1,6 @@
+{
+  "polybench:interpreter/DeltaBlue.jar": 5,
+  "polybench:interpreter/Fibonacci.jar": 5,
+  "polybench:interpreter/Richards.jar": 5,
+  "polybench:interpreter/Sieve.jar": 5
+}

vm/benchmarks/interpreter/java/Sieve/Sieve.java renamed to espresso/benchmarks/interpreter/Sieve/Sieve.java

@@ -935,5 +935,12 @@
             "dynamicDistDependencies": "jvm_standalone_deps",
             "maven": False,
         },
+
+        "ESPRESSO_POLYBENCH_BENCHMARKS": {
+            "description": "Distribution for Espresso polybench benchmarks",
+            "layout": {
+                # Layout is dynamically populated in mx_register_dynamic_suite_constituents
+            },
+        },
     }
 }

espresso/mx.espresso/mx_espresso.py

@@ -440,23 +440,32 @@ def build_report_args(self, is_gate: bool, graalvm_edition: str):
         return ['--emit=build-report'] if is_gate and graalvm_edition == "ee" else []
 
     def get_executable_name_and_output_dir_for_stage(self, stage: Stage, vm: NativeImageVM) -> Tuple[str, Path]:
-        # Form executable name
-        unique_suite_name = f"{self.bm_suite.benchSuiteName()}-{self.bm_suite.version().replace('.', '-')}" if self.bm_suite.version() != 'unknown' else self.bm_suite.benchSuiteName()
-        executable_name = (
-                unique_suite_name + '-' + self.benchmark_name).lower() if self.benchmark_name else unique_suite_name.lower()
+        executable_name = self.compute_executable_name()
         is_shared_library = stage is not None and stage.is_layered() and stage.layer_info.is_shared_library
         if is_shared_library:
             # Shared library layers have to start with 'lib' and are differentiated with the layer index
             executable_name = f"lib-layer{stage.layer_info.index}-{executable_name}"
 
         # Form output directory
         root_dir = Path(
-            self.benchmark_output_dir if self.benchmark_output_dir else mx.suite('vm').get_output_root(platformDependent=False,
+            self.benchmark_output_dir if self.benchmark_output_dir else mx.suite('sdk').get_output_root(platformDependent=False,
                                                                                              jdkDependent=False)).absolute()
         output_dir = root_dir / "native-image-benchmarks" / f"{executable_name}-{vm.config_name()}"
 
         return executable_name, output_dir
 
+    def compute_executable_name(self) -> str:
+        result = self.bm_suite.executable_name()
+        if result is not None:
+            return result
+
+        parts = [self.bm_suite.benchSuiteName()]
+        if self.bm_suite.version() != "unknown":
+            parts.append(self.bm_suite.version().replace(".", "-"))
+        if self.benchmark_name:
+            parts.append(self.benchmark_name.replace(os.sep, "_"))
+        return "-".join(parts).lower()
+
     def get_build_output_json_file(self, stage: StageName) -> Path:
         """
         Path to the build output statistics JSON file (see also ``-H:BuildOutputJSONFile``).
@@ -1810,6 +1819,11 @@ def _layerize_stages(self, bm_suite, bm_suite_args, stages: List[Stage]) -> List
         return layered_stages
 
 
+# Adds JAVA_HOME VMs so benchmarks can run on GraalVM binaries without building them first.
+for java_home_config in ['default', 'pgo', 'g1gc', 'g1gc-pgo', 'upx', 'upx-g1gc', 'quickbuild', 'quickbuild-g1gc']:
+    mx_benchmark.add_java_vm(NativeImageVM('native-image-java-home', java_home_config), _suite, 5)
+
+
 class ObjdumpSectionRule(mx_benchmark.StdOutRule):
     PATTERN = re.compile(r"^ *(?P<section_num>\d+)[ ]+.(?P<section>[a-zA-Z0-9._-]+?) +(?P<size>[0-9a-f]+?) +",
                          re.MULTILINE)
@@ -4197,6 +4211,10 @@ def get_stage_env(self) -> Optional[dict]:
         """Return the environment to be used when executing a stage."""
         return None
 
+    def executable_name(self) -> Optional[str]:
+        """Override to allow suites to control the executable name used in image builds."""
+        return None
+
 
 def measureTimeToFirstResponse(bmSuite):
     protocolHost = bmSuite.serviceHost()

espresso/mx.espresso/mx_espresso_benchmarks.py

@@ -0,0 +1,47 @@
+#
+# Copyright (c) 2025, 2025, Oracle and/or its affiliates.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification, are
+# permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+# conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list of
+# conditions and the following disclaimer in the documentation and/or other materials provided
+# with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used to
+# endorse or promote products derived from this software without specific prior written
+# permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+# GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+# OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+QUIETLY$(MX_VERBOSE) = @
+
+.PHONY: default
+
+SOURCE_FILES=$(wildcard ${VPATH}/*.c)
+SOURCES=${SOURCE_FILES:${VPATH}/%=%}
+BC_NATIVE_FILES=${SOURCES:%.c=interpreter/%.c.native.bc}
+
+default: ${BC_NATIVE_FILES}
+
+ifndef NATIVE_LLVM_CC
+$(error NATIVE_LLVM_CC not set)
+endif
+
+interpreter/%.c.native.bc: %.c Makefile
+	@mkdir -p $(shell dirname $@)
+	$(QUIETLY) $(NATIVE_LLVM_CC) -o $@ -c $<