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

siliconcompiler/pdks/interposer.py

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

siliconcompiler/remote/schema.py

@@ -2,7 +2,7 @@ from siliconcompiler.schema.schema_cfg import scparam
 from siliconcompiler.schema import Schema
 
 
-SCHEMA_VERSION = '0.0.1'
+SCHEMA_VERSION = '0.0.2'
 
 
 def schema_cfg():
@@ -93,6 +93,16 @@ def schema_cfg():
             schelp="""
             Provides explicit control over the level of debug logging printed.""")
 
+    scparam(cfg, ['option', 'checkinterval'],
+            sctype='int',
+            defvalue=30,
+            shorthelp="Interval for client",
+            switch="-checkinterval <int>",
+            example=["cli: -checkinterval 10",
+                     "api: chip.set('option', 'checkinterval', 10)"],
+            schelp="""
+            Interval between checks to announce to clients""")
+
     return cfg
 
 

siliconcompiler/remote/server.py

@@ -239,7 +239,7 @@ class Server:
 
         # Return a response to the client.
         return web.json_response({'message': f"Starting job: {job_hash}",
-                                  'interval': 30,
+                                  'interval': self.checkinterval,
                                   'job_hash': job_hash})
 
     ####################
@@ -375,7 +375,7 @@ class Server:
                 'sc_schema': sc_schema_version,
                 'sc_server': Server.__version__,
             },
-            'progress_interval': 30
+            'progress_interval': self.checkinterval
         }
 
         username = job_params['username']
@@ -490,6 +490,11 @@ class Server:
         # Ensure that NFS mounting path is absolute.
         return os.path.abspath(self.get('option', 'nfsmount'))
 
+    ###################
+    @property
+    def checkinterval(self):
+        return self.get('option', 'checkinterval')
+
     def get(self, *keypath, field='value'):
         return self.schema.get(*keypath, field=field)
 

siliconcompiler/report/dashboard/__init__.py

@@ -12,6 +12,7 @@ import atexit
 import shutil
 import fasteners
 import signal
+import socketserver
 
 from siliconcompiler.report.dashboard import utils
 
@@ -25,6 +26,8 @@ class Dashboard():
         pass
 
     def __init__(self, chip, port=None, graph_chips=None):
+        if not port:
+            port = Dashboard.get_next_port()
         if not port:
             port = Dashboard.__port
 
@@ -172,3 +175,9 @@ class Dashboard():
 
         if os.path.exists(self.__directory):
             shutil.rmtree(self.__directory)
+
+    @staticmethod
+    def get_next_port():
+        with socketserver.TCPServer(("localhost", 0), None) as s:
+            return s.server_address[1]
+        return None

siliconcompiler/report/dashboard/components/__init__.py

@@ -194,7 +194,7 @@ def setup_page():
         menu_items=SC_MENU)
 
 
-def file_viewer(chip, path, header_col_width=0.89):
+def file_viewer(chip, path, page_key=None, header_col_width=0.89):
     if not path:
         streamlit.error('Select a file')
         return
@@ -243,14 +243,25 @@ def file_viewer(chip, path, header_col_width=0.89):
 
             file_section = streamlit.container()
 
+            if page_key:
+                if state.get_key(page_key) is None:
+                    state.set_key(page_key, 1)
+                index = state.get_key(page_key)
+            else:
+                index = 1
+
             page = sac.pagination(
                 align='center',
+                index=index,
                 jump=True,
                 show_total=True,
                 page_size=page_size,
                 total=max_pages,
                 disabled=max_pages < state.get_key(state.MAX_FILE_LINES_TO_SHOW))
 
+            if page_key:
+                state.set_key(page_key, page)
+
             start_idx = (page - 1) * state.get_key(state.MAX_FILE_LINES_TO_SHOW)
             end_idx = start_idx + state.get_key(state.MAX_FILE_LINES_TO_SHOW)
             file_show = file_data[start_idx:end_idx]
@@ -465,6 +476,7 @@ def node_file_tree_viewer(chip, step, index):
 
     if selected and os.path.isfile(selected):
         state.set_key(state.SELECTED_FILE, selected)
