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

siliconcompiler/_metadata.py

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

siliconcompiler/apps/sc.py

@@ -95,7 +95,7 @@ def main():
 
     try:
         # Run flow
-        chip.run()
+        chip.run(raise_exception=True)
 
         # Print Job Summary
         chip.summary()

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:
@@ -233,6 +248,34 @@ To system debugging information (this should only be used to debug):
             if not install_tool(tool, tools[tool], args.build_dir, args.prefix):
                 return 1
 
+    if not args.show:
+        msgs = []
+        for env, path in (
+                ("PATH", "bin"),
+                ("LD_LIBRARY_PATH", "lib")):
+            check_path = os.path.join(args.prefix, path)
+            envs = [
+                os.path.expandvars(os.path.expanduser(p))
+                for p in os.getenv(env, "").split(":")
+            ]
+            print(envs)
+            if check_path not in envs:
+                msgs.extend([
+                    "",
+                    f"{check_path} not found in {env}",
+                    "you may need to add it the following your shell",
+                    "initialization script:",
+                    f'export {env}="{check_path}:${env}"'
+                ])
+        if msgs:
+            center_len = max(len(msg) for msg in msgs)
+            max_len = center_len + 4
+            print("#"*max_len)
+            for msg in msgs:
+                print(f"# {msg:<{center_len}} #")
+            print(f"# {' '*center_len} #")
+            print("#"*max_len)
+
     return 0
 
 

siliconcompiler/core.py

@@ -67,7 +67,7 @@ class Chip:
         except FileNotFoundError:
             raise SiliconCompilerError(
                 "SiliconCompiler must be run from a directory that exists. "
-                "If you are sure that your working directory is valid, try running `cd $(pwd)`.""")
+                "If you are sure that your working directory is valid, try running `cd $(pwd)`.")
 
         # Initialize custom error handling for codecs. This has to be called
         # by each spawned (as opposed to forked) subprocess
@@ -3153,7 +3153,7 @@ class Chip:
                     self.add('flowgraph', flow, newstep, index, 'input', (newin, in_index))
 
     ###########################################################################
-    def run(self):
+    def run(self, raise_exception=False):
         '''
         Executes tasks in a flowgraph.
 
@@ -3177,12 +3177,23 @@ class Chip:
         processes to exit before start, returning control to the the main
         program which can then exit.
 
+        Args:
+            raise_exception (bool): if True, will rethrow errors that the flow raises,
+                otherwise will report the error and return False
+
         Examples:
             >>> run()
             Runs the execution flow defined by the flowgraph dictionary.
         '''
 
-        sc_runner(self)
+        try:
+            sc_runner(self)
+        except Exception as e:
+            if raise_exception:
+                raise e
+            self.logger.error(str(e))
+            return False
+        return True
 
     ###########################################################################
     def show(self, filename=None, screenshot=False, extension=None):
@@ -3320,7 +3331,7 @@ class Chip:
 
         # run show flow
         try:
-            self.run()
+            self.run(raise_exception=True)
             if screenshot:
                 step, index = _get_flowgraph_exit_nodes(self, flow='showflow')[0]
                 success = self.find_result('png', step=step, index=index)

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/schema/schema_cfg.py

@@ -10,7 +10,7 @@ try:
 except ImportError:
     from siliconcompiler.schema.utils import trim
 
-SCHEMA_VERSION = '0.48.6'
+SCHEMA_VERSION = '0.49.0'
 
 #############################################################################
 # PARAM DEFINITION
@@ -1260,17 +1260,35 @@ def schema_datasheet(cfg, name='default', mode='default'):
             example=[
                 "cli: -datasheet_package_type 'abcd bga'",
                 "api: chip.set('datasheet', 'package', 'abcd', 'type', 'bga')"],
