siliconcompiler 0.29.3__py3-none-any.whl → 0.29.4__py3-none-any.whl

siliconcompiler/_metadata.py

@@ -1,5 +1,5 @@
 # Version number following semver standard.
-version = '0.29.3'
+version = '0.29.4'
 
 # Default server address for remote runs, if unspecified.
 default_server = 'https://server.siliconcompiler.com'

siliconcompiler/apps/sc_install.py

@@ -73,16 +73,18 @@ def show_tool(tool, script):
 def _get_os_name():
     machine_info = _get_machine_info()
     system = machine_info.get('system', "").lower()
-    distro = machine_info.get('distro', "").lower()
-    osversion = machine_info.get('osversion', "").lower()
     if system == 'linux':
+        distro = machine_info.get('distro', "").lower()
         if distro == 'ubuntu':
+            osversion = machine_info.get('osversion', "").lower()
             version, _ = osversion.split('.')
             return f"{distro}{version}"
         elif distro == 'rocky':
+            osversion = machine_info.get('osversion', "").lower()
             version, _ = osversion.split('.')
             return f"rhel{version}"
         elif distro == 'rhel':
+            osversion = machine_info.get('osversion', "").lower()
             version, _ = osversion.split('.')
             return f"rhel{version}"
     return None
@@ -134,6 +136,10 @@ def _recommended_tool_groups(tools):
     for group, group_tools in groups.items():
         if all([tool in tools for tool in group_tools]):
             filter_groups[group] = group_tools
+        else:
+            missing = sorted([tool for tool in group_tools if tool not in tools])
+            filter_groups[group] = f"{group} group is not available for {_get_os_name()} " \
+                f"due to lack of support for the following tools: {', '.join(missing)}"
     return filter_groups
 
 
@@ -172,6 +178,11 @@ To system debugging information (this should only be used to debug):
 
     tools = _get_tools_list()
 
+    if _get_os_name() is None:
+        print("Unsupported operating system", file=sys.stderr)
+        print_machine_info()
+        return 1
+
     tool_choices = ChoiceOptional(tools.keys())
     parser.add_argument(
         "tool",
@@ -220,7 +231,11 @@ To system debugging information (this should only be used to debug):
     args.tool = list(args.tool)
     if args.group:
         for group in args.group:
-            args.tool.extend(tool_groups[group])
+            if isinstance(tool_groups[group], str):
+                print(tool_groups[group], file=sys.stderr)
+                return 1
+            else:
+                args.tool.extend(tool_groups[group])
 
     tools_handled = set()
     for tool in args.tool:

siliconcompiler/remote/client.py

@@ -477,6 +477,9 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
             # Flush file to ensure everything is written
             upload_file.flush()
 
+            # We no longer need the collected files
+            shutil.rmtree(self.__chip._getcollectdir(jobname=self.__chip.get('option', 'jobname')))
+
         if 'pre_upload' in remote_status:
             self.__logger.info(remote_status['pre_upload']['message'])
             time.sleep(remote_status['pre_upload']['delay'])

siliconcompiler/scheduler/__init__.py

@@ -1628,8 +1628,14 @@ def _launch_nodes(chip, nodes_to_run, processes, local_processes):
             # Update dashboard if the manifest changed
             chip._dash.update_manifest()
 
-        # TODO: exponential back-off with max?
-        time.sleep(0.1)
+        if len(running_nodes) == 1:
+            # if there is only one node running, just join the thread
+            running_node = list(running_nodes.keys())[0]
+            processes[running_node]["proc"].join()
+        elif len(running_nodes) > 1:
+            # if there are more than 1, join the first with a timeout
+            running_node = list(running_nodes.keys())[0]
+            processes[running_node]["proc"].join(timeout=0.1)
 
 
 def _process_completed_nodes(chip, processes, running_nodes):
@@ -1949,7 +1955,7 @@ def check_node_inputs(chip, step, index):
                                            step=check_step, index=check_index)
 
                 if check_hash != prev_hash:
-                    print_warning(key)
+                    print_warning(key, "file hash")
                     return False
             else:
                 # check timestamps on current files

siliconcompiler/tools/__init__.py