+        state.set_key(state.SELECTED_FILE_PAGE, None)
 
 
 def node_viewer(chip, step, index, metric_dataframe, height=None):

siliconcompiler/report/dashboard/layouts/vertical_flowgraph.py

@@ -80,9 +80,10 @@ def layout():
         components.manifest_viewer(chip)
 
     with tabs["File Viewer"]:
-        path = state.get_key(state.SELECTED_FILE)
-
-        components.file_viewer(chip, path)
+        components.file_viewer(
+            chip,
+            state.get_key(state.SELECTED_FILE),
+            page_key=state.SELECTED_FILE_PAGE)
 
     if "Design Preview" in tabs:
         with tabs["Design Preview"]:

siliconcompiler/report/dashboard/layouts/vertical_flowgraph_node_tab.py

@@ -103,7 +103,10 @@ def layout():
         components.manifest_viewer(chip)
 
     if tab_selected == "File Viewer":
-        components.file_viewer(chip, state.get_key(state.SELECTED_FILE))
+        components.file_viewer(
+            chip,
+            state.get_key(state.SELECTED_FILE),
+            page_key=state.SELECTED_FILE_PAGE)
 
     if tab_selected == "Design Preview":
         components.file_viewer(chip, f'{chip.getworkdir()}/{chip.design}.png')

siliconcompiler/report/dashboard/layouts/vertical_flowgraph_sac_tabs.py

@@ -96,7 +96,10 @@ def layout():
         components.manifest_viewer(chip)
 
     if tab_selected == "File Viewer":
-        components.file_viewer(chip, state.get_key(state.SELECTED_FILE))
+        components.file_viewer(
+            chip,
+            state.get_key(state.SELECTED_FILE),
+            page_key=state.SELECTED_FILE_PAGE)
 
     if tab_selected == "Design Preview":
         components.file_viewer(chip, f'{chip.getworkdir()}/{chip.design}.png')

siliconcompiler/report/dashboard/state.py

@@ -16,6 +16,7 @@ SELECTED_FLOWGRAPH_NODE = "selected_flowgraph_node"
 SELECTED_SELECTOR_NODE = "selected_selector_node"
 NODE_SOURCE = "node_source"
 SELECTED_FILE = "selected_file"
+SELECTED_FILE_PAGE = "selected_file_page"
 LOADED_CHIPS = "loaded_chips"
 UI_WIDTH = "ui_width"
 MANIFEST_FILE = "manifest_file"
@@ -73,6 +74,7 @@ def init():
     _add_default(SELECTED_SELECTOR_NODE, None)
     _add_default(NODE_SOURCE, None)
     _add_default(SELECTED_FILE, None)
+    _add_default(SELECTED_FILE_PAGE, None)
     _add_default(LOADED_CHIPS, {})
     _add_default(MANIFEST_FILE, None)
     _add_default(MANIFEST_LOCK, None)
@@ -80,7 +82,7 @@ def init():
     _add_default(IS_RUNNING, False)
     _add_default(GRAPH_JOBS, None)
     _add_default(UI_WIDTH, None)
-    _add_default(APP_LAYOUT, "vertical_flowgraph")
+    _add_default(APP_LAYOUT, "vertical_flowgraph_sac_tabs")
     _add_default(APP_RERUN, None)
     _add_default(APP_RUNNING_REFRESH, 2 * 1000)
     _add_default(APP_STOPPED_REFRESH, 30 * 1000)

siliconcompiler/report/summary_table.py