-            schelp="""Package type specified on a named package basis.""")
+            schelp="""Package type.""")
 
     scparam(cfg, ['datasheet', 'package', name, 'footprint'],
-            sctype='str',
+            sctype='[file]',
             shorthelp="Datasheet: package footprint",
-            switch="-datasheet_package_footprint 'name <str>'",
+            switch="-datasheet_package_footprint 'name <file>'",
+            example=[
+                "cli: -datasheet_package_footprint 'abcd ./soic8.kicad_mod'",
+                "api: chip.set('datasheet', 'package', 'abcd', 'footprint', './soic8.kicad_mod')"],
+            schelp="""Package footprint file. Supported 3D model file formats include:
+
+            * (KICAD_MOD) KiCad Standard Footprint Format
+
+            """)
+
+    scparam(cfg, ['datasheet', 'package', name, '3dmodel'],
+            sctype='[file]',
+            shorthelp="Datasheet: package 3D model",
+            switch="-datasheet_package_3dmodel 'name <file>'",
             example=[
-                "cli: -datasheet_package_footprint 'abcd soic8'",
-                "api: chip.set('datasheet', 'package', 'abcd', 'footprint', 'soic8')"],
-            schelp="""Package footprint name. The name of the footprint can be a standard
-            footprint name or a reference designator from a footprint library.""")
+                "cli: -datasheet_package_3dmodel 'abcd ./soic8.step'",
+                "api: chip.set('datasheet', 'package', 'abcd', '3dmodel', './soic8.step')"],
+            schelp="""Package 3D model file. Supported 3D model file formats include:
+
+            * (STEP) Standard for the Exchange of Product Data Format
+            * (STL) Stereolithography Format
+            * (WRL) Virtually Reality Modeling Language Format
+
+            """)
 
     scparam(cfg, ['datasheet', 'package', name, 'drawing'],
             sctype='[file]',
@@ -1279,38 +1297,14 @@ def schema_datasheet(cfg, name='default', mode='default'):
             example=[
                 "cli: -datasheet_package_drawing 'abcd p484.pdf'",
                 "api: chip.set('datasheet', 'package', 'abcd', 'drawing', 'p484.pdf')"],
-            schelp="""Mechanical package outline for documentation purposes.
-            Common file formats include PDF, DOC, SVG, and PNG.""")
+            schelp="""Mechanical drawing for documentation purposes.
+            Supported file formats include: PDF, DOC, SVG, and PNG.""")
 
-    scparam(cfg, ['datasheet', 'package', name, 'pincount'],
-            sctype='int',
-            shorthelp="Datasheet: package total pincount",
-            switch="-datasheet_package_pincount 'name <int>'",
-            example=[
-                "cli: -datasheet_package_pincount 'abcd 484'",
-                "api: chip.set('datasheet', 'package', 'abcd', 'pincount', '484')"],
-            schelp="""Total number package pins of the named package.""")
-
-    scparam(cfg, ['datasheet', 'package', name, 'anchor'],
-            sctype='(float,float)',
-            defvalue=(0.0, 0.0),
-            unit='um',
-            shorthelp="Datasheeet: package anchor",
-            switch="-datasheet_package_anchor 'name <(float,float)>'",
-            example=[
-                "cli: -datasheet_package_anchor 'i0 (3.0,3.0)'",
-                "api: chip.set('datasheet', 'package', 'i0', 'anchor', (3.0, 3.0))"],
-            schelp="""
-            Package anchor point with respect to the lower left corner of the package.
-            When placing a component on a substrate, the placement location specifies
-            the distance from the substrate origin to the anchor point of the placed
-            object.""")
-
-    # critical dimensions
+    # key package metrics
     metrics = {'length': ['length', (4000, 4000, 4000), 'um'],
                'width': ['width', (4000, 4000, 4000), 'um'],
                'thickness': ['thickness', (900, 1000, 1100), 'um'],
-               'pitch': ['pitch', (800, 850, 900), 'um']
+               'pinpitch': ['pin pitch', (800, 850, 900), 'um']
                }
 
     for i, v in metrics.items():
@@ -1322,63 +1316,46 @@ def schema_datasheet(cfg, name='default', mode='default'):
                 example=[
                     f"cli: -datasheet_package_{i} 'abcd {v[1]}'",
                     f"api: chip.set('datasheet', 'package', 'abcd', '{i}', {v[1]}"],
