def test_python_smoke(args): """ Just a smoke test for now. """ if len(args) != 1: mx.abort('mx svm_test_python <python_svm_image_path>') out = mx.OutputCapture() err = mx.OutputCapture() expected_output = "Hello from Python" with tempfile.NamedTemporaryFile() as f: f.write("print('%s')\n" % expected_output) f.flush() os.system("ls -l %s" % args[0]) os.system("ls -l %s" % f.name) exitcode = mx.run([args[0], f.name], nonZeroIsFatal=False, out=out, err=err) if exitcode != 0: mx.abort("Python binary failed to execute: out=" + out.data + " err=" + err.data) if out.data != expected_output + "\n": mx.abort("Python smoke test failed") mx.log("Python binary says: " + out.data)
def run_mg_internal(args, verbose=False, extraVmArgs=None, env=None, jdk=None, **kwargs): vmArgs, mgArgs = mx.extract_VM_args(args) vmArgs = ['-cp', mx.classpath(["edu.uci.megaguards"])] vmArgs.append("edu.uci.megaguards.shell.MGMain") if not jdk: jdk = get_jdk() out = mx.OutputCapture() _out = out if not verbose else mx.TeeOutputCapture(out) out_err = mx.OutputCapture() _out_err = out if not verbose else mx.TeeOutputCapture(out_err) n = 3 for t in range(n): retcode = mx.run_java(vmArgs + [mgArgs], out=_out, err=_out_err, jdk=jdk, **kwargs) if retcode == 0: break return out.data
def runTester(self): config = self.loadConfiguration(self.benchmarkName()) wrkDirectory = self.getLibraryDirectory() if mx.get_os() == "linux": distro = "linux" elif mx.get_os() == "darwin": distro = "macos" else: mx.abort("{0} not supported in {1}.".format( BaseWrkBenchmarkSuite.__name__, mx.get_os())) wrkPath = os.path.join(wrkDirectory, "wrk-{os}".format(os=distro)) wrkFlags = self.setupWrkCmd(config) warmupDuration = None if self.inNativeMode(): warmupDuration = config.get("warmup-duration-native-image", None) elif "warmup-duration" in config: warmupDuration = config["warmup-duration"] if warmupDuration: warmupWrkCmd = [wrkPath] + ["--duration", str(warmupDuration)] + wrkFlags mx.log("Warming up with Wrk: {0}".format(warmupWrkCmd)) warmupOutput = mx.TeeOutputCapture(mx.OutputCapture()) mx.run(warmupWrkCmd, out=warmupOutput, err=warmupOutput) if "duration" in config: wrkFlags = ["--duration", str(config["duration"])] + wrkFlags runWrkCmd = [wrkPath] + wrkFlags mx.log("Running Wrk: {0}".format(runWrkCmd)) self.testerOutput = mx.TeeOutputCapture(mx.OutputCapture()) mx.run(runWrkCmd, out=self.testerOutput, err=self.testerOutput)
def check_aot(classpath, main_class, common_opts, expected_output, lib_module, program_args=None): aot_opts = [ '-XX:+UnlockDiagnosticVMOptions', '-XX:+UseAOTStrictLoading', '-XX:AOTLibrary=' + lib_module.name ] program_args = program_args or [] # Check AOT library is loaded. out = mx.OutputCapture() mx_compiler.run_vm(common_opts + aot_opts + ['-XX:+PrintAOT', '-version'], out=out, err=out, nonZeroIsFatal=False) if 'aot library' not in out.data: mx.abort( "Missing expected 'aot library' in -XX:+PrintAOT -version output. VM Output:\n" + str(out.data)) # Run main_class+AOT modules and check output. aot_out = mx.OutputCapture() mx_compiler.run_vm(common_opts + aot_opts + ['-cp', classpath, main_class] + program_args, out=aot_out) if expected_output != aot_out.data: mx.abort('Outputs differ, expected `{}` != `{}`'.format( expected_output, aot_out.data))
def check_megaguards(device='GPU', verbose=False, cmd=['mx', 'python'], testprogram='check_mg.py'): megaguards_opt = [ '--mg-target=' + device.lower(), '--mg-log=eyxd', '--mg-target-threshold=1' ] check_python_program = [ _suite.dir + os.sep + 'tests' + os.sep + testprogram ] n = 3 for t in range(n): out = mx.OutputCapture() _out = out if not verbose else mx.TeeOutputCapture(out) out_err = mx.OutputCapture() _out_err = out if not verbose else mx.TeeOutputCapture(out_err) print_progress('Testing OpenCL device %s accessibility' % device) retcode = mx.run(cmd + check_python_program + megaguards_opt, out=_out, err=_out_err, nonZeroIsFatal=False) if retcode == 0: break else: print("Execution failed.. retry %d of %d" % (t + 1, n)) successRe = r"Execution Target:.+" + device + r"" if not re.search(successRe, out.data, re.MULTILINE): print_error(opencl_err.format(device)) return False else: print_ok("OpenCL device {0} has been detected!".format(device)) return True
def get_megaguards_junit_status(verbose=False): is_ok = get_megaguards_home_dir(check_only=True) is_ok = is_ok and get_megaguards_build_dir(check_only=True) is_ok = is_ok and get_megaguards_polyhedral_ld(check_only=True) is_ok = is_ok and get_megaguards_test_dataset(check_only=True) if is_ok: n = 3 for t in range(n): out = mx.OutputCapture() _out = out if not verbose else mx.TeeOutputCapture(out) out_err = mx.OutputCapture() _out_err = out if not verbose else mx.TeeOutputCapture(out_err) print_progress( "Performing MegaGuards (core) junit tests.. (note: run 'mx junit-mg' for complete MegaGuards junit tests)" ) retcode = mx.run(['mx', 'junit-mg-core'], out=_out, err=_out_err, nonZeroIsFatal=False) if retcode == 0: break else: print_progress("Test failed.. retry %d of %d" % (t + 1, n)) if retcode == 0: print_ok('MegaGuards core junit tests') else: print_warn('MegaGuards core junit tests encountered some errors.') is_ok = is_ok and retcode == 0 return is_ok
def _vm_home(config): if config not in _vm_homes: # get things initialized (e.g., cloning) _mx_vm(['graalvm-home'], config, out=mx.OutputCapture()) capture = mx.OutputCapture() _mx_vm(['graalvm-home'], config, out=capture, quiet=True) _vm_homes[config] = capture.data.strip() return _vm_homes[config]
def benchmark_callback(suite, commit): suite.vc.update_to_branch(suite.vc_dir, commit) mx.run_mx(['sforceimports'], suite=suite) mx.run_mx(['--env', 'ce', 'sforceimports'], suite=get_suite('/vm')) if args.enterprise and suite.name != 'vm-enterprise': checkout_args = [ '--dynamicimports', '/vm-enterprise', 'checkout-downstream', 'vm', 'vm-enterprise' ] if fetched_enterprise[0]: checkout_args.append('--no-fetch') mx.run_mx(checkout_args, out=mx.OutputCapture()) # Make sure vm is imported before vm-enterprise get_suite('/vm') mx.run_mx(['--env', 'ee', 'sforceimports'], suite=get_suite('/vm-enterprise')) fetched_enterprise[0] = True suite.vc.update_to_branch(suite.vc_dir, commit) mx.run_mx(['sforceimports'], suite=suite) debug_str = "debug: graalpython={} graal={}".format( get_commit(get_suite('graalpython')), get_commit(get_suite('/vm'))) if args.enterprise: debug_str += " graal-enterprise={}".format( get_commit(get_suite('/vm-enterprise'))) print(debug_str) build_command = shlex.split(args.build_command) if not args.no_clean: try: clean_command = build_command[:build_command. index('build')] + ['clean'] retcode = mx.run(clean_command, nonZeroIsFatal=False) if retcode: print("Warning: clean command failed") except ValueError: pass retcode = mx.run(build_command, nonZeroIsFatal=False) if retcode: raise RuntimeError( "Failed to execute the build command for {}".format(commit)) output = mx.OutputCapture() retcode = mx.run(shlex.split(args.benchmark_command), out=mx.TeeOutputCapture(output), nonZeroIsFatal=False) if retcode: raise RuntimeError( "Failed to execute benchmark for {}".format(commit)) match = re.search( r'{}.*duration: ([\d.]+)'.format( re.escape(args.benchmark_criterion)), output.data) if not match: raise RuntimeError("Failed to get result from the benchmark") return float(match.group(1))
def benchmarks(self): out = mx.OutputCapture() jt(['where', 'repos', 'all-ruby-benchmarks'], out=out) all_ruby_benchmarks = out.data.strip() benchmarks = [] for root, dirs, files in os.walk(os.path.join(all_ruby_benchmarks, 'micro')): for name in files: if name.endswith('.rb'): benchmark_file = os.path.join(root, name)[len(all_ruby_benchmarks)+1:] out = mx.OutputCapture() if jt(['benchmark', 'list', benchmark_file], out=out): benchmarks.extend([benchmark_file + ':' + b.strip() for b in out.data.split('\n') if len(b.strip()) > 0]) else: sys.stderr.write(out.data) return benchmarks
def checkListingExclusions(exclusions, expected): parent_dir = os.path.normpath(file_dir + sep + "..") out = mx.TeeOutputCapture(mx.OutputCapture()) env = os.environ.copy() env["MX_PRIMARY_SUITE_PATH"] = parent_dir mx_bin = os.path.normpath(parent_dir + sep + "mx") mx.run([ mx_bin, 'benchmark', 'jmh-dist:MX_MICRO_BENCHMARKS', '--', '--', '-l' ] + exclusions, out=out, env=env, cwd=parent_dir) # Extract benchmark names from the output. benchmarks = [] start = re.compile("Benchmarks:") end = re.compile(r"\d+ benchmark data points dumped") collecting = False for line in out.underlying.data.splitlines(): if start.match(line): collecting = True elif end.match(line): collecting = False break elif collecting: # Collect unqualified name. benchmarks.append(line.split('.')[-1]) if set(benchmarks) != set(expected): mx.abort( f"Filtering benchmarks with {exclusions} gave {benchmarks}, expected {expected}" )
def __exit__(self, exc_type, exc_value, traceback): if self.mapFiles: try: with tempfile.NamedTemporaryFile() as inputFile: with tempfile.NamedTemporaryFile() as mapFile: if len(self.capture.data) != 0: inputFile.write(self.capture.data) inputFile.flush() for e in self.mapFiles: with open(e, 'r') as m: shutil.copyfileobj(m, mapFile) mapFile.flush() retraceOut = mx.OutputCapture() proguard_cp = mx.classpath( ['PROGUARD_RETRACE', 'PROGUARD']) mx.run([ jdk.java, '-cp', proguard_cp, 'proguard.retrace.ReTrace', mapFile.name, inputFile.name ], out=retraceOut) if self.capture.data != retraceOut.data: mx.log('>>>> BEGIN UNSTRIPPED OUTPUT') mx.log(retraceOut.data) mx.log('<<<< END UNSTRIPPED OUTPUT') except BaseException as e: mx.log( 'Error unstripping output from VM execution with stripped jars: ' + str(e)) return None
def generate_llvm_config(args=None, **kwargs): constants = [] # get config full string out = mx.OutputCapture() mx_sulong.llvm_tool(["llvm-config", "--version"] + list(args), out=out) full_version = out.data.strip() # NOTE: do not add full version until we need it to avoid regeneration # constants.append(("VERSION_FULL", full_version, "Full LLVM version string.")) # version without suffix s = full_version.split("-", 3) version = s[0] constants.append(("VERSION", version, "LLVM version string.")) # major, minor, patch s = version.split(".", 3) major_version, minor_version, patch_version = s[0], s[1], s[2] constants.append(("VERSION_MAJOR", int(major_version), "Major version of the LLVM API.")) constants.append(("VERSION_MINOR", int(minor_version), "Minor version of the LLVM API.")) constants.append(("VERSION_PATCH", int(patch_version), "Patch version of the LLVM API.")) file_comment = "GENERATED BY 'mx {}'. DO NOT MODIFY.".format( GENERATE_LLVM_CONFIG) _write_llvm_config_java(constants, file_comment) _write_llvm_config_mx(constants, file_comment)
def _find_classes_by_annotated_methods(annotations, suite): """ Scan distributions from binary suite dependencies for classes contain at least one method with an annotation from 'annotations' and return a dictionary from fully qualified class names to the distribution containing the class. """ binarySuiteDists = [ d for d in mx.dependencies(opt_limit_to_suite=True) if d.isJARDistribution() and isinstance(d.suite, mx.BinarySuite) and ( not suite or suite == d.suite) ] if len(binarySuiteDists) != 0: # Ensure Java support class is built mx.build(['--dependencies', 'com.oracle.mxtool.junit']) # Create map from jar file to the binary suite distribution defining it jars = {d.classpath_repr(): d for d in binarySuiteDists} cp = mx.classpath(['com.oracle.mxtool.junit'] + [d.name for d in binarySuiteDists]) out = mx.OutputCapture() mx.run_java(['-cp', cp] + ['com.oracle.mxtool.junit.FindClassesByAnnotatedMethods'] + annotations + jars.keys(), out=out) candidates = {} for line in out.data.strip().split('\n'): name, jar = line.split(' ') # Record class name to the binary suite distribution containing it candidates[name] = jars[jar] return candidates return {}
def gate(args, tasks): with Task('Vm: Basic GraalVM Tests', tasks, tags=[VmGateTasks.graal]) as t: if t: _java = join(mx_vm.graalvm_output(), 'bin', 'java') _out = mx.OutputCapture() if mx.run([_java, '-XX:+JVMCIPrintProperties'], nonZeroIsFatal=False, out=_out, err=_out): mx.log_error(_out.data) mx.abort('The GraalVM image is not built with a JVMCI-enabled JDK, it misses `-XX:+JVMCIPrintProperties`.') _out = subprocess.check_output([_java, '-version'], stderr=subprocess.STDOUT) if args.strict_mode: # A full open-source build should be built with an open-source JDK _version_regex = _openjdk_version_regex else: # Allow Oracle JDK in non-strict mode as it is common on developer machines _version_regex = _anyjdk_version_regex match = _version_regex.match(_out) if match is None: if args.strict_mode and _anyjdk_version_regex.match(_out): mx.abort("In --strict-mode, GraalVM must be built with OpenJDK") else: mx.abort('Unexpected version string:\n{}Does not match:\n{}'.format(_out, _version_regex.pattern)) elif match.group('graalvm_version') != _suite.release_version(): mx.abort("Wrong GraalVM version in -version string: got '{}', expected '{}'".format(match.group('graalvm_version'), _suite.release_version())) if mx_vm.has_component('js'): with Task('Vm: Graal.js tests', tasks, tags=[VmGateTasks.graal_js]) as t: if t: pass gate_sulong(tasks) gate_ruby(tasks)
def python_svm(args): mx.run_mx(_SVM_ARGS + ["build"]) out = mx.OutputCapture() mx.run_mx(_SVM_ARGS + ["graalvm-home"], out=mx.TeeOutputCapture(out)) svm_image = os.path.join(out.data.strip(), "bin", "graalpython") mx.run([svm_image] + args) return svm_image
def runBenchmark(self, benchmark, bmSuiteArgs): out = mx.OutputCapture() jt(['metrics', 'time', '--json'] + metrics_benchmarks[benchmark] + bmSuiteArgs, out=out) data = json.loads(out.data) return [{ 'benchmark': benchmark, 'extra.metric.region': region, 'metric.name': 'time', 'metric.value': sample, 'metric.unit': 's', 'metric.better': 'lower', 'metric.iteration': n, 'extra.metric.human': '%d/%d %s' % (n, len(region_data['samples']), region_data['human']) } for region, region_data in data.items() for n, sample in enumerate(region_data['samples'])]
def runBenchmark(self, benchmark, bmSuiteArgs): out = mx.OutputCapture() jt(['metrics', 'time', '--json'] + metrics_benchmarks[benchmark] + bmSuiteArgs, out=out) lines = [line for line in out.data.split('\n') if len(line) > 0] mx.log('\n'.join(lines[0:-1])) json_data = lines[-1] mx.log('JSON:') mx.log(json_data) data = json.loads(json_data) return [{ 'benchmark': benchmark, 'extra.metric.region': region, 'metric.name': 'time', 'metric.value': sample, 'metric.unit': 'ms', 'metric.better': 'lower', 'metric.iteration': n } for region, region_data in data.items() for n, sample in enumerate(region_data['samples'])]
def test_modules(classpath, main_class, modules, program_args=None): """(jaotc-)Compiles `modules` and runs `main_class` + AOT library. Compares the output vs. standard JVM. """ # Run on vanilla JVM. program_args = program_args or [] expected_out = mx.OutputCapture() mx_compiler.run_vm((['-cp', classpath] if classpath else []) + [main_class] + program_args, out=expected_out) # jaotc uses ':' as separator. module_list = ':'.join(modules) for common_opts in common_opts_variants: mx.log('(jaotc) Compiling module(s) {} with {}'.format( module_list, ' '.join(common_opts))) with mktemp_libfile() as lib_module: run_jaotc( ['-J' + opt for opt in common_opts] + ['--module', module_list] + ['--exit-on-error', '--info', '--output', lib_module.name]) check_aot(classpath, main_class, common_opts, expected_out.data, lib_module, program_args)
def jdk_omits_warning_for_jlink_set_ThreadPriorityPolicy(jdk): # pylint: disable=invalid-name """ Determines if the `jdk` suppresses a warning about ThreadPriorityPolicy when it is non-zero if the value is set from the jimage. https://bugs.openjdk.java.net/browse/JDK-8235908. """ if not hasattr(jdk, '.omits_ThreadPriorityPolicy_warning'): out = mx.OutputCapture() sink = lambda x: x tmpdir = tempfile.mkdtemp( prefix='jdk_omits_warning_for_jlink_set_ThreadPriorityPolicy') jlink_exe = jdk.javac.replace('javac', 'jlink') mx.run([ jlink_exe, '--add-options=-XX:ThreadPriorityPolicy=1', '--output=' + join(tmpdir, 'jdk'), '--add-modules=java.base' ]) mx.run([mx.exe_suffix(join(tmpdir, 'jdk', 'bin', 'java')), '-version'], out=sink, err=out) shutil.rmtree(tmpdir) setattr( jdk, '.omits_ThreadPriorityPolicy_warning', '-XX:ThreadPriorityPolicy=1 may require system level permission' not in out.data) return getattr(jdk, '.omits_ThreadPriorityPolicy_warning')
def _run(self, *args, **kwargs): cmd = [self.binary, '-j', self.parallelism] if mx.get_opts().very_verbose: cmd += ['-v'] cmd += args out = kwargs.get('out', mx.OutputCapture()) err = kwargs.get('err', subprocess.STDOUT) if mx.get_opts().verbose: if callable(out) and '-n' not in args: out = mx.TeeOutputCapture(out) if callable(err): err = mx.TeeOutputCapture(err) try: rc = mx.run(cmd, nonZeroIsFatal=False, out=out, err=err, cwd=self.build_dir) except OSError as e: if e.errno != errno.EACCES: mx.abort('Error executing \'{}\': {}'.format( ' '.join(cmd), str(e))) mx.logv( '{} is not executable. Trying to change permissions...'.format( self.binary)) os.chmod(self.binary, 0o755) self._run(*args, **kwargs) # retry else: not rc or mx.abort(rc if mx.get_opts().verbose else out.data) # pylint: disable=expression-not-assigned
def ext_version(self): out1 = mx.OutputCapture() out2 = mx.OutputCapture() mx.run([self.externalInterpreter(), "--version"], err=mx.TeeOutputCapture(out2), out=mx.TeeOutputCapture(out1)) out1 = [] if not out1 or len(out1.data) <= 1 else out1.data.split("\n") out1 = [] if not out1 or len(out1) <= 1 else out1[0].split(" ") out2 = [] if not out2 or len(out2.data) <= 1 else out2.data.split("\n") out2 = [] if not out2 or len(out2) <= 1 else out2[0].split(" ") if len(out1) > 1: return out1[out1.index("Python") + 1].replace('-', '_') elif len(out2) > 1: return out2[out2.index("Python") + 1].replace('-', '_') else: return "unknown"
def test_modules(opts_set, classpath, main_class, modules, vm_args, program_args, commands): """(jaotc-)Compiles `modules` and runs `main_class` + AOT library. Compares the output vs. standard JVM. """ # Run on vanilla JVM. program_args = program_args or [] vm_args = vm_args or [] commands = commands or '' expected_out = mx.OutputCapture() mx_compiler.run_vm((['-cp', classpath] if classpath else []) + vm_args + [main_class] + program_args, out=expected_out) # jaotc uses ':' as separator. module_list = ':'.join(modules) for common_opts in opts_set: mx.log('(jaotc) Compiling module(s) {} with {}'.format(module_list, ' '.join(common_opts))) with mktemp_libfile() as lib_module: lib_module.file.close() with tempfile.NamedTemporaryFile(mode='w', prefix='cmds_', suffix='.txt') as cmd_file: cmd_file.write(commands) cmd_file.file.close() run_jaotc(['-J' + opt for opt in common_opts] + ['--module', module_list] + ['--compile-commands', cmd_file.name] + ['--exit-on-error', '--info', '--output', lib_module.name]) check_aot(classpath, main_class, common_opts, expected_out.data, lib_module, program_args)
def benchmark_callback(suite, commit): suite.vc.update_to_branch(suite.vc_dir, commit) mx.run_mx(['sforceimports'], suite=suite) mx.run_mx(['--env', 'ce', 'sforceimports'], suite=get_suite('/vm')) if args.enterprise and suite.name != 'vm-enterprise': checkout_args = [ '--dynamicimports', '/vm-enterprise', 'checkout-downstream', 'vm', 'vm-enterprise' ] if fetched_enterprise[0]: checkout_args.append('--no-fetch') mx.run_mx(checkout_args, out=mx.OutputCapture()) # Make sure vm is imported before vm-enterprise get_suite('/vm') mx.run_mx(['--env', 'ee', 'sforceimports'], suite=get_suite('/vm-enterprise')) fetched_enterprise[0] = True suite.vc.update_to_branch(suite.vc_dir, commit) mx.run_mx(['sforceimports'], suite=suite) debug_str = "debug: graalpython={} graal={}".format( get_commit(get_suite('graalpython')), get_commit(get_suite('/vm'))) if args.enterprise: debug_str += " graal-enterprise={}".format( get_commit(get_suite('/vm-enterprise'))) print(debug_str) env = os.environ.copy() env['MX_ALT_OUTPUT_ROOT'] = 'mxbuild-{}'.format(commit) retcode = mx.run(shlex.split(args.build_command), env=env, nonZeroIsFatal=False) if retcode: raise RuntimeError( "Failed to execute the build command for {}".format(commit)) output = mx.OutputCapture() retcode = mx.run(shlex.split(args.benchmark_command), env=env, out=mx.TeeOutputCapture(output), nonZeroIsFatal=False) if retcode: raise RuntimeError( "Failed to execute benchmark for {}".format(commit)) match = re.search( r'{}.*duration: ([\d.]+)'.format( re.escape(args.benchmark_criterion)), output.data) if not match: raise RuntimeError("Failed to get result from the benchmark") return float(match.group(1))
def _test_libgraal_fatal_error_handling(): """ Tests that fatal errors in libgraal route back to HotSpot fatal error handling. """ vmargs = [ '-XX:+PrintFlagsFinal', '-Dlibgraal.CrashAt=length,hashCode', '-Dlibgraal.CrashAtIsFatal=true' ] cmd = ["dacapo:avrora", "--tracker=none", "--" ] + vmargs + ["--", "--preserve"] out = mx.OutputCapture() exitcode, bench_suite, _ = mx_benchmark.gate_mx_benchmark( cmd, out=out, err=out, nonZeroIsFatal=False) if exitcode == 0: if 'CrashAtIsFatal: no fatalError function pointer installed' in out.data: # Executing a VM that does not configure fatal errors handling # in libgraal to route back through the VM. pass else: mx.abort('Expected benchmark to result in non-zero exit code: ' + ' '.join(cmd) + linesep + out.data) else: if len(bench_suite.scratchDirs()) == 0: mx.abort("No scratch dir found despite error being expected!") latest_scratch_dir = bench_suite.scratchDirs()[-1] seen_libjvmci_log = False hs_errs = glob.glob(join(latest_scratch_dir, 'hs_err_pid*.log')) if not hs_errs: mx.abort( 'Expected a file starting with "hs_err_pid" in test directory. Entries found=' + str(listdir(latest_scratch_dir))) for hs_err in hs_errs: mx.log("Verifying content of {}".format( join(latest_scratch_dir, hs_err))) with open(join(latest_scratch_dir, hs_err)) as fp: contents = fp.read() if 'libjvmci' in hs_err: seen_libjvmci_log = True if 'Fatal error: Forced crash' not in contents: mx.abort( 'Expected "Fatal error: Forced crash" to be in contents of ' + hs_err + ':' + linesep + contents) else: if 'Fatal error in JVMCI' not in contents: mx.abort( 'Expected "Fatal error in JVMCI" to be in contents of ' + hs_err + ':' + linesep + contents) if 'JVMCINativeLibraryErrorFile' in out.data and not seen_libjvmci_log: mx.abort( 'Expected a file matching "hs_err_pid*_libjvmci.log" in test directory. Entries found=' + str(listdir(latest_scratch_dir))) # Only clean up scratch dir on success for scratch_dir in bench_suite.scratchDirs(): mx.log("Cleaning up scratch dir after gate task completion: {}".format( scratch_dir)) mx.rmtree(scratch_dir)
def run(self, cwd, args): _check_vm_args(self.name(), args) out = mx.OutputCapture() stdout_capture = mx.TeeOutputCapture(out) ret_code = mx.run([self.interpreter] + args, out=stdout_capture, err=stdout_capture) return ret_code, out.data
def run(self, cwd, args): out = mx.TeeOutputCapture(mx.OutputCapture()) args = self.post_process_command_line_args(args) mx.log("Running JVM with args: {0}".format(args)) code = self.run_java(args, out=out, err=out, cwd=cwd, nonZeroIsFatal=False) out = out.underlying.data dims = self.dimensions(cwd, args, code, out) return code, out, dims
def _gate_python_benchmarks_tests(name, iterations): run_java = mx.run_java vmargs += ['-cp', mx.classpath(["com.oracle.graal.python"]), "com.oracle.graal.python.shell.GraalPythonMain", name, str(iterations)] success_pattern = re.compile(r"^(?P<benchmark>[a-zA-Z0-9.\-]+): (?P<score>[0-9]+(\.[0-9]+)?$)") out = mx.OutputCapture() run_java(vmargs, out=mx.TeeOutputCapture(out), err=subprocess.STDOUT) if not re.search(success_pattern, out.data, re.MULTILINE): mx.abort('Benchmark "' + name + '" doesn\'t match success pattern: ' + str(success_pattern))
def testPeakPerformance(self, warmup): jmeterDirectory = mx.library("APACHE_JMETER_" + self.jmeterVersion(), True).get_path(True) jmeterPath = os.path.join(jmeterDirectory, "apache-jmeter-" + self.jmeterVersion(), "bin/ApacheJMeter.jar") jmeterCmd = [mx.get_jdk().java, "-jar", jmeterPath, "-n", "-t", self.workloadConfigurationPath(), "-j", "/dev/stdout"] # pylint: disable=line-too-long mx.log("Running JMeter: {0}".format(jmeterCmd)) output = mx.TeeOutputCapture(mx.OutputCapture()) mx.run(jmeterCmd, out=output, err=output) self.peakOutput = output.underlying.data
def _ctw_system_properties_suffix(): out = mx.OutputCapture() out.data = 'System properties for CTW:\n\n' args = ['-XX:+EnableJVMCI'] + _ctw_jvmci_export_args() args.extend(['-cp', mx.classpath('org.graalvm.compiler.hotspot.test', jdk=jdk), '-DCompileTheWorld.Help=true', 'org.graalvm.compiler.hotspot.test.CompileTheWorld']) run_java(args, out=out, addDefaultArgs=False) return out.data
def benchmarkList(self, _): jdk = mx.get_jdk(mx.distribution(BENCHMARKCASES_DISTRIBUTION).javaCompliance) jvm_args = mx.get_runtime_jvm_args([BENCHMARKCASES_DISTRIBUTION], jdk=jdk) args = jvm_args + [MEMORY_PROFILER_CLASS_NAME, "--list"] out = mx.OutputCapture() jdk.run_java(args, out=out) return out.data.split()