| #!/usr/bin/env python3 |
| # Copyright lowRISC contributors. |
| # Licensed under the Apache License, Version 2.0, see LICENSE for details. |
| # SPDX-License-Identifier: Apache-2.0 |
| r"""Parses lint report and dump filtered messages in hjson format. |
| """ |
| import argparse |
| import re |
| import sys |
| from pathlib import Path |
| |
| import hjson |
| |
| # this allows both scientific and fixed point numbers |
| FP_NUMBER = r"[-+]?\d+\.\d+[Ee]?[-+]?\d*" |
| # fp relative error threshold for report checksums |
| CROSSCHECK_REL_TOL = 0.001 |
| |
| |
| def _match_fp_number(full_file, patterns): |
| """Extract numbers from patterns in full_file (a string) |
| |
| patterns is a list of pairs, (key, pattern). Each pattern should be a |
| regular expression with exactly one capture group. Any match for group will |
| be parsed as a float. |
| |
| Returns a pair (nums, errs) where nums is a dictionary keyed by the keys in |
| patterns. The value at K is a list of floats matching patterns[K] if there |
| was more than one match. If there was exactly one match for the |
| patterns[K], the value at K is that float (rather than a singleton list). |
| |
| errs is a list of error messages (caused by failed float conversions or |
| when there is no match for a pattern). |
| |
| """ |
| nums = {} |
| errs = [] |
| for key, pattern in patterns: |
| floats = [] |
| matches = re.findall(pattern, full_file, flags=re.MULTILINE) |
| if not matches: |
| errs.append('Pattern {!r} of key {!r} not found'.format( |
| pattern, key)) |
| continue |
| |
| for match in matches: |
| try: |
| floats.append(float(match)) |
| except ValueError as err: |
| errs.append('ValueError: {}'.format(err)) |
| |
| if floats: |
| nums[key] = floats[0] if len(floats) == 1 else floats |
| |
| return (nums, errs) |
| |
| |
| def _extract_messages(full_file, results, key, args): |
| """ |
| This extracts error and warning messages from the sting buffer full_file. |
| """ |
| err_warn_patterns = [("%s_errors" % key, r"^Error: .*"), |
| ("%s_errors" % key, r"^ERROR: .*"), |
| ("%s_errors" % key, r"^.*command not found.*"), |
| ("%s_warnings" % key, r"^Warning: .*"), |
| ("%s_warnings" % key, r"^WARNING: .*")] |
| for severity, pattern in err_warn_patterns: |
| results['messages'][severity] += re.findall(pattern, |
| full_file, |
| flags=re.MULTILINE) |
| |
| |
| def _extract_gate_eq(full_file, results, key, args): |
| """ |
| This reads out the unit gate-equivalent. |
| """ |
| try: |
| results[key]["ge"] = float(full_file.strip()) |
| except ValueError as err: |
| results["messages"]["flow_errors"] += ["ValueError: %s" % err] |
| |
| |
| def _rel_err(val, ref): |
| """ |
| Calculate relative error with respect to reference |
| """ |
| if ref == 0.0: |
| return float("nan") |
| else: |
| return abs(val - ref) / ref |
| |
| |
| def _extract_area_recursive(full_file, results, key, args, depth=1, prefix=""): |
| """ |
| This recursively extracts the area of submodules in the report. |
| """ |
| # current depth level of sub-modules |
| pattern = r"^(" + prefix + r"[\.0-9A-Za-z_\[\]]+){1}(?:(?:/[\.0-9A-Za-z_\[\]]+)*)" |
| |
| for k in range(5): |
| pattern += r"\s+(" + FP_NUMBER + r")" |
| matches = re.findall(pattern, full_file, flags=re.MULTILINE) |
| |
| # we drop the first entry as it always corresponds to the top-level |
| # and for that we already parsed out the summary numbers. |
| if matches and depth == 1: |
| matches = matches[1:] |
| |
| instances = results[key]['instances'] |
| try: |
| for match in matches: |
| name = match[0] |
| |
| if name not in instances: |
| instances.update({ |
| name: { |
| "comb": 0.0, |
| "reg": 0.0, |
| "buf": float("nan"), # not available here |
| "logic": 0.0, |
| "macro": 0.0, |
| "total": 0.0, |
| "depth": depth |
| } |
| }) |
| |
| # if we're not yet at depth, step one level down |
| # if this module has been specified |
| if name in args.expand_modules or depth < args.expand_depth: |
| _extract_area_recursive(full_file, |
| results, |
| key, |
| args, |
| depth=depth + 1, |
| prefix=name + "/") |
| |
| comb = float(match[3]) |
| reg = float(match[4]) |
| macro = float(match[5]) |
| |
| instance = instances[name] |
| |
| instance["comb"] += comb |
| instance["reg"] += reg |
| instance["logic"] += comb + reg |
| instance["macro"] += macro |
| instance["total"] += comb + reg + macro |
| |
| except ValueError as err: |
| results["messages"]["flow_errors"] += ["ValueError: %s" % err] |
| |
| |
| def _check_area(results, key, args): |
| """ |
| Checks whether the calculated area aggregates are |
| consistent among depth levels. |
| """ |
| |
| instances = list(results[key]["instances"].values()) |
| names = list(results[key]["instances"].keys()) |
| for k, inst in enumerate(instances[:-1]): |
| # checksums |
| comb_check = 0.0 |
| reg_check = 0.0 |
| macro_check = 0.0 |
| do_check = False |
| for subinst in instances[k + 1:]: |
| # if the subinst is one level below, add the |
| # numbers to the checksums. |
| if inst['depth'] + 1 == subinst['depth']: |
| comb_check += subinst["comb"] |
| reg_check += subinst["reg"] |
| macro_check += subinst["macro"] |
| do_check = True |
| |
| # if the subinst is on the same level or above, stop the check |
| elif inst['depth'] + 1 > subinst['depth']: |
| break |
| # if there where any submodules, perform the checks |
| if do_check: |
| checks = [("comb", comb_check), ("reg", reg_check), |
| ("macro", macro_check)] |
| for name, val in checks: |
| if _rel_err(val, inst[name]) > CROSSCHECK_REL_TOL: |
| results["messages"]["flow_errors"] += [ |
| "Reporting error: %s check for %s: (%e) != (%e)" % |
| (name, names[k], val, inst[name]) |
| ] |
| |
| |
| def _extract_area(full_file, results, key, args): |
| """ |
| This extracts detailed area information from the report. |
| Area will be reported in gate equivalents. |
| """ |
| |
| # this extracts the top-level summary |
| patterns = [("comb", r"^Combinational area: \s* (\d+\.\d+)"), |
| ("buf", r"^Buf/Inv area: \s* (\d+\.\d+)"), |
| ("reg", r"^Noncombinational area: \s* (\d+\.\d+)"), |
| ("macro", r"^Macro/Black Box area: \s* (\d+\.\d+)"), |
| ("total", r"^Total cell area: \s* (\d+\.\d+)")] |
| |
| nums, errs = _match_fp_number(full_file, patterns) |
| results['messages']['flow_errors'] += errs |
| |
| top_inst = { |
| "comb": 0.0, |
| "reg": 0.0, |
| "buf": 0.0, |
| "logic": 0.0, |
| "macro": 0.0, |
| "total": 0.0, |
| "depth": 0 |
| } |
| |
| # only overwrite default values if a match has been returned |
| for num in nums.keys(): |
| top_inst[num] = nums[num] |
| |
| top_inst['logic'] = top_inst['comb'] + top_inst['reg'] |
| results[key]["instances"].update({args.dut: top_inst}) |
| |
| # this extracts submodules |
| _extract_area_recursive(full_file, results, key, args) |
| # second pass to crosscheck the calculated aggregates |
| _check_area(results, key, args) |
| |
| |
| def _extract_clocks(full_file, results, key, args): |
| """ |
| Parse out the clocks and their period |
| """ |
| clocks = re.findall(r"^(.+)\s+(\d+\.?\d*)\s+\{\d+.?\d* \d+.?\d*\}\s+", |
| full_file, |
| flags=re.MULTILINE) |
| try: |
| # get clock period |
| for k, c in enumerate(clocks): |
| if c[0].strip() not in results[key]: |
| results[key].update({ |
| c[0].strip(): { |
| "tns": 0.0, |
| "wns": 0.0, |
| "period": float(c[1]) |
| } |
| }) |
| except ValueError as err: |
| results["messages"]["flow_errors"] += ["ValueError: %s" % err] |
| |
| |
| def _extract_timing(full_file, results, key, args): |
| """ |
| This extracts the TNS and WNS for all defined clocks. |
| """ |
| groups = re.findall(r"^ Path Group:\s(.+)\s", |
| full_file, |
| flags=re.MULTILINE) |
| |
| slack = re.findall(r"^ slack \(.+\) \s*(" + FP_NUMBER + ")", |
| full_file, |
| flags=re.MULTILINE) |
| try: |
| # get TNS and WNS in that group |
| for k, g in enumerate(groups): |
| if g.strip() not in results[key]: |
| results[key].update({ |
| g.strip(): { |
| "tns": 0.0, |
| "wns": 0.0, |
| "period": float("nan") |
| } |
| }) |
| value = float(slack[k]) if float(slack[k]) < 0.0 else 0.0 |
| results[key][g]["wns"] = min(results[key][g]["wns"], value) |
| results[key][g]["tns"] += value |
| except ValueError as err: |
| results["messages"]["flow_errors"] += ["ValueError: %s" % err] |
| |
| |
| def _match_units(full_file, patterns, key, results): |
| """ |
| Compares the match to the units given and stores the corresponding |
| order of magnitude as a floating point value. |
| """ |
| for subkey, pattern, units in patterns: |
| match = re.findall(pattern, full_file, flags=re.MULTILINE) |
| try: |
| if match: |
| if len(match[0]) == 2: |
| if match[0][1].strip() in units: |
| results[key][subkey] = float(match[0][0]) * \ |
| units[match[0][1].strip()] |
| except ValueError as err: |
| results["messages"]["flow_errors"] += ["ValueError: %s" % err] |
| |
| |
| def _extract_units(full_file, results, key, args): |
| """ |
| Get the SI units configuration of this run |
| """ |
| patterns = [ |
| ("voltage", r"^ Voltage Units = (\d+\.?\d*)(nV|uV|mV|V)", { |
| "nV": 1E-9, |
| "uV": 1E-6, |
| "mV": 1E-3, |
| "V": 1E0 |
| }), |
| ("capacitance", r"^ Capacitance Units = (\d+\.?\d*)(ff|pf|nf|uf)", { |
| "ff": 1E-15, |
| "pf": 1E-12, |
| "nf": 1E-9, |
| "uf": 1E-6 |
| }), |
| ("time", r"^ Time Units = (\d+\.?\d*)(ps|ns|us|ms)", { |
| "ps": 1E-12, |
| "ns": 1E-9, |
| "us": 1E-6, |
| "ms": 1E-3 |
| }), |
| ("dynamic", r"^ Dynamic Power Units = (\d+\.?\d*)(pW|nW|uW|mW|W)", { |
| "pW": 1E-12, |
| "nW": 1E-9, |
| "uW": 1E-6, |
| "mW": 1E-3, |
| "W": 1E0 |
| }), |
| ("static", r"^ Leakage Power Units = (\d+\.?\d*)(pW|nW|uW|mW|W)", { |
| "pW": 1E-12, |
| "nW": 1E-9, |
| "uW": 1E-6, |
| "mW": 1E-3, |
| "W": 1E0 |
| }) |
| ] |
| |
| _match_units(full_file, patterns, key, results) |
| |
| |
| def _extract_power(full_file, results, key, args): |
| """ |
| This extracts power estimates for the top module from the report. |
| """ |
| |
| # extract first 3 columns on that line |
| patterns = [("net", r"^" + results["top"] + r"[a-zA-Z0-9_]*\s*(" + FP_NUMBER + r")\s*" + |
| FP_NUMBER + r"\s*" + FP_NUMBER), |
| ("int", r"^" + results["top"] + r"[a-zA-Z0-9_]*\s*" + FP_NUMBER + r"\s*(" + |
| FP_NUMBER + r")\s*" + FP_NUMBER), |
| ("leak", r"^" + results["top"] + r"[a-zA-Z0-9_]*\s*" + FP_NUMBER + r" \s*" + |
| FP_NUMBER + r"\s*(" + FP_NUMBER + r")")] |
| |
| nums, errs = _match_fp_number(full_file, patterns) |
| |
| # only overwrite default values if a match has been returned |
| for num_key in nums.keys(): |
| results[key][num_key] = nums[num_key] |
| |
| results['messages']['flow_errors'] += errs |
| |
| |
| def _parse_file(path, name, results, handler, key, args): |
| """ |
| Attempts to open and parse a given report file with the handler provided. |
| """ |
| try: |
| with Path(path).joinpath(name).open() as f: |
| full_file = f.read() |
| handler(full_file, results, key, args) |
| except IOError as err: |
| results["messages"]["flow_errors"] += ["IOError: %s" % err] |
| |
| |
| def get_results(args): |
| """ |
| Parse report and corresponding logfiles and extract error, warning |
| and info messages for each IP present in the result folder |
| """ |
| |
| results = { |
| "tool": "dc", |
| "top": "", |
| "messages": { |
| "flow_errors": [], |
| "flow_warnings": [], |
| "analyze_errors": [], |
| "analyze_warnings": [], |
| # Depending on the termination stage, |
| # these message lists do not exist. |
| "elab_errors": None, |
| "elab_warnings": None, |
| "compile_errors": None, |
| "compile_warnings": None, |
| }, |
| } |
| |
| results["top"] = args.dut |
| |
| args.expand_modules = args.expand_modules.strip().split(',') |
| |
| # Check whether the termination stage is known and define the |
| # associated reports to be parsed. |
| if args.termination_stage not in ["analyze", "elab", "compile", "reports"]: |
| results['messages']['flow_errors'].append( |
| 'Unknown termination stage {}'.format(args.termination_stage)) |
| |
| # We always run analysis, and we always look at the synthesis log. |
| rep_types = [(args.log_path, 'synthesis.log', 'flow', _extract_messages), |
| (args.rep_path, 'analyze.rpt', 'analyze', _extract_messages)] |
| |
| if args.termination_stage in ["elab", "compile", "reports"]: |
| rep_types += [(args.rep_path, 'elab.rpt', 'elab', _extract_messages)] |
| results["messages"]["elab_errors"] = [] |
| results["messages"]["elab_warnings"] = [] |
| if args.termination_stage in ["compile", "reports"]: |
| rep_types += [(args.rep_path, 'compile.rpt', 'compile', _extract_messages)] |
| results["messages"]["compile_errors"] = [] |
| results["messages"]["compile_warnings"] = [] |
| if args.termination_stage in ["reports"]: |
| rep_types += [(args.rep_path, 'gate_equiv.rpt', 'area', _extract_gate_eq), |
| (args.rep_path, 'area.rpt', 'area', _extract_area), |
| (args.rep_path, 'clocks.rpt', 'timing', _extract_clocks), |
| (args.rep_path, 'timing.rpt', 'timing', _extract_timing), |
| (args.rep_path, 'power.rpt', 'power', _extract_power), |
| (args.rep_path, 'power.rpt', 'units', _extract_units)] |
| results.update({ |
| "timing": { |
| # field for each timing group with tns, wns |
| # and the period if this is a clock |
| }, |
| "area": { |
| # gate equivalent of a NAND2 gate |
| "ge": float("nan"), |
| # hierchical report with "comb", "buf", "reg", "macro", "total" |
| "instances": {}, |
| }, |
| "power": { |
| "net": float("nan"), |
| "int": float("nan"), |
| "leak": float("nan"), |
| }, |
| "units": { |
| "voltage": float("nan"), |
| "capacitance": float("nan"), |
| "time": float("nan"), |
| "dynamic": float("nan"), |
| "static": float("nan"), |
| } |
| }) |
| |
| for path, name, key, handler in rep_types: |
| _parse_file(path, name, results, handler, key, args) |
| |
| return results |
| |
| |
| def main(): |
| parser = argparse.ArgumentParser( |
| description="""This script parses DC log and report files from |
| a synthesis run, filters the messages and creates an aggregated result |
| .hjson file with the following fields: |
| |
| results = { |
| "tool": "dc", |
| "top" : <name of toplevel>, |
| |
| "messages": { |
| "flow_errors" : [], |
| "flow_warnings" : [], |
| "analyze_errors" : [], |
| "analyze_warnings" : [], |
| "elab_errors" : [], |
| "elab_warnings" : [], |
| "compile_errors" : [], |
| "compile_warnings" : [], |
| }, |
| |
| "timing": { |
| # per timing group (ususally a clock domain) |
| # in nano seconds |
| <group> : { |
| "tns" : <value>, |
| "wns" : <value>, |
| "period" : <value>, |
| ... |
| } |
| }, |
| |
| "area": { |
| # gate equivalent of a NAND2 gate |
| "ge" : <value>, |
| |
| # summary report, in GE |
| "comb" : <value>, |
| "buf" : <value>, |
| "reg" : <value>, |
| "macro" : <value>, |
| "total" : <value>, |
| |
| # hierchical report of first submodule level |
| "instances" : { |
| <name> : { |
| "comb" : <value>, |
| "buf" : <value>, |
| "reg" : <value>, |
| "macro" : <value>, |
| "total" : <value>, |
| }, |
| ... |
| }, |
| }, |
| |
| "power": { |
| "net" : <value>, |
| "int" : <value>, |
| "leak" : <value>, |
| }, |
| |
| "units": { |
| "voltage" : <value>, |
| "capacitance" : <value>, |
| "time" : <value>, |
| "dynamic" : <value>, |
| "static" : <value>, |
| } |
| } |
| |
| The script returns nonzero status if any errors are present. |
| """) |
| |
| parser.add_argument( |
| '--dut', |
| type=str, |
| help="""Name of the DUT. This is needed to parse the reports.""") |
| |
| parser.add_argument('--log-path', |
| type=str, |
| help=""" |
| Path to log files for the flow. |
| This script expects the following log files to be present: |
| |
| - <log-path>/synthesis.log : output of synopsys shell |
| |
| """) |
| |
| parser.add_argument('--rep-path', |
| type=str, |
| help=""" |
| Path to report files of the flow. |
| This script expects the following report |
| files to be present: |
| |
| - <rep-path>/analyze.rpt : output of analyze command |
| - <rep-path>/elab.rpt : output of elab command |
| - <rep-path>/compile.rpt : output of compile_ultra |
| - <rep-path>/area.rpt : output of report_area |
| - <rep-path>/timing.rpt : output of report_timing |
| - <rep-path>/power.rpt : output of report_power |
| |
| """) |
| |
| parser.add_argument('--out-dir', |
| type=str, |
| default="./", |
| help="""Output directory for the 'results.hjson' file. |
| Defaults to './'""") |
| |
| parser.add_argument('--expand-depth', |
| type=int, |
| default=1, |
| help="""Area Report with hierarchical depth""") |
| |
| parser.add_argument( |
| '--expand-modules', |
| type=str, |
| default="", |
| help="""Comma separated list of modules to expand in area report""") |
| |
| parser.add_argument( |
| '--termination-stage', |
| type=str, |
| default="", |
| help="""Can be either 'analyze', 'elab', 'compile' or 'reports'""") |
| |
| args = parser.parse_args() |
| results = get_results(args) |
| |
| with Path( |
| args.out_dir).joinpath("results.hjson").open("w") as results_file: |
| hjson.dump(results, |
| results_file, |
| ensure_ascii=False, |
| for_json=True, |
| use_decimal=True) |
| |
| # helper function |
| def _getlen(x): |
| return len(x) if x is not None else 0 |
| |
| # return nonzero status if any warnings or errors are present |
| # lint infos do not count as failures |
| nr_errors = (_getlen(results["messages"]["flow_errors"]) + |
| _getlen(results["messages"]["analyze_errors"]) + |
| _getlen(results["messages"]["elab_errors"]) + |
| _getlen(results["messages"]["compile_errors"])) |
| |
| print("""------------- Summary ------------- |
| Flow Warnings: %s |
| Flow Errors: %s |
| Analyze Warnings: %s |
| Analyze Errors: %s |
| Elab Warnings: %s |
| Elab Errors: %s |
| Compile Warnings: %s |
| Compile Errors: %s |
| -----------------------------------""" % |
| (_getlen(results["messages"]["flow_warnings"]), |
| _getlen(results["messages"]["flow_errors"]), |
| _getlen(results["messages"]["analyze_warnings"]), |
| _getlen(results["messages"]["analyze_errors"]), |
| _getlen(results["messages"]["elab_warnings"]), |
| _getlen(results["messages"]["elab_errors"]), |
| _getlen(results["messages"]["compile_warnings"]), |
| _getlen(results["messages"]["compile_errors"]))) |
| |
| if nr_errors > 0: |
| print("Synthesis not successful.") |
| sys.exit(1) |
| |
| print("Synthesis successful.") |
| sys.exit(0) |
| |
| |
| if __name__ == "__main__": |
| main() |
