siliconcompiler 0.31.1__py3-none-any.whl → 0.32.1__py3-none-any.whl

siliconcompiler/report/dashboard/components/flowgraph.py

@@ -34,6 +34,9 @@ def get_nodes_and_edges(chip):
     nodes = []
     edges = []
 
+    if not chip.get('option', 'flow'):
+        return nodes, edges
+
     default_node_border_width = 1
     successful_path_node_width = 3
     default_edge_width = 3

siliconcompiler/report/dashboard/utils/__init__.py

@@ -24,8 +24,9 @@ def make_node_to_step_index_map(chip, metric_dataframe):
             nodes of the selected chip
     '''
     node_to_step_index_map = {}
-    for step, index in _get_flowgraph_nodes(chip, chip.get('option', 'flow')):
-        node_to_step_index_map[f'{step}{index}'] = (step, index)
+    if chip.get('option', 'flow'):
+        for step, index in _get_flowgraph_nodes(chip, chip.get('option', 'flow')):
+            node_to_step_index_map[f'{step}{index}'] = (step, index)
 
     # concatenate step and index
     metric_dataframe.columns = metric_dataframe.columns.map(lambda x: f'{x[0]}{x[1]}')
@@ -54,6 +55,8 @@ def make_metric_to_metric_unit_map(metric_dataframe):
 
 
 def is_running(chip):
+    if not chip.get('option', 'flow'):
+        return False
     for step, index in _get_flowgraph_nodes(chip, chip.get('option', 'flow')):
         state = chip.get('record', 'status', step=step, index=index)
         if not NodeStatus.is_done(state):

siliconcompiler/report/report.py

@@ -302,20 +302,20 @@ def get_metrics_source(chip, step, index):
         index (string) : Index of node.
     '''
     file_to_metric = {}
+    metric_primary_source = {}
     tool, task = get_tool_task(chip, step, index)
     if not chip.valid('tool', tool, 'task', task, 'report'):
-        return file_to_metric
+        return metric_primary_source, file_to_metric
 
     metrics = chip.getkeys('tool', tool, 'task', task, 'report')
 
     for metric in metrics:
         sources = chip.get('tool', tool, 'task', task, 'report', metric, step=step, index=index)
+        if sources:
+            metric_primary_source.setdefault(sources[0], []).append(metric)
         for source in sources:
-            if source in file_to_metric:
-                file_to_metric[source].append(metric)
-            else:
-                file_to_metric[source] = [metric]
-    return file_to_metric
+            file_to_metric.setdefault(source, []).append(metric)
+    return metric_primary_source, file_to_metric
 
 
 def get_files(chip, step, index):

siliconcompiler/report/utils.py

@@ -40,6 +40,9 @@ def _find_summary_metrics(chip, metrics_map):
 def _collect_data(chip, flow=None, flowgraph_nodes=None, format_as_string=True):
     if not flow:
         flow = chip.get('option', 'flow')
+    if not flow:
+        return [], {}, {}, {}, [], {}
+
     if not flowgraph_nodes:
         flowgraph_nodes = nodes_to_execute(chip)
         # only report tool based steps functions

siliconcompiler/scheduler/run_node.py

@@ -45,6 +45,9 @@ def main():
                         metavar='<package>:<directory>',
                         nargs='+',
                         help='Map of caches to prepopulate runner with')
