siliconcompiler 0.28.3__py3-none-any.whl → 0.28.5__py3-none-any.whl

siliconcompiler/_metadata.py

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

siliconcompiler/apps/_common.py

@@ -1,7 +1,11 @@
-import glob
 import os
 
 
+# TODO: this is a hack to get around design name requirement: since legal
+# design names probably can't contain spaces, we can detect if it is unset.
+UNSET_DESIGN = '  unset  '
+
+
 def manifest_switches():
     '''
     Returns a list of manifest switches that can be used
@@ -14,63 +18,91 @@ def manifest_switches():
             '-jobname']
 
 
-def load_manifest(chip, src_file):
-    manifest = None
-    if (src_file is not None) and (not chip.get('option', 'cfg')):
-        if not os.path.exists(src_file):
-            chip.logger.error(f'{src_file} cannot be found.')
-            return False
-        # only autoload manifest if user doesn't supply manually
-        manifest = _get_manifest(os.path.dirname(src_file))
-        if not manifest:
-            design = os.path.splitext(os.path.basename(src_file))[0]
-            chip.logger.error(f'Unable to automatically find manifest for design {design}. '
-                              'Please provide a manifest explicitly using -cfg.')
-            return False
-    elif not chip.get('option', 'cfg'):
-        manifest = _get_manifest_from_design(chip)
-        if not manifest:
-            chip.logger.error(f'Could not find manifest for {chip.design}')
-            return False
+def _get_manifests(cwd):
+    manifests = {}
 
-    if manifest:
-        chip.logger.info(f'Loading manifest: {manifest}')
-        chip.read_manifest(manifest)
-    return True
-
-
-def _get_manifest(dirname, design='*'):
-    # pkg.json file may have a different name from the design due to the entrypoint
-    glob_paths = [os.path.join(dirname, f'{design}.pkg.json'),
-                  os.path.join(dirname, 'outputs', f'{design}.pkg.json')]
-    manifest = None
-    for path in glob_paths:
-        manifest = glob.glob(path)
-        if manifest:
-            manifest = manifest[0]
-            break
-
-    if not manifest or not os.path.isfile(manifest):
+    def get_dirs(cwd):
+        dirs = []
+        for dirname in os.listdir(cwd):
+            fullpath = os.path.join(cwd, dirname)
+            if os.path.isdir(fullpath):
+                dirs.append((dirname, fullpath))
+        return dirs
+
+    for _, buildpath in get_dirs(cwd):
+        for design, designdir in get_dirs(buildpath):
+            for jobname, jobdir in get_dirs(designdir):
+                manifest = os.path.join(jobdir, f'{design}.pkg.json')
+                if os.path.isfile(manifest):
+                    manifests[(design, jobname, None, None)] = manifest
+                for step, stepdir in get_dirs(jobdir):
+                    for index, indexdir in get_dirs(stepdir):
+                        manifest = os.path.join(indexdir, 'outputs', f'{design}.pkg.json')
+                        if os.path.isfile(manifest):
+                            manifests[(design, jobname, step, index)] = manifest
+                        else:
+                            manifest = os.path.join(indexdir, 'inputs', f'{design}.pkg.json')
+                            if os.path.isfile(manifest):
+                                manifests[(design, jobname, step, index)] = manifest
+
+    organized_manifest = {}
+    for (design, job, step, index), manifest in manifests.items():
+        jobs = organized_manifest.setdefault(design, {})
+        jobs.setdefault(job, {})[step, index] = os.path.abspath(manifest)
+
+    return organized_manifest
+
+
+def pick_manifest_from_file(chip, src_file, all_manifests):
+    if src_file is None:
         return None
-    return manifest
 
+    if not os.path.exists(src_file):
+        chip.logger.error(f'{src_file} cannot be found.')
+        return None
+
+    src_dir = os.path.abspath(os.path.dirname(src_file))
+    for _, jobs in all_manifests.items():
+        for _, nodes in jobs.items():
+            for manifest in nodes.values():
+                if src_dir == os.path.dirname(manifest):
+                    return manifest
 
-def _get_manifest_from_design(chip):
-    for jobname, step, index in [
-            (chip.get('option', 'jobname'),
-             chip.get('arg', 'step'),
-             chip.get('arg', 'index')),
-            (chip.get('option', 'jobname'),
-             None,
-             None),
-            (chip.schema.get_default('option', 'jobname'),
-             chip.get('arg', 'step'),
-             chip.get('arg', 'index')),
-            (chip.schema.get_default('option', 'jobname'),
-             None,
-             None)]:
-        manifest = _get_manifest(chip.getworkdir(jobname=jobname, step=step, index=index))
-
-        if manifest:
-            return manifest
     return None
+
+
+def pick_manifest(chip, src_file=None):
+    all_manifests = _get_manifests(os.getcwd())
+
+    manifest = pick_manifest_from_file(chip, src_file, all_manifests)
+    if manifest:
+        return manifest
+
+    if chip.design == UNSET_DESIGN:
+        if len(all_manifests) == 1:
+            chip.set('design', list(all_manifests.keys())[0])
+        else:
+            chip.logger.error('Design name is not set')
+            return None
+
+    if chip.design not in all_manifests:
+        chip.logger.error(f'Could not find manifest for {chip.design}')
+        return None
+
+    if chip.get('option', 'jobname') not in all_manifests[chip.design] and \
+            len(all_manifests[chip.design]) != 1:
+        chip.logger.error(f'Could not determine jobname for {chip.design}')
+        return None
+
+    jobname = chip.get('option', 'jobname')
+    if chip.get('option', 'jobname') not in all_manifests[chip.design]:
+        jobname = list(all_manifests[chip.design].keys())[0]
+
+    if (None, None) in all_manifests[chip.design][jobname]:
+        manifest = all_manifests[chip.design][jobname][None, None]
+    else:
+        # pick newest manifest
+        manifest = list(sorted(all_manifests[chip.design][jobname].values(),
+                               key=lambda file: os.stat(file).st_ctime))[-1]
+
+    return manifest

siliconcompiler/apps/sc.py

@@ -10,6 +10,37 @@ from siliconcompiler.targets import skywater130_demo
 from siliconcompiler import SiliconCompilerError
 
 
+def _infer_designname(chip):
+    topfile = None
+    sourcesets = chip.getkeys('input')
+    for sourceset in reversed(('rtl', 'hll')):
+        if sourceset in sourcesets:
+            sourcesets.remove(sourceset)
+            sourcesets.insert(0, sourceset)
+    for sourceset in sourcesets:
+        for filetype in chip.getkeys('input', sourceset):
+            all_vals = chip.schema._getvals('input', sourceset, filetype)
+            if all_vals:
+                # just look at first value
+                sources, _, _ = all_vals[0]
+                # grab first source
+                topfile = sources[0]
+                break
+        if topfile:
+            break
+
+    if not topfile:
+        return None
+
+    root = os.path.basename(topfile)
+    while True:
+        root, ext = os.path.splitext(root)
+        if not ext:
+            break
+
+    return root
+
+
 ###########################
 def main():
     progname = "sc"
@@ -50,24 +81,12 @@ def main():
 
     # Set design if none specified
     if chip.get('design') == UNSET_DESIGN:
-        topfile = None
-        for sourceset in ('rtl', 'hll'):
-            for filetype in chip.getkeys('input', sourceset):
-                all_vals = chip.schema._getvals('input', sourceset, filetype)
-                if all_vals:
-                    # just look at first value
-                    sources, _, _ = all_vals[0]
-                    # grab first source
-                    topfile = sources[0]
-                    break
-            if topfile:
-                break
+        topmodule = _infer_designname(chip)
 
-        if not topfile:
+        if not topmodule:
             chip.logger.error('Invalid arguments: either specify -design or provide sources.')
             return 1
 
-        topmodule = os.path.splitext(os.path.basename(topfile))[0]
         chip.set('design', topmodule)
 
     # Set demo target if none specified

siliconcompiler/apps/sc_dashboard.py

@@ -2,7 +2,7 @@
 import sys
 import siliconcompiler
 import os
-from siliconcompiler.apps._common import load_manifest, manifest_switches
+from siliconcompiler.apps._common import pick_manifest, manifest_switches, UNSET_DESIGN
 
 
 def main():
@@ -11,9 +11,16 @@ def main():
 -----------------------------------------------------------
 SC app to open a dashboard for a given manifest.
 
-To open:
+To open and allow sc-dashboard to autoload manifest:
+    sc-dashboard
+
+To open by specifying manifest:
     sc-dashboard -cfg <path to manifest>
 
+To open by specifying design and optionally jobname:
+    sc-dashboard -design <name>
+    sc-dashboard -design <name> -jobname <jobname>
+
 To specify a different port than the default:
     sc-dashboard -cfg <path to manifest> -port 10000
 
@@ -23,10 +30,6 @@ To include another chip object to compare to:
 -----------------------------------------------------------
 """
 
-    # TODO: this is a hack to get around design name requirement: since legal
-    # design names probably can't contain spaces, we can detect if it is unset.
-    UNSET_DESIGN = '  unset  '
-
     # Create a base chip class.
     chip = siliconcompiler.Chip(UNSET_DESIGN)
 
@@ -54,15 +57,19 @@ To include another chip object to compare to:
         chip.logger.error(e)
         return 1
 
+    if not chip.get('option', 'cfg'):
+        manifest = pick_manifest(chip)
+
+        if manifest:
+            chip.logger.info(f'Loading manifest: {manifest}')
+            chip.read_manifest(manifest)
+
     # Error checking
     design = chip.get('design')
     if design == UNSET_DESIGN:
         chip.logger.error('Design not loaded')
         return 1
 
-    if not load_manifest(chip, None):
-        return 1
-
     graph_chips = []
     if switches['graph_cfg']:
         for i, name_and_file_path in enumerate(switches['graph_cfg']):
@@ -88,7 +95,7 @@ To include another chip object to compare to:
                 'cfg_path': os.path.abspath(file_path)
             })
 
-    chip._dashboard(wait=True, port=switches['port'], graph_chips=graph_chips)
+    chip.dashboard(wait=True, port=switches['port'], graph_chips=graph_chips)
 
     return 0
 

siliconcompiler/apps/sc_show.py

@@ -3,7 +3,7 @@ import sys
 import os
 import siliconcompiler
 from siliconcompiler.utils import get_default_iomap
-from siliconcompiler.apps._common import load_manifest, manifest_switches
+from siliconcompiler.apps._common import manifest_switches, pick_manifest, UNSET_DESIGN
 from siliconcompiler.utils import get_file_ext
 
 
@@ -18,6 +18,9 @@ def main():
 
     Examples:
 
+    sc-show
+    (displays build/adder/job0/write_gds/0/outputs/adder.gds)
+
     sc-show -design adder
     (displays build/adder/job0/write_gds/0/outputs/adder.gds)
 
@@ -40,10 +43,6 @@ def main():
     (displays build/adder/job0/route/1/outputs/adder.def)
     """
 
-    # TODO: this is a hack to get around design name requirement: since legal
-    # design names probably can't contain spaces, we can detect if it is unset.
-    UNSET_DESIGN = '  unset  '
-
     # Create a base chip class.
     chip = siliconcompiler.Chip(UNSET_DESIGN)
 
@@ -81,10 +80,6 @@ def main():
         chip.logger.error(e)
         return 1
 
-    # Error checking
-    design = chip.get('design')
-    design_set = design != UNSET_DESIGN
-
     # Search input keys for files
     input_mode = []
     for fileset in chip.getkeys('input'):
@@ -92,11 +87,6 @@ def main():
             if chip.schema._getvals('input', fileset, mode):
                 input_mode = [('input', fileset, mode)]
 
-    if not (design_set or input_mode):
-        chip.logger.error('Nothing to load: please define a target with '
-                          '-cfg, -design, and/or inputs.')
-        return 1
-
     filename = None
     if input_mode:
         check_ext = list(chip._showtools.keys())
@@ -115,7 +105,19 @@ def main():
 
         filename = get_file_from_keys()
 
-    if not load_manifest(chip, filename):
+    # Attempt to load a manifest
+    if not chip.get('option', 'cfg'):
+        manifest = pick_manifest(chip, src_file=filename)
+        if manifest:
+            chip.logger.info(f'Loading manifest: {manifest}')
+            chip.read_manifest(manifest)
+
+    # Error checking
+    design = chip.get('design')
+    design_set = design != UNSET_DESIGN
+    if not (design_set or input_mode):
+        chip.logger.error('Nothing to load: please define a target with '
+                          '-cfg, -design, and/or inputs.')
         return 1
 
     # Read in file

siliconcompiler/core.py

@@ -1363,7 +1363,7 @@ class Chip:
             basename = str(pathlib.PurePosixPath(*path_paths[0:n]))
             endname = str(pathlib.PurePosixPath(*path_paths[n:]))
 
-            import_name = self.__get_imported_filename(basename, package)
+            import_name = utils.get_hashed_filename(basename, package=package)
             if import_name not in collected_files:
                 continue
 
@@ -2051,6 +2051,30 @@ class Chip:
             dot.graph_attr['ranksep'] = '0.75'
         dot.attr(bgcolor=background)
 
+        subgraphs = {
+            "graphs": {
+                "sc-inputs": {
+                    "graphs": {},
+                    "nodes": []
+                }
+            },
+            "nodes": []
+        }
+        for node, info in nodes.items():
+            if info['is_input']:
+                subgraph_temp = subgraphs["graphs"]["sc-inputs"]
+            else:
+                subgraph_temp = subgraphs
+
+            for key in node.split(".")[0:-1]:
+                if key not in subgraph_temp["graphs"]:
+                    subgraph_temp["graphs"][key] = {
+                        "graphs": {},
+                        "nodes": []
+                    }
+                subgraph_temp = subgraph_temp["graphs"][key]
+            subgraph_temp["nodes"].append(node)
+
         with dot.subgraph(name='inputs') as input_graph:
             input_graph.graph_attr['cluster'] = 'true'
             input_graph.graph_attr['color'] = background
@@ -2062,34 +2086,74 @@ class Chip:
                     fontcolor=fontcolor, fontsize=fontsize, ordering="in",
                     penwidth=penwidth, fillcolor=fillcolor, shape="box")
 
-        with dot.subgraph(name='input_nodes') as input_graph_nodes:
-            input_graph_nodes.graph_attr['cluster'] = 'true'
-            input_graph_nodes.graph_attr['color'] = background
+        def make_node(graph, node, prefix):
+            info = nodes[node]
 
-            # add nodes
             shape = "oval" if not show_io else "Mrecord"
-            for node, info in nodes.items():
-                task_label = f"\\n ({info['task']})" if info['task'] is not None else ""
-                if show_io:
-                    input_labels = [f"<{ikey}> {ifile}" for ifile, ikey in info['inputs'].items()]
-                    output_labels = [f"<{okey}> {ofile}" for ofile, okey in info['outputs'].items()]
-                    center_text = f"\\n {node} {task_label} \\n\\n"
-                    labelname = "{"
-                    if input_labels:
-                        labelname += f"{{ {' | '.join(input_labels)} }} |"
-                    labelname += center_text
-                    if output_labels:
-                        labelname += f"| {{ {' | '.join(output_labels)} }}"
-                    labelname += "}"
+            task_label = f"\\n ({info['task']})" if info['task'] is not None else ""
+            if show_io:
+                input_labels = [f"<{ikey}> {ifile}" for ifile, ikey in info['inputs'].items()]
+                output_labels = [f"<{okey}> {ofile}" for ofile, okey in info['outputs'].items()]
+                center_text = f"\\n {node.replace(prefix, '')} {task_label} \\n\\n"
+                labelname = "{"
+                if input_labels:
+                    labelname += f"{{ {' | '.join(input_labels)} }} |"
+                labelname += center_text
+                if output_labels:
+                    labelname += f"| {{ {' | '.join(output_labels)} }}"
+                labelname += "}"
+            else:
+                labelname = f"{node.replace(prefix, '')}{task_label}"
+
+            graph.node(node, label=labelname, bordercolor=fontcolor, style='filled',
+                       fontcolor=fontcolor, fontsize=fontsize, ordering="in",
+                       penwidth=penwidth, fillcolor=fillcolor, shape=shape)
+
+        graph_idx = 0
+
+        def get_node_count(graph_info):
+            nodes = len(graph_info["nodes"])
+
+            for subgraph in graph_info["graphs"]:
+                nodes += get_node_count(graph_info["graphs"][subgraph])
+
+            return nodes
+
+        def build_graph(graph_info, parent, prefix):
+            nonlocal graph_idx
+
+            for subgraph in graph_info["graphs"]:
+                child_prefix = prefix
+                if get_node_count(graph_info["graphs"][subgraph]) > 1:
+                    child_prefix = f"{child_prefix}{subgraph}."
+                    graph = graphviz.Digraph(name=f"cluster_{graph_idx}")
+                    graph_idx += 1
+
+                    graph.graph_attr['rankdir'] = rankdir
+                    graph.attr(bgcolor=background)
+
+                    if subgraph == "sc-inputs":
+                        graph.attr(style='invis')
+                    else:
+                        graph.attr(color=fontcolor)
+                        graph.attr(style='rounded')
+                        graph.attr(shape='oval')
+                        graph.attr(label=subgraph)
+                        graph.attr(labeljust='l')
+                        graph.attr(fontcolor=fontcolor)
+                        graph.attr(fontsize=str(int(fontsize) + 2))
                 else:
-                    labelname = f"{node}{task_label}"
+                    graph = parent
+
+                build_graph(graph_info["graphs"][subgraph], graph, child_prefix)
+
+                if graph is not parent:
+                    parent.subgraph(graph)
 
-                dst = dot
-                if info['is_input']:
-                    dst = input_graph_nodes
-                dst.node(node, label=labelname, bordercolor=fontcolor, style='filled',
-                         fontcolor=fontcolor, fontsize=fontsize, ordering="in",
-                         penwidth=penwidth, fillcolor=fillcolor, shape=shape)
+            for subnode in graph_info["nodes"]:
+                make_node(parent, subnode, prefix)
+
+        build_graph(subgraphs, dot, "")
 
         for edge0, edge1, weight in edges:
             dot.edge(f'{edge0}{out_label_suffix}', f'{edge1}{in_label_suffix}', weight=str(weight))
@@ -2394,7 +2458,7 @@ class Chip:
 
             abspath = dirs[(package, path)]
             if abspath:
-                filename = self.__get_imported_filename(posix_path, package)
+                filename = utils.get_hashed_filename(posix_path, package=package)
                 dst_path = os.path.join(directory, filename)
                 if os.path.exists(dst_path):
                     continue
@@ -2466,7 +2530,7 @@ class Chip:
 
             abspath = files[(package, path)]
             if abspath:
-                filename = self.__get_imported_filename(posix_path, package)
+                filename = utils.get_hashed_filename(posix_path, package=package)
                 dst_path = os.path.join(directory, filename)
                 if verbose:
                     self.logger.info(f"Copying {abspath} to '{directory}' directory")
@@ -2702,12 +2766,12 @@ class Chip:
         return hashlist
 
     ###########################################################################
-    def _dashboard(self, wait=True, port=None, graph_chips=None):
+    def dashboard(self, wait=True, port=None, graph_chips=None):
         '''
         Open a session of the dashboard.
 
         The dashboard can be viewed in any webbrowser and can be accessed via:
