env = os.environ.get(name)

if env is None:

return default

'--experimental-options',

'--python.PosixModuleBackend=java',

'--python.Sha3ModuleBackend=java',

'--python.CompressionModulesBackend=java',

'--python.PyExpatModuleBackend=java',

'--python.UnicodeCharacterDatabaseNativeFallback=false',

'test_entropy_subprocess',

'test_repl',

'test_reparse',

'test_venv',

'test_patched_pip',

'test_wheel',

'test_startup',

'cpyext/test_shutdown',

'cpyext/test_fatal_exit',

platform = f"{mx.get_os()}/{mx.get_arch()}"

libc = _libc()

if libc == "musl-swcfi":

if platform != "linux/amd64":

mx.abort(f"Unsupported GraalPy resource target: {platform}/{libc}")

return f"{platform}/{libc}"

if "musl" in libc:

mx.abort(f"No GraalPy resource variant for libc: {libc}")

non_internal = []

additional_dists = []

for arg in args:

# Class path extensions

if arg.startswith('-add-dist='):

additional_dists += [arg[10:]]

else:

non_internal += [arg]

if register_project and register_distribution:

isolate_build_options = [

'-H:+DetectUserDirectoriesInImageHeap',

]

meta_pom = None

for dist in SUITE.dists:

if dist.name == 'PYTHON_POM':

meta_pom = dist

assert meta_pom, "Cannot find python meta-POM distribution in the graalpython suite"

