siliconcompiler 0.29.2__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.2'
+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
 
 
@@ -168,10 +174,15 @@ To system debugging information (this should only be used to debug):
     parser = argparse.ArgumentParser(
         prog=progname,
         description=description,
-        formatter_class=argparse.RawDescriptionHelpFormatter)
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
 
     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/core.py

@@ -21,6 +21,7 @@ from siliconcompiler.remote import client
 from siliconcompiler.schema import Schema, SCHEMA_VERSION
 from siliconcompiler.schema import utils as schema_utils
 from siliconcompiler import utils
+from siliconcompiler.utils.logging import LoggerFormatter, ColorStreamFormatter
 from siliconcompiler import _metadata
 from siliconcompiler import NodeStatus, SiliconCompilerError
 from siliconcompiler.report import _show_summary_table
@@ -225,7 +226,8 @@ class Chip:
         else:
             in_run = False
 
-        log_format = ['%(levelname)-7s']
+        level_format = '%(levelname)-7s'
+        log_format = [level_format]
         if loglevel == 'debug':
             log_format.append('%(funcName)-10s')
             log_format.append('%(lineno)-4s')
@@ -261,14 +263,17 @@ class Chip:
             log_formatprefix = ""
 
         log_format.append('%(message)s')
-        logformat = log_formatprefix + ' | '.join(log_format)
+        stream_logformat = log_formatprefix + ' | '.join(log_format[1:])
 
         if not self.logger.hasHandlers():
             stream_handler = logging.StreamHandler(stream=sys.stdout)
             self.logger.addHandler(stream_handler)
 
         for handler in self.logger.handlers:
-            formatter = logging.Formatter(logformat)
+            if ColorStreamFormatter.supports_color(handler):
+                formatter = ColorStreamFormatter(log_formatprefix, level_format, stream_logformat)
+            else:
+                formatter = LoggerFormatter(log_formatprefix, level_format, stream_logformat)
             handler.setFormatter(formatter)
 
         self.logger.setLevel(schema_utils.translate_loglevel(loglevel))

siliconcompiler/flowgraph.py

@@ -205,18 +205,36 @@ def _get_flowgraph_execution_order(chip, flow, reverse=False):
             else:
                 ex_map.setdefault((istep, iindex), set()).add((step, index))
 
+    rev_ex_map = {}
+    for node, edges in ex_map.items():
+        for step, index in edges:
+            rev_ex_map.setdefault((step, index), set()).add(node)
+
     # Collect execution order of nodes
     if reverse:
         order = [set(_get_flowgraph_exit_nodes(chip, flow))]
     else:
         order = [set(_get_flowgraph_entry_nodes(chip, flow))]
 
+    visited = set()
     while True:
         next_level = set()
-        for step, index in order[-1]:
-            if (step, index) in ex_map and \
-               not any([(step, index) in v for v in ex_map.values()]):
-                next_level.update(ex_map.pop((step, index)))
+        next_visited = set()
+        for step, index in sorted(order[-1]):
+            if (step, index) not in rev_ex_map:
+                # No edges so assume inputs are okay
+                inputs_valid = True
+            else:
+                inputs_valid = all([node in visited for node in rev_ex_map[(step, index)]])
+
+            if inputs_valid:
+                next_visited.add((step, index))
+                if (step, index) in ex_map:
+                    next_level.update(ex_map.pop((step, index)))
+            else:
+                next_level.add((step, index))
+
+        visited.update(next_visited)
 
         if not next_level:
             break
@@ -233,7 +251,7 @@ def _get_flowgraph_execution_order(chip, flow, reverse=False):
 
     exec_order.reverse()
 
-    return exec_order
+    return [sorted(level) for level in exec_order]
 
 
 def get_executed_nodes(chip, flow):

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

@@ -55,6 +55,10 @@ def _get_callback(hook):
     return None
 
 