-                schelp=f"""Datasheet: package {v[0]}. Values are tuples of
+                schelp=f"""Package {v[0]}. Values are tuples of
                 (min, nominal, max).""")
 
-    # pinout diagram
-    pinnumber = 'default'
-    scparam(cfg, ['datasheet', 'package', name, 'pin', pinnumber, 'shape'],
-            sctype='enum',
-            enum=['circle', 'rectangle', 'square', 'octagon'],
-            shorthelp="Datasheet: package pin shape",
-            switch="-datasheet_package_pin_shape 'name pinnumber <str>'",
+    # pin
+    scparam(cfg, ['datasheet', 'package', name, 'pincount'],
+            sctype='int',
+            shorthelp="Datasheet: package pin count",
+            switch="-datasheet_package_pincount 'name <int>'",
             example=[
-                "cli: -datasheet_package_pin_shape 'abcd B1 circle'",
-                "api: chip.set('datasheet', 'package', 'abcd', 'pin', 'B1', 'shape', 'circle')"],
-            schelp="""Datasheet: package pin shape specified on a per package
-            and per pin number basis.""")
-
-    metrics = {'width': ['width', (200, 250, 300), 'um'],
-               'length': ['length', (200, 250, 300), 'um']
-               }
+                "cli: -datasheet_package_pincount 'abcd 484'",
+                "api: chip.set('datasheet', 'package', 'abcd', 'pincount', '484')"],
+            schelp="""Total number package pins.""")
 
-    for i, v in metrics.items():
-        scparam(cfg, ['datasheet', 'package', name, 'pin', pinnumber, i],
-                unit=v[2],
-                sctype='(float,float,float)',
-                shorthelp=f"Datasheet: package pin {v[0]}",
-                switch=f"-datasheet_package_pin_{i} 'name pinnumber <(float,float,float)>'",
-                example=[
-                    f"cli: -datasheet_package_pin_{i} 'abcd B1 {v[1]}'",
-                    f"api: chip.set('datasheet', 'package', 'abcd', 'pin', 'B1', '{i}', {v[1]}"],
-                schelp=f"""Datsheet: {v[0]} specified on a per package and per pin number
-                basis. Values are tuples of (min, nominal, max).""")
+    number = 'default'
+    scparam(cfg, ['datasheet', 'package', name, 'pin', number, 'signal'],
+            sctype='str',
+            shorthelp="Datasheet: package pin signal map",
+            switch="-datasheet_package_pin_signal 'name number <str>'",
+            example=[
+                "cli: -datasheet_package_pin_signal 'abcd B1 clk'",
+                "api: chip.set('datasheet', 'package', 'abcd', 'pin', 'B1', 'signal', 'clk')"],
+            schelp="""Mapping between the package physical pin name ("1", "2", "A1", "B3", ...)
+            and the corresponding device signal name ("VDD", "CLK", "NRST") found in the
+            :keypath:`datasheet,pin`.""")
 
-    scparam(cfg, ['datasheet', 'package', name, 'pin', pinnumber, 'loc'],
+    # anchor
+    scparam(cfg, ['datasheet', 'package', name, 'anchor'],
             sctype='(float,float)',
+            defvalue=(0.0, 0.0),
             unit='um',
-            shorthelp="Datasheet: package pin location",
-            switch="-datasheet_package_pin_loc 'name pinnumber <(float,float)>'",
+            shorthelp="Datasheet: package anchor",
+            switch="-datasheet_package_anchor 'name <(float,float)>'",
             example=[
-                "cli: -datasheet_package_pin_loc 'abcd B1 (500,500)'",
-                "api: chip.set('datasheet', 'package', 'abcd', 'pin', 'B1', 'loc', (500,500)"],
-            schelp="""Datsheet: Package pin location specified as an (x,y) tuple on a per
-            package and per pin number basis. Locations specify the center of the pin with
-            respect to the center of the package.""")
-
-    scparam(cfg, ['datasheet', 'package', name, 'pin', pinnumber, 'name'],
-            sctype='str',
-            shorthelp="Datasheet: package pin name",
-            switch="-datasheet_package_pin_name 'name pinnumber <str>'",
-            example=[
-                "cli: -datasheet_package_pin_name 'abcd B1 clk'",
-                "api: chip.set('datasheet', 'package', 'abcd', 'pin', 'B1', 'name', 'clk')"],
-            schelp="""Datsheet: Package pin name specified on a per package and per pin
-            number basis. The pin number is generally an integer starting at '1' in the case of
-            packages like qfn, qfp and an array index ('A1', 'A2') in the case of array packages
-            like bgas. The pin name refers to the logical function assigned to the physical
-            pin number (e.g clk, vss, in). Details regarding the logical pin is stored in
-            the :keypath:`datasheet,pin`.""")
+                "cli: -datasheet_package_anchor 'i0 (3.0, 3.0)'",
+                "api: chip.set('datasheet', 'package', 'i0', 'anchor', (3.0, 3.0))"],
+            schelp="""
+            Package anchor point with respect to the lower left corner of the package.
+            When placing a component on a substrate, the placement location specifies
+            the distance from the substrate origin to the anchor point of the placed
+            object.""")
 
     ######################
     # Pin Specifications
@@ -3784,10 +3761,11 @@ def schema_constraint(cfg):
                 "api: chip.set('constraint', 'component', 'i0', 'halo', (1, 1))"],
             schelp="""
             Placement keepout halo around the named component, specified as a
