| """ |
| 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 * |
| |
| LOGGER = logging.getLogger() |
| |
| def collect_cov(log_dir, out, iss, testlist, batch_size, lsf_cmd, steps, \ |
| opts, timeout, simulator, simulator_yaml, custom_target, target): |
| """Collect functional coverage from the instruction trace |
| |
| Args: |
| log_dir : ISS log directory |
| out : Output directory |
| iss : Instruction set simulator |
| test_list : Testlist of the coverage test |
| batch_size : Number of trace CSV to process per test |
| lsf_cmd : LSF command used to run the instruction generator |
| steps : csv:log to CSV, cov:sample coverage |
| opts : Additional options to the instruction generator |
| timeout : Timeout limit in seconds |
| simulator : RTL simulator used to run |
| simulator_yaml : RTL simulator configuration file in YAML format |
| custom_target : Path for the custom target dir |
| target : Predefined target |
| """ |
| cwd = os.path.dirname(os.path.realpath(__file__)) |
| log_list = [] |
| csv_list = [] |
| trace_log = ("%s/%s_trace_log" % (out, iss)) |
| logging.info("Processing trace log under %s" % log_dir) |
| run_cmd("find %s -name \"*.log\" | sort > %s" % (log_dir, trace_log)) |
| with open(trace_log) as f: |
| for line in f: |
| line = line.rstrip() |
| log_list.append(line) |
| csv = line[0:-4] + ".csv" |
| csv_list.append(csv) |
| if steps == "all" or re.match("csv", steps): |
| for i in range(len(log_list)): |
| log = log_list[i] |
| csv = csv_list[i] |
| logging.info("Process %0s log[%0d/%0d] : %s" % (iss, i+1, len(log_list), log)) |
| if iss == "spike": |
| process_spike_sim_log(log, csv, 1) |
| elif iss == "ovpsim": |
| process_ovpsim_sim_log(log, csv, 1) |
| else: |
| logging.error("Full trace for %s is not supported yet" % iss) |
| sys.exit(1) |
| if steps == "all" or re.match("cov", steps): |
| build_cmd = ("python3 %s/run.py --simulator %s --simulator_yaml %s " |
| " --co -o %s --cov -tl %s %s " % |
| (cwd, simulator, simulator_yaml, out, testlist, opts)) |
| base_sim_cmd = ("python3 %s/run.py --simulator %s --simulator_yaml %s " |
| "--so -o %s --cov -tl %s %s " |
| "-tn riscv_instr_cov_test --steps gen --sim_opts \"<trace_csv_opts>\"" % |
| (cwd, simulator, simulator_yaml, out, testlist, opts)) |
| if target: |
| build_cmd += (" --target %s" % target) |
| if custom_target: |
| build_cmd += (" --custom_target %s" % custom_target) |
| if target: |
| base_sim_cmd += (" --target %s" % target) |
| if custom_target: |
| base_sim_cmd += (" --custom_target %s" % custom_target) |
| logging.info("Building the coverage collection framework") |
| run_cmd(build_cmd) |
| file_idx = 0 |
| trace_idx = 0 |
| trace_csv_opts = "" |
| batch_cnt = 1 |
| sim_cmd_list = [] |
| logging.info("Collecting functional coverage from %0d trace CSV" % len(csv_list)) |
| if batch_size > 0: |
| batch_cnt = (len(csv_list)+batch_size-1)/batch_size; |
| logging.info("Batch size: %0d, Batch cnt:%0d" % (batch_size, batch_cnt)) |
| for i in range(len(csv_list)): |
| if batch_size > 0: |
| file_idx = i / batch_size; |
| trace_idx = i % batch_size; |
| else: |
| file_idx = 0 |
| trace_idx = i |
| trace_csv_opts += (" +trace_csv_%0d=%s" % (trace_idx, csv_list[i])) |
| if ((i == len(csv_list)-1) or ((batch_size > 0) and (trace_idx == batch_size-1))): |
| sim_cmd = base_sim_cmd.replace("<trace_csv_opts>", trace_csv_opts) |
| sim_cmd += (" --log_suffix _%d" % file_idx) |
| if lsf_cmd == "": |
| logging.info("Processing batch %0d/%0d" % (file_idx+1, batch_cnt)) |
| run_cmd(sim_cmd) |
| else: |
| sim_cmd += (" --lsf_cmd \"%s\"" % lsf_cmd) |
| sim_cmd_list.append(sim_cmd) |
| trace_csv_opts = "" |
| if lsf_cmd != "": |
| run_parallel_cmd(sim_cmd_list, timeout) |
| logging.info("Collecting functional coverage from %0d trace CSV...done" % len(csv_list)) |
| |
| |
| def run_cov_debug_test(out, instr_cnt, testlist, batch_size, opts, lsf_cmd,\ |
| timeout, simulator, simulator_yaml, custom_target, target): |
| """Collect functional coverage from the instruction trace |
| |
| Args: |
| out : Output directory |
| instr_cnt : Number of instruction to randomize |
| test_list : Testlist of the coverage test |
| batch_size : Number of trace CSV to process per test |
| lsf_cmd : LSF command used to run the instruction generator |
| opts : Additional options to the instruction generator |
| timeout : Timeout limit in seconds |
| simulator : RTL simulator used to run |
| simulator_yaml : RTL simulator configuration file in YAML format |
| custom_target : Path for the custom target dir |
| target : Predefined target |
| """ |
| cwd = os.path.dirname(os.path.realpath(__file__)) |
| sim_cmd_list = [] |
| logging.info("Building the coverage collection framework") |
| build_cmd = ("python3 %s/run.py --simulator %s --simulator_yaml %s " |
| "--co -o %s --cov -tl %s %s" % |
| (cwd, simulator, simulator_yaml, out, testlist, opts)) |
| if target: |
| build_cmd += (" --target %s" % target) |
| if custom_target: |
| build_cmd += (" --custom_target %s" % custom_target) |
| run_cmd(build_cmd) |
| base_sim_cmd = ("python3 %s/run.py --simulator %s --simulator_yaml %s " |
| "--so -o %s --cov -tl %s %s " |
| "-tn riscv_instr_cov_debug_test --steps gen " |
| "--sim_opts \"+num_of_iterations=<instr_cnt>\"" % |
| (cwd, simulator, simulator_yaml, out, testlist, opts)) |
| if target: |
| base_sim_cmd += (" --target %s" % target) |
| if custom_target: |
| base_sim_cmd += (" --custom_target %s" % custom_target) |
| if batch_size > 0: |
| batch_cnt = int((instr_cnt+batch_size-1)/batch_size) |
| logging.info("Batch size: %0d, Batch cnt:%0d" % (batch_size, batch_cnt)) |
| else: |
| batch_cnt = 1 |
| logging.info("Randomizing %0d instructions in %0d batches", instr_cnt, batch_cnt) |
| for i in range(batch_cnt): |
| if batch_size > 0: |
| if i == batch_cnt - 1: |
| batch_instr_cnt = instr_cnt - batch_size * (batch_cnt - 1) |
| else: |
| batch_instr_cnt = batch_size |
| else: |
| batch_instr_cnt = instr_cnt |
| sim_cmd = base_sim_cmd.replace("<instr_cnt>", str(batch_instr_cnt)) |
| sim_cmd += (" --log_suffix _%d" % i) |
| if lsf_cmd == "": |
| logging.info("Running batch %0d/%0d" % (i+1, batch_cnt)) |
| run_cmd(sim_cmd) |
| else: |
| sim_cmd += (" --lsf_cmd \"%s\"" % lsf_cmd) |
| sim_cmd_list.append(sim_cmd) |
| if lsf_cmd != "": |
| run_parallel_cmd(sim_cmd_list, timeout) |
| logging.info("Collecting functional coverage from %0d random instructions...done" % instr_cnt) |
| |
| |
| def setup_parser(): |
| """Create a command line parser. |
| |
| Returns: The created parser. |
| """ |
| # Parse input arguments |
| parser = argparse.ArgumentParser() |
| parser.add_argument("-o", "--output", type=str, |
| help="Output directory name", dest="o") |
| parser.add_argument("-v", "--verbose", dest="verbose", action="store_true", |
| help="Verbose logging") |
| parser.add_argument("--dir", type=str, |
| help="Directory of ISS log") |
| parser.add_argument("-bz", "--batch_size", dest="batch_size", type=int, default=0, |
| help="Number of CSV to process per run") |
| parser.add_argument("-d", "--debug_mode", dest="debug_mode", action="store_true", |
| help="Debug mode, randomize and sample the coverage directly") |
| parser.add_argument("-i", "--instr_cnt", dest="instr_cnt", type=int, default=0, |
| help="Random instruction count for debug mode") |
| parser.add_argument("-to", "--timeout", dest="timeout", type=int, default=1000, |
| help="Number of CSV to process per run") |
| parser.add_argument("-s", "--steps", type=str, default="all", |
| help="Run steps: csv,cov", dest="steps") |
| parser.add_argument("--iss", type=str, default="spike", |
| help="RISC-V instruction set simulator: spike,ovpsim,sail") |
| parser.add_argument("-tl", "--testlist", type=str, default="", |
| help="Regression testlist", dest="testlist") |
| parser.add_argument("--opts", type=str, default="", |
| help="Additional options for the instruction generator") |
| parser.add_argument("--lsf_cmd", type=str, default="", |
| help="LSF command. Run in local sequentially if lsf \ |
| command is not specified") |
| parser.add_argument("--target", type=str, default="rv32imc", |
| help="Run the generator with pre-defined targets: \ |
| rv32imc, rv32i, rv64imc, rv64gc") |
| parser.add_argument("-si", "--simulator", type=str, default="vcs", |
| help="Simulator used to run the generator, default VCS", dest="simulator") |
| parser.add_argument("--simulator_yaml", type=str, default="", |
| help="RTL simulator setting YAML") |
| 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.set_defaults(verbose=False) |
| parser.set_defaults(debug_mode=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__)) |
| setup_logging(args.verbose) |
| |
| if args.verbose: |
| args.opts += "-v" |
| |
| if not args.testlist: |
| args.testlist = cwd + "/yaml/cov_testlist.yaml" |
| |
| if not args.simulator_yaml: |
| args.simulator_yaml = cwd + "/yaml/simulator.yaml" |
| |
| # Debug mode only works for RV64GC target |
| if args.debug_mode: |
| args.target = "rv64gc" |
| |
| # 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: |
| args.core_setting_dir = cwd + "/target/"+ args.target |
| else: |
| args.testlist = args.custom_target + "/testlist.yaml" |
| |
| # 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]) |
| |
| if args.debug_mode: |
| run_cov_debug_test(output_dir, args.instr_cnt, args.testlist, |
| args.batch_size, args.opts, args.lsf_cmd, args.timeout, |
| args.simulator, args.simulator_yaml, args.custom_target, args.target) |
| else: |
| collect_cov(args.dir, output_dir, args.iss, args.testlist, args.batch_size, |
| args.lsf_cmd, args.steps, args.opts, args.timeout, |
| args.simulator, args.simulator_yaml, args.custom_target, args.target) |
| |
| if __name__ == "__main__": |
| main() |