@@ -12,10 +12,9 @@ def _show_summary_table(chip, flow, flowgraph_nodes, show_all_indices):
     '''
 
     # Display data
-    max_line_width = 135
     column_width = 15
 
-    max_line_width = max(max_line_width, int(0.9*shutil.get_terminal_size((80, 20)).columns))
+    max_line_width = max(2 * column_width, int(0.95*shutil.get_terminal_size().columns))
 
     nodes, _, metrics, metrics_unit, metrics_to_show, _ = \
         _collect_data(chip, flow, flowgraph_nodes)

siliconcompiler/report/utils.py

@@ -143,8 +143,7 @@ def _get_flowgraph_path(chip, flow, nodes_to_execute, only_include_successful=Fa
     end_nodes = _get_flowgraph_exit_nodes(chip, flow, steps=flowgraph_steps)
     for node in end_nodes:
         if only_include_successful:
-            if chip.get('record', 'status', step=node[0], index=node[1]) == \
-               NodeStatus.SUCCESS:
+            if NodeStatus.is_success(chip.get('record', 'status', step=node[0], index=node[1])):
                 selected_nodes.add(node)
                 to_search.append(node)
         else:

siliconcompiler/scheduler/__init__.py

@@ -688,7 +688,9 @@ def _makecmd(chip, tool, task, step, index, script_name='replay.sh', include_pat
         runtime_options = getattr(chip._get_tool_module(step, index), 'runtime_options', None)
     if runtime_options:
         try:
+            chip.schema._start_record_access()
             cmdlist.extend(parse_options(runtime_options(chip)))
+            chip.schema._stop_record_access()
         except Exception as e:
             chip.logger.error(f'Failed to get runtime options for {tool}/{task}')
             raise e
@@ -898,6 +900,7 @@ def _run_executable_or_builtin(chip, step, index, version, toolpath, workdir, ru
 
                 cmd_start_time = time.time()
                 proc = subprocess.Popen(cmdlist,
+                                        stdin=subprocess.DEVNULL,
                                         stdout=stdout_writer,
                                         stderr=stderr_writer,
                                         preexec_fn=preexec_fn)
@@ -982,7 +985,9 @@ def _post_process(chip, step, index):
     func = getattr(chip._get_task_module(step, index, flow=flow), 'post_process', None)
     if func:
         try:
+            chip.schema._start_record_access()
             func(chip)
+            chip.schema._stop_record_access()
         except Exception as e:
             chip.logger.error(f'Failed to run post-process for {tool}/{task}.')
             print_traceback(chip, e)
@@ -1075,7 +1080,9 @@ def _pre_process(chip, step, index):
     func = getattr(chip._get_task_module(step, index, flow=flow), 'pre_process', None)
     if func:
         try:
+            chip.schema._start_record_access()
             func(chip)
+            chip.schema._stop_record_access()
         except Exception as e:
             chip.logger.error(f"Pre-processing failed for '{tool}/{task}'.")
             raise e
@@ -1087,6 +1094,8 @@ def _pre_process(chip, step, index):
 def _set_env_vars(chip, step, index):
     flow = chip.get('option', 'flow')
     tool, task = get_tool_task(chip, step, index, flow)
+
+    chip.schema._start_record_access()
     # License file configuration.
     for item in chip.getkeys('tool', tool, 'licenseserver'):
         license_file = chip.get('tool', tool, 'licenseserver', item, step=step, index=index)
@@ -1099,6 +1108,8 @@ def _set_env_vars(chip, step, index):
         if val:
             os.environ[item] = val
 
+    chip.schema._stop_record_access()
+
 
 def _check_tool_version(chip, step, index, run_func=None):
     '''
@@ -1118,6 +1129,7 @@ def _check_tool_version(chip, step, index, run_func=None):
             cmdlist = [exe]
             cmdlist.extend(veropt)
             proc = subprocess.run(cmdlist,
+                                  stdin=subprocess.DEVNULL,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.STDOUT,
                                   universal_newlines=True)
@@ -1189,6 +1201,9 @@ def _hash_files(chip, step, index, setup=False):
 
 
 def _finalizenode(chip, step, index, replay):
+    if chip.schema._do_record_access():
+        assert_required_accesses(chip, step, index)
+
     flow = chip.get('option', 'flow')
     tool, task = get_tool_task(chip, step, index, flow)
     quiet = (
@@ -1284,6 +1299,86 @@ def assert_output_files(chip, step, index):
             chip=chip)
 
 
