| """ | |
| Copyright 2019 Google LLC | |
| Licensed under the Apache License, Version 2.0 (the "License"); | |
| you may not use this file except in compliance with the License. | |
| You may obtain a copy of the License at | |
| http://www.apache.org/licenses/LICENSE-2.0 | |
| Unless required by applicable law or agreed to in writing, software | |
| distributed under the License is distributed on an "AS IS" BASIS, | |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| See the License for the specific language governing permissions and | |
| limitations under the License. | |
| Regression script for RISC-V random instruction generator | |
| """ | |
| import argparse | |
| import os | |
| import subprocess | |
| import re | |
| import sys | |
| import logging | |
| from datetime import date | |
| from scripts.lib import * | |
| from scripts.spike_log_to_trace_csv import * | |
| from scripts.ovpsim_log_to_trace_csv import * | |
| from scripts.sail_log_to_trace_csv import * | |
| from scripts.instr_trace_compare import * | |
| LOGGER = logging.getLogger() | |
| def get_generator_cmd(simulator, simulator_yaml, cov): | |
| """ Setup the compile and simulation command for the generator | |
| Args: | |
| simulator : RTL simulator used to run instruction generator | |
| simulator_yaml : RTL simulator configuration file in YAML format | |
| cov : Enable functional coverage | |
| Returns: | |
| compile_cmd : RTL simulator command to compile the instruction generator | |
| sim_cmd : RTL simulator command to run the instruction generator | |
| """ | |
| logging.info("Processing simulator setup file : %s" % simulator_yaml) | |
| yaml_data = read_yaml(simulator_yaml) | |
| # Search for matched simulator | |
| for entry in yaml_data: | |
| if entry['tool'] == simulator: | |
| logging.info("Found matching simulator: %s" % entry['tool']) | |
| compile_spec = entry['compile'] | |
| compile_cmd = compile_spec['cmd'] | |
| for i in range(len(compile_cmd)): | |
| if ('cov_opts' in compile_spec) and cov: | |
| compile_cmd[i] = re.sub('<cov_opts>', compile_spec['cov_opts'].rstrip(), compile_cmd[i]) | |
| else: | |
| compile_cmd[i] = re.sub('<cov_opts>', '', compile_cmd[i]) | |
| sim_cmd = entry['sim']['cmd'] | |
| if ('cov_opts' in entry['sim']) and cov: | |
| sim_cmd = re.sub('<cov_opts>', entry['sim']['cov_opts'].rstrip(), sim_cmd) | |
| else: | |
| sim_cmd = re.sub('<cov_opts>', '', sim_cmd) | |
| if 'env_var' in entry: | |
| for env_var in entry['env_var'].split(','): | |
| for i in range(len(compile_cmd)): | |
| compile_cmd[i] = re.sub("<"+env_var+">", get_env_var(env_var), compile_cmd[i]) | |
| sim_cmd = re.sub("<"+env_var+">", get_env_var(env_var), sim_cmd) | |
| return compile_cmd, sim_cmd | |
| logging.error("Cannot find RTL simulator %0s" % simulator) | |
| sys.exit(1) | |
| def parse_iss_yaml(iss, iss_yaml, isa, setting_dir): | |
| """Parse ISS YAML to get the simulation command | |
| Args: | |
| iss : target ISS used to look up in ISS YAML | |
| iss_yaml : ISS configuration file in YAML format | |
| isa : ISA variant passed to the ISS | |
| setting_dir : Generator setting directory | |
| Returns: | |
| cmd : ISS run command | |
| """ | |
| logging.info("Processing ISS setup file : %s" % iss_yaml) | |
| yaml_data = read_yaml(iss_yaml) | |
| cwd = os.path.dirname(os.path.realpath(__file__)) | |
| # Search for matched ISS | |
| for entry in yaml_data: | |
| if entry['iss'] == iss: | |
| logging.info("Found matching ISS: %s" % entry['iss']) | |
| cmd = entry['cmd'].rstrip() | |
| cmd = re.sub("\<path_var\>", get_env_var(entry['path_var']), cmd) | |
| if iss == "ovpsim": | |
| cmd = re.sub("\<cfg_path\>", setting_dir, cmd) | |
| else: | |
| cmd = re.sub("\<variant\>", isa, cmd) | |
| return cmd | |
| logging.error("Cannot find ISS %0s" % iss) | |
| sys.exit(1) | |
| def get_iss_cmd(base_cmd, elf, log): | |
| """Get the ISS simulation command | |
| Args: | |
| base_cmd : Original command template | |
| elf : ELF file to run ISS simualtion | |
| log : ISS simulation log name | |
| Returns: | |
| cmd : Command for ISS simulation | |
| """ | |
| cmd = re.sub("\<elf\>", elf, base_cmd) | |
| cmd += (" &> %s" % log) | |
| return cmd | |
| def gen(test_list, csr_file, end_signature_addr, isa, simulator, | |
| simulator_yaml, output_dir, sim_only, compile_only, lsf_cmd, seed, | |
| cwd, cmp_opts, sim_opts, timeout_s, core_setting_dir, ext_dir, cov, | |
| log_suffix, batch_size, seed_yaml): | |
| """Run the instruction generator | |
| Args: | |
| test_list : List of assembly programs to be compiled | |
| csr_file : YAML file containing description of all CSRs | |
| end_signature_addr : Address that tests will write pass/fail signature to at end of test | |
| isa : Processor supported ISA subset | |
| simulator : RTL simulator used to run instruction generator | |
| simulator_yaml : RTL simulator configuration file in YAML format | |
| output_dir : Output directory of the ELF files | |
| sim_only : Simulation only | |
| compile_only : Compile the generator only | |
| lsf_cmd : LSF command used to run the instruction generator | |
| seed : Seed to the instruction generator | |
| cmp_opts : Compile options for the generator | |
| sim_opts : Simulation options for the generator | |
| timeout_s : Timeout limit in seconds | |
| core_setting_dir : Path for riscv_core_setting.sv | |
| ext_dir : User extension directory | |
| cov : Enable functional coverage | |
| log_suffix : Simulation log file name suffix | |
| batch_size : Number of tests to generate per run | |
| seed_yaml : Seed specification from a prior regression | |
| """ | |
| # Mutually exclusive options between compile_only and sim_only | |
| if compile_only and sim_only: | |
| logging.error("argument -co is not allowed with argument -so") | |
| # Setup the compile and simulation command for the generator | |
| compile_cmd = [] | |
| sim_cmd = "" | |
| compile_cmd, sim_cmd = get_generator_cmd(simulator, simulator_yaml, cov); | |
| if ((compile_only == 0) and (len(test_list) == 0)): | |
| return | |
| # Compile the instruction generator | |
| if not sim_only: | |
| if (not((len(test_list) == 1) and (test_list[0]['test'] == 'riscv_csr_test'))): | |
| logging.info("Building RISC-V instruction generator") | |
| for cmd in compile_cmd: | |
| cmd = re.sub("<out>", os.path.abspath(output_dir), cmd) | |
| cmd = re.sub("<setting>", core_setting_dir, cmd) | |
| if ext_dir == "": | |
| cmd = re.sub("<user_extension>", "<cwd>/user_extension", cmd) | |
| else: | |
| cmd = re.sub("<user_extension>", ext_dir, cmd) | |
| cmd = re.sub("<cwd>", cwd, cmd) | |
| cmd = re.sub("<cmp_opts>", cmp_opts, cmd) | |
| logging.debug("Compile command: %s" % cmd) | |
| logging.debug(run_cmd(cmd)) | |
| # Run the instruction generator | |
| if not compile_only: | |
| cmd_list = [] | |
| sim_cmd = re.sub("<out>", os.path.abspath(output_dir), sim_cmd) | |
| sim_cmd = re.sub("<cwd>", cwd, sim_cmd) | |
| sim_cmd = re.sub("<sim_opts>", sim_opts, sim_cmd) | |
| if seed_yaml: | |
| rerun_seed = read_yaml(seed_yaml) | |
| else: | |
| rerun_seed = {} | |
| logging.info("Running RISC-V instruction generator") | |
| sim_seed = {} | |
| for test in test_list: | |
| iterations = test['iterations'] | |
| logging.info("Generating %d %s" % (iterations, test['test'])) | |
| if iterations > 0: | |
| """ | |
| If we are running a CSR test, need to call a separate python script | |
| to generate directed CSR test code, located at scripts/gen_csr_test.py. | |
| """ | |
| if test['test'] == 'riscv_csr_test': | |
| cmd = "python3 scripts/gen_csr_test.py" + \ | |
| (" --csr_file %s" % csr_file) + \ | |
| (" --xlen %s" % re.search(r"(?P<xlen>[0-9]+)", isa).group("xlen")) + \ | |
| (" --iterations %i" % iterations) + \ | |
| (" --out %s/asm_tests" % output_dir) + \ | |
| (" --end_signature_addr %s" % end_signature_addr) | |
| if lsf_cmd: | |
| cmd_list.append(cmd) | |
| else: | |
| run_cmd(cmd, timeout_s) | |
| else: | |
| if batch_size > 0: | |
| batch_cnt = int((iterations + batch_size - 1) / batch_size); | |
| else: | |
| batch_cnt = 1 | |
| logging.info("Running %s with %0d batches" % (test['test'], batch_cnt)) | |
| for i in range(0, batch_cnt): | |
| test_id = '%0s_%0d' % (test['test'], i) | |
| if test_id in rerun_seed: | |
| rand_seed = rerun_seed[test_id] | |
| else: | |
| rand_seed = get_seed(seed) | |
| if i < batch_cnt - 1: | |
| test_cnt = batch_size | |
| else: | |
| test_cnt = iterations - i * batch_size; | |
| cmd = lsf_cmd + " " + sim_cmd.rstrip() + \ | |
| (" +UVM_TESTNAME=%s " % test['gen_test']) + \ | |
| (" +num_of_tests=%i " % test_cnt) + \ | |
| (" +start_idx=%d " % (i*batch_size)) + \ | |
| (" +asm_file_name=%s/asm_tests/%s " % (output_dir, test['test'])) + \ | |
| (" -l %s/sim_%s_%d%s.log " % (output_dir, test['test'], i, log_suffix)) | |
| cmd = re.sub("<seed>", str(rand_seed), cmd) | |
| sim_seed[test_id] = str(rand_seed) | |
| if "gen_opts" in test: | |
| cmd += test['gen_opts'] | |
| if not re.search("c", isa): | |
| cmd += "+disable_compressed_instr=1 "; | |
| if lsf_cmd: | |
| cmd_list.append(cmd) | |
| else: | |
| logging.info("Running %s, batch %0d/%0d, test_cnt:%0d" % | |
| (test['test'], i+1, batch_cnt, test_cnt)) | |
| run_cmd(cmd, timeout_s) | |
| if sim_seed: | |
| with open(('%s/seed.yaml' % os.path.abspath(output_dir)) , 'w') as outfile: | |
| yaml.dump(sim_seed, outfile, default_flow_style=False) | |
| if lsf_cmd: | |
| run_parallel_cmd(cmd_list, timeout_s) | |
| def gcc_compile(test_list, output_dir, isa, mabi, opts): | |
| """Use riscv gcc toolchain to compile the assembly program | |
| Args: | |
| test_list : List of assembly programs to be compiled | |
| output_dir : Output directory of the ELF files | |
| isa : ISA variant passed to GCC | |
| mabi : MABI variant passed to GCC | |
| """ | |
| cwd = os.path.dirname(os.path.realpath(__file__)) | |
| for test in test_list: | |
| for i in range(0, test['iterations']): | |
| if 'no_gcc' in test and test['no_gcc'] == 1: | |
| continue | |
| prefix = ("%s/asm_tests/%s_%d" % (output_dir, test['test'], i)) | |
| asm = prefix + ".S" | |
| elf = prefix + ".o" | |
| binary = prefix + ".bin" | |
| test_isa = isa | |
| # gcc comilation | |
| cmd = ("%s -static -mcmodel=medany \ | |
| -fvisibility=hidden -nostdlib \ | |
| -nostartfiles %s \ | |
| -I%s/user_extension \ | |
| -T%s/scripts/link.ld %s -o %s " % \ | |
| (get_env_var("RISCV_GCC"), asm, cwd, cwd, opts, elf)) | |
| if 'gcc_opts' in test: | |
| cmd += test['gcc_opts'] | |
| if 'gen_opts' in test: | |
| # Disable compressed instruction | |
| if re.search('disable_compressed_instr', test['gen_opts']): | |
| test_isa = re.sub("c", "", test_isa) | |
| # If march/mabi is not defined in the test gcc_opts, use the default | |
| # setting from the command line. | |
| if not re.search('march', cmd): | |
| cmd += (" -march=%s" % test_isa) | |
| if not re.search('mabi', cmd): | |
| cmd += (" -mabi=%s" % mabi) | |
| logging.info("Compiling %s" % asm) | |
| logging.debug(cmd) | |
| output = subprocess.check_output(cmd.split()) | |
| logging.debug(output) | |
| # Convert the ELF to plain binary, used in RTL sim | |
| logging.info("Converting to %s" % binary) | |
| cmd = ("%s -O binary %s %s" % (get_env_var("RISCV_OBJCOPY"), elf, binary)) | |
| output = subprocess.check_output(cmd.split()) | |
| logging.debug(output) | |
| def run_assembly(asm_test, iss_yaml, isa, mabi, iss): | |
| """Run a directed assembly test with spike | |
| Args: | |
| asm_tset : Assembly test file | |
| iss_yaml : ISS configuration file in YAML format | |
| isa : ISA variant passed to the ISS | |
| mabi : MABI variant passed to GCC | |
| iss : Instruction set simulators | |
| """ | |
| cwd = os.path.dirname(os.path.realpath(__file__)) | |
| asm = asm_test | |
| elf = asm_test + ".o" | |
| binary = asm_test + ".bin" | |
| log = asm_test + ".log" | |
| logging.info("Compiling assembly test : %s" % asm) | |
| # gcc comilation | |
| cmd = ("%s -static -mcmodel=medany \ | |
| -fvisibility=hidden -nostdlib \ | |
| -nostartfiles %s \ | |
| -I%s/user_extension \ | |
| -T%s/scripts/link.ld -o %s " % \ | |
| (get_env_var("RISCV_GCC"), asm, cwd, cwd, elf)) | |
| cmd += (" -march=%s" % isa) | |
| cmd += (" -mabi=%s" % mabi) | |
| logging.info("Compiling %s" % asm) | |
| output = subprocess.check_output(cmd.split()) | |
| # Convert the ELF to plain binary, used in RTL sim | |
| logging.info("Converting to %s" % binary) | |
| cmd = ("%s -O binary %s %s" % (get_env_var("RISCV_OBJCOPY"), elf, binary)) | |
| output = subprocess.check_output(cmd.split()) | |
| logging.debug(output) | |
| base_cmd = parse_iss_yaml(iss, iss_yaml, isa) | |
| logging.info("[%0s] Running ISS simulation: %s" % (iss, elf)) | |
| cmd = get_iss_cmd(base_cmd, elf, log) | |
| run_cmd(cmd, 20) | |
| logging.info("[%0s] Running ISS simulation: %s ...done" % (iss, elf)) | |
| def iss_sim(test_list, output_dir, iss_list, iss_yaml, isa, setting_dir, timeout_s): | |
| """Run ISS simulation with the generated test program | |
| Args: | |
| test_list : List of assembly programs to be compiled | |
| output_dir : Output directory of the ELF files | |
| iss_list : List of instruction set simulators | |
| iss_yaml : ISS configuration file in YAML format | |
| isa : ISA variant passed to the ISS | |
| setting_dir : Generator setting directory | |
| timeout_s : Timeout limit in seconds | |
| """ | |
| for iss in iss_list.split(","): | |
| log_dir = ("%s/%s_sim" % (output_dir, iss)) | |
| base_cmd = parse_iss_yaml(iss, iss_yaml, isa, setting_dir) | |
| logging.info("%s sim log dir: %s" % (iss, log_dir)) | |
| subprocess.run(["mkdir", "-p", log_dir]) | |
| for test in test_list: | |
| if 'no_iss' in test and test['no_iss'] == 1: | |
| continue | |
| else: | |
| for i in range(0, test['iterations']): | |
| prefix = ("%s/asm_tests/%s_%d" % (output_dir, test['test'], i)) | |
| elf = prefix + ".o" | |
| log = ("%s/%s.%d.log" % (log_dir, test['test'], i)) | |
| cmd = get_iss_cmd(base_cmd, elf, log) | |
| logging.info("Running %s sim: %s" % (iss, elf)) | |
| run_cmd(cmd, timeout_s) | |
| logging.debug(cmd) | |
| def iss_cmp(test_list, iss, output_dir, isa): | |
| """Compare ISS simulation reult | |
| Args: | |
| test_list : List of assembly programs to be compiled | |
| iss : List of instruction set simulators | |
| output_dir : Output directory of the ELF files | |
| isa : ISA | |
| """ | |
| iss_list = iss.split(",") | |
| if len(iss_list) != 2: | |
| return | |
| report = ("%s/iss_regr.log" % output_dir).rstrip() | |
| run_cmd("rm -rf %s" % report) | |
| for test in test_list: | |
| for i in range(0, test['iterations']): | |
| elf = ("%s/asm_tests/%s_%d.o" % (output_dir, test['test'], i)) | |
| logging.info("Comparing ISS sim result %s/%s : %s" % | |
| (iss_list[0], iss_list[1], elf)) | |
| csv_list = [] | |
| run_cmd(("echo 'Test binary: %s' >> %s" % (elf, report))) | |
| for iss in iss_list: | |
| log = ("%s/%s_sim/%s.%d.log" % (output_dir, iss, test['test'], i)) | |
| csv = ("%s/%s_sim/%s.%d.csv" % (output_dir, iss, test['test'], i)) | |
| csv_list.append(csv) | |
| if iss == "spike": | |
| process_spike_sim_log(log, csv) | |
| elif iss == "ovpsim": | |
| process_ovpsim_sim_log(log, csv) | |
| elif iss == "sail": | |
| process_sail_sim_log(log, csv) | |
| else: | |
| logging.error("Unsupported ISS" % iss) | |
| sys.exit(1) | |
| compare_trace_csv(csv_list[0], csv_list[1], iss_list[0], iss_list[1], report) | |
| passed_cnt = run_cmd("grep PASSED %s | wc -l" % report).strip() | |
| failed_cnt = run_cmd("grep FAILED %s | wc -l" % report).strip() | |
| summary = ("%s PASSED, %s FAILED" % (passed_cnt, failed_cnt)) | |
| logging.info(summary) | |
| run_cmd(("echo %s >> %s" % (summary, report))) | |
| logging.info("ISS regression report is saved to %s" % report) | |
| def setup_parser(): | |
| """Create a command line parser. | |
| Returns: The created parser. | |
| """ | |
| # Parse input arguments | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--target", type=str, default="rv64imc", | |
| help="Run the generator with pre-defined targets: \ | |
| rv32imc, rv32i, rv64imc, rv64gc") | |
| parser.add_argument("-o", "--output", type=str, | |
| help="Output directory name", dest="o") | |
| parser.add_argument("-tl", "--testlist", type=str, default="", | |
| help="Regression testlist", dest="testlist") | |
| parser.add_argument("-tn", "--test", type=str, default="all", | |
| help="Test name, 'all' means all tests in the list", dest="test") | |
| parser.add_argument("--seed", type=int, default=-1, | |
| help="Randomization seed, default -1 means random seed") | |
| parser.add_argument("-i", "--iterations", type=int, default=0, | |
| help="Override the iteration count in the test list", dest="iterations") | |
| parser.add_argument("-si", "--simulator", type=str, default="vcs", | |
| help="Simulator used to run the generator, default VCS", dest="simulator") | |
| parser.add_argument("--iss", type=str, default="spike", | |
| help="RISC-V instruction set simulator: spike,ovpsim,sail") | |
| parser.add_argument("-v", "--verbose", dest="verbose", action="store_true", | |
| help="Verbose logging") | |
| parser.add_argument("--co", dest="co", action="store_true", | |
| help="Compile the generator only") | |
| parser.add_argument("--cov", dest="cov", action="store_true", | |
| help="Enable functional coverage") | |
| parser.add_argument("--so", dest="so", action="store_true", | |
| help="Simulate the generator only") | |
| parser.add_argument("--cmp_opts", type=str, default="", | |
| help="Compile options for the generator") | |
| parser.add_argument("--sim_opts", type=str, default="", | |
| help="Simulation options for the generator") | |
| parser.add_argument("--gcc_opts", type=str, default="", | |
| help="GCC compile options") | |
| parser.add_argument("-s", "--steps", type=str, default="all", | |
| help="Run steps: gen,gcc_compile,iss_sim,iss_cmp", dest="steps") | |
| parser.add_argument("--lsf_cmd", type=str, default="", | |
| help="LSF command. Run in local sequentially if lsf \ | |
| command is not specified") | |
| parser.add_argument("--isa", type=str, default="", | |
| help="RISC-V ISA subset") | |
| parser.add_argument("-m", "--mabi", type=str, default="", | |
| help="mabi used for compilation", dest="mabi") | |
| parser.add_argument("--gen_timeout", type=int, default=360, | |
| help="Generator timeout limit in seconds") | |
| parser.add_argument("--end_signature_addr", type=str, default="0", | |
| help="Address that privileged CSR test writes to at EOT") | |
| parser.add_argument("--iss_timeout", type=int, default=10, | |
| help="ISS sim timeout limit in seconds") | |
| parser.add_argument("--iss_yaml", type=str, default="", | |
| help="ISS setting YAML") | |
| parser.add_argument("--simulator_yaml", type=str, default="", | |
| help="RTL simulator setting YAML") | |
| parser.add_argument("--csr_yaml", type=str, default="", | |
| help="CSR description file") | |
| parser.add_argument("--seed_yaml", type=str, default="", | |
| help="Rerun the generator with the seed specification \ | |
| from a prior regression") | |
| parser.add_argument("-ct", "--custom_target", type=str, default="", | |
| help="Directory name of the custom target") | |
| parser.add_argument("-cs", "--core_setting_dir", type=str, default="", | |
| help="Path for the riscv_core_setting.sv") | |
| parser.add_argument("-ext", "--user_extension_dir", type=str, default="", | |
| help="Path for the user extension directory") | |
| parser.add_argument("--asm_test", type=str, default="", | |
| help="Directed assembly test") | |
| parser.add_argument("--log_suffix", type=str, default="", | |
| help="Simulation log name suffix") | |
| parser.add_argument("-bz", "--batch_size", type=int, default=0, | |
| help="Number of tests to generate per run. You can split a big" | |
| " job to small batches with this option") | |
| parser.set_defaults(co=False) | |
| parser.set_defaults(so=False) | |
| parser.set_defaults(verbose=False) | |
| parser.set_defaults(cov=False) | |
| return parser | |
| def main(): | |
| """This is the main entry point.""" | |
| parser = setup_parser() | |
| args = parser.parse_args() | |
| cwd = os.path.dirname(os.path.realpath(__file__)) | |
| os.environ["RISCV_DV_ROOT"] = cwd | |
| setup_logging(args.verbose) | |
| if not args.csr_yaml: | |
| args.csr_yaml = cwd + "/yaml/csr_template.yaml" | |
| if not args.iss_yaml: | |
| args.iss_yaml = cwd + "/yaml/iss.yaml" | |
| if not args.simulator_yaml: | |
| args.simulator_yaml = cwd + "/yaml/simulator.yaml" | |
| # Keep the core_setting_dir option to be backward compatible, suggest to use | |
| # --custom_target | |
| if args.core_setting_dir: | |
| if not args.custom_target: | |
| args.custom_target = args.core_setting_dir | |
| else: | |
| args.core_setting_dir = args.custom_target | |
| if not args.custom_target: | |
| if not args.testlist: | |
| args.testlist = cwd + "/target/"+ args.target +"/testlist.yaml" | |
| args.core_setting_dir = cwd + "/target/"+ args.target | |
| if args.target == "rv32imc": | |
| args.mabi = "ilp32" | |
| args.isa = "rv32imc" | |
| elif args.target == "rv32i": | |
| args.mabi = "ilp32" | |
| args.isa = "rv32i" | |
| elif args.target == "rv64imc": | |
| args.mabi = "lp64" | |
| args.isa = "rv64imc" | |
| elif args.target == "ml": | |
| args.mabi = "lp64" | |
| args.isa = "rv64imc" | |
| else: | |
| print ("Unsupported pre-defined target: %0s" % args.target) | |
| else: | |
| if (not args.mabi) or (not args.isa): | |
| sys.exit("mabi and isa must be specified for custom target %0s" % args.custom_target) | |
| if not args.testlist: | |
| args.testlist = args.custom_target + "/testlist.yaml" | |
| if args.asm_test != "": | |
| run_assembly(args.asm_test, args.iss_yaml, args.isa, args.mabi, args.iss) | |
| return | |
| # Create output directory | |
| if args.o is None: | |
| output_dir = "out_" + str(date.today()) | |
| else: | |
| output_dir = args.o | |
| subprocess.run(["mkdir", "-p", output_dir]) | |
| subprocess.run(["mkdir", "-p", ("%s/asm_tests" % output_dir)]) | |
| # Process regression test list | |
| matched_list = [] | |
| if not args.co: | |
| process_regression_list(args.testlist, args.test, args.iterations, matched_list) | |
| if len(matched_list) == 0: | |
| sys.exit("Cannot find %s in %s" % (args.test, args.testlist)) | |
| # Run instruction generator | |
| if args.steps == "all" or re.match(".*gen.*", args.steps): | |
| gen(matched_list, args.csr_yaml, args.end_signature_addr, args.isa, | |
| args.simulator, args.simulator_yaml, output_dir, args.so, | |
| args.co, args.lsf_cmd, args.seed, cwd, args.cmp_opts, | |
| args.sim_opts, args.gen_timeout, args.core_setting_dir, | |
| args.user_extension_dir, args.cov, args.log_suffix, args.batch_size, | |
| args.seed_yaml) | |
| if not args.co: | |
| # Compile the assembly program to ELF, convert to plain binary | |
| if args.steps == "all" or re.match(".*gcc_compile.*", args.steps): | |
| gcc_compile(matched_list, output_dir, args.isa, args.mabi, args.gcc_opts) | |
| # Run ISS simulation | |
| if args.steps == "all" or re.match(".*iss_sim.*", args.steps): | |
| iss_sim(matched_list, output_dir, args.iss, args.iss_yaml, | |
| args.isa, args.core_setting_dir, args.iss_timeout) | |
| # Compare ISS simulation result | |
| if args.steps == "all" or re.match(".*iss_cmp.*", args.steps): | |
| iss_cmp(matched_list, args.iss, output_dir, args.isa) | |
| if __name__ == "__main__": | |
| main() |