| # Copyright 2020-2021 Efabless Corporation |
| # |
| # 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. |
| |
| import os |
| import re |
| import sys |
| import yaml |
| from typing import Iterable, Optional |
| |
| sys.path.append(os.path.dirname(os.path.dirname(__file__))) |
| |
| from .get_file_name import get_name # noqa E402 |
| from utils.utils import get_run_path # noqa E402 |
| |
| |
| def debug(*args, **kwargs): |
| if os.getenv("REPORT_INFRASTRUCTURE_VERBOSE") == "1": |
| print(*args, **kwargs, file=sys.stderr) |
| |
| |
| def parse_to_report( |
| input_log: str, output_report: str, start: str, end: Optional[str] = None |
| ): |
| """ |
| Parses a log in the format |
| START_MARKER |
| data |
| END_MARKER |
| to a report file. |
| """ |
| if end is None: |
| end = f"{start}_end" |
| |
| log_lines = open(input_log).read().split("\n") |
| with open(output_report, "w") as f: |
| started = False |
| |
| for line in log_lines: |
| if line.strip() == end: |
| break |
| if started: |
| f.write(line + "\n") |
| if line.strip() == start: |
| started = True |
| |
| if not started: |
| f.write("SKIPPED!") |
| |
| |
| class Artifact(object): |
| def __init__( |
| self, |
| run_path: str, |
| kind: str, |
| step: str, |
| filename: str, |
| find_by_partial_match: bool = False, |
| ): |
| self.run_path = run_path |
| self.kind = kind |
| self.step = step |
| |
| self.pathname = os.path.join(self.run_path, self.kind, self.step) |
| self.filename = filename |
| |
| self.index, self.path = get_name( |
| self.pathname, self.filename, find_by_partial_match |
| ) |
| |
| if self.is_valid(): |
| debug(f"Resolved {kind}, {step}, {filename} to {self.path}") |
| else: |
| debug(f"Failed to resolve {kind}, {step}, {filename}") |
| |
| def is_valid(self) -> bool: |
| valid = os.path.exists(self.path) and os.path.isfile(self.path) |
| return valid |
| |
| def get_content(self) -> Optional[str]: |
| if not self.is_valid(): |
| return None |
| return open(self.path).read() |
| |
| def is_logtoreport_valid(self) -> bool: |
| # >10 bytes is a magic number, yes. It was this way in the script I rewrote and I'm not a fan of shaking beehives. |
| return self.is_valid() and os.path.getsize(self.path) > 10 |
| |
| def log_to_report(self, report_name: str, start: str, end: Optional[str] = None): |
| report_path = os.path.join(self.run_path, "reports", self.step, report_name) |
| if not self.is_logtoreport_valid(): |
| debug(f"{self.step}:{self.filename} not found or empty.") |
| return |
| parse_to_report(self.path, report_path, start, end) |
| |
| def generate_reports(self, *args: Iterable[Iterable[str]]): |
| if (self.index or "") == "": |
| self.index = "X" |
| for report in args: |
| filename = f"{self.index}-{report[0]}" |
| start = report[1] |
| end = None |
| try: |
| end = report[2] |
| except Exception: |
| pass |
| self.log_to_report(filename, start, end) |
| |
| |
| class Report(object): |
| def __init__(self, design_path, tag, design_name, params, run_path=None): |
| self.design_path = design_path |
| self.design_name = design_name |
| self.tag = tag |
| self.current_directory = os.path.dirname(__file__) |
| if run_path is None: |
| run_path = get_run_path(design=design_path, tag=tag) |
| self.run_path = run_path |
| self.configuration = params |
| self.raw_report = None |
| self.formatted_report = None |
| |
| values = ( |
| [ |
| "design", |
| "design_name", |
| "config", |
| "flow_status", |
| "total_runtime", |
| "routed_runtime", |
| "DIEAREA_mm^2", |
| "CellPer_mm^2", |
| "OpenDP_Util", |
| "Peak_Memory_Usage_MB", |
| "cell_count", |
| "tritonRoute_violations", |
| "Short_violations", |
| "MetSpc_violations", |
| "OffGrid_violations", |
| "MinHole_violations", |
| "Other_violations", |
| "Magic_violations", |
| "antenna_violations", |
| "lvs_total_errors", |
| "cvc_total_errors", |
| "klayout_violations", |
| "wire_length", |
| "vias", |
| "wns", |
| "pl_wns", |
| "optimized_wns", |
| "fastroute_wns", |
| "spef_wns", |
| "tns", |
| "pl_tns", |
| "optimized_tns", |
| "fastroute_tns", |
| "spef_tns", |
| "HPWL", |
| "routing_layer1_pct", |
| "routing_layer2_pct", |
| "routing_layer3_pct", |
| "routing_layer4_pct", |
| "routing_layer5_pct", |
| "routing_layer6_pct", |
| "wires_count", |
| "wire_bits", |
| "public_wires_count", |
| "public_wire_bits", |
| "memories_count", |
| "memory_bits", |
| "processes_count", |
| "cells_pre_abc", |
| "AND", |
| "DFF", |
| "NAND", |
| "NOR", |
| "OR", |
| "XOR", |
| "XNOR", |
| "MUX", |
| ] |
| + (["NOT"] if os.getenv("MORE_METRICS") else []) |
| + [ |
| "inputs", |
| "outputs", |
| "level", |
| "EndCaps", |
| "TapCells", |
| "Diodes", |
| "Total_Physical_Cells", |
| ] |
| ) |
| |
| @classmethod |
| def get_header(Self): |
| header = ",".join(Self.values) |
| return header |
| |
| def reports_from_logs(self): |
| rp = self.run_path |
| |
| basic_set = [ |
| ("_sta.rpt", "check_report"), |
| ("_sta.min.rpt", "min_report"), |
| ("_sta.max.rpt", "max_report"), |
| ("_sta.wns.rpt", "wns_report"), |
| ("_sta.tns.rpt", "tns_report"), |
| ("_sta.clock_skew.rpt", "clock_skew"), |
| ] |
| |
| additional_set = [ |
| ("_sta.slew.rpt", "check_slew"), |
| ("_sta.worst_slack.rpt", "worst_slack"), |
| ("_sta.clock_skew.rpt", "clock_skew"), |
| ("_sta.power.rpt", "power_report"), |
| ("_sta.area.rpt", "area_report"), |
| ] |
| |
| for name, log in [ |
| ("cts", Artifact(rp, "logs", "cts", "cts.log")), |
| ("gpl", Artifact(rp, "logs", "placement", "global.log")), |
| ("grt", Artifact(rp, "logs", "routing", "global.log")), |
| ]: |
| generate_report_args = [ |
| (name + report_postfix, report_locus) |
| for report_postfix, report_locus in basic_set |
| ] |
| log.generate_reports(*generate_report_args) |
| |
| for name, log in [ |
| ("syn", Artifact(rp, "logs", "synthesis", "sta.log")), |
| ("cts_rsz", Artifact(rp, "logs", "cts", "resizer.log")), |
| ("pl_rsz", Artifact(rp, "logs", "placement", "resizer.log")), |
| ("rt_rsz", Artifact(rp, "logs", "routing", "resizer.log")), |
| ("rcx", Artifact(rp, "logs", "signoff", "parasitics_sta.log")), |
| ( |
| "rcx_mca", |
| Artifact(rp, "logs", "signoff", "parasitics_multi_corner_sta.log"), |
| ), |
| ]: |
| generate_report_args = [ |
| (name + report_postfix, report_locus) |
| for report_postfix, report_locus in (basic_set + additional_set) |
| ] |
| log.generate_reports(*generate_report_args) |
| |
| def extract_all_values(self): |
| rp = self.run_path |
| self.reports_from_logs() |
| |
| def re_get_last_capture(rx, string): |
| matches = re.findall(rx, string) |
| if len(matches) == 0: |
| return None |
| return matches[-1] |
| |
| # Runtime |
| |
| flow_status = "flow_exceptional_failure" |
| total_runtime = -1 |
| routed_runtime = -1 |
| try: |
| runtime_yaml_str = open(os.path.join(rp, "runtime.yaml")).read() |
| yaml_docs = list(yaml.safe_load_all(runtime_yaml_str)) |
| if len(yaml_docs) != 2: |
| raise Exception("Attempted to generate report on a non-finalized run.") |
| |
| routed_info, total_info = yaml_docs[1] |
| |
| flow_status = total_info["status"] |
| total_runtime = total_info["runtime_ts"] |
| routed_runtime = routed_info["runtime_ts"] |
| except Exception as e: |
| print( |
| f"Failed to extract runtime info for {self.design_name}/{self.tag}: {e}", |
| file=sys.stderr, |
| ) |
| |
| # Cell Count |
| cell_count = -1 |
| yosys_report = Artifact(rp, "reports", "synthesis", "synthesis.stat.rpt", True) |
| yosys_report_content = yosys_report.get_content() |
| if yosys_report_content is not None: |
| match = re.search(r"Number of cells:\s*(\d+)", yosys_report_content) |
| if match is not None: |
| cell_count = int(match[1]) |
| |
| # Die Area |
| die_area = -1 |
| placed_def = Artifact(rp, "results", "floorplan", f"{self.design_name}.def") |
| def_content = placed_def.get_content() |
| if def_content is not None: |
| match = re.search( |
| r"DIEAREA\s*\(\s*(\d+)\s+(\d+)\s*\)\s*\(\s*(\d+)\s+(\d+)\s*\)", |
| def_content, |
| ) |
| if match is not None: |
| lx, ly, ux, uy = ( |
| float(match[1]), |
| float(match[2]), |
| float(match[3]), |
| float(match[4]), |
| ) |
| |
| die_area = ((ux - lx) / 1000) * ((uy - ly) / 1000) |
| |
| die_area /= 1000000 # To mm^2 |
| |
| # Cells per micrometer |
| cells_per_mm = -1 |
| if cell_count != -1 and die_area != -1: |
| cells_per_mm = cell_count / die_area |
| |
| # OpenDP Utilization and HPWL |
| utilization = -1 |
| hpwl = -1 # Half Perimeter Wire Length? |
| global_placement_log = Artifact(rp, "logs", "placement", "global.log") |
| global_log_content = global_placement_log.get_content() |
| if global_log_content is not None: |
| match = re.search(r"Util\(%\):\s*([\d\.]+)", global_log_content) |
| |
| if match is not None: |
| utilization = float(match[1]) |
| |
| match = re_get_last_capture(r"HPWL:\s*([\d\.]+)", global_log_content) |
| if match is not None: |
| hpwl = float(match) |
| |
| # TritonRoute Logged Info Extraction |
| tr_log = Artifact(rp, "logs", "routing", "detailed.log") |
| tr_log_content = tr_log.get_content() |
| |
| tr_memory_peak = -1 |
| tr_violations = -1 |
| wire_length = -1 |
| vias = -1 |
| if tr_log_content is not None: |
| match = re_get_last_capture(r"peak\s*=\s*([\d\.]+)", tr_log_content) |
| if match is not None: |
| tr_memory_peak = float(match) |
| |
| match = re_get_last_capture( |
| r"Number of violations\s*=\s*(\d+)", tr_log_content |
| ) |
| if match is not None: |
| tr_violations = int(match) |
| |
| match = re_get_last_capture( |
| r"Total wire length = ([\d\.]+)\s*\wm", tr_log_content |
| ) |
| if match is not None: |
| wire_length = int(match) |
| |
| match = re_get_last_capture(r"Total number of vias = (\d+)", tr_log_content) |
| if match is not None: |
| vias = int(match) |
| |
| # TritonRoute DRC Extraction |
| tr_drc = Artifact(rp, "reports", "routing", "detailed.drc") |
| tr_drc_content = tr_drc.get_content() |
| |
| other_violations = tr_violations |
| short_violations = -1 |
| metspc_violations = -1 |
| offgrid_violations = -1 |
| minhole_violations = -1 |
| if tr_drc_content is not None: |
| short_violations = 0 |
| metspc_violations = 0 |
| offgrid_violations = 0 |
| minhole_violations = 0 |
| for line in tr_drc_content.split("\n"): |
| if "Short" in line: |
| short_violations += 1 |
| other_violations -= 1 |
| if "MetSpc" in line: |
| metspc_violations += 1 |
| other_violations -= 1 |
| if "OffGrid" in line: |
| offgrid_violations += 1 |
| other_violations -= 1 |
| if "MinHole" in line: |
| minhole_violations += 1 |
| other_violations -= 1 |
| |
| # Magic Violations |
| magic_drc = Artifact(rp, "reports", "signoff", "drc.rpt") |
| magic_drc_content = magic_drc.get_content() |
| |
| magic_violations = -1 |
| if magic_drc_content is not None: |
| # Magic DRC Content |
| match = re.search(r"COUNT:\s*(\d+)", magic_drc_content) |
| if match is not None: |
| magic_violations_raw = int(match[1]) |
| |
| # Not really sure why we do this |
| magic_violations = (magic_violations_raw + 3) // 4 |
| |
| # Klayout DRC Violations |
| klayout_drc = Artifact(rp, "reports", "signoff", "magic.lydrc", True) |
| klayout_drc_content = klayout_drc.get_content() |
| |
| klayout_violations = -1 |
| if klayout_drc_content is not None: |
| klayout_violations = 0 |
| for line in klayout_violations.split("\n"): |
| if "<item>" in line: |
| klayout_violations += 1 |
| |
| # Antenna Violations |
| arc_antenna_report = Artifact(rp, "reports", "signoff", "antenna.rpt") |
| aar_content = arc_antenna_report.get_content() |
| |
| antenna_violations = -1 |
| if aar_content is not None: |
| match = re.search(r"Number of pins violated:\s*(\d+)", aar_content) |
| |
| if match is not None: |
| antenna_violations = int(match[1]) |
| else: |
| # Old Magic-Based Check: Just Count The Lines |
| magic_antenna_report = Artifact( |
| rp, "reports", "routing", "antenna_violators.rpt" |
| ) |
| mar_content = magic_antenna_report.get_content() |
| |
| if mar_content is not None: |
| antenna_violations = len(mar_content.split("\n")) |
| |
| # STA Report Extractions |
| def sta_report_extraction( |
| sta_report_filename: str, filter: str, kind="reports", step="synthesis" |
| ): |
| value = -1 |
| report = Artifact(rp, kind, step, sta_report_filename) |
| report_content = report.get_content() |
| if report_content is not None: |
| match = re.search(rf"{filter}\s+(-?[\d\.]+)", report_content) |
| if match is not None: |
| value = float(match[1]) |
| else: |
| debug( |
| f"Didn't find {filter} in {kind}/{step}/{sta_report_filename}" |
| ) |
| else: |
| debug(f"Can't find {sta_report_filename}") |
| return value |
| |
| wns = sta_report_extraction("syn_sta.wns.rpt", "wns", step="synthesis") |
| spef_wns = sta_report_extraction("rcx_sta.wns.rpt", "wns", step="routing") |
| opt_wns = sta_report_extraction("rt_rsz_sta.wns.rpt", "wns", step="routing") |
| pl_wns = sta_report_extraction( |
| "global.log", "wns", kind="logs", step="placement" |
| ) |
| fr_wns = sta_report_extraction("global.log", "wns", kind="logs", step="routing") |
| |
| tns = sta_report_extraction("syn_sta.tns.rpt", "tns", step="synthesis") |
| spef_tns = sta_report_extraction("rcx_sta.tns.rpt", "tns", step="routing") |
| opt_tns = sta_report_extraction("rt_rsz_sta.tns.rpt", "tns", step="routing") |
| pl_tns = sta_report_extraction( |
| "global.log", "tns", kind="logs", step="placement" |
| ) |
| fr_tns = sta_report_extraction("global.log", "tns", kind="logs", step="routing") |
| |
| # Yosys Metrics |
| yosys_metrics = [ |
| "Number of wires:", |
| "Number of wire bits:", |
| "Number of public wires:", |
| "Number of public wire bits:", |
| "Number of memories:", |
| "Number of memory bits:", |
| "Number of processes:", |
| "Number of cells:", |
| "$_AND_", |
| "$_DFF_", |
| "$_NAND_", |
| "$_NOR_", |
| "$_OR_", |
| "$_XOR_", |
| "$_XNOR_", |
| "$_MUX_", |
| ] |
| |
| if os.getenv("MORE_METRICS"): |
| yosys_metrics.append("$_NOT_") |
| |
| yosys_log = Artifact(rp, "logs", "synthesis", "synthesis.log") |
| yosys_log_content = yosys_log.get_content() |
| |
| yosys_metrics_values = [] |
| for metric in yosys_metrics: |
| metric_value = -1 |
| if yosys_log_content is not None: |
| metric_value = 0 |
| metric_name_escaped = re.escape(metric) |
| |
| if metric == "$_DFF_": |
| metric_name_escaped = r"\$_DFF_(?:\w+)?" |
| |
| match = re.search(rf"{metric_name_escaped}\s+(\d+)", yosys_log_content) |
| |
| if match is not None: |
| metric_value = int(match[1]) |
| yosys_metrics_values.append(metric_value) |
| |
| # ABC Info |
| abc_i = -1 |
| abc_o = -1 |
| abc_level = -1 |
| |
| if yosys_log_content is not None: |
| match = re.search( |
| r"ABC:\s*netlist\s*:\s*i\/o\s*=\s*(\d+)\/\s*(\d+)\s+lat\s*=\s*(\d+)\s+nd\s*=\s*(\d+)\s*edge\s*=\s*(\d+)\s*area\s*=\s*([\d\.]+)\s+delay\s*=\s*([\d\.]+)\s*lev\s*=\s*(\d+)", |
| yosys_log_content, |
| ) |
| |
| if match is not None: |
| abc_i = match[1] |
| abc_o = match[2] |
| # We don't use most of the ones in the middle. |
| abc_level = match[8] |
| |
| # Fastroute Layer Usage Percentages |
| routing_log = Artifact(rp, "logs", "routing", "global.log") |
| routing_log_content = routing_log.get_content() |
| |
| # MAGIC NUMBER ALERT |
| layer_usage = [-1] * 6 |
| if routing_log_content is not None: |
| routing_log_lines = routing_log_content.split("\n") |
| |
| final_congestion_report_start_line = None |
| for i, line in enumerate(routing_log_lines): |
| if "Final congestion report" in line: |
| final_congestion_report_start_line = i |
| break |
| |
| if final_congestion_report_start_line is not None: |
| start = final_congestion_report_start_line |
| header = start + 1 |
| separator = header + 1 |
| layer_start = separator + 1 |
| for i in range(6): |
| line = routing_log_lines[layer_start + i] |
| match = re.search(r"([\d\.]+)%", line) |
| if match is not None: |
| layer_usage[i] = float(match[1]) |
| |
| # Process Filler Cells |
| # Also includes endcap info |
| tapcell_log = Artifact(rp, "logs", "floorplan", "tap.log") |
| tapcell_log_content = tapcell_log.get_content() |
| |
| diode_log = Artifact(rp, "logs", "routing", "diodes.log") |
| diode_log_content = diode_log.get_content() |
| |
| tapcells, endcaps, diodes = 0, 0, 0 |
| if tapcell_log_content is not None: |
| match = re.search(r"Inserted (\d+) end\s*caps\.", tapcell_log_content) |
| |
| if match is not None: |
| endcaps = int(match[1]) |
| |
| match = re.search(r"Inserted (\d+) tap\s*cells\.", tapcell_log_content) |
| |
| if match is not None: |
| tapcells = int(match[1]) |
| |
| if diode_log_content is not None: |
| match = None |
| if "inserted!" in diode_log_content: |
| match = re.search(r"(\d+)\s+of\s+.+?\s+inserted!", diode_log_content) |
| else: |
| match = re.search(r"(\d+)\s+diodes\s+inserted\.", diode_log_content) |
| if match is not None: |
| diodes = int(match[1]) |
| |
| filler_cells = tapcells + endcaps + diodes |
| |
| # LVS Total Errors |
| lvs_report = Artifact(rp, "logs", "signoff", f"{self.design_name}.lvs.lef.log") |
| lvs_report_content = lvs_report.get_content() |
| |
| lvs_total_errors = -1 |
| if lvs_report_content is not None: |
| lvs_total_errors = 0 |
| match = re.search(r"Total errors\s*=\s*(\d+)", lvs_report_content) |
| if match is not None: |
| lvs_total_errors = int(match[1]) |
| |
| # CVC Total Errors |
| cvc_log = Artifact(rp, "logs", "signoff", "erc_screen.log") |
| cvc_log_content = cvc_log.get_content() |
| |
| cvc_total_errors = -1 |
| if cvc_log_content is not None: |
| match = re.search(r"CVC:\s*Total:\s*(\d+)", cvc_log_content) |
| if match is not None: |
| cvc_total_errors = int(match[1]) |
| |
| return [ |
| flow_status, |
| total_runtime, |
| routed_runtime, |
| die_area, |
| cells_per_mm, |
| utilization, |
| tr_memory_peak, |
| cell_count, |
| tr_violations, |
| short_violations, |
| metspc_violations, |
| offgrid_violations, |
| minhole_violations, |
| other_violations, |
| magic_violations, |
| antenna_violations, |
| lvs_total_errors, |
| cvc_total_errors, |
| klayout_violations, |
| wire_length, |
| vias, |
| wns, |
| pl_wns, |
| opt_wns, |
| fr_wns, |
| spef_wns, |
| tns, |
| pl_tns, |
| opt_tns, |
| fr_tns, |
| spef_tns, |
| hpwl, |
| *layer_usage, |
| *yosys_metrics_values, |
| abc_i, |
| abc_o, |
| abc_level, |
| endcaps, |
| tapcells, |
| diodes, |
| filler_cells, |
| ] |
| |
| def get_report(self): |
| row = [ |
| self.design_path, |
| self.design_name, |
| self.tag, |
| *self.extract_all_values(), |
| *self.configuration, |
| ] |
| return ",".join([f"{cell}" for cell in row]) |