+def assert_required_accesses(chip, step, index):
+    flow = chip.get('option', 'flow')
+    jobname = chip.get('option', 'jobname')
+    tool, task = get_tool_task(chip, step, index, flow)
+
+    if tool == 'builtin':
+        return
+
+    gets = chip.schema._get_record_access()
+    logfile = os.path.join(
+        chip.getworkdir(jobname=jobname, step=step, index=index),
+        f'{step}.log')
+
+    with sc_open(logfile) as f:
+        for line in f:
+            if line.startswith(Schema._RECORD_ACCESS_IDENTIFIER):
+                key = line[len(Schema._RECORD_ACCESS_IDENTIFIER):].strip().split(',')
+                if chip.valid(*key, check_complete=True):
+                    gets.add(tuple(key))
+
+    def get_value(*key):
+        if chip.get(*key, field='pernode') == 'never':
+            return chip.get(*key)
+        else:
+            return chip.get(*key, step=step, index=index)
+
+    getkeys = set()
+    # Remove keys with empty values
+    for key in set(sorted(gets)):
+        if get_value(*key):
+            getkeys.add(key)
+
+    # Remove keys that dont matter
+    exempt = [
+        ('design',),
+        ('arg', 'step'), ('arg', 'index'),
+        ('option', 'jobname'), ('option', 'flow'), ('option', 'strict'), ('option', 'builddir'),
+        ('option', 'quiet'),
+        ('tool', tool, 'exe'),
+        ('tool', tool, 'task', task, 'require'),
+        ('tool', tool, 'task', task, 'threads'),
+        ('flowgraph', flow, step, index, 'tool'), ('flowgraph', flow, step, index, 'task'),
+        ('flowgraph', flow, step, index, 'taskmodule')]
+    for key in chip.getkeys('metric'):
+        exempt.append(('metric', key))
+    for key in chip.getkeys('tool', tool, 'task', task, 'report'):
+        exempt.append(('tool', tool, 'task', task, 'report', key))
+
+    # Get exempted keys from task
+    func = getattr(chip._get_task_module(step, index, flow=flow), 'exempt_keys', None)
+    if func:
+        # No need for try / except since this must work properly
+        exempt.extend(func(chip))
+
+    required = set(
+        [tuple(key.split(',')) for key in chip.get('tool', tool, 'task', task, 'require',
+                                                   step=step, index=index)])
+
+    for key in set(exempt):
+        if key in getkeys:
+            getkeys.remove(key)
+        if key in required:
+            required.remove(key)
+
+    excess_require = required.difference(getkeys)
+    if True:
+        for key in sorted(excess_require):
+            chip.logger.error(f"{step}{index} does not require requirement: {','.join(key)}")
+    missing_require = getkeys.difference(required)
+    for key in sorted(missing_require):
+        chip.logger.error(f"{step}{index} has an unexpressed requirement: "
+                          f"{','.join(key)} = {get_value(*key)}")
+
+    if missing_require:
+        raise SiliconCompilerError(
+            f'Requirements for {step}{index} does not match access list: '
+            f'{", ".join([",".join(key) for key in sorted(missing_require)])}',
+            chip=chip)
+
+
 def _reset_flow_nodes(chip, flow, nodes_to_execute):
     # Reset flowgraph/records/metrics by probing build directory. We need
     # to set values to None for steps we may re-run so that merging

siliconcompiler/schema/schema_cfg.py

@@ -10,7 +10,7 @@ try:
 except ImportError:
     from siliconcompiler.schema.utils import trim
 
-SCHEMA_VERSION = '0.48.2'
+SCHEMA_VERSION = '0.48.4'
 
 #############################################################################
 # PARAM DEFINITION
@@ -1252,7 +1252,6 @@ def schema_datasheet(cfg, name='default', mode='default'):
     # Package Description
     #########################
 
-    # high level description
     scparam(cfg, ['datasheet', 'package', name, 'type'],
             sctype='enum',
             enum=['bga', 'lga', 'csp', 'qfn', 'qfp', 'sop', 'die', 'wafer'],
@@ -1263,6 +1262,16 @@ def schema_datasheet(cfg, name='default', mode='default'):
                 "api: chip.set('datasheet', 'package', 'abcd', 'type', 'bga')"],
             schelp="""Package type specified on a named package basis.""")
 
