Merge branch 'oracle:master' into master

Author: dasarathirout

common.json

@@ -4,7 +4,7 @@
     "Jsonnet files should not include this file directly but use ci/common.jsonnet instead."
   ],
 
-  "mx_version": "7.61.0",
+  "mx_version": "7.62.0",
 
   "COMMENT.jdks": "When adding or removing JDKs keep in sync with JDKs in ci/common.jsonnet",
   "jdks": {

sdk/mx.sdk/mx_sdk.py

@@ -200,6 +200,7 @@ def mx_register_dynamic_suite_constituents(register_project, register_distributi
 
 def mx_post_parse_cmd_line(args):
     mx_sdk_vm_impl.mx_post_parse_cmd_line(args)
+    mx_sdk_benchmark.register_graalvm_vms()
 
 
 mx.update_commands(_suite, {

sdk/mx.sdk/mx_sdk_benchmark.py

@@ -157,6 +157,9 @@ def post_process_command_line_args(self, args):
         return [arg if not callable(arg) else arg() for arg in self.extra_args] + args
 
     def get_jdk(self):
+        if self.run_on_java_home():
+            # forcing the use of the default JAVA_HOME VM as runtime instead of the one pointed at by the tag
+            return mx.get_jdk()
         tag = mx.get_jdk_option().tag
         if tag and tag != JVMCI_JDK_TAG:
             mx.abort("The '{0}/{1}' VM requires '--jdk={2}'".format(
@@ -254,7 +257,7 @@ def post_process_launcher_command_line_args(self, args):
             args
 
     def home(self):
-        if self.name() == 'native-image-java-home':
+        if self.run_on_java_home() or self.name() == 'native-image-java-home':
             return mx.get_jdk().home
         return mx_sdk_vm_impl.graalvm_home(fatalIfMissing=True)
 
@@ -341,18 +344,24 @@ def __init__(self, vm: NativeImageVM, bm_suite: BenchmarkSuite | NativeImageBenc
         self.skip_agent_assertions = bm_suite.skip_agent_assertions(self.benchmark_name, args)
         current_stage = vm.stages_info.current_stage
         is_shared_library = current_stage is not None and current_stage.is_layered() and current_stage.layer_info.is_shared_library
+        # base image name (used for auxiliary output files)
+        base_image_name = self.bm_suite.get_base_image_name(shared_library_layer_index=current_stage.layer_info.index if is_shared_library else None)
+        # full image name qualified with vm suffix (passed as -o argument to native-image)
+        self.final_image_name = self.bm_suite.get_full_image_name(base_image_name, vm.config_name())
+        # root directory for all output. can be overridden with -Dnative-image.benchmark.benchmark-output-dir
         self.benchmark_output_dir = self.bm_suite.benchmark_output_dir(self.benchmark_name, args)
-        executable_name, output_dir = self.get_executable_name_and_output_dir_for_stage(current_stage, vm)
-        self.executable_name: str = executable_name
-        self.output_dir: Path = output_dir
-        self.final_image_name = self.executable_name + '-' + vm.config_name()
-        self.profile_path: Path = self.output_dir / f"{self.executable_name}.iprof"
-        self.source_mappings_path: Path = self.output_dir / f"{self.executable_name}.sourceMappings.json"
-        self.perf_script_path: Path = self.output_dir / f"{self.executable_name}.perf.script.out"
-        self.perf_data_path: Path = self.output_dir / f"{self.executable_name}.perf.data"
+        # specific directory with output for this image build.
+        self.output_dir: Path = self.bm_suite.get_image_output_dir(self.benchmark_output_dir, self.final_image_name)
+        # path of the final executable.
+        self.image_path: Path = self.output_dir / self.bm_suite.get_image_file_name(self.final_image_name, shared_library=is_shared_library)
+        self.instrumented_image_path = self.output_dir / self.bm_suite.get_image_file_name(f"{base_image_name}-instrument")
+        self.profile_path: Path = self.output_dir / f"{base_image_name}.iprof"
+        self.source_mappings_path: Path = self.output_dir / f"{base_image_name}.sourceMappings.json"
+        self.perf_script_path: Path = self.output_dir / f"{base_image_name}.perf.script.out"
+        self.perf_data_path: Path = self.output_dir / f"{base_image_name}.perf.data"
         self.config_dir: Path = self.output_dir / "config"
         self.log_dir: Path = self.output_dir
-        self.ml_log_dump_path: Path = self.output_dir / f"{self.executable_name}.ml.log.csv"
+        self.ml_log_dump_path: Path = self.output_dir / f"{base_image_name}.ml.log.csv"
         base_image_build_args = ['--no-fallback']
         if not vm.pgo_use_perf:
             # Can only have debug info when not using perf, [GR-66850]
@@ -405,13 +414,6 @@ def __init__(self, vm: NativeImageVM, bm_suite: BenchmarkSuite | NativeImageBenc
 
         self.image_build_reports_directory: Path = self.output_dir / "reports"
 
-        # Path of the final executable
-        self.image_path = self.output_dir / self.final_image_name
-        self.instrumented_image_path = self.output_dir / f"{self.executable_name}-instrument"
-        if is_shared_library:
-            self.image_path = self.image_path.parent / f"{self.image_path.name}.so"
-            self.instrumented_image_path = self.instrumented_image_path.parent / f"{self.instrumented_image_path.name}.so"
-
         if vm.is_quickbuild:
             base_image_build_args += ['-Ob']
         if vm.graalos or vm.graalhost_graalos:
@@ -465,33 +467,6 @@ def build_report_args(self, is_gate: bool, graalvm_edition: str):
         # Generate Build Report only when the benchmark is a part of EE gate.
         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]:
-        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('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``).
@@ -1638,7 +1613,10 @@ def get_layer_aware_build_args(self) -> List[str]:
                 mx.abort("Failed to find any shared library layer image stages!")
             layer_output_dirs = []
             for stage in shared_library_stages:
-                _, stage_output_dir = self.config.get_executable_name_and_output_dir_for_stage(stage, self)
+                assert isinstance(self.bmSuite, NativeImageBenchmarkMixin)
+                layer_base_image_name = self.bmSuite.get_base_image_name(shared_library_layer_index=stage.layer_info.index)
+                layer_full_image_name = self.bmSuite.get_full_image_name(layer_base_image_name, self.config_name())
+                stage_output_dir = self.bmSuite.get_image_output_dir(self.config.benchmark_output_dir, layer_full_image_name)
                 layer_output_dirs.append(stage_output_dir.absolute().as_posix())
             linker_r_path = ",".join(layer_output_dirs)
             app_layer_build_args = [f"-H:LinkerRPath={linker_r_path}"]
@@ -1845,9 +1823,29 @@ 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)
+def register_graalvm_vms():
+    # a simple JVM config that runs without any custom flag
+    mx_benchmark.add_java_vm(JvmciJdkVm('server', 'vanilla', []), _suite, 2)
+
+    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)
+
+    optimization_levels = ['O0', 'O1', 'O2', 'O3', 'Os']
+    analysis_context_sensitivity = ['insens', 'allocsens', '1obj', '2obj1h', '3obj2h', '4obj3h']
+
+    for short_name, config_suffix in [(None, ''), ('niee', '-ee'), ('ni', '-ce')]:
+        if short_name is None or any(component.short_name == short_name for component in mx_sdk_vm_impl.registered_graalvm_components(stage1=False)):
+            config_names = list()
+            for main_config in ['default', 'gate', 'llvm', 'native-architecture', 'future-defaults-all', 'preserve-all', 'preserve-classpath'] + analysis_context_sensitivity + (['g1gc', 'pgo', 'g1gc-pgo'] if config_suffix != '-ce' else []):
+                config_names.append(f'{main_config}{config_suffix}')
+
+            for optimization_level in optimization_levels:
+                config_names.append(f'{optimization_level}{config_suffix}')
+                for main_config in ['llvm', 'native-architecture', 'g1gc', 'native-architecture-g1gc', 'preserve-all', 'preserve-classpath'] + analysis_context_sensitivity:
+                    config_names.append(f'{main_config}-{optimization_level}{config_suffix}')
+
+            for config_name in config_names:
+                mx_benchmark.add_java_vm(NativeImageVM('native-image', config_name, ['--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED']), _suite, 10)
 
 
 class ObjdumpSectionRule(mx_benchmark.StdOutRule):
@@ -4196,7 +4194,7 @@ def benchmark_output_dir(self, _, args):
         if parsed_args:
             return parsed_args[0]
         else:
-            return None
+            return mx.suite('sdk').get_output_root(platformDependent=False, jdkDependent=False)
 
     def filter_stages_with_cli_requested_stages(self, bm_suite_args: List[str], stages: List[Stage]) -> List[Stage]:
         """
@@ -4252,9 +4250,47 @@ 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 _base_image_name(self: BenchmarkSuite | NativeImageBenchmarkMixin) -> str:
+        """
+        Returns the name to use in image builds. May be overridden.
+        Note that this name is not necessarily the full image name (there may be prefixes/suffixes added).
+        Use `get_image_path` to obtain the final image path.
+        """
+        parts = [self.benchSuiteName()]
+        if self.version() != "unknown":
+            parts.append(self.version().replace(".", "-"))
+        parts.append(self.benchmarkName())
+        return "-".join(parts).lower()
+
+    def get_base_image_name(self, shared_library_layer_index: Optional[int] = None) -> str:
+        """
+        Returns the base image name to use for auxiliary build files (e.g., iprof files).
+        """
+        base_image_name = self._base_image_name()
+        if shared_library_layer_index is not None:
+            # Shared library layers have to start with 'lib' and are differentiated with the layer index
+            base_image_name = f"lib-layer{shared_library_layer_index}-{base_image_name}"
+        return base_image_name
+
+    def get_full_image_name(self, base_image_name: str, vm_config: str) -> str:
+        """
+        Returns the base image name qualified by the vm suffix. This name is passed as the -o argument to native-image.
+        """
+        return f"{base_image_name}-{vm_config}"
+
+    def get_image_file_name(self, full_image_name: str, shared_library: bool = False) -> str:
+        """
+        Returns the file name of the generated image.
+        """
+        if shared_library:
+            return f"{full_image_name}.so"
+        return full_image_name
+
+    def get_image_output_dir(self, benchmark_output_dir: str, full_image_name: str) -> Path:
+        """
+        Returns the output directory for the given image name, as a subdirectory of the root output directory.
+        """
+        return Path(benchmark_output_dir).absolute() / "native-image-benchmarks" / full_image_name
 
 
 def measureTimeToFirstResponse(bmSuite):

sdk/src/org.graalvm.nativebridge.launcher/src/launcher.cc

@@ -51,13 +51,18 @@
 
 #if defined(__linux__)
 #include<dlfcn.h>
+#include<sys/stat.h>
+#include<unistd.h>
 #elif defined(__APPLE__)
 #include<dlfcn.h>
 #include<pthread.h>
+#include<sys/stat.h>
+#include<unistd.h>
 #include<Cocoa/Cocoa.h>
 #include<objc/objc-runtime.h>
 #include<objc/objc-auto.h>
 #elif defined(_WIN32)
+#include <io.h>
 #include<windows.h>
 #include<libloaderapi.h>
 #include<process.h>
@@ -105,6 +110,20 @@ static CreateJavaVM loadIsolateLibrary(const std::string library_path) {
         const char* err = dlerror();
         std::stringstream builder {};
         builder << "Failed to load isolate library " << library_path;
+        struct stat sb;
+        if (stat(library_path.c_str(), &sb) == -1) {
+            builder << " (file does not exist)";
+        } else {
+            if (!S_ISREG(sb.st_mode)) {
+                builder << " (not a regular file)";
+            } else {
+                bool readable = (access(library_path.c_str(), R_OK) == 0);
+                bool executable = (access(library_path.c_str(), X_OK) == 0);
+                builder << " (regular file, "
+                        << (readable ? "readable" : "not readable") << ", "
+                        << (executable ? "executable" : "not executable") << ")";
+            }
+        }
         if (err) {
             builder << " due to: " << err;
         }
@@ -115,8 +134,39 @@ static CreateJavaVM loadIsolateLibrary(const std::string library_path) {
     if (handle) {
         return reinterpret_cast<CreateJavaVM>(GetProcAddress(handle, "JNI_CreateJavaVM"));
     } else {
+        DWORD errorMessageID = GetLastError();
+        std::string err;
+        if (errorMessageID != 0) {
+            LPSTR messageBuffer = nullptr;
+            size_t size = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+                                         nullptr,
+                                         errorMessageID,
+                                         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                                         (LPSTR)&messageBuffer,
+                                         0,
+                                        nullptr);
+            err = std::string {messageBuffer, size};
+            LocalFree(messageBuffer);
+        };
         std::stringstream builder {};
         builder << "Failed to load isolate library " << library_path;
+        DWORD attrs = GetFileAttributesA(library_path.c_str());
+        if (attrs == INVALID_FILE_ATTRIBUTES) {
+            builder << " (file does not exist)";
+        } else {
+            if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
+                builder << " (is a directory)";
+            } else {
+                bool readable = (_access(library_path.c_str(), 4) == 0);
+                bool executable = (_access(library_path.c_str(), 1) == 0);
+                builder << " (regular file, "
+                        << (readable ? "readable" : "not readable") << ", "
+                        << (executable ? "executable" : "not executable") << ")";
+            }
+        }
+        if (!err.empty()) {
+            builder << " due to: " << err;
+        }
         ABORT(builder.str().c_str())
     }
 #else

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/results/StrengthenGraphs.java

@@ -60,6 +60,7 @@
 import jdk.graal.compiler.nodes.calc.IntegerEqualsNode;
 import jdk.graal.compiler.nodes.calc.IntegerLowerThanNode;
 import jdk.graal.compiler.nodes.calc.IsNullNode;
+import jdk.graal.compiler.nodes.extended.BranchProbabilityNode;
 import jdk.graal.compiler.nodes.extended.ValueAnchorNode;
 import jdk.graal.compiler.nodes.java.InstanceOfNode;
 import jdk.graal.compiler.nodes.java.LoadFieldNode;
@@ -322,7 +323,8 @@ protected JavaTypeProfile makeTypeProfile(TypeState typeState, boolean injectNot
     }
 
     private JavaTypeProfile createTypeProfile(TypeState typeState, boolean injectNotRecordedProbability) {
-        double probability = 1d / (typeState.typesCount() + (injectNotRecordedProbability ? 1 : 0));
+        final double notRecordedProb = injectNotRecordedProbability ? BranchProbabilityNode.EXTREMELY_SLOW_PATH_PROBABILITY : 0.0d;
+        final double probability = (1.0 - notRecordedProb) / typeState.typesCount();
 
         Stream<? extends ResolvedJavaType> stream = typeState.typesStream(bb);
         if (converter != null) {
@@ -332,7 +334,7 @@ private JavaTypeProfile createTypeProfile(TypeState typeState, boolean injectNot
                         .map(type -> new JavaTypeProfile.ProfiledType(type, probability))
                         .toArray(JavaTypeProfile.ProfiledType[]::new);
 
-        return new JavaTypeProfile(TriState.get(typeState.canBeNull()), injectNotRecordedProbability ? probability : 0, pitems);
+        return new JavaTypeProfile(TriState.get(typeState.canBeNull()), notRecordedProb, pitems);
     }
 
     protected JavaMethodProfile makeMethodProfile(Collection<AnalysisMethod> callees, boolean injectNotRecordedProbability) {
@@ -347,15 +349,16 @@ protected JavaMethodProfile makeMethodProfile(Collection<AnalysisMethod> callees
     private CachedJavaMethodProfile createMethodProfile(Collection<AnalysisMethod> callees, boolean injectNotRecordedProbability) {
         JavaMethodProfile.ProfiledMethod[] pitems = new JavaMethodProfile.ProfiledMethod[callees.size()];
         int hashCode = 0;
-        double probability = 1d / (pitems.length + (injectNotRecordedProbability ? 1 : 0));
+        final double notRecordedProb = injectNotRecordedProbability ? BranchProbabilityNode.EXTREMELY_SLOW_PATH_PROBABILITY : 0.0d;
+        final double probability = (1.0 - notRecordedProb) / pitems.length;
 
         int idx = 0;
         for (AnalysisMethod aMethod : callees) {
             ResolvedJavaMethod convertedMethod = converter == null ? aMethod : converter.lookup(aMethod);
             pitems[idx++] = new JavaMethodProfile.ProfiledMethod(convertedMethod, probability);
             hashCode = hashCode * 31 + convertedMethod.hashCode();
         }
-        return new CachedJavaMethodProfile(new JavaMethodProfile(injectNotRecordedProbability ? probability : 0, pitems), hashCode);
+        return new CachedJavaMethodProfile(new JavaMethodProfile(notRecordedProb, pitems), hashCode);
     }
 }