xref: /XiangShan/scripts/xiangshan.py (revision 3feeca589ef817691cad9cad7fa5ce19e13d8ac0) 
1#***************************************************************************************
2# Copyright (c) 2020-2021 Institute of Computing Technology, Chinese Academy of Sciences
3# Copyright (c) 2020-2021 Peng Cheng Laboratory
4#
5# XiangShan is licensed under Mulan PSL v2.
6# You can use this software according to the terms and conditions of the Mulan PSL v2.
7# You may obtain a copy of Mulan PSL v2 at:
8#          http://license.coscl.org.cn/MulanPSL2
9#
10# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
11# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
12# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
13#
14# See the Mulan PSL v2 for more details.
15#***************************************************************************************
16
17# Simple version of xiangshan python wrapper
18
19import argparse
20import os
21import random
22import subprocess
23import sys
24import time
25
26
27class XSArgs(object):
28    script_path = os.path.realpath(__file__)
29    # default path to the repositories
30    noop_home = os.path.join(os.path.dirname(script_path), "..")
31    nemu_home = os.path.join(noop_home, "../NEMU")
32    am_home = os.path.join(noop_home, "../nexus-am")
33    dramsim3_home = os.path.join(noop_home, "../DRAMsim3")
34    rvtest_home = os.path.join(noop_home, "../riscv-tests")
35
36    def __init__(self, args):
37        # all path environment variables that should be set
38        all_path = [
39            # (python argument, environment variable, default, target function)
40            (None, "NOOP_HOME", self.noop_home, self.set_noop_home),
41            (args.nemu, "NEMU_HOME", self.nemu_home, self.set_nemu_home),
42            (args.am, "AM_HOME", self.am_home, self.set_am_home),
43            (args.dramsim3, "DRAMSIM3_HOME", self.dramsim3_home, self.set_dramsim3_home),
44            (args.rvtest, "RVTEST_HOME", self.rvtest_home, self.set_rvtest_home),
45        ]
46        for (arg_in, env, default, set_func) in all_path:
47            set_func(self.__extract_path(arg_in, env, default))
48        # Chisel arguments
49        self.disable_log = args.disable_log
50        self.num_cores = args.num_cores
51        # Makefile arguments
52        self.threads = args.threads
53        self.with_dramsim3 = 1 if args.with_dramsim3 else None
54        self.trace = 1 if args.trace else None
55        self.config = args.config
56        # emu arguments
57        self.max_instr = args.max_instr
58        self.seed = random.randint(0, 9999)
59        self.numa = args.numa
60
61    def get_env_variables(self):
62        all_env = {
63            "NOOP_HOME"    : self.noop_home,
64            "NEMU_HOME"    : self.nemu_home,
65            "AM_HOME"      : self.am_home,
66            "DRAMSIM3_HOME": self.dramsim3_home
67        }
68        return all_env
69
70    def get_chisel_args(self, prefix=None):
71        chisel_args = [
72            (self.disable_log, "disable-log")
73        ]
74        args = map(lambda x: x[1], filter(lambda arg: arg[0], chisel_args))
75        if prefix is not None:
76            args = map(lambda x: prefix + x, args)
77        return args
78
79    def get_makefile_args(self):
80        makefile_args = [
81            (self.threads,       "EMU_THREADS"),
82            (self.with_dramsim3, "WITH_DRAMSIM3"),
83            (self.trace,         "EMU_TRACE"),
84            (self.config,        "CONFIG"),
85            (self.num_cores,     "NUM_CORES")
86        ]
87        args = filter(lambda arg: arg[0] is not None, makefile_args)
88        return args
89
90    def get_emu_args(self):
91        emu_args = [
92            (self.max_instr, "max-instr"),
93            (self.seed,      "seed")
94        ]
95        args = filter(lambda arg: arg[0] is not None, emu_args)
96        return args
97
98    def show(self):
99        print("Extra environment variables:")
100        env = self.get_env_variables()
101        for env_name in env:
102            print(f"{env_name}: {env[env_name]}")
103        print()
104        print("Chisel arguments:")
105        print(" ".join(self.get_chisel_args()))
106        print()
107        print("Makefile arguments:")
108        for val, name in self.get_makefile_args():
109            print(f"{name}={val}")
110        print()
111        print("emu arguments:")
112        for val, name in self.get_emu_args():
113            print(f"--{name} {val}")
114        print()
115
116    def __extract_path(self, path, env=None, default=None):
117        if path is None and env is not None:
118            path = os.getenv(env)
119        if path is None and default is not None:
120            path = default
121        path = os.path.realpath(path)
122        return path
123
124    def set_noop_home(self, path):
125        self.noop_home = path
126
127    def set_nemu_home(self, path):
128        self.nemu_home = path
129
130    def set_am_home(self, path):
131        self.am_home = path
132
133    def set_dramsim3_home(self, path):
134        self.dramsim3_home = path
135
136    def set_rvtest_home(self, path):
137        self.rvtest_home = path
138
139# XiangShan environment
140class XiangShan(object):
141    def __init__(self, args):
142        self.args = XSArgs(args)
143
144    def show(self):
145        self.args.show()
146
147    def generate_verilog(self):
148        print("Generating XiangShan verilog with the following configurations:")
149        self.show()
150        sim_args = " ".join(self.args.get_chisel_args(prefix="--"))
151        make_args = " ".join(map(lambda arg: f"{arg[1]}={arg[0]}", self.args.get_makefile_args()))
152        return_code = self.__exec_cmd(f'make -C $NOOP_HOME verilog SIM_ARGS="{sim_args}" {make_args}')
153        return return_code
154
155    def build_emu(self):
156        print("Building XiangShan emu with the following configurations:")
157        self.show()
158        sim_args = " ".join(self.args.get_chisel_args(prefix="--"))
159        make_args = " ".join(map(lambda arg: f"{arg[1]}={arg[0]}", self.args.get_makefile_args()))
160        return_code = self.__exec_cmd(f'make -C $NOOP_HOME emu -j200 SIM_ARGS="{sim_args}" {make_args}')
161        return return_code
162
163    def run_emu(self, workload):
164        print("Running XiangShan emu with the following configurations:")
165        self.show()
166        emu_args = " ".join(map(lambda arg: f"--{arg[1]} {arg[0]}", self.args.get_emu_args()))
167        print("workload:", workload)
168        numa_args = f"numactl -m 1 -C 64-{64+self.args.threads-1}" if self.args.numa else ""
169        return_code = self.__exec_cmd(f'{numa_args} $NOOP_HOME/build/emu -i {workload} {emu_args}')
170        return return_code
171
172    def run(self, args):
173        if args.ci is not None:
174            return self.run_ci(args.ci)
175        actions = [
176            (args.generate, lambda _ : self.generate_verilog()),
177            (args.build, lambda _ : self.build_emu()),
178            (args.workload, lambda args: self.run_emu(args.workload))
179        ]
180        valid_actions = map(lambda act: act[1], filter(lambda act: act[0], actions))
181        for i, action in enumerate(valid_actions):
182            print(f"Action {i}:")
183            ret = action(args)
184            if ret:
185                return ret
186        return 0
187
188    def __exec_cmd(self, cmd):
189        env = dict(os.environ)
190        env.update(self.args.get_env_variables())
191        print("subprocess call cmd:", cmd)
192        start = time.time()
193        return_code = subprocess.call(cmd, shell=True, env=env)
194        end = time.time()
195        print(f"Elapsed time: {end - start} seconds")
196        return return_code
197
198    def __get_ci_cputest(self, name=None):
199        base_dir = os.path.join(self.args.am_home, "tests/cputest/build")
200        cputest = os.listdir(base_dir)
201        cputest = filter(lambda x: x.endswith(".bin"), cputest)
202        cputest = map(lambda x: os.path.join(base_dir, x), cputest)
203        return cputest
204
205    def __get_ci_rvtest(self, name=None):
206        base_dir = os.path.join(self.args.rvtest_home, "isa/build")
207        riscv_tests = os.listdir(base_dir)
208        riscv_tests = filter(lambda x: x.endswith(".bin"), riscv_tests)
209        all_rv_tests = ["rv64ui", "rv64um", "rv64ua", "rv64uf", "rv64ud"]
210        riscv_tests = filter(lambda x: x[:6] in all_rv_tests, riscv_tests)
211        riscv_tests = map(lambda x: os.path.join(base_dir, x), riscv_tests)
212        return riscv_tests
213
214    def __get_ci_misc(self, name=None):
215        base_dir = "/home/ci-runner/xsenv/workloads"
216        workloads = [
217            "bitmanip/bitMisc.bin",
218            "crypto/crypto-riscv64-noop.bin",
219            "coremark_rv64gc_o2/coremark-riscv64-xs.bin",
220            "coremark_rv64gc_o3/coremark-riscv64-xs.bin",
221            "coremark_rv64gcb_o3/coremark-riscv64-xs.bin",
222            "ext_intr/amtest-riscv64-xs.bin",
223            "cache-alias/aliastest-riscv64-xs.bin"
224        ]
225        misc_tests = map(lambda x: os.path.join(base_dir, x), workloads)
226        return misc_tests
227
228    def __am_apps_path(self, bench):
229        filename = f"{bench}-riscv64-noop.bin"
230        return [os.path.join(self.args.am_home, "apps", bench, "build", filename)]
231
232    def __get_ci_workloads(self, name):
233        workloads = {
234            "linux-hello": "bbl.bin",
235            "povray": "_700480000000_.gz",
236            "mcf": "_17520000000_.gz",
237            "xalancbmk": "_266100000000_.gz",
238            "gcc": "_39720000000_.gz",
239            "namd": "_434640000000_.gz",
240            "milc": "_103620000000_.gz",
241            "lbm": "_140840000000_.gz",
242            "gromacs": "_275480000000_.gz",
243            "wrf": "_1916220000000_.gz",
244            "astar": "_122060000000_.gz"
245        }
246        return [os.path.join("/home/ci-runner/xsenv/workloads", name, workloads[name])]
247
248    def run_ci(self, test):
249        all_tests = {
250            "cputest": self.__get_ci_cputest,
251            "riscv-tests": self.__get_ci_rvtest,
252            "misc-tests": self.__get_ci_misc,
253            "microbench": self.__am_apps_path,
254            "coremark": self.__am_apps_path
255        }
256        for target in all_tests.get(test, self.__get_ci_workloads)(test):
257            print(target)
258            ret = self.run_emu(target)
259            if ret:
260                return ret
261        return 0
262
263if __name__ == "__main__":
264    parser = argparse.ArgumentParser(description='Python wrapper for XiangShan')
265    parser.add_argument('workload', nargs='?', type=str, default="",
266                        help='input workload file in binary format')
267    # actions
268    parser.add_argument('--build', action='store_true', help='build XS emu')
269    parser.add_argument('--generate', action='store_true', help='generate XS verilog')
270    parser.add_argument('--ci', nargs='?', type=str, const="", help='run CI tests')
271    # environment variables
272    parser.add_argument('--nemu', nargs='?', type=str, help='path to nemu')
273    parser.add_argument('--am', nargs='?', type=str, help='path to nexus-am')
274    parser.add_argument('--dramsim3', nargs='?', type=str, help='path to dramsim3')
275    parser.add_argument('--rvtest', nargs='?', type=str, help='path to riscv-tests')
276    # chisel arguments
277    parser.add_argument('--disable-log', action='store_true', help='disable log')
278    parser.add_argument('--num-cores', type=int, help='number of cores')
279    # makefile arguments
280    parser.add_argument('--with-dramsim3', action='store_true', help='enable dramsim3')
281    parser.add_argument('--threads', nargs='?', type=int, help='number of emu threads')
282    parser.add_argument('--trace', action='store_true', help='enable waveform')
283    parser.add_argument('--config', nargs='?', type=str, help='config')
284    # emu arguments
285    parser.add_argument('--numa', action='store_true', help='use numactl')
286    parser.add_argument('--max-instr', nargs='?', type=int, help='max instr')
287
288    args = parser.parse_args()
289
290    xs = XiangShan(args)
291    ret = xs.run(args)
292
293    sys.exit(ret)
294