mx_truffle.register_polyglot_isolate_distributions(SUITE, register_project, register_distribution, 'python',

'graalpython', meta_pom.name, meta_pom.maven_group_id(), meta_pom.theLicense,

if not SUITE_COMPILER:

if must_be_jvmci:

mx.abort('** Error ** : graal compiler was not found!')

if vm_warning:

include_truffle_runtime = not mx.env_var_to_bool("EXCLUDE_TRUFFLE_RUNTIME")

deps = mx_truffle.resolve_truffle_dist_names(use_optimized_runtime=include_truffle_runtime)

if _with_bouncycastle():

mx.logv("Including bouncycastle with GraalPy standalone")

deps += [

"graalpython:GRAALPYTHON_BOUNCYCASTLE",

"graalpython:BOUNCYCASTLE-PROVIDER",

"graalpython:BOUNCYCASTLE-PKIX",

"graalpython:BOUNCYCASTLE-UTIL",

]

if not branch:

return ""

branch = branch.strip()

for prefix in ("refs/heads/", "origin/"):

if branch.startswith(prefix):

return branch[len(prefix):]

"""Return True if the GraalPy commit is already reachable from the branch."""

# Check the remote-tracking branch, not the local branch or HEAD. Regular branch-run

# workspaces may put a synthetic merge commit on a local branch, while origin/<branch>

# still represents the target branch state used to decide whether the GraalPy commit has

# really landed.

if not commit or not branch or not SUITE.vc:

return None

merge_base = SUITE.vc.git_command(

SUITE.dir,

["merge-base", commit, f"origin/{branch}"],

abortOnError=False,

)

"""Return target-branch ancestor commits that may have CI-generated PGO profiles."""

merge_base = _graalpython_merge_base_with_branch(commit, branch)

if not merge_base:

return []

commit_ts = SUITE.vc.git_command(

SUITE.dir,

["show", "-s", "--format=%ct", merge_base],

abortOnError=False,

)

if not commit_ts:

return []

try:

since_ts = int(commit_ts.strip()) - max_age_days * 24 * 60 * 60

except ValueError:

mx.warn(f"Cannot parse commit timestamp for GraalPy PGO profile search: {commit_ts!r}")

return []

candidates = SUITE.vc.git_command(

SUITE.dir,

["rev-list", "--first-parent", f"--since=@{since_ts}", merge_base],

abortOnError=False,

)

try:

return os.path.isfile(path or "") and os.path.getsize(path) > 0

except OSError:

"""Return the GraalPy commit imported by the target branch's VM suite.

vm_suite = mx.suite("vm", fatalIfMissing=False)

if not vm_suite or not vm_suite.vc:

mx.warn("Cannot resolve target-branch GraalPy import: mx suite 'vm' is not available")

return None

target_branch = _normalize_branch_name(target_branch)

suite_path = "vm/mx.vm/suite.py"

# Some CI checkouts do not keep origin/<target>. In PR merge checkouts, the

# first parent is the target branch side of the merge and therefore still

# gives us the target branch's imported GraalPy commit without fetching.

suite_text = None

refs = [f"origin/{target_branch}"]

parents = vm_suite.vc.git_command(

vm_suite.vc_dir,

["rev-list", "--parents", "-n", "1", "HEAD"],

abortOnError=False,

)

if parents and len(parents.split()) > 2:

refs.append("HEAD^1")

for ref in refs:

if ref:

suite_text = vm_suite.vc.git_command(

vm_suite.vc_dir,

["show", f"{ref}:{suite_path}"],

abortOnError=False,

)

if suite_text:

break

if not suite_text:

suite_file = os.path.join(vm_suite.dir, f"mx.{vm_suite.name}", "suite.py")

try:

with open(suite_file, encoding="utf-8") as f:

suite_text = f.read()

except OSError:

mx.warn(f"Cannot read {suite_path} to resolve the GraalPy profile source")

return None

try:

suite_node = next(

node.value

for node in ast.parse(suite_text, filename=suite_path).body

if isinstance(node, ast.Assign)

and any(isinstance(target, ast.Name) and target.id == "suite" for target in node.targets)

)

suite = ast.literal_eval(suite_node)

imports = suite.get("imports", {}).get("suites", [])

matches = []

for imported_suite in imports:

version = imported_suite.get("version")

if (

imported_suite.get("name") == "graalpython"

and isinstance(version, str)

and re.match(r"^[0-9a-f]{40}$", version)

):

matches.append(version)

except (StopIteration, SyntaxError, ValueError, TypeError) as e:

mx.warn(f"Cannot evaluate {suite_path} to resolve the GraalPy profile source: {e}")

return None

if len(matches) == 1:

return matches[0]

mx.warn(f"Expected exactly one graalpython import in target vm suite, found {len(matches)}")

# Determine memory and parallelism for GitHub CI builds

# Use 90% of available memory up to 14GB, but at least 8GB

# Set cores to number of CPUs if at least 4 cores and enough memory, otherwise 1

total_mem = 0

try:

if mx.is_windows():

for m in subprocess.check_output(['wmic', 'memorychip', 'get', 'capacity'], encoding='utf-8').splitlines():

try:

total_mem += int(m) / 1024**3

except ValueError:

pass

else:

total_mem = os.sysconf('SC_PAGE_SIZE') * os.sysconf('SC_PHYS_PAGES') / 1024**3

except:

total_mem = 16.0

min_bound = 8

max_mem = 14*1024

min_mem = int(1024 * (total_mem if total_mem < min_bound else total_mem * .9))

os_cpu = os.cpu_count() or int(os.environ.get("NUMBER_OF_PROCESSORS", 1)) or 1

build_mem = min(min_mem, max_mem)

parallelism = os_cpu if os_cpu >= 4 and build_mem >= min_bound*1024 else 1

return ["-Ob",

f"-J-Xms{build_mem}m",

f"--parallelism={parallelism}"

build_args = []

if os.environ.get("GITHUB_CI"):

build_args += github_ci_build_args()

if graalos := _is_graalos_build():

build_args += ['-H:+GraalOS']

else:

build_args += [

"-Dpolyglot.image-build-time.PreinitializeContexts=python",

"-H:+UnlockExperimentalVMOptions",

'-H:+RelativeCodePointers',

"-H:-UnlockExperimentalVMOptions",

]

if (

not graalos

and mx_sdk_vm_ng.is_nativeimage_ee()

and not os.environ.get('NATIVE_IMAGE_AUXILIARY_ENGINE_CACHE')

and not _is_overridden_native_image_arg("--gc")

):

build_args += ['-H:-ProtectionKeys']

profile = None

require_profile = get_boolean_env("GRAALPY_REQUIRE_PGO_PROFILE")

if (

"GRAALPY_PGO_PROFILE" not in os.environ

and mx.suite('graalpython-enterprise', fatalIfMissing=False)

and mx_sdk_vm_ng.get_bootstrap_graalvm_version() >= mx.VersionSpec("25.0")

and not _is_overridden_native_image_arg("--pgo")

):

vc = SUITE.vc

source_commit = str(vc.tip(SUITE.dir)).strip()

source_branch = _normalize_branch_name(

os.environ.get("FROM_BRANCH") or vc.active_branch(SUITE.dir, abortOnError=False) or 'master'

)

target_branch = _normalize_branch_name(os.environ.get("TO_BRANCH"))

profile_source_commit = source_commit

profile_source_branch = source_branch

profile_source_reason = "current GraalPy commit"

profile_source_candidates = [(profile_source_commit, profile_source_branch, profile_source_reason)]

override = os.environ.get("GRAALPY_PGO_PROFILE_SOURCE_COMMIT")

if override:

profile_source_commit = override.strip()

if not re.match(r"^[0-9a-f]{40}$", profile_source_commit):

mx.abort(f"GRAALPY_PGO_PROFILE_SOURCE_COMMIT must be a 40-character lowercase git commit, got: {override}")

profile_source_reason = "GRAALPY_PGO_PROFILE_SOURCE_COMMIT"

profile_source_candidates = [(profile_source_commit, profile_source_branch, profile_source_reason)]

elif (

target_branch

and source_branch

and source_branch != target_branch

and not (source_branch == MAIN_BRANCH or source_branch.startswith(("release/", "cpu/")))

and not _graalpython_commit_is_ancestor_of_branch(source_commit, target_branch)

):

# Feature branch commits usually have no released-product profile yet,

# but use one if it was explicitly generated. Otherwise prefer the

# nearest available target-branch ancestor profile, then fall back to

# the VM suite's target import for compatibility with older CI workspaces.

profile_search_days = 14

target_candidates = _graalpython_target_branch_profile_candidates(

source_commit, target_branch, profile_search_days

)

target_import_commit = _graalpython_target_import_commit(target_branch)

profile_source_candidates = [

(source_commit, source_branch, "current GraalPy branch commit"),

] + [

(commit, target_branch, f"target branch ancestor from {target_branch}")

for commit in target_candidates

]

if (

target_import_commit

and target_import_commit not in {commit for commit, _, _ in profile_source_candidates}

):

profile_source_candidates.append(

(target_import_commit, target_branch, f"target branch import from {target_branch}")

)

artifact_name = f"{GRAALPY_PGO_PROFILE_ARTIFACT_GROUP}/{GRAALPY_PGO_PROFILE_ARTIFACT_PREFIX}{profile_source_commit}"

mx.log(f"GraalPy source commit for PGO profile lookup: {source_commit}")

if script := os.environ.get("ARTIFACT_DOWNLOAD_SCRIPT"):

# This is always available in the GraalPy CI

profile = f"cached_profile.iprof.gz"

for candidate_commit, candidate_branch, candidate_reason in profile_source_candidates:

profile_source_commit = candidate_commit

profile_source_branch = candidate_branch

profile_source_reason = candidate_reason

artifact_name = f"{GRAALPY_PGO_PROFILE_ARTIFACT_GROUP}/{GRAALPY_PGO_PROFILE_ARTIFACT_PREFIX}{profile_source_commit}"

mx.log(f"GraalPy PGO profile source commit: {profile_source_commit} ({profile_source_reason})")

if os.path.exists(profile):

os.remove(profile)

run(

[

sys.executable,

script,

artifact_name,

profile,

],

nonZeroIsFatal=False,

)

if _graalpython_pgo_profile_exists(profile):

break

elif not require_profile:

mx.log(f"GraalPy PGO profile source commit: {profile_source_commit} ({profile_source_reason})")

# Locally, we try to get a reasonable profile

get_profile = mx.command_function('python-get-latest-profile', fatalIfMissing=False)

if get_profile:

seen_branches = set()

for b in [profile_source_branch, source_branch, MAIN_BRANCH]:

b = _normalize_branch_name(b)

if not b or b in seen_branches:

continue

seen_branches.add(b)

if not profile:

try:

profile = get_profile(["--branch", b])

except BaseException:

pass

profile_missing = not _graalpython_pgo_profile_exists(profile)

if require_profile and profile_missing:

mx.abort("\n".join([

"GRAALPY_REQUIRE_PGO_PROFILE is set, but no CI generated GraalPy PGO profile was found.",

f"GraalPy source commit: {source_commit}",

f"Source branch: {source_branch or '<unknown>'}",

f"Target branch: {target_branch or '<unset>'}",

f"PGO profile source commit: {profile_source_commit} ({profile_source_reason})",

f"Expected artifact: {artifact_name}",

"The product profile configuration does not fall back to benchmark-local PGO.",

"Run the GraalPy CI job python-pgo-profile-post_merge-linux-amd64-jdk-latest for the PGO profile source commit, then retry the product-ee benchmark.",

]))

if CI and profile_missing:

mx.log("No profile in CI job")

# When running on a release branch or attempting to merge into

# a release/CPU branch, make sure we can use a PGO profile, and

# when running in the CI on a bench runner, ensure a PGO profile.

if (

any(

_normalize_branch_name(b).startswith(("release/", "cpu/"))

for b in [source_branch, target_branch]

)

or ("bench" in os.environ.get('BUILD_NAME', ''))

):

mx.warn("PGO profile must exist for benchmarking and release, creating one now...")

profile = graalpy_native_pgo_build_and_test()

if _graalpython_pgo_profile_exists(profile):

print(invert(f"Automatically chose PGO profile {profile}. To disable this, set GRAALPY_PGO_PROFILE to an empty string'", blinking=True), file=sys.stderr)

build_args += [

f"--pgo={profile}",

"-H:+UnlockExperimentalVMOptions",

"-H:+PGOPrintProfileQuality",

"-H:-UnlockExperimentalVMOptions",

]

else:

print(invert("Not using an automatically selected PGO profile"), file=sys.stderr)

"""

if mx_sdk_vm_ng.get_bootstrap_graalvm_version() < mx.VersionSpec("25.0"):

mx.abort("python-native-pgo not supported on GraalVM < 25")

host_inlining_log = Path(SUITE.dir) / "host-inlining.txt"

host_inlining_log_gz = Path(str(host_inlining_log) + ".gz")

if host_inlining_log.exists():

host_inlining_log.unlink()

if host_inlining_log_gz.exists():

host_inlining_log_gz.unlink()

with set_env(GRAALPY_PGO_PROFILE=""):

mx.log(mx.colorize("[PGO] Building PGO-instrumented native image", color="yellow"))

build_home = graalpy_standalone_home('native', enterprise=True, build=True)

instrumented_home = build_home + "_PGO_INSTRUMENTED"

shutil.rmtree(instrumented_home, ignore_errors=True)

shutil.copytree(build_home, instrumented_home, symlinks=True, ignore_dangling_symlinks=True)

instrumented_launcher = os.path.join(instrumented_home, 'bin', _graalpy_launcher())

mx.log(mx.colorize(f"[PGO] Instrumented build complete: {instrumented_home}", color="yellow"))

mx.log(mx.colorize(f"[PGO] Running graalpytest with instrumented binary: {instrumented_launcher}", color="yellow"))

with tempfile.TemporaryDirectory() as d:

with set_env(

GRAALPYTEST_ALLOW_NO_JAVA_ASSERTIONS="true",

GRAAL_PYTHON_VM_ARGS="\v".join([

f"--vm.XX:ProfilesDumpFile={os.path.join(d, '$UUID$.iprof')}",

f"--vm.XX:ProfilesLCOVFile={os.path.join(d, '$UUID$.info')}",

]),

GRAALPY_HOME=instrumented_home,

):

graalpytest(["--python", instrumented_launcher, "test_venv.py"])

mx.log(mx.colorize("[PGO] Training native POSIX runtime paths", color="yellow"))

mx.command_function('benchmark')([

"micro-small:posix-operations", "--",

"--python-vm", "graalpython", "--python-vm-config", "custom",

"--experimental-options", "--python.PosixModuleBackend=native",

# Keep the workload in the host interpreter so its AOT paths are profiled.

"--engine.Compilation=false",

])

mx.command_function('benchmark')(["meso-small:*", "--", "--python-vm", "graalpython", "--python-vm-config", 'custom'])

iprof_path = Path(SUITE.dir) / f'default.iprof'

lcov_path = Path(SUITE.dir) / f'default.lcov'

run([

os.path.join(

graalvm_jdk(enterprise=True),

"bin",

f"native-image-configure{'.exe' if mx.is_windows() else ''}",

),

"merge-pgo-profiles",

f"--input-dir={d}",

f"--output-file={iprof_path}"

])

run([

"/usr/bin/env",

"lcov",

"-o", str(lcov_path),

*itertools.chain.from_iterable([

["-a", f.absolute().as_posix()] for f in Path(d).glob("*.info")

])

], nonZeroIsFatal=False)

run([

"/usr/bin/env",

"genhtml",

"--source-directory", str(Path(SUITE.dir) / "com.oracle.graal.python" / "src"),

"--source-directory", str(Path(SUITE.dir) / "com.oracle.graal.python.pegparser" / "src"),

"--source-directory", str(Path(SUITE.get_output_root()) / "com.oracle.graal.python" / "src_gen"),

"--include", "com/oracle/graal/python",

"--keep-going",

"-o", "lcov_html",

str(lcov_path),

], nonZeroIsFatal=False)

if not os.path.isfile(iprof_path):

mx.abort(f"[PGO] Could not find profile file at expected location: {iprof_path}")

with set_env(GRAALPY_PGO_PROFILE=str(iprof_path), GRAALPY_HOST_INLINING_LOG=str(host_inlining_log)):

mx.log(mx.colorize("[PGO] Building optimized native image with collected profile", color="yellow"))

native_bin = graalpy_standalone('native', enterprise=True, build=True)

mx.log(mx.colorize(f"[PGO] Optimized PGO build complete: {native_bin}", color="yellow"))

if host_inlining_log.exists():

mx.log(mx.colorize(f"[PGO] Host inlining log at: {host_inlining_log}", color="yellow"))

with open(host_inlining_log, 'rb') as f_in, gzip.open(host_inlining_log_gz, 'wb') as f_out:

shutil.copyfileobj(f_in, f_out)

host_inlining_log.unlink()

mx.log(mx.colorize(f"[PGO] Gzipped host inlining log at: {host_inlining_log_gz}", color="yellow"))

check_call_host_inlining([str(host_inlining_log_gz)])

else:

mx.abort(f"[PGO] Host inlining log was not produced at expected location: {host_inlining_log}")

iprof_gz_path = str(iprof_path) + '.gz'

with open(iprof_path, 'rb') as f_in, gzip.open(iprof_gz_path, 'wb') as f_out:

shutil.copyfileobj(f_in, f_out)

mx.log(mx.colorize(f"[PGO] Gzipped profile at: {iprof_gz_path}", color="yellow"))

if script := os.environ.get("ARTIFACT_UPLOADER_SCRIPT"):

commit = str(SUITE.vc.tip(SUITE.dir)).strip()

run(

[

sys.executable,

script,

iprof_gz_path,

f"{GRAALPY_PGO_PROFILE_ARTIFACT_PREFIX}{commit}",

GRAALPY_PGO_PROFILE_ARTIFACT_GROUP,

"--lifecycle",

"cache",

"--artifact-repo-key",

os.environ.get("ARTIFACT_REPO_KEY_LOCATION"),

'--skip-existing',

],

)

if args is None:

"""Run python from standalone build (unless kwargs are given). Does not build GraalPython sources automatically."""

if not any(arg.startswith('--python.WithJavaStacktrace') for arg in args):

args.insert(0, '--python.WithJavaStacktrace=1')

if "--hosted" in args[:2]:

return do_run_python(args)

if '--vm.da' not in args:

args.insert(0, '--vm.ea')

if not any(arg.startswith('--experimental-options') for arg in args):

args.insert(0, '--experimental-options')

handle_debug_arg(args)

for arg in itertools.chain(

itertools.chain(*map(shlex.split, reversed(mx._opts.java_args_sfx))),

reversed(shlex.split(mx._opts.java_args if mx._opts.java_args else "")),

itertools.chain(*map(shlex.split, reversed(mx._opts.java_args_pfx))),

):

if arg.startswith("-"):

args.insert(0, f"--vm.{arg[1:]}")

else:

mx.warn(f"Dropping {arg}, cannot pass it to launcher")

standalone_home = graalpy_standalone_home('jvm', dev=True, build=False)

graalpy_path = os.path.join(standalone_home, 'bin', _graalpy_launcher())

if not os.path.exists(graalpy_path):

mx.abort("GraalPy standalone doesn't seem to be built.\n" +

"To build it: mx python-jvm")

if "--hosted" in args[:2]:

args.remove("--hosted")

if not any(arg.startswith('--python.WithJavaStacktrace') for arg in args):

args.insert(0, '--python.WithJavaStacktrace=1')

if not any(arg.startswith("--python.CAPI") for arg in args):

capi_home = _get_capi_home()

args.insert(0, "--python.CAPI=%s" % capi_home)

args.insert(0, "--experimental-options")

if not env:

env = os.environ.copy()

env.setdefault("GRAAL_PYTHONHOME", _dev_pythonhome())

delete_bad_env_keys(env)

check_vm_env = env.get('GRAALPYTHON_MUST_USE_GRAAL', False)

if check_vm_env:

if check_vm_env == '1':

check_vm(must_be_jvmci=True)

elif check_vm_env == '0':

check_vm()

if minimal:

x = [x for x in SUITE.dists if x.name == "GRAALPYTHON"][0]

dists = [dep for dep in x.deps if dep.isJavaProject() or dep.isJARDistribution() and dep.exists()]

# Hack: what we should just do is + ['GRAALPYTHON_VERSIONS_MAIN'] and let MX figure out

# the class-path and other VM arguments necessary for it. However, due to a bug in MX,

# LayoutDirDistribution causes an exception if passed to mx.get_runtime_jvm_args,

# because it does not properly initialize its super class ClasspathDependency, see MX PR: 1665.

ver_dep = mx.distribution('GRAALPYTHON_VERSIONS_MAIN').get_output()

cp_prefix = ver_dep if cp_prefix is None else (str(ver_dep) + os.pathsep + cp_prefix)

else:

dists = ['GRAALPYTHON']

dists += ['GRAALPYTHON-LAUNCHER']

vm_args, graalpython_args = mx.extract_VM_args(args, useDoubleDash=True, defaultAllVMArgs=False)

if minimal:

vm_args.insert(0, f"-Dorg.graalvm.language.python.home={_dev_pythonhome()}")

graalpython_args, additional_dists = _extract_graalpython_internal_options(graalpython_args)

dists += additional_dists

if extra_dists:

dists += extra_dists

if not CI:

# Try eagerly to include tools for convenience when running Python

if not mx.suite("tools", fatalIfMissing=False):

SUITE.import_suite("tools", version=None, urlinfos=None, in_subdir=True)

if mx.suite("tools", fatalIfMissing=False):

for tool in ["CHROMEINSPECTOR", "TRUFFLE_COVERAGE"]:

if os.path.exists(mx.distribution(tool).path):

dists.append(tool)

graalpython_args.insert(0, '--experimental-options=true')

vm_args += mx.get_runtime_jvm_args(dists, jdk=jdk, cp_prefix=cp_prefix, cp_suffix=cp_suffix, force_cp=True)

if not jdk:

jdk = get_jdk()

# default: assertion checking is enabled

if extra_vm_args is None or '-da' not in extra_vm_args:

vm_args += ['-ea', '-esa']

if extra_vm_args:

vm_args += extra_vm_args

vm_args.append(main_class)

download_script = os.environ.get("ARTIFACT_DOWNLOAD_SCRIPT")

if not download_script:

mx.abort("Cannot build delvewheel venv: need CPython >= 3.12 or ARTIFACT_DOWNLOAD_SCRIPT")

cache_dir = Path(SUITE.get_output_root()).absolute() / "delvewheel-graalpy"

archive = cache_dir / Path(DELVEEWHEEL_GRAALPY_ARTIFACT).name

extracted = cache_dir / "extracted"

graalpy = extracted / DELVEEWHEEL_GRAALPY_HOME / "bin" / "graalpy.exe"

if graalpy.exists():

return str(graalpy)

cache_dir.mkdir(parents=True, exist_ok=True)

if not archive.exists():

mx.log(

f"{time.strftime('[%H:%M:%S] ')} Downloading GraalPy for delvewheel venv: "

f"{DELVEEWHEEL_GRAALPY_ARTIFACT}"

)

subprocess.check_call([sys.executable, download_script, DELVEEWHEEL_GRAALPY_ARTIFACT, str(archive)])

extracted.mkdir(parents=True, exist_ok=True)

mx.Extractor.create(str(archive)).extract(str(extracted))

if not graalpy.exists():

mx.abort(f"Could not find bin/graalpy.exe in downloaded artifact {archive}")

path = os.environ.get("PATH", "")

if mx.is_linux() and not shutil.which("patchelf"):

venv = Path(SUITE.get_output_root()).absolute() / "patchelf-venv"

path += os.pathsep + str(venv / "bin")

if not shutil.which("patchelf", path=path):

mx.log(f"{time.strftime('[%H:%M:%S] ')} Building patchelf-venv with {sys.executable}... [patchelf not found on PATH]")

t0 = time.time()

subprocess.check_call([sys.executable, "-m", "venv", str(venv)])

subprocess.check_call([str(venv / "bin" / "pip"), "install", "patchelf"])

mx.log(f"{time.strftime('[%H:%M:%S] ')} Building patchelf-venv with {sys.executable}... [duration: {time.time() - t0}]")

if mx.is_windows() and HAS_JEP_454 and not shutil.which("delvewheel"):

venv = Path(SUITE.get_output_root()).absolute() / "delvewheel-venv"

path += os.pathsep + str(venv / "Scripts")

if not shutil.which("delvewheel", path=path):

if sys.implementation.name == "cpython" and sys.version_info >= (3, 12):

venv_python = [sys.executable]

else:

venv_python = [_downloaded_graalpy_for_delvewheel(), "-X", "jit=0"]

mx.log(

f"{time.strftime('[%H:%M:%S] ')} Building delvewheel-venv with {shlex.join(venv_python)}... "

"[delvewheel not found on PATH]"

)

t0 = time.time()

subprocess.check_call(venv_python + ["-m", "venv", str(venv)])

subprocess.check_call(

[

str(venv / "Scripts" / "python.exe"),

"-m",

"pip",

"install",

"delvewheel>=1.13.0",

]

)

mx.log(

f"{time.strftime('[%H:%M:%S] ')} Building delvewheel-venv with {shlex.join(venv_python)}... "

f"[duration: {time.time() - t0}]"

)

"""

path = get_path_with_patchelf()

args = [] if ars is None else ars

@dataclass

class TestConfig:

identifier: str

args: list

useResources: bool

reportConfig: Union[Task, bool, None] = report

def __str__(self):

return f"args={self.args!r}, useResources={self.useResources}, report={self.reportConfig}"

def __post_init__(self):

assert ' ' not in self.identifier

configs = []

skip_leak_tests = False

if "--no-leak-tests" in args:

skip_leak_tests = True

args.remove("--no-leak-tests")

if is_collecting_coverage():

skip_leak_tests = True

vm_args = ['-Dpolyglot.engine.WarnInterpreterOnly=false']

if mx.suite('compiler', fatalIfMissing=False):