| #!/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_strings(full_file, master_key, patterns, results): |
| """ |
| This searches for string patterns in the full_file buffer. |
| The argument patterns needs to be a list of tuples with |
| (<error_severity>, <pattern_to_match_for>). |
| """ |
| for severity, pattern in patterns: |
| results[master_key][severity] += re.findall(pattern, |
| full_file, |
| flags=re.MULTILINE) |
| return results |
| |
| |
| def _match_fp_number(full_file, master_key, patterns, results): |
| """ |
| This extracts numbers from the sting buffer full_file. |
| The argument patterns needs to be a list of tuples with |
| (<key>, <pattern_to_match_for>). |
| """ |
| for key, pattern in patterns: |
| match = re.findall(pattern, full_file, flags=re.MULTILINE) |
| if len(match) == 1: |
| try: |
| results[master_key][key] = float(match[0]) |
| except ValueError as err: |
| results["messages"]["flow_errors"] += ["ValueError: %s" % err] |
| elif len(match) > 0: |
| for item in match: |
| try: |
| results[master_key][key] += [float(item)] |
| except ValueError as err: |
| results["messages"]["flow_errors"] += [ |
| "ValueError: %s" % err |
| ] |
| else: |
| results["messages"]["flow_errors"] += [ |
| "Pattern '%s' of key '%s' not found" % (pattern, key) |
| ] |
| |
| return results |
| |
| |
| def _extract_messages(full_file, results, key): |
| """ |
| This extracts error and warning messages from the sting buffer full_file. |
| """ |
| err_warn_patterns = [("%s_errors" % key, r"^Error: .*"), |
| ("%s_warnings" % key, r"^Warning: .*")] |
| _match_strings(full_file, "messages", err_warn_patterns, results) |
| |
| return results |
| |
| |
| def _extract_gate_equiv(full_file, results, key): |
| """ |
| 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] |
| |
| return results |
| |
| |
| 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(full_file, results, key): |
| """ |
| This extracts detailed area information from the report. |
| Area will be reported in gate equivalents. |
| """ |
| # TODO: covert to gate equivalents |
| 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+)")] |
| |
| results = _match_fp_number(full_file, key, patterns, results) |
| # aggregate one level of sub-modules |
| pattern = 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) |
| |
| # checksums |
| comb_check = 0.0 |
| reg_check = 0.0 |
| macro_check = 0.0 |
| try: |
| for item in matches: |
| if item[0] not in results[key]["instances"]: |
| results[key]["instances"].update({ |
| item[0]: { |
| "comb": 0.0, |
| "reg": 0.0, |
| "buf": float("nan"), # not available here |
| "macro": 0.0, |
| "total": 0.0, |
| } |
| }) |
| results[key]["instances"][item[0]]["comb"] += float(item[3]) |
| results[key]["instances"][item[0]]["reg"] += float(item[4]) |
| results[key]["instances"][item[0]]["macro"] += float(item[5]) |
| results[key]["instances"][item[0]]["total"] += float(item[3]) + \ |
| float(item[4]) + \ |
| float(item[5]) |
| comb_check += float(item[3]) |
| reg_check += float(item[4]) |
| macro_check += float(item[5]) |
| |
| except ValueError as err: |
| results["messages"]["flow_errors"] += ["ValueError: %s" % err] |
| |
| # cross check whether the above accounting is correct |
| if _rel_err(comb_check, results["area"]["comb"]) > CROSSCHECK_REL_TOL: |
| results["messages"]["flow_errors"] += [ |
| "Reporting error: comb_check (%e) != (%e)" % |
| (comb_check, results["area"]["comb"]) |
| ] |
| if _rel_err(reg_check, results["area"]["reg"]) > CROSSCHECK_REL_TOL: |
| results["messages"]["flow_errors"] += [ |
| "Reporting error: reg_check (%e) != (%e)" % |
| (reg_check, results["area"]["reg"]) |
| ] |
| if _rel_err(macro_check, results["area"]["macro"]) > CROSSCHECK_REL_TOL: |
| results["messages"]["flow_errors"] += [ |
| "Reporting error: macro_check (%e) != (%e)" % |
| (macro_check, results["area"]["macro"]) |
| ] |
| |
| return results |
| |
| |
| def _extract_clocks(full_file, results, key): |
| """ |
| 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] |
| |
| return results |
| |
| |
| def _extract_timing(full_file, results, key): |
| """ |
| 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] |
| |
| return results |
| |
| |
| 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] |
| |
| return results |
| |
| |
| def _extract_units(full_file, results, key): |
| """ |
| 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) |
| |
| return results |
| |
| |
| def _extract_power(full_file, results, key): |
| """ |
| This extracts power estimates for the top module from the report. |
| """ |
| |
| # extract first 3 columns on that line |
| patterns = [("net", r"^" + results["top"] + r"\s*(" + FP_NUMBER + r")\s*" + |
| FP_NUMBER + r"\s*" + FP_NUMBER), |
| ("int", r"^" + results["top"] + r"\s*" + FP_NUMBER + r"\s*(" + |
| FP_NUMBER + r")\s*" + FP_NUMBER), |
| ("leak", r"^" + results["top"] + r"\s*" + FP_NUMBER + r" \s*" + |
| FP_NUMBER + r"\s*(" + FP_NUMBER + r")")] |
| |
| results = _match_fp_number(full_file, key, patterns, results) |
| |
| return results |
| |
| |
| def _parse_file(path, name, results, handler, key): |
| """ |
| Attempts to open and aprse a given report file with the handler provided. |
| """ |
| try: |
| with Path(path).joinpath(name).open() as f: |
| full_file = f.read() |
| results = handler(full_file, results, key) |
| except IOError as err: |
| results["messages"]["flow_errors"] += ["IOError: %s" % err] |
| return results |
| |
| |
| def get_results(logpath, reppath, dut): |
| """ |
| 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": [], |
| "elab_errors": [], |
| "elab_warnings": [], |
| "compile_errors": [], |
| "compile_warnings": [], |
| }, |
| "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"), |
| # summary, in GE |
| "comb": float("nan"), |
| "buf": float("nan"), |
| "reg": float("nan"), |
| "macro": float("nan"), |
| "total": 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"), |
| } |
| } |
| |
| results["top"] = dut |
| |
| # flow messages |
| results = _parse_file(logpath, 'synthesis.log', results, _extract_messages, |
| "flow") |
| |
| # messages |
| for rep_type in ["analyze", "elab", "compile"]: |
| results = _parse_file(reppath, '%s.rpt' % rep_type, results, |
| _extract_messages, rep_type) |
| |
| # get gate equivalents |
| results = _parse_file(reppath, 'gate_equiv.rpt', results, |
| _extract_gate_equiv, "area") |
| # area |
| results = _parse_file(reppath, 'area.rpt', results, _extract_area, "area") |
| # clocks. this complements the timing report later below |
| results = _parse_file(reppath, 'clocks.rpt', results, _extract_clocks, |
| "timing") |
| # timing |
| results = _parse_file(reppath, 'timing.rpt', results, _extract_timing, |
| "timing") |
| # power |
| results = _parse_file(reppath, 'power.rpt', results, _extract_power, |
| "power") |
| # units |
| results = _parse_file(reppath, 'power.rpt', results, _extract_units, |
| "units") |
| |
| 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('--logpath', |
| type=str, |
| help="""Path to log files for the flow. |
| This script expects the following log files to be present: |
| |
| - <logpath>/synthesis.log : output of synopsys shell |
| |
| """) |
| |
| parser.add_argument('--reppath', |
| type=str, |
| help="""Path to report files of the flow. |
| This script expects the following report files to be present: |
| |
| - <reppath>/analyze.rpt : output of analyze command |
| - <reppath>/elab.rpt : output of elab command |
| - <reppath>/compile.rpt : output of compile_ultra |
| - <reppath>/area.rpt : output of report_area |
| - <reppath>/timing.rpt : output of report_timing |
| - <reppath>/power.rpt : output of report_power |
| |
| """) |
| |
| parser.add_argument('--outdir', |
| type=str, |
| default="./", |
| help="""Output directory for the 'results.hjson' file. |
| Defaults to './'""") |
| |
| args = parser.parse_args() |
| results = get_results(args.logpath, args.reppath, args.dut) |
| |
| with Path(args.outdir).joinpath("results.hjson").open("w") as results_file: |
| hjson.dump(results, |
| results_file, |
| ensure_ascii=False, |
| for_json=True, |
| use_decimal=True) |
| |
| # return nonzero status if any warnings or errors are present |
| # lint infos do not count as failures |
| nr_errors = len(results["messages"]["flow_errors"]) + \ |
| len(results["messages"]["analyze_errors"]) + \ |
| len(results["messages"]["elab_errors"]) + \ |
| len(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 |
| -----------------------------------""" % |
| (len(results["messages"]["flow_warnings"]), |
| len(results["messages"]["flow_errors"]), |
| len(results["messages"]["analyze_warnings"]), |
| len(results["messages"]["analyze_errors"]), |
| len(results["messages"]["elab_warnings"]), |
| len(results["messages"]["elab_errors"]), |
| len(results["messages"]["compile_warnings"]), |
| len(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() |