+# Max lines to print from failed node log
+_failed_log_lines = 20
+
+
 ###############################################################################
 class SiliconCompilerTimeout(Exception):
     ''' Minimal Exception wrapper used to raise sc timeout errors.
@@ -833,6 +837,8 @@ def _run_executable_or_builtin(chip, step, index, version, toolpath, workdir, ru
     is_stderr_log = chip.get('tool', tool, 'task', task, 'stderr', 'destination',
                              step=step, index=index) == 'log' and stderr_file != stdout_file
 
+    chip.logger.info(f'Running in {workdir}')
+
     retcode = 0
     cmdlist = []
     cmd_args = []
@@ -877,7 +883,6 @@ def _run_executable_or_builtin(chip, step, index, version, toolpath, workdir, ru
         # Make record of tool options
         __record_tool(chip, step, index, version, toolpath, cmd_args)
 
-        chip.logger.info('Running in %s', workdir)
         chip.logger.info('%s', printable_cmd)
         timeout = chip.get('option', 'timeout', step=step, index=index)
         logfile = step + '.log'
@@ -988,10 +993,10 @@ def _run_executable_or_builtin(chip, step, index, version, toolpath, workdir, ru
         msg = f'Command failed with code {retcode}.'
         if logfile:
             if quiet:
-                # Print last 10 lines of log when in quiet mode
+                # Print last N lines of log when in quiet mode
                 with sc_open(logfile) as logfd:
                     loglines = logfd.read().splitlines()
-                    for logline in loglines[-10:]:
+                    for logline in loglines[-_failed_log_lines:]:
                         chip.logger.error(logline)
                 # No log file for pure-Python tools.
             msg += f' See log file {os.path.abspath(logfile)}'
@@ -1239,6 +1244,13 @@ def _finalizenode(chip, step, index, replay):
 
     if not is_skipped:
         _check_logfile(chip, step, index, quiet, run_func)
+
+    # Report metrics
+    for metric in ['errors', 'warnings']:
+        val = chip.get('metric', metric, step=step, index=index)
+        if val is not None:
+            chip.logger.info(f'Number of {metric}: {val}')
+
     _hash_files(chip, step, index)
 
     # Capture wall runtime and cpu cores
@@ -1535,12 +1547,13 @@ def _check_node_dependencies(chip, node, deps, deps_was_successful):
 def _launch_nodes(chip, nodes_to_run, processes, local_processes):
     running_nodes = {}
     max_parallel_run = chip.get('option', 'scheduler', 'maxnodes')
-    max_threads = os.cpu_count()
+    max_cores = utils.get_cores(chip)
+    max_threads = utils.get_cores(chip)
     if not max_parallel_run:
-        max_parallel_run = max_threads
+        max_parallel_run = utils.get_cores(chip)
 
-    # clip max parallel jobs to 1 <= jobs <= max_threads
-    max_parallel_run = max(1, min(max_parallel_run, max_threads))
+    # clip max parallel jobs to 1 <= jobs <= max_cores
+    max_parallel_run = max(1, min(max_parallel_run, max_cores))
 
     def allow_start(node):
         if node not in local_processes:
@@ -1561,7 +1574,7 @@ def _launch_nodes(chip, nodes_to_run, processes, local_processes):
         # clamp to max_parallel to avoid getting locked up
         requested_threads = max(1, min(requested_threads, max_threads))
 
-        if requested_threads + sum(running_nodes.values()) > max_threads:
+        if requested_threads + sum(running_nodes.values()) > max_cores:
             # delay until there are enough core available
             return False, 0
 
@@ -1615,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):
@@ -1936,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
@@ -2062,7 +2081,6 @@ def check_logfile(chip, jobname=None, step=None, index='0',
                             chip.logger.info(f'{suffix}: {line_with_num}')
 
     for suffix in ordered_suffixes:
-        chip.logger.info(f'Number of {suffix}: {matches[suffix]}')
         checks[suffix]['report'].close()
 
     return matches

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,8 +1,19 @@
 import os
+import re
 import shutil
+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):
@@ -10,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
@@ -27,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', os.cpu_count(),
-             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'])
 
@@ -54,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)}')
 
@@ -75,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/bluespec/convert.py

@@ -3,6 +3,7 @@ import shutil
 from siliconcompiler.tools._common import \
     add_require_input, add_frontend_requires, get_frontend_options, get_input_files, \
     get_tool_task, has_input_files
+from siliconcompiler import utils
 from siliconcompiler import sc_open
 
 # Directory inside step/index dir to store bsc intermediate results.
@@ -33,7 +34,7 @@ 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', os.cpu_count(),
+    chip.set('tool', tool, 'task', task, 'threads', utils.get_cores(chip),
              step=step, index=index, clobber=False)
 
     # Input/Output requirements

siliconcompiler/tools/chisel/convert.py

@@ -3,6 +3,7 @@ import shutil
 import glob
 from siliconcompiler.tools._common import add_frontend_requires, get_tool_task, has_input_files
 from siliconcompiler import sc_open, SiliconCompilerError
+from siliconcompiler import utils
 
 
 def setup(chip):
@@ -28,7 +29,7 @@ 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', os.cpu_count(),
+    chip.set('tool', tool, 'task', task, 'threads', utils.get_cores(chip),
              step=step, index=index, clobber=False)
 
     chip.set('tool', tool, 'task', task, 'option', ['-batch',

siliconcompiler/tools/genfasm/bitstream.py

@@ -1,5 +1,5 @@
-import os
 import shutil
+from siliconcompiler import utils
 from siliconcompiler.tools.genfasm import genfasm
 from siliconcompiler.tools.vpr import vpr
 from siliconcompiler.tools._common import get_tool_task
@@ -15,7 +15,7 @@ def setup(chip):
     index = chip.get('arg', 'index')
     tool, task = get_tool_task(chip, step, index)
 
-    chip.set('tool', tool, 'task', task, 'threads', os.cpu_count(),
+    chip.set('tool', tool, 'task', task, 'threads', utils.get_cores(chip),
              step=step, index=index, clobber=False)
 
     chip.set('tool', tool, 'task', task, 'regex', 'warnings', "^Warning",

siliconcompiler/tools/ghdl/convert.py

@@ -1,6 +1,6 @@
-import os
 from siliconcompiler.tools._common import add_require_input, add_frontend_requires, \
     get_input_files, get_tool_task, has_input_files
+from siliconcompiler import utils
 
 
 def setup(chip):
@@ -23,7 +23,7 @@ def setup(chip):
     chip.set('tool', tool, 'vswitch', '--version')
     chip.set('tool', tool, 'version', '>=4.0.0-dev', clobber=clobber)
 
-    chip.set('tool', tool, 'task', task, 'threads', os.cpu_count(),
+    chip.set('tool', tool, 'task', task, 'threads', utils.get_cores(chip),
              step=step, index=index, clobber=clobber)
     chip.set('tool', tool, 'task', task, 'option', '',
              step=step, index=index, clobber=clobber)