+    scparam(cfg, ['datasheet', 'package', name, 'footprint'],
+            sctype='str',
+            shorthelp="Datasheet: package footprint",
+            switch="-datasheet_package_footprint 'name <str>'",
+            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.""")
+
     scparam(cfg, ['datasheet', 'package', name, 'drawing'],
             sctype='[file]',
             shorthelp="Datasheet: package drawing",
@@ -2158,7 +2167,10 @@ def schema_metric(cfg, step='default', index='default'):
                 device families.""")
 
     metrics = {'cellarea': 'cell area (ignoring fillers)',
-               'totalarea': 'physical die area'}
+               'totalarea': 'physical die area',
+               'macroarea': 'macro cell area',
+               'padcellarea': 'io pad cell area',
+               'stdcellarea': 'standard cell area'}
 
     for item, val in metrics.items():
         scparam(cfg, ['metric', item],

siliconcompiler/schema/schema_obj.py

@@ -61,6 +61,8 @@ class Schema:
         logger (logging.Logger): instance of the parent logger if available
     """
 
+    _RECORD_ACCESS_IDENTIFIER = "SC_CFG_ACCESS_KEY"
+
     # Special key in node dict that represents a value corresponds to a
     # global default for all steps/indices.
     GLOBAL_KEY = 'global'
@@ -70,6 +72,9 @@ class Schema:
         if cfg is not None and manifest is not None:
             raise ValueError('You may not specify both cfg and manifest')
 
+        # Use during testing to record calls to Schema.get
+        self._init_record_access()
+
         self._init_logger(logger)
 
         self._stop_journal()
@@ -256,6 +261,10 @@ class Schema:
 
         See :meth:`~siliconcompiler.core.Chip.get` for detailed documentation.
         """
+
+        if self.__record_access["recording"]:
+            self.__record_access["record"].add(tuple(keypath))
+
         # Prevent accidental modifications of the schema content by not passing a reference
         return copy.copy(self.__get(*keypath, field=field, job=job, step=step, index=index))
 
@@ -1087,7 +1096,9 @@ class Schema:
 
         if template:
             fout.write(template.render(manifest_dict='\n'.join(tcl_set_cmds),
-                                       scroot=os.path.abspath(PACKAGE_ROOT)))
+                                       scroot=os.path.abspath(PACKAGE_ROOT),
+                                       record_access=self._do_record_access(),
+                                       record_access_id=Schema._RECORD_ACCESS_IDENTIFIER))
         else:
             for cmd in tcl_set_cmds:
                 fout.write(cmd + '\n')
@@ -1305,6 +1316,45 @@ class Schema:
             except Exception as e:
                 self.logger.error(f'Exception: {e}')
 
