def print_signatures_md(self,
severity_filter: List[str] = [],
max_per_bucket: int = -1) -> str:
'''
Render signatures into a string buffer.
The bucket labels are used as subtitles in this printout.
If severity_filter is not empty, only the buckets with the listed
severities will be returned.
The number of messages printed per bucket can be limited by
setting max_per_bucket to a nonnegative value.
'''
msgs = ''
keys = self.get_keys(severity_filter)
for k in keys:
msgs += print_msg_list(f'#### {self.buckets[k].label}',
self.buckets[k].signatures, max_per_bucket)
return msgs
def _gen_results(self):
# '''
# The function is called after the regression has completed. It looks
# for a regr_results.hjson file with aggregated results from the
# synthesis run. The hjson needs to have the following (potentially
# empty) 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>,
# }
# }
#
# note that if this is a primary config, the results will
# be generated using the _gen_results_summary function
# '''
def _create_entry(val, norm=1.0, total=None, perctag="%"):
"""
Create normalized entry with an optional
percentage appended in brackets.
"""
if val is not None and norm is not None:
if total is not None:
perc = float(val) / float(total) * 100.0
entry = "%2.1f %s" % (perc, perctag)
else:
value = float(val) / norm
entry = "%2.1f" % (value)
else:
entry = "--"
return entry
self.result = {}
# Generate results table for runs.
results_str = "## " + self.results_title + "\n\n"
results_str += "### " + self.timestamp_long + "\n"
if self.revision:
results_str += "### " + self.revision + "\n"
results_str += "### Branch: " + self.branch + "\n"
results_str += "### Synthesis Tool: " + self.tool.upper() + "\n\n"
# TODO: extend this to support multiple build modes
for mode in self.build_modes:
# results_str += "## Build Mode: " + mode.name + "\n\n"
result_data = Path(
subst_wildcards(self.build_dir, {"build_mode": mode.name}) +
'/results.hjson')
log.info("looking for result data file at %s", result_data)
try:
with result_data.open() as results_file:
self.result = hjson.load(results_file, use_decimal=True)
except IOError as err:
log.warning("%s", err)
self.result = {
"messages": {
"flow_errors": ["IOError: %s" % err],
"flow_warnings": [],
"analyze_errors": [],
"analyze_warnings": [],
"elab_errors": [],
"elab_warnings": [],
"compile_errors": [],
"compile_warnings": [],
},
}
# Message summary
# results_str += "### Tool Message Summary\n\n"
if "messages" in self.result:
header = [
"Build Mode", "Flow Warnings", "Flow Errors",
"Analyze Warnings", "Analyze Errors", "Elab Warnings",
"Elab Errors", "Compile Warnings", "Compile Errors"
]
colalign = ("left", ) + ("center", ) * (len(header) - 1)
table = [header]
messages = self.result["messages"]
table.append([
mode.name,
str(len(messages["flow_warnings"])) + " W ",
str(len(messages["flow_errors"])) + " E ",
str(len(messages["analyze_warnings"])) + " W ",
str(len(messages["analyze_errors"])) + " E ",
str(len(messages["elab_warnings"])) + " W ",
str(len(messages["elab_errors"])) + " E ",
str(len(messages["compile_warnings"])) + " W ",
str(len(messages["compile_errors"])) + " E ",
])
if len(table) > 1:
results_str += tabulate(table,
headers="firstrow",
tablefmt="pipe",
colalign=colalign) + "\n\n"
else:
results_str += "No messages found\n\n"
else:
results_str += "No messages found\n\n"
# Hierarchical Area report
results_str += "### Circuit Complexity in [kGE]\n\n"
if "area" in self.result:
header = [
"Instance", "Comb ", "Buf/Inv", "Regs", "Macros", "Total",
"Total [%]"
]
colalign = ("left", ) + ("center", ) * (len(header) - 1)
table = [header]
# print top-level summary first
row = ["**" + self.result["top"] + "**"]
try:
kge = float(self.result["area"]["ge"]) * 1000.0
for field in ["comb", "buf", "reg", "macro", "total"]:
row += [
"**" +
_create_entry(self.result["area"][field], kge) +
"**"
]
row += ["**--**"]
table.append(row)
# go through submodules
for name in self.result["area"]["instances"].keys():
if name == self.result["top"]:
continue
row = [name]
for field in ["comb", "buf", "reg", "macro", "total"]:
row += [
_create_entry(
self.result["area"]["instances"][name]
[field], kge)
]
# add percentage of total
row += [
_create_entry(
self.result["area"]["instances"][name][field],
kge, self.result["area"]["total"], "%u")
]
table.append(row)
except TypeError:
results_str += "Gate equivalent is not properly defined\n\n"
if len(table) > 1:
results_str += tabulate(table,
headers="firstrow",
tablefmt="pipe",
colalign=colalign) + "\n\n"
else:
results_str += "No area report found\n\n"
else:
results_str += "No area report found\n\n"
# Timing report
results_str += "### Timing in [ns]\n\n"
if "timing" in self.result and "units" in self.result:
header = ["Clock", "Period", "WNS", "TNS"]
colalign = ("left", ) + ("center", ) * (len(header) - 1)
table = [header]
for clock in self.result["timing"].keys():
row = [clock]
row += [
_create_entry(
self.result["timing"][clock]["period"],
1.0E-09 / float(self.result["units"]["time"])),
_create_entry(
self.result["timing"][clock]["wns"], 1.0E-09 /
float(self.result["units"]["time"])) + " EN",
_create_entry(
self.result["timing"][clock]["tns"], 1.0E-09 /
float(self.result["units"]["time"])) + " EN"
]
table.append(row)
if len(table) > 1:
results_str += tabulate(table,
headers="firstrow",
tablefmt="pipe",
colalign=colalign) + "\n\n"
else:
results_str += "No timing report found\n\n"
else:
results_str += "No timing report found\n\n"
# Power report
results_str += "### Power Estimates in [mW]\n\n"
if "power" in self.result and "units" in self.result:
header = ["Network", "Internal", "Leakage", "Total"]
colalign = ("center", ) * len(header)
table = [header]
try:
self.result["power"]["net"]
power = [
float(self.result["power"]["net"]) *
float(self.result["units"]["dynamic"]),
float(self.result["power"]["int"]) *
float(self.result["units"]["dynamic"]),
float(self.result["power"]["leak"]) *
float(self.result["units"]["static"])
]
total_power = sum(power)
row = [
_create_entry(power[0], 1.0E-3) + " / " +
_create_entry(power[0], 1.0E-3, total_power),
_create_entry(power[1], 1.0E-3) + " / " +
_create_entry(power[1], 1.0E-3, total_power),
_create_entry(power[2], 1.0E-3) + " / " +
_create_entry(power[2], 1.0E-3, total_power),
_create_entry(total_power, 1.0E-3)
]
table.append(row)
# in case fp values are NoneType
except TypeError:
results_str += "No power report found\n\n"
if len(table) > 1:
results_str += tabulate(table,
headers="firstrow",
tablefmt="pipe",
colalign=colalign) + "\n\n"
else:
results_str += "No power report found\n\n"
# Append detailed messages if they exist
# Note that these messages are omitted in publication mode
hdr_key_pairs = [("Flow Warnings", "flow_warnings"),
("Flow Errors", "flow_errors"),
("Analyze Warnings", "analyze_warnings"),
("Analyze Errors", "analyze_errors"),
("Elab Warnings", "elab_warnings"),
("Elab Errors", "elab_errors"),
("Compile Warnings", "compile_warnings"),
("Compile Errors", "compile_errors")]
# Synthesis fails if any warning or error message has occurred
self.errors_seen = False
fail_msgs = ""
for _, key in hdr_key_pairs:
if key in self.result['messages']:
if self.result['messages'].get(key):
self.errors_seen = True
break
if self.errors_seen:
fail_msgs += "\n### Errors and Warnings for Build Mode `'" + mode.name + "'`\n"
for hdr, key in hdr_key_pairs:
msgs = self.result['messages'].get(key)
fail_msgs += print_msg_list("#### " + hdr, msgs,
self.max_msg_count)
# the email and published reports will default to self.results_md if they are
# empty. in case they need to be sanitized, override them and do not append
# detailed messages.
if self.sanitize_email_results:
self.email_results_md = results_str
if self.sanitize_publish_results:
self.publish_results_md = results_str
# locally generated result always contains all details
self.results_md = results_str + fail_msgs
# TODO: add support for pie / bar charts for area splits and
# QoR history
# Write results to the scratch area
results_file = self.scratch_path + "/results_" + self.timestamp + ".md"
with open(results_file, 'w') as f:
f.write(self.results_md)
log.log(VERBOSE, "[results page]: [%s] [%s]", self.name, results_file)
return self.results_md
def _gen_results(self):
# '''
# The function is called after the regression has completed. It looks
# for a regr_results.hjson file with aggregated results from the lint run.
# The hjson needs to have the following (potentially empty) fields
#
# {
# tool: ""
# errors: []
# warnings: []
# lint_errors: []
# lint_warning: []
# lint_infos: []
# }
#
# where each entry is a string representing a lint message. This allows
# to reuse the same LintCfg class with different tools since just the
# parsing script that transforms the tool output into the hjson above
# needs to be adapted.
#
# note that if this is a primary config, the results will
# be generated using the _gen_results_summary function
# '''
# Generate results table for runs.
results_str = "## " + self.results_title + "\n\n"
results_str += "### " + self.timestamp_long + "\n"
if self.revision:
results_str += "### " + self.revision + "\n"
results_str += "### Branch: " + self.branch + "\n"
results_str += "### Lint Tool: " + self.tool.upper() + "\n\n"
header = [
"Build Mode", "Tool Warnings", "Tool Errors", "Lint Warnings",
"Lint Errors"
]
colalign = ("center", ) * len(header)
table = [header]
# aggregated counts
self.result_summary["warnings"] = []
self.result_summary["errors"] = []
self.result_summary["lint_warnings"] = []
self.result_summary["lint_errors"] = []
fail_msgs = ""
for mode in self.build_modes:
result_data = Path(
subst_wildcards(self.build_dir, {"build_mode": mode.name}) +
'/results.hjson')
log.info("[results:hjson]: [%s]: [%s]", self.name, result_data)
try:
with result_data.open() as results_file:
self.result = hjson.load(results_file, use_decimal=True)
except IOError as err:
log.warning("%s", err)
self.result = {
"tool": "",
"errors": ["IOError: %s" % err],
"warnings": [],
"lint_errors": [],
"lint_warnings": [],
"lint_infos": []
}
if self.result:
table.append([
mode.name,
str(len(self.result["warnings"])) + " W ",
str(len(self.result["errors"])) + " E",
# We currently do not publish these infos at
# the moment len(self.result["lint_infos"]),
str(len(self.result["lint_warnings"])) + " W",
str(len(self.result["lint_errors"])) + " E"
])
else:
self.result = {
"tool": "",
"errors": [],
"warnings": [],
"lint_errors": [],
"lint_warnings": [],
"lint_infos": []
}
self.result_summary["warnings"] += self.result["warnings"]
self.result_summary["errors"] += self.result["errors"]
self.result_summary["lint_warnings"] += self.result[
"lint_warnings"]
self.result_summary["lint_errors"] += self.result["lint_errors"]
# Append detailed messages if they exist
hdr_key_pairs = [("Tool Warnings", "warnings"),
("Tool Errors", "errors"),
("Lint Warnings", "lint_warnings"),
("Lint Errors", "lint_errors")]
# Lint fails if any warning or error message has occurred
self.errors_seen = False
for _, key in hdr_key_pairs:
if key in self.result:
if self.result.get(key):
self.errors_seen = True
break
if self.errors_seen:
fail_msgs += "\n### Errors and Warnings for Build Mode `'" + mode.name + "'`\n"
for hdr, key in hdr_key_pairs:
msgs = self.result.get(key)
fail_msgs += print_msg_list("#### " + hdr, msgs,
self.max_msg_count)
if len(table) > 1:
self.results_md = results_str + tabulate(
table, headers="firstrow", tablefmt="pipe",
colalign=colalign) + "\n"
# the email and published reports will default to self.results_md if they are
# empty. in case they need to be sanitized, override them and do not append
# detailed messages.
if self.sanitize_email_results:
self.email_results_md = self.results_md
if self.sanitize_publish_results:
self.publish_results_md = self.results_md
# locally generated result always contains all details
self.results_md += fail_msgs
else:
self.results_md = results_str + "\nNo results to display.\n"
self.email_results_md = self.results_md
self.publish_results_md = self.results_md
# Write results to the scratch area
results_file = self.scratch_path + "/results_" + self.timestamp + ".md"
with open(results_file, 'w') as f:
f.write(self.results_md)
log.log(VERBOSE, "[results page]: [%s] [%s]", self.name, results_file)
return self.results_md