-            (horizontal, vertical) tuple represented in microns.""")
+            (horizontal, vertical) tuple.""")
 
     scparam(cfg, ['constraint', 'component', inst, 'rotation'],
             sctype='enum',
+            pernode='optional',
             defvalue='R0',
             enum=['R0', 'R90', 'R180', 'R270',
                   'MX', 'MX_R90', 'MX_R180', 'MX_R270',
@@ -3795,7 +3773,6 @@ def schema_constraint(cfg):
                   'MZ', 'MZ_R90', 'MZ_R180', 'MZ_R270',
                   'MZ_MX', 'MZ_MX_R90', 'MZ_MX_R180', 'MZ_MX_R270',
                   'MZ_MY', 'MZ_MY_R90', 'MZ_MY_R180', 'MZ_MY_R270'],
-            pernode='optional',
             shorthelp="Constraint: component rotation",
             switch="-constraint_component_rotation 'inst <str>'",
             example=[
@@ -3829,6 +3806,49 @@ def schema_constraint(cfg):
         * ``MZ_MX_R270``, ``MZ_MY_R90``: Reverse metal stack, flip on x-axis and rotate 270 deg ccw
             """)
 
+    scparam(cfg, ['constraint', 'component', inst, 'substrate'],
+            sctype='str',
+            pernode='optional',
+            shorthelp="Constraint: component substrate",
+            switch="-constraint_component_substrate 'inst <str>'",
+            example=[
+                "cli: -constraint_component_substrate 'i0 pcb0'",
+                "api: chip.set('constraint', 'component', 'i0', 'substrate', 'pcb0')"],
+            schelp="""
+            Substrates are supporting material that components are placed upon.
+            List of supported substrates includes (but not limited to):
+            wafers, dies, panels, PCBs.""")
+
+    scparam(cfg, ['constraint', 'component', inst, 'side'],
+            sctype='enum',
+            enum=['left', 'right', 'front', 'back', 'top', 'bottom'],
+            pernode='optional',
+            shorthelp="Constraint: component side",
+            switch="-constraint_component_side 'inst <str>'",
+            example=[
+                "cli: -constraint_component_side 'i0 top'",
+                "api: chip.set('constraint', 'component', 'i0', 'side', 'top')"],
+            schelp="""
+            Side of the substrate where the component should be placed. The `side`
+            definitions are with respect to a viewer looking sideways at an object.
+            Top is towards the sky, front is the side closest to the viewer, and
+            right is right. The maximum number of sides per substrate is six""")
+
+    scparam(cfg, ['constraint', 'component', inst, 'zheight'],
+            sctype='float',
+            pernode='optional',
+            unit='um',
+            shorthelp="Constraint: component placement zheight",
+            switch="-constraint_component_zheight 'inst <float>'",
+            example=[
+                "cli: -constraint_component_zheight 'i0 100.0'",
+                "api: chip.set('constraint', 'component', 'i0', 'zheight', 100.0)"],
+            schelp="""
+            Height above the substrate for component placement. The space
+            between the component and substrate is occupied by material,
+            supporting scaffolding, and electrical connections (eg. bumps,
+            vias, pillars).""")
+
     # PINS
     name = 'default'
     scparam(cfg, ['constraint', 'pin', name, 'placement'],
@@ -3848,6 +3868,44 @@ def schema_constraint(cfg):
             may adjust sizes to meet competing goals such as manufacturing design
             rules and grid placement guidelines.""")
 
+    metrics = {'width': ['width', 1.0],
+               'length': ['length', 1.0],
+               'height': ['height', 1.0]
+               }
+
+    for i, v in metrics.items():
+        scparam(cfg, ['constraint', 'pin', name, i],
+                sctype='float',
+                unit='um',
+                pernode='optional',
+                shorthelp=f"Constraint: pin {i}",
+                switch=f"-constraint_pin_{i} 'name <float>'",
+                example=[
+                    f"cli: -constraint_pin_{i} 'nreset {v[1]}'",
+                    f"api: chip.set('constraint', 'pin', 'nreset', {i}, {v[1]})"],
+                schelp=f"""
+                Pin {i} constraint. This parameter represents goal/intent, not an exact
+                specification. The layout system may adjust sizes to meet
+                competing goals such as manufacturing design rules and grid placement
+                guidelines.""")
+
+    scparam(cfg, ['constraint', 'pin', name, 'shape'],
+            sctype='enum',
+            enum=['circle', 'rectangle', 'square',
+                  'hexagon', 'octagon', 'oval', 'pill', 'polygon'],
+            pernode='optional',
+            shorthelp="Constraint: pin shape",
+            switch="-constraint_pin_shape 'name <str>'",
+            example=[
+                "cli: -constraint_pin_shape 'nreset circle'",
+                "api: chip.set('constraint', 'pin', 'nreset', 'shape', 'circle')"],
+            schelp="""
+            Pin shape constraint specified on a per pin basis. In 3D design systems,
+            the pin shape represents the cross section of the pin in the direction
+            orthogonal to the signal flow direction. The 'pill' (aka stadium) shape,
+            is rectangle with semicircles at a pair of opposite sides. The other
+            pin shapes represent common geometric shape definitions.""")
+
     scparam(cfg, ['constraint', 'pin', name, 'layer'],
             sctype='str',
             pernode='optional',
@@ -3903,8 +3961,8 @@ def schema_constraint(cfg):
                 "cli: -constraint_net_maxlength 'nreset 1000'",
                 "api: chip.set('constraint', 'net', 'nreset', 'maxlength', '1000')"],
             schelp="""
-            Maximum total length of a net, specified in microns.
-            Wildcards ('*') can be used for net names.""")
+            Maximum total length of a net. Wildcards ('*') can be used for
+            net names.""")
 
     scparam(cfg, ['constraint', 'net', name, 'maxresistance'],
             sctype='float',
@@ -3930,9 +3988,8 @@ def schema_constraint(cfg):
                 "api: chip.set('constraint', 'net', 'nreset', 'ndr', (0.4, 0.4))"],
             schelp="""
             Definitions of non-default routing rule specified on a per