@@ -1,4 +1,4 @@
-from siliconcompiler.tools.bambu import bambu
+from siliconcompiler.tools import bambu
 from siliconcompiler.tools.bluespec import bluespec
 from siliconcompiler.tools.builtin import builtin
 from siliconcompiler.tools.chisel import chisel

siliconcompiler/tools/_common/asic.py

@@ -194,6 +194,9 @@ def set_tool_task_lib_var(chip,
 
         values.update(chip.get(*lib_key, step=get_step, index=get_index))
 
+    if default_value and not check_value(values):
+        values = default_value
+
     if check_value(values):
         chip.set('tool', tool, 'task', task, 'var', param_key, values,
                  step=step, index=index, clobber=False)

siliconcompiler/tools/_common/asic_clock.py

@@ -0,0 +1,101 @@
+import re
+from siliconcompiler.utils import sc_open
+from siliconcompiler.tools._common.asic import get_tool_task
+
+
+def __get_clock_data(chip, clock_units_multiplier=1):
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+
+    period = None
+    # get clock information from sdc files
+    if chip.valid('input', 'constraint', 'sdc'):
+        for sdc in chip.find_files('input', 'constraint', 'sdc', step=step, index=index):
+            lines = []
+            with sc_open(sdc) as f:
+                lines = f.read().splitlines()
+
+            # collect simple variables in case clock is specified with a variable
+            re_var = r"[A-Za-z0-9_]+"
+            re_num = r"[0-9\.]+"
+            sdc_vars = {}
+            for line in lines:
+                tcl_variable = re.findall(fr"^\s*set\s+({re_var})\s+({re_num}|\${re_var})", line)
+                if tcl_variable:
+                    var_name, var_value = tcl_variable[0]
+                    sdc_vars[f'${var_name}'] = var_value
+
+            # TODO: handle line continuations
+            for line in lines:
+                clock_period = re.findall(fr"create_clock\s.*-period\s+({re_num}|\${re_var})",
+                                          line)
+                if clock_period:
+                    convert_period = clock_period[0]
+                    while isinstance(convert_period, str) and convert_period[0] == "$":
+                        if convert_period in sdc_vars:
+                            convert_period = sdc_vars[convert_period]
+                        else:
+                            break
+                    if isinstance(convert_period, str) and convert_period[0] == "$":
+                        chip.logger.warning('Unable to identify clock period from '
+                                            f'{clock_period[0]}.')
+                        continue
+                    else:
+                        try:
+                            clock_period = float(convert_period)
+                        except TypeError:
+                            continue
+
+                    clock_period = clock_period * clock_units_multiplier
+
+                    if period is None:
+                        period = clock_period
+                    else:
+                        period = min(period, clock_period)
+
+        if period is not None:
+            return period, None, [('input', 'constraint', 'sdc')]
+
+    if period is None:
+        keys = []
+        key_pin = None
+        # get clock information from defined clocks
+        for pin in chip.getkeys('datasheet', 'pin'):
+            for mode in chip.getkeys('datasheet', 'pin', pin, 'type'):
+                if chip.get('datasheet', 'pin', pin, 'type', mode) == 'clock':
+                    clock_period = min(chip.get('datasheet', 'pin', pin, 'tperiod', mode)) * 1e9
+
+                    if period is None:
+                        period = clock_period
+                        keys = [
+                            ('datasheet', 'pin', pin, 'type', mode),
+                            ('datasheet', 'pin', pin, 'tperiod', mode)
+                        ]
+                        key_pin = pin
+                    else:
+                        if clock_period < period:
+                            period = clock_period
+                            keys = [
+                                ('datasheet', 'pin', pin, 'type', mode),
+                                ('datasheet', 'pin', pin, 'tperiod', mode)
+                            ]
+                            key_pin = pin
+        return period, key_pin, keys
+
+    return None, None, []
+
+
+def add_clock_requirements(chip):
+    _, _, keys = __get_clock_data(chip)
+
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+    for key in keys:
+        chip.add('tool', tool, 'task', task, 'require', ','.join(key),
+                 step=step, index=index)
+
+
+def get_clock_period(chip, clock_units_multiplier=1):
+    period, name, _ = __get_clock_data(chip, clock_units_multiplier=clock_units_multiplier)
+    return name, period

siliconcompiler/tools/bambu/__init__.py

@@ -0,0 +1,32 @@
+'''
+The primary objective of the PandA project is to develop a usable framework that will
+enable the research of new ideas in the HW-SW Co-Design field.
+
+The PandA framework includes methodologies supporting the research on high-level synthesis
+of hardware accelerators, on parallelism extraction for embedded systems, on hardware/software
+partitioning and mapping, on metrics for performance estimation of embedded software
+applications and on dynamic reconfigurable devices.
+
+Documentation: https://github.com/ferrandi/PandA-bambu
+
+Sources: https://github.com/ferrandi/PandA-bambu
+
+Installation: https://panda.dei.polimi.it/?page_id=88
+'''
+
+from siliconcompiler.tools.bambu import convert
+
+
+####################################################################
+# Make Docs
+####################################################################
+def make_docs(chip):
+    convert.setup(chip)
+    return chip
+
+
+def parse_version(stdout):
+    # Long multiline output, but second-to-last line looks like:
+    # Version: PandA 0.9.6 - Revision 5e5e306b86383a7d85274d64977a3d71fdcff4fe-main
+    version_line = stdout.split('\n')[-3]
+    return version_line.split()[2]

siliconcompiler/tools/bambu/convert.py

@@ -1,9 +1,19 @@
 import os
+import re
 import shutil
-from siliconcompiler import utils
+from siliconcompiler.utils import sc_open
+from siliconcompiler.tools._common.asic import set_tool_task_var, set_tool_task_lib_var, get_mainlib
+from siliconcompiler.tools._common.asic_clock import get_clock_period, add_clock_requirements
 from siliconcompiler.tools._common import \
     add_frontend_requires, add_require_input, get_frontend_options, get_input_files, \
-    get_tool_task, has_input_files
+    get_tool_task, has_input_files, record_metric
+
+
+def make_docs(chip):
+    from siliconcompiler.targets import freepdk45_demo
+    chip.use(freepdk45_demo)
+    chip.input('<design>.c')
+    return setup(chip)
 
 
 def setup(chip):
@@ -11,13 +21,13 @@ def setup(chip):
     Performs high level synthesis to generate a verilog output
     '''
 
-    if not has_input_files(chip, 'input', 'hll', 'c'):
-        return "no files in [input,hll,c]"
+    if not has_input_files(chip, 'input', 'hll', 'c') and \
+       not has_input_files(chip, 'input', 'hll', 'llvm'):
+        return "no files in [input,hll,c] or [input,hll,llvm]"
 
-    tool = 'bambu'
     step = chip.get('arg', 'step')
     index = chip.get('arg', 'index')
-    _, task = get_tool_task(chip, step, index)
+    tool, task = get_tool_task(chip, step, index)
 
     # Standard Setup
     refdir = 'tools/' + tool
@@ -28,24 +38,41 @@ def setup(chip):
     chip.set('tool', tool, 'task', task, 'refdir', refdir,
              step=step, index=index,
              package='siliconcompiler', clobber=False)
-    chip.set('tool', tool, 'task', task, 'threads', utils.get_cores(chip),
-             step=step, index=index, clobber=False)
 
     # Input/Output requirements
     chip.add('tool', tool, 'task', task, 'output', chip.top() + '.v', step=step, index=index)
 
+    add_clock_requirements(chip)
+
     # Schema requirements
     add_require_input(chip, 'input', 'hll', 'c')
+    add_require_input(chip, 'input', 'hll', 'llvm')
     add_frontend_requires(chip, ['idir', 'define'])
 
+    set_tool_task_var(chip, 'device',
+                      schelp="Device to use during bambu synthesis")
+    set_tool_task_lib_var(chip, 'memorychannels', default_value=1,
+                          schelp="Number of memory channels available")
+
+    # Require clock conversion factor, from library units to ns
+    mainlib = get_mainlib(chip)
+    chip.add('tool', tool, 'task', task, 'require',
+             ','.join(['library', mainlib, 'option', 'var', 'bambu_clock_multiplier']),
+             step=step, index=index)
+
+    set_tool_task_var(chip, 'clock_multiplier',
+                      schelp="Clock multiplier used to convert library units to ns")
+
 
 ################################
 #  Custom runtime options
 ################################
 def runtime_options(chip):
-    cmdlist = []
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
 
-    cmdlist.append('--memory-allocation-policy=NO_BRAM')
+    cmdlist = []
 
     opts = get_frontend_options(chip, ['idir', 'define'])
 
@@ -55,11 +82,34 @@ def runtime_options(chip):
         cmdlist.append('-D' + value)
     for value in get_input_files(chip, 'input', 'hll', 'c'):
         cmdlist.append(value)
+    if not has_input_files(chip, 'input', 'hll', 'c'):
+        # Only use llvm if C is empty
+        for value in get_input_files(chip, 'input', 'hll', 'llvm'):
+            cmdlist.append(value)
 
+    cmdlist.append('--soft-float')
     cmdlist.append('--memory-allocation-policy=NO_BRAM')
 
-    step = chip.get('arg', 'step')
-    index = chip.get('arg', 'index')
+    mem_channels = int(chip.get('tool', tool, 'task', task, 'var', 'memorychannels',
+                                step=step, index=index)[0])
+    if mem_channels > 0:
+        cmdlist.append(f'--channels-number={mem_channels}')
+
+    mainlib = get_mainlib(chip)
+    clock_multiplier = float(chip.get('library', mainlib, 'option', 'var',
+                                      'bambu_clock_multiplier')[0])
+    clock_name, period = get_clock_period(chip, clock_units_multiplier=clock_multiplier)
+    if clock_name:
+        cmdlist.append(f'--clock-name={clock_name}')
+    if period:
+        cmdlist.append(f'--clock-period={period}')
+
+    cmdlist.append('--disable-function-proxy')
+
+    device = chip.get('tool', tool, 'task', task, 'var', 'device',
+                      step=step, index=index)
+    if device:
+        cmdlist.append(f'--device={device[0]}')
 
     cmdlist.append(f'--top-fname={chip.top(step, index)}')
 
@@ -76,3 +126,34 @@ def post_process(chip):
     index = chip.get('arg', 'index')
 
     shutil.copy2(f'{chip.top(step, index)}.v', os.path.join('outputs', f'{chip.top()}.v'))
+
+    ff = re.compile(fr"Total number of flip-flops in function {chip.top(step, index)}: (\d+)")
+    area = re.compile(r"Total estimated area: (\d+)")
+    fmax = re.compile(r"Estimated max frequency \(MHz\): (\d+\.?\d*)")
+    slack = re.compile(r"Minimum slack: (\d+\.?\d*)")
+
+    log_file = f"{step}.log"
+    with sc_open(log_file) as log:
+        for line in log:
+            ff_match = ff.findall(line)
+            area_match = area.findall(line)
+            fmax_match = fmax.findall(line)
+            slack_match = slack.findall(line)
+            if ff_match:
+                record_metric(chip, step, index, "registers", int(ff_match[0]), log_file)
+            if area_match:
+                record_metric(chip, step, index, "cellarea", float(area_match[0]), log_file,
+                              source_unit='um^2')
+            if fmax_match:
+                record_metric(chip, step, index, "fmax", float(fmax_match[0]), log_file,
+                              source_unit='MHz')
+            if slack_match:
+                slack_ns = float(slack_match[0])
+                if slack_ns >= 0:
+                    record_metric(chip, step, index, "setupwns", 0, log_file,
+                                  source_unit='ns')
+                else:
+                    record_metric(chip, step, index, "setupwns", slack_ns, log_file,
+                                  source_unit='ns')
+                record_metric(chip, step, index, "setupslack", slack_ns, log_file,
+                              source_unit='ns')

siliconcompiler/tools/openroad/_apr.py

@@ -148,6 +148,10 @@ def extract_metrics(chip):
 
     metrics_file = "reports/metrics.json"
 
+    if not os.path.exists(metrics_file):
+        chip.logger.warning("OpenROAD metrics file is missing")
+        return
+
     def get_metric_sources(metric):
         metric_sources = [metrics_file]
         if metric in metric_reports:
@@ -572,6 +576,13 @@ def define_rsz_params(chip):
                       default_value='100',
                       schelp='percentage of violating nets to attempt to repair (0 - 100)')
 
+    set_tool_task_var(chip, param_key='rsz_skip_recover_power',
+                      default_value=False,
+                      schelp='skip power recovery')
+    set_tool_task_var(chip, param_key='rsz_recover_power',
+                      default_value=100,
+                      schelp='percentage of paths to attempt to recover power (0 - 100)')
+
     step = chip.get('arg', 'step')
     index = chip.get('arg', 'index')
     tool, task = get_tool_task(chip, step, index)

siliconcompiler/tools/openroad/fillmetal_insertion.py

@@ -43,7 +43,6 @@ def setup(chip):
         'hold',
         'unconstrained',
         'clock_skew',
-        'power',
         'drv_violations',
         'fmax',
 

siliconcompiler/tools/openroad/init_floorplan.py

@@ -1,5 +1,5 @@
 from siliconcompiler.tools._common import input_provides, add_common_file, get_tool_task
-from siliconcompiler.tools._common.asic import set_tool_task_var
+from siliconcompiler.tools._common.asic import set_tool_task_var, get_mainlib
 
 from siliconcompiler.tools.openroad._apr import setup as apr_setup
 from siliconcompiler.tools.openroad._apr import set_reports, set_pnr_inputs, set_pnr_outputs
@@ -74,6 +74,8 @@ def setup(chip):
         'power'
     ])
 
+    mainlib = get_mainlib(chip)
+
     # Setup required
     for component in chip.getkeys('constraint', 'component'):
         for key in chip.getkeys('constraint', 'component', component):
@@ -92,6 +94,10 @@ def setup(chip):
             chip.add('tool', tool, 'task', task, 'require',
                      ','.join(['constraint', ifp]),
                      step=step, index=index)
+    if chip.valid('library', mainlib, 'option', 'file', 'openroad_tracks'):
+        chip.add('tool', tool, 'task', task, 'require',
+                 ','.join(['library', mainlib, 'option', 'file', 'openroad_tracks']),
+                 step=step, index=index)
 
 
 def pre_process(chip):

siliconcompiler/tools/openroad/macro_placement.py

@@ -40,8 +40,7 @@ def setup(chip):
 
     set_reports(chip, [
         'setup',
-        'unconstrained',
-        'power'
+        'unconstrained'
     ])
 
 

siliconcompiler/tools/openroad/pin_placement.py

@@ -38,7 +38,6 @@ def setup(chip):
     set_reports(chip, [
         'setup',
         'unconstrained',
-        'power',
 
         # Images
         'placement_density',

siliconcompiler/tools/openroad/scripts/apr/preamble.tcl

@@ -91,5 +91,6 @@ if { [llength $openroad_dont_touch] > 0 } {
     # set don't touch list
     set_dont_touch $openroad_dont_touch
 }
-tee -file reports/dont_touch.start.rpt {report_dont_touch}
-tee -file reports/dont_use.start.rpt {report_dont_use}
+tee -quiet -file reports/dont_touch.start.rpt {report_dont_touch}
+tee -quiet -file reports/dont_use.start.rpt {report_dont_use}
+tee -file reports/global_connections.start.rpt {report_global_connect}

siliconcompiler/tools/openroad/scripts/apr/sc_init_floorplan.tcl

@@ -25,6 +25,7 @@ if { [sc_cfg_tool_task_exists {file} global_connect] } {
         source $global_connect
     }
 }
+tee -file reports/global_connections.rpt {report_global_connect}
 
 ###############################
 # Initialize floorplan

siliconcompiler/tools/openroad/scripts/apr/sc_power_grid.tcl

@@ -33,6 +33,7 @@ foreach pdnconfig [sc_cfg_tool_task_get {file} pdn_config] {
 
     lappend pdn_files $pdnconfig
 }
+tee -quiet -file reports/power_grid_configuration.rpt {pdngen -report_only}
 pdngen -failed_via_report "reports/${sc_design}_pdngen_failed_vias.rpt"
 
 ###############################

siliconcompiler/tools/openroad/scripts/apr/sc_repair_timing.tcl

@@ -20,6 +20,7 @@ set rsz_hold_slack_margin [lindex [sc_cfg_tool_task_get {var} rsz_hold_slack_mar
 set rsz_slew_margin [lindex [sc_cfg_tool_task_get {var} rsz_slew_margin] 0]
 set rsz_cap_margin [lindex [sc_cfg_tool_task_get {var} rsz_cap_margin] 0]
 set rsz_repair_tns [lindex [sc_cfg_tool_task_get {var} rsz_repair_tns] 0]
+set rsz_recover_power [lindex [sc_cfg_tool_task_get {var} rsz_recover_power] 0]
 
 set repair_timing_args []
 if { [lindex [sc_cfg_tool_task_get {var} rsz_skip_pin_swap] 0] == "true" } {
@@ -77,6 +78,29 @@ if { [lindex [sc_cfg_tool_task_get var rsz_skip_hold_repair] 0] != "true" } {
     sc_set_dont_use
 }
 
+if { [lindex [sc_cfg_tool_task_get var rsz_skip_recover_power] 0] != "true" } {
+    ###############################
+    # Recover power
+    ###############################
+
+    estimate_parasitics -placement
+
+    # Enable cells
+    sc_set_dont_use -hold -scanchain -multibit -report dont_use.repair_timing.power
+
+    repair_timing \
+        -recover_power $rsz_recover_power \
+        -verbose \
+        -setup_margin $rsz_setup_slack_margin \
+        -hold_margin $rsz_hold_slack_margin \
+        {*}$repair_timing_args
+
+    sc_detailed_placement
+
+    # Restore dont use
+    sc_set_dont_use
+}
+
 global_connect
 
 # estimate for metrics

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

@@ -758,6 +758,7 @@ proc sc_set_dont_use { args } {
     }
 
     if { [info exists keys(-report)] } {
-        tee -file reports/$keys(-report).rpt {report_dont_use}
+        puts "Dont use report: reports/$keys(-report).rpt"
+        tee -quiet -file reports/$keys(-report).rpt {report_dont_use}
     }
 }

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

@@ -56,4 +56,5 @@ if { [sc_has_input_files odb "input layout odb"] } {
             source $global_connect
         }
     }
+    tee -file reports/global_connections.rpt {report_global_connect}
 }

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

@@ -168,17 +168,4 @@ foreach markerdb [[ord::get_db_block] getMarkerCategories] {
 
 utl::push_metrics_stage "sc__cellarea__{}"
 tee -file reports/cell_usage.rpt {report_cell_usage -verbose}
-
-foreach modinst [[ord::get_db_block] getModInsts] {
-    tee -quiet -append -file reports/cell_usage.rpt { puts "" }
-    tee -quiet -append -file reports/cell_usage.rpt {
-    puts "########################################################"
-}
-    tee -quiet -append -file reports/cell_usage.rpt { puts "" }
-
-    utl::metric "design__instance__name__in_module:[[$modinst getMaster] getName]" \
-        [$modinst getHierarchicalName]
-    tee -quiet -append -file reports/cell_usage.rpt \
-        "report_cell_usage -verbose [$modinst getHierarchicalName]"
-}
 utl::pop_metrics_stage

siliconcompiler/tools/slang/__init__.py

@@ -120,6 +120,7 @@ def common_runtime_options(chip):
     ###############################
     # Set up user-provided parameters to ensure we elaborate the correct modules
     for param, value in opts['param']:
+        value = value.replace('"', '\\"')
         options.append(f'-G {param}={value}')
 
     return options

siliconcompiler/tools/verilator/verilator.py

@@ -137,6 +137,7 @@ def runtime_options(chip):
         cmdlist.append(value)
 
     for param, value in frontend_opts['param']:
+        value = value.replace('"', '\\"')
         cmdlist.append(f'-G{param}={value}')
 
     if os.path.isfile(f'inputs/{design}.v'):