+    parser.add_argument('-fetch_cache',
+                        action='store_true',
+                        help='Allow for cache downloads')
     parser.add_argument('-step',
                         required=True,
                         metavar='<step>',
@@ -105,7 +108,7 @@ def main():
 
     # Populate cache
     for package in chip.getkeys('package', 'source'):
-        sc_path(chip, package)
+        sc_path(chip, package, fetch=args.fetch_cache)
 
     # Run the task.
     error = True

siliconcompiler/schema/schema_obj.py

@@ -39,7 +39,7 @@ except ImportError:
     _has_yaml = False
 
 from .schema_cfg import schema_cfg
-from .utils import escape_val_tcl, PACKAGE_ROOT, translate_loglevel, PerNode, Scope
+from .utils import escape_val_tcl, translate_loglevel, PerNode, Scope
 
 
 class Schema:
@@ -1122,7 +1122,8 @@ class Schema:
 
         if template:
             fout.write(template.render(manifest_dict='\n'.join(tcl_set_cmds),
-                                       scroot=os.path.abspath(PACKAGE_ROOT),
+                                       scroot=os.path.abspath(
+                                           os.path.join(os.path.dirname(__file__), '..')),
                                        record_access=self._do_record_access(),
                                        record_access_id=Schema._RECORD_ACCESS_IDENTIFIER))
         else:

siliconcompiler/schema/utils.py

@@ -4,13 +4,10 @@
 # SC dependencies outside of its directory, since it may be used by tool drivers
 # that have isolated Python environments.
 
-import os
 import re
 import sys
 from enum import Enum
 
-PACKAGE_ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')
-
 
 #############################################################################
 # ENUM DEFINITIONs

siliconcompiler/targets/fpgaflow_demo.py

@@ -1,7 +1,6 @@
 import siliconcompiler
 from siliconcompiler import SiliconCompilerError
 from siliconcompiler.fpgas import lattice_ice40
-from siliconcompiler.fpgas import vpr_example
 
 from siliconcompiler.flows import fpgaflow
 
@@ -30,7 +29,6 @@ def setup(chip, partname=None):
 
     # 2.  Load all available FPGAs
     chip.use(lattice_ice40)
-    chip.use(vpr_example)
 
     # 3. Load flow
     chip.use(fpgaflow, partname=partname)

siliconcompiler/tools/openroad/_apr.py

@@ -84,12 +84,16 @@ def extract_metrics(chip):
     metric_reports = {
         "setuptns": [
             "timing/total_negative_slack.rpt",
-            "timing/setup.rpt"
+            "timing/setup.rpt",
+            "timing/setup.histogram.rpt",
+            "images/timing/setup.histogram.png"
         ],
         "setupslack": [
             "timing/worst_slack.setup.rpt",
             "timing/setup.rpt",
-            "timing/setup.topN.rpt"
+            "timing/setup.topN.rpt",
+            "timing/setup.histogram.rpt",
+            "images/timing/setup.histogram.png"
         ],
         "setupskew": [
             "timing/skew.setup.rpt",
@@ -99,12 +103,16 @@ def extract_metrics(chip):
         ],
         "setuppaths": [
             "timing/setup.rpt",
-            "timing/setup.topN.rpt"
+            "timing/setup.topN.rpt",
+            "timing/setup.histogram.rpt",
+            "images/timing/setup.histogram.png"
         ],
         "holdslack": [
             "timing/worst_slack.hold.rpt",
             "timing/hold.rpt",
-            "timing/hold.topN.rpt"
+            "timing/hold.topN.rpt",
+            "timing/hold.histogram.rpt",
+            "images/timing/hold.histogram.png"
         ],
         "holdskew": [
             "timing/skew.hold.rpt",
@@ -114,7 +122,9 @@ def extract_metrics(chip):
         ],
         "holdpaths": [
             "timing/hold.rpt",
-            "timing/hold.topN.rpt"
+            "timing/hold.topN.rpt",
+            "timing/hold.histogram.rpt",
+            "images/timing/hold.histogram.png"
         ],
         "unconstrained": [
             "timing/unconstrained.rpt",

siliconcompiler/tools/openroad/scripts/common/reports.tcl

@@ -27,6 +27,11 @@ if { [sc_cfg_tool_task_check_in_list setup var reports] } {
     tee -file reports/timing/total_negative_slack.rpt \
         "report_tns"
     report_tns_metric -setup
+
+    if { [sc_check_version 19519] } {
+        tee -quiet -file reports/timing/setup.histogram.rpt \
+            "report_timing_histogram -num_bins 20 -setup"
+    }
 }
 
 if { [sc_cfg_tool_task_check_in_list hold var reports] } {
@@ -42,6 +47,11 @@ if { [sc_cfg_tool_task_check_in_list hold var reports] } {
     report_worst_slack_metric -hold
 
     report_tns_metric -hold
+
+    if { [sc_check_version 19519] } {
+        tee -quiet -file reports/timing/hold.histogram.rpt \
+            "report_timing_histogram -num_bins 20 -hold"
+    }
 }
 
 if { [sc_cfg_tool_task_check_in_list unconstrained var reports] } {

siliconcompiler/tools/openroad/scripts/common/write_images.tcl

@@ -304,6 +304,30 @@ proc sc_image_clocktree { } {
     gui::hide_widget "Clock Tree Viewer"
 }
 
+proc sc_image_timing_histograms { } {
+    if { ![sc_check_version 19526] } {
+        return
+    }
+    file mkdir reports/images/timing
+
+    if { [sc_cfg_tool_task_check_in_list setup var reports] } {
+        set path reports/images/timing/setup.histogram.png
+        utl::info FLW 1 "Saving setup timing histogram to $path"
+        save_histogram_image $path \
+            -mode setup \
+            -width 500 \
+            -height 500
+    }
+    if { [sc_cfg_tool_task_check_in_list hold var reports] } {
+        set path reports/images/timing/hold.histogram.png
+        utl::info FLW 1 "Saving hold timing histogram to $path"
+        save_histogram_image $path \
+            -mode hold \
+            -width 500 \
+            -height 500
+    }
+}
+
 proc sc_image_optimizer { } {
     global sc_design
     sc_image_setup_default
@@ -390,6 +414,9 @@ if { [sc_cfg_tool_task_check_in_list module_view var reports] } {
 # Markers
 sc_image_markers
 
+# Histograms
+sc_image_timing_histograms
+
 # Heatmaps
 if { [sc_cfg_tool_task_check_in_list placement_density var reports] } {
     sc_image_placement_density

siliconcompiler/tools/slang/__init__.py

@@ -10,55 +10,56 @@ Sources: https://github.com/MikePopoloski/slang
 
 Installation: https://sv-lang.com/building.html
 '''
-import re
-from siliconcompiler import sc_open
-from siliconcompiler.tools._common import record_metric
+import os
+
+try:
+    import pyslang
+except ModuleNotFoundError:
+    pyslang = None
+
 from siliconcompiler.tools._common import \
-    get_frontend_options, get_input_files, get_tool_task
+    add_require_input, add_frontend_requires, get_frontend_options, get_input_files, \
+    get_tool_task, record_metric
 
 
-################################
-# Setup Tool (pre executable)
-################################
-def setup(chip):
-    tool = 'slang'
+def has_pyslang():
+    return pyslang is not None
 
-    # Standard Setup
-    chip.set('tool', tool, 'exe', 'slang')
-    chip.set('tool', tool, 'vswitch', '--version')
-    chip.set('tool', tool, 'version', '>=6.0', clobber=False)
 
+def test_version():
+    if not has_pyslang():
+        return "pyslang is not installed"
 
-def parse_version(stdout):
-    # slang --version output looks like:
-    # slang version 6.0.121+c2c478cf
+    version = pyslang.VersionInfo
+    if version.getMajor() >= 7 and version.getMinor() >= 0:
+        return None
 
-    # grab version # by splitting on whitespace
-    return stdout.strip().split()[-1].split('+')[0]
+    ver = f"{version.getMajor()}.{version.getMinor()}.{version.getPatch()}"
 
+    return f"incorrect pyslang version: {ver}"
 
-def post_process(chip):
-    step = chip.get('arg', 'step')
-    index = chip.get('arg', 'index')
 
-    log = f'{step}.log'
-    with sc_open(log) as f:
-        for line in f:
-            match = re.search(r'(\d+) errors, (\d+) warnings', line)
-            if match:
-                record_metric(chip, step, index, 'errors', match.group(1), log)
-                record_metric(chip, step, index, 'warnings', match.group(2), log)
+################################
+# Setup Tool (pre executable)
+################################
+def setup(chip):
+    add_require_input(chip, 'input', 'rtl', 'verilog')
+    add_require_input(chip, 'input', 'rtl', 'systemverilog')
+    add_require_input(chip, 'input', 'cmdfile', 'f')
+    add_frontend_requires(chip, ['ydir', 'idir', 'vlib', 'libext', 'define', 'param'])
 
 
 def common_runtime_options(chip):
-    options = []
-
     step = chip.get('arg', 'step')
     index = chip.get('arg', 'index')
     tool, task = get_tool_task(chip, step, index)
 
-    options.extend(['-j', str(chip.get('tool', tool, 'task', task, 'threads',
-                              step=step, index=index))])
+    options = chip.get('tool', tool, 'task', task, 'option', step=step, index=index)
+
+    options.append('--single-unit')
+
+    options.extend(['--threads', str(chip.get('tool', tool, 'task', task, 'threads',
+                                              step=step, index=index))])
 
     opts = get_frontend_options(chip,
                                 ['ydir',
@@ -113,7 +114,7 @@ def common_runtime_options(chip):
     #######################
     # Top Module
     #######################
-    options.append('--top ' + chip.top())
+    options.append('--top ' + chip.top(step, index))
 
     ###############################
     # Parameters (top module only)
@@ -124,3 +125,92 @@ def common_runtime_options(chip):
         options.append(f'-G {param}={value}')
 
     return options
+
+
+def _get_driver(chip, options_func, ignored_diagnotics=None):
+    driver = pyslang.Driver()
+    driver.addStandardArgs()
+
+    options = options_func(chip)
+
+    parseOpts = pyslang.CommandLineOptions()
+    parseOpts.ignoreProgramName = True
+    opts = " ".join(options)
+    code = 0
+    if not driver.parseCommandLine(opts, parseOpts):
+        code = 1
+
+    if code == 0 and not driver.processOptions():
+        code = 2
+
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+    for warning in chip.get('tool', tool, 'task', task, 'warningoff', step=step, index=index):
+        if hasattr(pyslang.Diags, warning):
+            driver.diagEngine.setSeverity(
+                getattr(pyslang.Diags, warning),
+                pyslang.DiagnosticSeverity.Ignored)
+        elif not chip.get('option', 'quiet', step=step, index=index):
+            chip.logger.warning(f'{warning} is not a valid slang category')
+
+    if not ignored_diagnotics:
+        ignored_diagnotics = []
+    for ignore in ignored_diagnotics:
+        driver.diagEngine.setSeverity(
+            ignore,
+            pyslang.DiagnosticSeverity.Ignored)
+
+    return driver, code
+
+
+def _compile(chip, driver):
+    ok = driver.parseAllSources()
+    compilation = driver.createCompilation()
+    return compilation, ok
+
+
+def _diagnostics(chip, driver, compilation):
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+
+    report = {
+        "error": [],
+        "warning": [],
+    }
+    diags = driver.diagEngine
+    for diag in compilation.getAllDiagnostics():
+        severity = diags.getSeverity(diag.code, diag.location)
+        report_level = None
+        if severity == pyslang.DiagnosticSeverity.Warning:
+            report_level = "warning"
+        elif severity == pyslang.DiagnosticSeverity.Error:
+            report_level = "error"
+        elif severity == pyslang.DiagnosticSeverity.Fatal:
+            report_level = "error"
+
+        if report_level:
+            for n, line in enumerate(diags.reportAll(driver.sourceManager, [diag]).splitlines()):
+                if line.strip():
+                    if n == 0:
+                        line_parts = line.split(":")
+                        if os.path.exists(line_parts[0]):
+                            line_parts[0] = os.path.abspath(line_parts[0])
+                        line = ":".join(line_parts)
+
+                    report[report_level].append(line)
+
+    if not chip.get('option', 'quiet', step=step, index=index):
+        if report["warning"]:
+            for line in report["warning"]:
+                chip.logger.warning(line)
+        if report["error"]:
+            for line in report["error"]:
+                chip.logger.error(line)
+
+    diags.clearCounts()
+    for diag in compilation.getAllDiagnostics():
+        diags.issue(diag)
+
+    record_metric(chip, step, index, 'errors', diags.numErrors, [])
+    record_metric(chip, step, index, 'warnings', diags.numWarnings, [])

siliconcompiler/tools/slang/elaborate.py

@@ -1,13 +1,21 @@
 from siliconcompiler import utils
 from siliconcompiler.tools import slang
-from siliconcompiler.tools._common import \
-    add_require_input, add_frontend_requires, get_tool_task, has_input_files
+import os
+from siliconcompiler.tools._common import get_tool_task, has_input_files
+from siliconcompiler.tools.slang import pyslang
 
 
 def setup(chip):
     '''
     Elaborate verilog design files and generate a unified file.
     '''
+    if slang.test_version():
+        return slang.test_version()
+
+    if not has_input_files(chip, 'input', 'rtl', 'verilog') and \
+       not has_input_files(chip, 'input', 'rtl', 'systemverilog'):
+        return "no files in [input,rtl,systemverilog] or [input,rtl,verilog]"
+
     slang.setup(chip)
 
     step = chip.get('arg', 'step')
@@ -17,30 +25,127 @@ def setup(chip):
     chip.set('tool', tool, 'task', task, 'threads', utils.get_cores(chip),
              clobber=False, step=step, index=index)
 
-    add_require_input(chip, 'input', 'rtl', 'verilog')
-    add_require_input(chip, 'input', 'rtl', 'systemverilog')
-    add_frontend_requires(chip, ['ydir', 'idir', 'vlib', 'libext', 'define', 'param'])
-
-    chip.set('tool', tool, 'task', task, 'stdout', 'destination', 'output', step=step, index=index)
-    chip.set('tool', tool, 'task', task, 'stdout', 'suffix', 'v', step=step, index=index)
+    chip.set('tool', tool, 'task', task, 'stdout', 'destination', 'log', step=step, index=index)
+    chip.set('tool', tool, 'task', task, 'stderr', 'destination', 'log', step=step, index=index)
 
     chip.set('tool', tool, 'task', task, 'output', __outputfile(chip), step=step, index=index)
 
+    chip.set('tool', tool, 'task', task, 'var', 'include_source_paths', True,
+             step=step, index=index, clobber=False)
+    chip.set('tool', tool, 'task', task, 'var', 'include_source_paths',
+             "true/false, if true add the source file path information", field="help")
+
+
+def __outputfile(chip):
+    is_systemverilog = has_input_files(chip, 'input', 'rtl', 'systemverilog')
+    if is_systemverilog:
+        return f'{chip.top()}.sv'
+    return f'{chip.top()}.v'
+
+
+def __get_files(manager, tree):
+    files = set()
+
+    from queue import Queue
+    nodes = Queue(maxsize=0)
+    nodes.put(tree.root)
+
+    def procRange(range):
+        files.add(manager.getFileName(range.start))
+        files.add(manager.getFileName(range.end))
+
+    while not nodes.empty():
+        node = nodes.get()
+        procRange(node.sourceRange)
+        for token in node:
+            if isinstance(token, pyslang.Token):
+                procRange(token.range)
+            else:
+                nodes.put(token)
+
+    return sorted([os.path.abspath(f) for f in files if os.path.isfile(f)])
+
+
+def run(chip):
+    # Override default errors
+    ignored = [
+        pyslang.Diags.MissingTimeScale,
+        pyslang.Diags.UsedBeforeDeclared,
+        pyslang.Diags.UnusedParameter,
+        pyslang.Diags.UnusedDefinition,
+        pyslang.Diags.UnusedVariable,
+        pyslang.Diags.UnusedPort,
+        pyslang.Diags.UnusedButSetNet,
+        pyslang.Diags.UnusedImplicitNet,
+        pyslang.Diags.UnusedButSetVariable,
+        pyslang.Diags.UnusedButSetPort,
+        pyslang.Diags.UnusedTypedef,
+        pyslang.Diags.UnusedGenvar,
+        pyslang.Diags.UnusedAssertionDecl
+    ]
+
+    driver, exitcode = slang._get_driver(
+        chip,
+        runtime_options,
+        ignored_diagnotics=ignored)
+    if exitcode:
+        return exitcode
+
+    compilation, ok = slang._compile(chip, driver)
+
+    slang._diagnostics(chip, driver, compilation)
+
+    manager = compilation.sourceManager
+
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+    add_source = chip.get('tool', tool, 'task', task, 'var', 'include_source_paths',
+                          step=step, index=index)[0] == 'true'
+
+    def printFiles(out, files):
+        for src_file in files:
+            out.write(f'//   File: {src_file}\n')
+
+    with open(f'outputs/{__outputfile(chip)}', 'w') as out:
+        for tree in compilation.getSyntaxTrees():
+            files = []
+            if add_source:
+                files = __get_files(manager, tree)
+
+            writer = pyslang.SyntaxPrinter(manager)
+
+            writer.setIncludeMissing(False)
+            writer.setIncludeSkipped(False)
+            writer.setIncludeDirectives(False)
+
+            writer.setIncludePreprocessed(True)
+            writer.setIncludeTrivia(True)
+            writer.setIncludeComments(True)
+            writer.setSquashNewlines(True)
+
+            out.write("////////////////////////////////////////////////////////////////\n")
+            out.write("// Start:\n")
+            printFiles(out, files)
+
+            out.write(writer.print(tree).str() + '\n')
+
+            out.write("// End:\n")
+            printFiles(out, files)
+            out.write("////////////////////////////////////////////////////////////////\n")
+
+    if ok:
+        return 0
+    else:
+        return 1
+
 
 def runtime_options(chip):
     options = slang.common_runtime_options(chip)
     options.extend([
-        "--preprocess",
-        "--comments",
+        "--allow-use-before-declare",
         "--ignore-unknown-modules",
-        "--allow-use-before-declare"
+        "-Weverything"
     ])
 
     return options
-
-
-def __outputfile(chip):
-    is_systemverilog = has_input_files(chip, 'input', 'rtl', 'systemverilog')
-    if is_systemverilog:
-        return f'{chip.top()}.sv'
-    return f'{chip.top()}.v'

siliconcompiler/tools/slang/lint.py

@@ -1,13 +1,15 @@
 from siliconcompiler import utils
 from siliconcompiler.tools import slang
-from siliconcompiler.tools._common import \
-    add_require_input, add_frontend_requires, get_tool_task
+from siliconcompiler.tools._common import get_tool_task
 
 
 def setup(chip):
     '''
     Lint system verilog
     '''
+    if slang.test_version():
+        return slang.test_version()
+
     slang.setup(chip)
 
     step = chip.get('arg', 'step')
@@ -17,19 +19,27 @@ def setup(chip):
     chip.set('tool', tool, 'task', task, 'threads', utils.get_cores(chip),
              clobber=False, step=step, index=index)
 
-    add_require_input(chip, 'input', 'rtl', 'verilog')
-    add_require_input(chip, 'input', 'rtl', 'systemverilog')
-    add_frontend_requires(chip, ['ydir', 'idir', 'vlib', 'libext', 'define', 'param'])
+
+def run(chip):
+    driver, exitcode = slang._get_driver(chip, runtime_options)
+    if exitcode:
+        return exitcode
+
+    compilation, ok = slang._compile(chip, driver)
+    slang._diagnostics(chip, driver, compilation)
+
+    if ok:
+        return 0
+    else:
+        return 1
 
 
 def runtime_options(chip):
     options = slang.common_runtime_options(chip)
     options.extend([
-        "--lint-only"
+        "--lint-only",
+        "-Weverything",
+        "-Werror"
     ])
 
     return options
-
-
-def post_process(chip):
-    slang.post_process(chip)