-            net basis. Constraints are entered as a (width, space) tuples
-            specified in microns. Wildcards ('*') can be used
-            for net names.""")
+            net basis. Constraints are entered as a (width, space) tuples.
+            Wildcards ('*') can be used for net names.""")
 
     scparam(cfg, ['constraint', 'net', name, 'minlayer'],
             sctype='str',

siliconcompiler/tools/__init__.py

@@ -1,11 +1,12 @@
-from siliconcompiler.tools.bambu import bambu
-from siliconcompiler.tools.bluespec import bluespec
+from siliconcompiler.tools import bambu
+from siliconcompiler.tools import bluespec
 from siliconcompiler.tools.builtin import builtin
 from siliconcompiler.tools.chisel import chisel
 from siliconcompiler.tools.execute import execute
 from siliconcompiler.tools.genfasm import genfasm
 from siliconcompiler.tools.ghdl import ghdl
 from siliconcompiler.tools import gtkwave
+from siliconcompiler.tools import graphviz
 from siliconcompiler.tools.icarus import icarus
 from siliconcompiler.tools.icepack import icepack
 from siliconcompiler.tools.klayout import klayout
@@ -39,6 +40,7 @@ def get_tools():
             execute,
             genfasm,
             ghdl,
+            graphviz,
             gtkwave,
             icarus,
             icepack,

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)