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 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 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 _test_libgraal_basic(extra_vm_arguments): """ Tests basic libgraal execution by running a DaCapo benchmark, ensuring it has a 0 exit code and that the output for -DgraalShowConfiguration=info describes a libgraal execution. """ expect = r"Using compiler configuration '[^']+' provided by [\.\w]+ loaded from[ \w]* JVMCI native library" compiler_log_file = abspath('graal-compiler.log') args = [ '-Dgraal.ShowConfiguration=info', '-Dgraal.LogFile=' + compiler_log_file, '-jar', mx.library('DACAPO').get_path(True), 'avrora', '-n', '1' ] # Verify execution via raw java launcher in `mx graalvm-home`. try: mx.run([join(mx_sdk_vm_impl.graalvm_home(), 'bin', 'java')] + args) finally: _check_compiler_log(compiler_log_file, expect) # Verify execution via `mx vm`. import mx_compiler try: mx_compiler.run_vm(extra_vm_arguments + args) finally: _check_compiler_log(compiler_log_file, expect)
def test_javac(project_name, opts_set): """(jaotc-)Compiles the `jdk.compiler` module and compiles (mx) project_name using `javac` (+ AOT module).""" # jaotc uses ':' as separator. modules = ':'.join(['jdk.compiler']) for common_opts in opts_set: out_dir = tempfile.mkdtemp() try: mx.log('(jaotc) Compiling module(s) {} with {}'.format( modules, ' '.join(common_opts))) with mktemp_libfile() as lib_module: lib_module.file.close() run_jaotc(['-J' + opt for opt in common_opts] + [ '--exit-on-error', '--info', '--module', modules, '--output', lib_module.name ]) aot_opts = [ '-XX:+UnlockDiagnosticVMOptions', '-XX:+UseAOTStrictLoading', '-XX:AOTLibrary=' + lib_module.name ] project = mx.project(project_name) java_files = collect_java_sources(project.source_dirs()) javac_args = mx.JavacCompiler(jdk).prepare( sourceFiles=java_files, project=project, outputDir=out_dir, classPath=mx.classpath(project, includeSelf=False, jdk=jdk, ignoreStripped=True), sourceGenDir=project.source_gen_dir(), jnigenDir=project.jni_gen_dir(), processorPath=project.annotation_processors_path(jdk), disableApiRestrictions=True, warningsAsErrors=False, showTasks=False, postCompileActions=[], forceDeprecationAsWarning=False) mx_compiler.run_vm(common_opts + aot_opts + ['com.sun.tools.javac.Main'] + javac_args) finally: shutil.rmtree(out_dir)
def test_class(classpath, main_class, program_args=None): """(jaotc-)Compiles simple HelloWorld program. 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) for common_opts in common_opts_variants: mx.log('Running {} with {}'.format(main_class, ' '.join(common_opts))) with mktemp_libfile() as lib_module: run_jaotc(['-J' + opt for opt in common_opts] + ['--exit-on-error', '--info', '--output', lib_module.name, main_class], classpath=classpath) check_aot(classpath, main_class, common_opts, expected_out.data, lib_module, program_args)
def test_class(classpath, main_class, program_args=None): """(jaotc-)Compiles simple HelloWorld program. 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) for common_opts in common_opts_variants: mx.log('Running {} with {}'.format(main_class, ' '.join(common_opts))) with mktemp_libfile() as lib_module: run_jaotc(['-J' + opt for opt in common_opts] + ['--info', '--output', lib_module.name, main_class], classpath=classpath) check_aot(classpath, main_class, common_opts, expected_out.data, lib_module, program_args)
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 run_jaotc(args, classpath=None, cwd=None): """run AOT compiler with classes in this repo instead of those in the JDK""" if jdk.javaCompliance < '11': mx.abort( 'jaotc command is only available if JAVA_HOME is JDK 11 or later') jaotc_entry = mx_compiler.JVMCIClasspathEntry('JAOTC') jvmci_classpath_adjusted = False if jaotc_entry not in mx_compiler._jvmci_classpath: mx_compiler.add_jvmci_classpath_entry(jaotc_entry) jvmci_classpath_adjusted = True vm_args = [a[2:] for a in args if a.startswith('-J')] args = [a for a in args if not a.startswith('-J')] verbose = ['--verbose'] if mx._opts.very_verbose else [] cp = ['-cp', classpath] if classpath else [] try: mx_compiler.run_vm([ '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.aarch64=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.amd64=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.code=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.code.site=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.code.stack=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.common=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.hotspot=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.hotspot.aarch64=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.hotspot.amd64=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.hotspot.sparc=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.meta=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.runtime=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.sparc=jdk.internal.vm.compiler,jdk.aot', '-XX:+CalculateClassFingerprint' ] + vm_args + cp + ['-m', 'jdk.aot/jdk.tools.jaotc.Main'] + verbose + args, cwd=cwd) finally: if jvmci_classpath_adjusted: mx_compiler._jvmci_classpath.remove(jaotc_entry)
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] + ['--info', '--output', lib_module.name]) check_aot(classpath, main_class, common_opts, expected_out.data, lib_module, program_args)
def test_javac(project_name): """(jaotc-)Compiles the `jdk.compiler` module and compiles (mx) project_name using `javac` (+ AOT module).""" # jaotc uses ':' as separator. modules = ':'.join(['jdk.compiler']) for common_opts in common_opts_variants: out_dir = tempfile.mkdtemp() try: mx.log('(jaotc) Compiling module(s) {} with {}'.format(modules, ' '.join(common_opts))) with mktemp_libfile() as lib_module: run_jaotc(['-J' + opt for opt in common_opts] + ['--info', '--module', modules, '--output', lib_module.name]) aot_opts = [ '-XX:+UnlockDiagnosticVMOptions', '-XX:+UseAOTStrictLoading', '-XX:AOTLibrary=' + lib_module.name ] project = mx.project(project_name) java_files = collect_java_sources(project.source_dirs()) javac_args = mx.JavacCompiler(jdk).prepare( sourceFiles=java_files, project=project, outputDir=out_dir, classPath=mx.classpath(project, includeSelf=False, jdk=jdk, ignoreStripped=True), sourceGenDir=project.source_gen_dir(), jnigenDir=project.jni_gen_dir(), processorPath=project.annotation_processors_path(jdk), disableApiRestrictions=True, warningsAsErrors=False, showTasks=False, postCompileActions=[], forceDeprecationAsWarning=False) mx_compiler.run_vm(common_opts + aot_opts + ['com.sun.tools.javac.Main'] + javac_args) finally: shutil.rmtree(out_dir)
def run_jaotc(args, classpath=None, cwd=None): """run AOT compiler with classes in this repo instead of those in the JDK""" if jdk.javaCompliance < '11': mx.abort('jaotc command is only available if JAVA_HOME is JDK 11 or later') jaotc_entry = mx_compiler.JVMCIClasspathEntry('JAOTC') jvmci_classpath_adjusted = False if jaotc_entry not in mx_compiler._jvmci_classpath: mx_compiler.add_jvmci_classpath_entry(jaotc_entry) jvmci_classpath_adjusted = True vm_args = [a[2:] for a in args if a.startswith('-J')] args = [a for a in args if not a.startswith('-J')] verbose = ['--verbose'] if mx._opts.very_verbose else [] cp = ['-cp', classpath] if classpath else [] try: mx_compiler.run_vm( ['--add-exports=jdk.internal.vm.ci/jdk.vm.ci.aarch64=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.amd64=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.code=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.code.site=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.code.stack=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.common=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.hotspot=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.hotspot.aarch64=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.hotspot.amd64=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.hotspot.sparc=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.meta=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.runtime=jdk.internal.vm.compiler,jdk.aot', '--add-exports=jdk.internal.vm.ci/jdk.vm.ci.sparc=jdk.internal.vm.compiler,jdk.aot', '-XX:+CalculateClassFingerprint'] + vm_args + cp + ['-m', 'jdk.aot/jdk.tools.jaotc.Main'] + verbose + args, cwd=cwd) finally: if jvmci_classpath_adjusted: mx_compiler._jvmci_classpath.remove(jaotc_entry)