+    #######################################
+    def _do_record_access(self):
+        '''
+        Determine if Schema should record calls to .get
+        '''
+        return False
+
+    #######################################
+    def _init_record_access(self):
+        '''
+        Initialize record access data record
+        '''
+        self.__record_access = {
+            "do": self._do_record_access(),
+            "recording": False,
+            "record": set()
+        }
+
+    #######################################
+    def _start_record_access(self):
+        '''
+        Start recording calls to .get
+        '''
+        self.__record_access["recording"] = True
+
+    #######################################
+    def _stop_record_access(self):
+        '''
+        Stop recording calls to .get
+        '''
+        self.__record_access["recording"] = False
+
+    #######################################
+    def _get_record_access(self):
+        '''
+        Return calls to record_access
+        '''
+        return self.__record_access["record"].copy()
+
     #######################################
     def get_default(self, *keypath):
         '''Returns default value of a parameter.

siliconcompiler/sphinx_ext/dynamicgen.py

@@ -343,6 +343,8 @@ class DynamicGen(SphinxDirective):
             type_heading = "Variables"
         elif type == "file":
             type_heading = "Files"
+        elif type == "dir":
+            type_heading = "Directories"
 
         table = [[strong('Parameters'), strong('Help')]]
         for key, params in cfg.items():
@@ -657,6 +659,9 @@ class ToolGen(DynamicGen):
         '''Display config under `eda, <modname>` in a single table.'''
         cfg = chip.getdict('tool', toolname, 'task', taskname)
         schema = Schema(cfg=cfg)
+        for vals, step, index in schema._getvals('require'):
+            schema.set('require', sorted(set(vals)),
+                       step=step, index=index)
         schema.prune()
         pruned = schema.cfg
         table = build_schema_value_table(pruned, self.env.docname,
@@ -789,6 +794,7 @@ class ToolGen(DynamicGen):
         key_path = ['tool', '<tool>', 'task', '<task>']
         self._document_free_params(cfg, 'var', key_path + ['var'], reference_prefix, s)
         self._document_free_params(cfg, 'file', key_path + ['file'], reference_prefix, s)
+        self._document_free_params(cfg, 'dir', key_path + ['dir'], reference_prefix, s)
 
     def _handle_setup(self, chip, module):
         setup = self.get_setup_method(module)

siliconcompiler/targets/interposer_demo.py

@@ -0,0 +1,56 @@
+from siliconcompiler import Chip
+from siliconcompiler.flows import interposerflow, drcflow
+
+from lambdapdk import interposer
+from lambdapdk.interposer.libs import bumps
+
+
+####################################################
+# Target Setup
+####################################################
+def setup(chip):
+    '''
+    Interposer Demo Target
+    '''
+
+    # 1. Load PDK, flow, libs
+    chip.use(interposer)
+    chip.use(bumps)
+    chip.use(interposerflow)
+    chip.use(drcflow)
+
+    # 2. Set default targets
+    chip.set('option', 'flow', 'interposerflow', clobber=False)
+    chip.set('option', 'pdk', 'interposer', clobber=False)
+    chip.set('option', 'stackup', '3ML_0400', clobber=False)
+    chip.set('option', 'var', 'openroad_libtype', 'none', clobber=False)
+    chip.set('option', 'var', 'klayout_libtype', 'none', clobber=False)
+
+    # 3. Set project specific design choices
+    chip.set('asic', 'macrolib', 'interposer_bumps', clobber=False)
+
+    # 4. get project specific design choices
+    chip.set('asic', 'delaymodel', 'nldm', clobber=False)
+
+    # 5. Timing corners
+    chip.set('constraint', 'timing', 'slow', 'libcorner', 'slow', clobber=False)
+    chip.set('constraint', 'timing', 'slow', 'pexcorner', 'maximum', clobber=False)
+    chip.set('constraint', 'timing', 'slow', 'mode', 'func', clobber=False)
+    chip.set('constraint', 'timing', 'slow', 'check', ['setup', 'hold'], clobber=False)
+
+    chip.set('constraint', 'timing', 'fast', 'libcorner', 'fast', clobber=False)
+    chip.set('constraint', 'timing', 'fast', 'pexcorner', 'minimum', clobber=False)
+    chip.set('constraint', 'timing', 'fast', 'mode', 'func', clobber=False)
+    chip.set('constraint', 'timing', 'fast', 'check', ['setup', 'hold'], clobber=False)
+
+    chip.set('constraint', 'timing', 'typical', 'libcorner', 'typ', clobber=False)
+    chip.set('constraint', 'timing', 'typical', 'pexcorner', 'typical', clobber=False)
+    chip.set('constraint', 'timing', 'typical', 'mode', 'func', clobber=False)
+    chip.set('constraint', 'timing', 'typical', 'check', ['setup', 'hold'], clobber=False)
+
+
+#########################
+if __name__ == "__main__":
+    target = Chip('<target>')
+    setup(target)
+    target.write_manifest('interposer_demo.json')

siliconcompiler/templates/tcl/manifest.tcl.j2

@@ -16,6 +16,8 @@ proc sc_cfg_get { args } {
     # Refer to global sc_cfg dictionary
     global sc_cfg
 
+    {% if record_access %}puts "{{ record_access_id }} [join $args ,]"{% endif %}
+
     if { ![sc_cfg_exists {*}$args] } {
         throw {FLOW KEYERROR} "key \"$args\" is not in the siliconcompiler configuration"
     }