|
3718
|
1 #
|
|
|
2 # commands.py - the default commands available to gl.py
|
|
|
3 #
|
|
|
4 # ----------------------------------------------------------------------------------------------------
|
|
|
5 #
|
|
|
6 # Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
|
|
|
7 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
|
8 #
|
|
|
9 # This code is free software; you can redistribute it and/or modify it
|
|
|
10 # under the terms of the GNU General Public License version 2 only, as
|
|
|
11 # published by the Free Software Foundation.
|
|
|
12 #
|
|
|
13 # This code is distributed in the hope that it will be useful, but WITHOUT
|
|
|
14 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
15 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
16 # version 2 for more details (a copy is included in the LICENSE file that
|
|
|
17 # accompanied this code).
|
|
|
18 #
|
|
|
19 # You should have received a copy of the GNU General Public License version
|
|
|
20 # 2 along with this work; if not, write to the Free Software Foundation,
|
|
|
21 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
22 #
|
|
|
23 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
|
24 # or visit www.oracle.com if you need additional information or have any
|
|
|
25 # questions.
|
|
|
26 #
|
|
|
27 # ----------------------------------------------------------------------------------------------------
|
|
|
28
|
|
|
29 import os, sys
|
|
|
30 from os.path import join, exists, dirname, isfile
|
|
|
31
|
|
|
32 graal_home = dirname(dirname(__file__))
|
|
|
33
|
|
|
34 def clean(env, args):
|
|
|
35 """cleans the GraalVM source tree"""
|
|
|
36 os.environ.update(ARCH_DATA_MODEL='64', LANG='C', HOTSPOT_BUILD_JOBS='16')
|
|
|
37 env.run([env.gmake_cmd(), 'clean'], cwd=join(graal_home, 'make'))
|
|
|
38
|
|
|
39 def example(env, args):
|
|
|
40 """run some or all Graal examples"""
|
|
|
41 examples = {
|
|
|
42 'safeadd': ['com.oracle.max.graal.examples.safeadd', 'com.oracle.max.graal.examples.safeadd.Main'],
|
|
|
43 'vectorlib': ['com.oracle.max.graal.examples.vectorlib', 'com.oracle.max.graal.examples.vectorlib.Main'],
|
|
|
44 }
|
|
|
45
|
|
|
46 def run_example(env, verbose, project, mainClass):
|
|
|
47 cp = env.pdb.classpath(project)
|
|
|
48 sharedArgs = ['-Xcomp', '-XX:CompileOnly=Main', mainClass]
|
|
|
49
|
|
|
50 res = []
|
|
|
51 env.log("=== Server VM ===")
|
|
|
52 printArg = '-XX:+PrintCompilation' if verbose else '-XX:-PrintCompilation'
|
|
|
53 res.append(vm(env, ['-cp', cp, printArg] + sharedArgs, vm="-server"))
|
|
|
54 env.log("=== Graal VM ===")
|
|
|
55 printArg = '-G:+PrintCompilation' if verbose else '-G:-PrintCompilation'
|
|
|
56 res.append(vm(env, ['-cp', cp, printArg, '-G:-Extend', '-G:-Inline'] + sharedArgs))
|
|
|
57 env.log("=== Graal VM with extensions ===")
|
|
|
58 res.append(vm(env, ['-cp', cp, printArg, '-G:+Extend', '-G:-Inline'] + sharedArgs))
|
|
|
59
|
|
|
60 if len([x for x in res if x != 0]) != 0:
|
|
|
61 return 1
|
|
|
62 return 0
|
|
|
63
|
|
|
64 verbose = False
|
|
|
65 if '-v' in args:
|
|
|
66 verbose = True
|
|
|
67 args = [a for a in args if a != '-v']
|
|
|
68
|
|
|
69 if len(args) == 0:
|
|
|
70 args = examples.keys()
|
|
|
71 for a in args:
|
|
|
72 config = examples.get(a)
|
|
|
73 if config is None:
|
|
|
74 env.log('unknown example: ' + a + ' {available examples = ' + str(examples.keys()) + '}')
|
|
|
75 else:
|
|
|
76 env.log('--------- ' + a + ' ------------')
|
|
|
77 project, mainClass = config
|
|
|
78 run_example(env, verbose, project, mainClass)
|
|
|
79
|
|
|
80 def dacapo(env, args):
|
|
|
81 """run a DaCapo benchmark"""
|
|
|
82
|
|
|
83 benchmarks = {
|
|
|
84 'avrora': ['-n', '5'],
|
|
|
85 'batik': ['-n', '5'],
|
|
|
86 'eclipse': ['-n', '5'],
|
|
|
87 'fop': ['-n', '5'],
|
|
|
88 'h2': ['-n', '5'],
|
|
|
89 'jython': ['-n', '5'],
|
|
|
90 'luindex': ['-n', '5'],
|
|
|
91 'lusearch': ['-n', '5'],
|
|
|
92 'pmd': ['-n', '5'],
|
|
|
93 'sunflow': ['-n', '5'],
|
|
|
94 'tomcat': ['-n', '5'],
|
|
|
95 'tradebeans': ['-n', '5'],
|
|
|
96 'tradesoap': ['-n', '5'],
|
|
|
97 'xalan': ['-n', '5'],
|
|
|
98 }
|
|
|
99
|
|
|
100 if len(args) == 0:
|
|
|
101 args = args[0:]
|
|
|
102 for bm in benchmarks:
|
|
|
103 run_dacapo(env, args + ['Harness', '-n', '2'] + [bm])
|
|
|
104 return
|
|
|
105 else:
|
|
|
106 bm = args[0]
|
|
|
107 config = benchmarks.get(bm)
|
|
|
108 if (config is None):
|
|
|
109 env.abort('unknown benchmark: ' + bm + '\nselect one of: ' + str(benchmarks.keys()))
|
|
|
110 args = args[1:]
|
|
|
111 return run_dacapo(env, args + ['Harness'] + config + [bm])
|
|
|
112
|
|
|
113 def tests(env, args):
|
|
|
114 """run a selection of the Maxine JTT tests in Graal"""
|
|
|
115
|
|
|
116 maxine = env.check_get_env('MAXINE_HOME')
|
|
|
117 def jtt(name):
|
|
|
118 return join(maxine, 'com.oracle.max.vm', 'test', 'jtt', name)
|
|
|
119
|
|
|
120 return vm(env, ['-ea', '-esa', '-Xcomp', '-XX:+PrintCompilation', '-XX:CompileOnly=jtt'] + args +
|
|
|
121 ['-Xbootclasspath/p:' + join(maxine, 'com.oracle.max.vm', 'bin'),
|
|
|
122 '-Xbootclasspath/p:' + join(maxine, 'com.oracle.max.base', 'bin'),
|
|
|
123 'test.com.sun.max.vm.compiler.JavaTester',
|
|
|
124 '-verbose=1', '-gen-run-scheme=false', '-run-scheme-package=all',
|
|
|
125 jtt('bytecode'),
|
|
|
126 jtt('except'),
|
|
|
127 jtt('jdk'),
|
|
|
128 jtt('hotpath'),
|
|
|
129 jtt('jdk'),
|
|
|
130 jtt('lang'),
|
|
|
131 jtt('loop'),
|
|
|
132 jtt('micro'),
|
|
|
133 jtt('optimize'),
|
|
|
134 jtt('reflect'),
|
|
|
135 jtt('threads'),
|
|
|
136 jtt('hotspot')])
|
|
|
137
|
|
|
138 def _jdk7(env, build='product'):
|
|
|
139 jdk7 = env.check_get_env('JDK7')
|
|
|
140 if build == 'product':
|
|
|
141 pass
|
|
|
142 elif build in ['debug', 'fastdebug', 'optimized']:
|
|
|
143 jdk7 = join(jdk7, build)
|
|
|
144 else:
|
|
|
145 env.abort('Unknown build type: ' + build)
|
|
|
146 return jdk7
|
|
|
147
|
|
|
148 def make(env, args):
|
|
|
149 """builds the GraalVM binary"""
|
|
|
150
|
|
|
151 def fix_jvm_cfg(env, jdk):
|
|
|
152 jvmCfg = join(jdk, 'jre', 'lib', 'amd64', 'jvm.cfg')
|
|
|
153 found = False
|
|
|
154 if not exists(jvmCfg):
|
|
|
155 env.abort(jvmCfg + ' does not exist')
|
|
|
156
|
|
|
157 with open(jvmCfg) as f:
|
|
|
158 for line in f:
|
|
|
159 if '-graal KNOWN' in line:
|
|
|
160 found = True
|
|
|
161 break
|
|
|
162 if not found:
|
|
|
163 env.log('Appending "-graal KNOWN" to ' + jvmCfg)
|
|
|
164 with open(jvmCfg, 'a') as f:
|
|
|
165 f.write('-graal KNOWN\n')
|
|
|
166
|
|
|
167 build = 'product' if len(args) == 0 else args[0]
|
|
|
168 jdk7 = _jdk7(env, build)
|
|
|
169 if build == 'debug':
|
|
|
170 build = 'jvmg'
|
|
|
171
|
|
|
172 fix_jvm_cfg(env, jdk7)
|
|
|
173
|
|
|
174 if env.os != 'windows':
|
|
|
175 javaLink = join(graal_home, 'hotspot', 'java')
|
|
|
176 if not exists(javaLink):
|
|
|
177 javaExe = join(jdk7, 'jre', 'bin', 'java')
|
|
|
178 env.log('Creating link: ' + javaLink + ' -> ' + javaExe)
|
|
|
179 os.symlink(javaExe, javaLink)
|
|
|
180
|
|
|
181 graalVmDir = join(jdk7, 'jre', 'lib', 'amd64', 'graal')
|
|
|
182 if not exists(graalVmDir):
|
|
|
183 env.log('Creating Graal directory in JDK7: ' + graalVmDir)
|
|
|
184 os.makedirs(graalVmDir)
|
|
|
185
|
|
|
186 def filterXusage(line):
|
|
|
187 if not 'Xusage.txt' in line:
|
|
|
188 sys.stderr.write(line + os.linesep)
|
|
|
189
|
|
|
190 os.environ.update(ARCH_DATA_MODEL='64', LANG='C', HOTSPOT_BUILD_JOBS='3', ALT_BOOTDIR=jdk7, INSTALL='y')
|
|
|
191 env.run([env.gmake_cmd(), build + 'graal'], cwd=join(graal_home, 'make'), err=filterXusage)
|
|
|
192
|
|
|
193 def vm(env, args, vm='-graal', build='product'):
|
|
|
194 """run the GraalVM"""
|
|
|
195 if env.java_dbg:
|
|
|
196 args = ['-Xdebug', '-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000'] + args
|
|
|
197 os.environ['MAXINE'] = env.check_get_env('GRAAL_HOME')
|
|
|
198 exe = join(_jdk7(env, build), 'bin', env.exe_suffix('java'))
|
|
|
199 return env.run([exe, vm] + args)
|
|
|
200
|
|
|
201 def vm_g(env, args):
|
|
|
202 """run the debug GraalVM"""
|
|
|
203 return vm(env, args, build='debug')
|
|
|
204
|
|
|
205 def vm_f(env, args):
|
|
|
206 """run the fastdebug GraalVM"""
|
|
|
207 return vm(env, args, build='fastdebug')
|
|
|
208
|
|
|
209 def vm_o(env, args):
|
|
|
210 """run the optimized GraalVM"""
|
|
|
211 return vm(env, args, build='optimized')
|
|
|
212
|
|
|
213 def mx_init(env):
|
|
|
214 commands = {
|
|
|
215 'dacapo': [dacapo, 'benchmark [VM options]'],
|
|
|
216 'example': [example, '[-v] example names...'],
|
|
|
217 'clean': [clean, ''],
|
|
|
218 'make': [make, ''],
|
|
|
219 'tests': [tests, ''],
|
|
|
220 'vm_g': [vm_g, ''],
|
|
|
221 'vm_f': [vm_f, ''],
|
|
|
222 'vm_o': [vm_o, ''],
|
|
|
223 'vm': [vm, ''],
|
|
|
224 }
|
|
|
225 env.commands.update(commands)
|
|
|
226
|
|
|
227 def run_dacapo(env, args):
|
|
|
228 dacapo = env.check_get_env('DACAPO_CP')
|
|
|
229 if not isfile(dacapo) or not dacapo.endswith('.jar'):
|
|
|
230 env.abort('Specified DaCapo jar file does not exist or is not a jar file: ' + dacapo)
|
|
|
231 return vm(env, ['-Xms1g', '-Xmx2g', '-esa', '-cp', dacapo] + args)
|