-        http://localhost:8501/
+        http://localhost:<port>/
 
         Args:
             wait (bool): If True, this call will wait in this method
@@ -2718,7 +2782,7 @@ class Chip:
                 {'chip': chip object, 'name': chip name}
 
         Examples:
-            >>> chip._dashboard()
+            >>> chip.dashboard()
             Opens a sesison of the dashboard.
         '''
         if self._dash:
@@ -3143,6 +3207,7 @@ class Chip:
         self.set('option', 'nodisplay', False, clobber=True)
         self.set('option', 'continue', True, clobber=True)
         self.set('option', 'quiet', False, clobber=True)
+        self.set('option', 'clean', True, clobber=True)
         self.set('arg', 'step', None, clobber=True)
         self.set('arg', 'index', None, clobber=True)
         self.unset('option', 'to')
@@ -3237,31 +3302,6 @@ class Chip:
 
         return os.path.join(*dirlist)
 
-    #######################################
-    def __get_imported_filename(self, pathstr, package=None):
-        ''' Utility to map collected file to an unambiguous name based on its path.
-
-        The mapping looks like:
-        path/to/file.ext => file_<md5('path/to/file.ext')>.ext
-        '''
-        path = pathlib.PurePosixPath(pathstr)
-        ext = ''.join(path.suffixes)
-
-        # strip off all file suffixes to get just the bare name
-        barepath = path
-        while barepath.suffix:
-            barepath = pathlib.PurePosixPath(barepath.stem)
-        filename = str(barepath.parts[-1])
-
-        if not package:
-            package = ''
-        else:
-            package = f'{package}:'
-        path_to_hash = f'{package}{str(path)}'
-        pathhash = hashlib.sha1(path_to_hash.encode('utf-8')).hexdigest()
-
-        return f'{filename}_{pathhash}{ext}'
-
     def error(self, msg):
         '''
         Raises error.

siliconcompiler/flows/drcflow.py

@@ -0,0 +1,13 @@
+from siliconcompiler import Flow
+
+from siliconcompiler.tools.klayout import drc
+
+
+def setup():
+    '''
+    Perform a DRC run on an input GDS
+    '''
+    flow = Flow('drcflow')
+    flow.node('drcflow', 'drc', drc)
+
+    return flow

siliconcompiler/flows/interposerflow.py

@@ -0,0 +1,17 @@
+from siliconcompiler import Flow
+
+from siliconcompiler.tools.openroad import rdlroute
+from siliconcompiler.tools.klayout import export
+
+
+def setup():
+    '''
+    A flow to perform RDL routing and generate a GDS
+    '''
+    flow = Flow('interposerflow')
+    flow.node('interposerflow', 'rdlroute', rdlroute)
+    flow.node('interposerflow', 'write_gds', export)
+
+    flow.edge('interposerflow', 'rdlroute', 'write_gds')
+
+    return flow

siliconcompiler/fpgas/vpr_example.py

@@ -43,6 +43,14 @@ def setup():
 
         fpga.set('fpga', part_name, 'vendor', vendor)
 
+        # Part name is specified per architecture file.  Device code specifies
+        # which <fixed_layout> name to use when running VPR.  These examples
+        # use the following names:
+        if (part_name == 'example_arch_X005Y005'):
+            fpga.set('fpga', part_name, 'var', 'vpr_device_code', 'fpga_beta')
+        else:
+            fpga.set('fpga', part_name, 'var', 'vpr_device_code', part_name)
+
         fpga.set('fpga', part_name, 'lutsize', lut_size)
 
         arch_root = os.path.join(flow_root, 'arch', part_name)

siliconcompiler/libs/interposer.py

@@ -0,0 +1,8 @@
+import siliconcompiler
+from lambdapdk.interposer.libs.bumps import setup
+
+
+#########################
+if __name__ == "__main__":
+    lib = setup(siliconcompiler.Chip('<lib>'))
+    lib.write_manifest(f'{lib.top()}.json')

siliconcompiler/package.py

@@ -88,7 +88,8 @@ def _path(chip, package, download_handler):
             chip._packages[package] = data_path
         return data_path
 
-    raise SiliconCompilerError(f'Extracting {package} data to {data_path} failed')
+    raise SiliconCompilerError(f'Extracting {package} data to {data_path} failed',
+                               chip=chip)
 
 
 def path(chip, package):
@@ -188,7 +189,7 @@ def clone_synchronized(chip, package, data, data_path):
             elif url.scheme in ['git', 'git+https']:
                 chip.logger.error('Failed to authenticate. Please use a token or ssh.')
         else:
-            raise e
+            chip.logger.error(str(e))
 
 
 def clone_from_git(chip, package, data, repo_path):