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

siliconcompiler/report/dashboard/state.py

@@ -0,0 +1,215 @@
+import argparse
+import json
+import os
+import streamlit
+import streamlit_javascript
+import fasteners
+
+from siliconcompiler import Chip
+
+
+DISPLAY_FLOWGRAPH = "show_flowgraph"
+SELECTED_JOB = "selected_job"
+SELECTED_NODE = "selected_node"
+# This is needed until the graph supports setting a selected node
+SELECTED_FLOWGRAPH_NODE = "selected_flowgraph_node"
+SELECTED_SELECTOR_NODE = "selected_selector_node"
+NODE_SOURCE = "node_source"
+SELECTED_FILE = "selected_file"
+LOADED_CHIPS = "loaded_chips"
+UI_WIDTH = "ui_width"
+MANIFEST_FILE = "manifest_file"
+MANIFEST_LOCK = "manifest_lock"
+MANIFEST_TIME = "manifest_time"
+IS_RUNNING = "is_flow_running"
+GRAPH_JOBS = "graph_jobs"
+APP_LAYOUT = "app_layout"
+APP_RERUN = "app_rerun"
+APP_RUNNING_REFRESH = "app_running_refresh"
+APP_STOPPED_REFRESH = "app_stopped_refresh"
+MAX_DICT_ITEMS_TO_SHOW = "max_dict_items"
+MAX_FILE_LINES_TO_SHOW = "max_file_lines"
+SELECT_TAB = "select_tab"
+TAB_INDEX = "tab-index"
+TAB_STATE = "tab-state"
+
+_DEBUG = False
+DEVELOPER = False
+
+
+def _add_default(key, value):
+    if key not in streamlit.session_state:
+        streamlit.session_state[key] = value
+
+
+def update_manifest():
+    file_time = os.stat(get_key(MANIFEST_FILE)).st_mtime
+
+    if get_key(MANIFEST_TIME) != file_time:
+        chip = Chip(design='')
+
+        with get_key(MANIFEST_LOCK):
+            chip.read_manifest(get_key(MANIFEST_FILE))
+        set_key(MANIFEST_TIME, file_time)
+        debug_print("Read manifest", get_key(MANIFEST_FILE))
+
+        add_chip("default", chip)
+
+        for history in chip.getkeys('history'):
+            history_chip = Chip(design='')
+            history_chip.schema.cfg = chip.getdict('history', history)
+            history_chip.set('design', chip.design)
+            add_chip(history, history_chip)
+
+        return True
+    return False
+
+
+def init():
+    _add_default(DISPLAY_FLOWGRAPH, True)
+    _add_default(SELECTED_JOB, None)
+    _add_default(SELECTED_NODE, None)
+    _add_default(SELECTED_FLOWGRAPH_NODE, None)
+    _add_default(SELECTED_SELECTOR_NODE, None)
+    _add_default(NODE_SOURCE, None)
+    _add_default(SELECTED_FILE, None)
+    _add_default(LOADED_CHIPS, {})
+    _add_default(MANIFEST_FILE, None)
+    _add_default(MANIFEST_LOCK, None)
+    _add_default(MANIFEST_TIME, None)
+    _add_default(IS_RUNNING, False)
+    _add_default(GRAPH_JOBS, None)
+    _add_default(UI_WIDTH, None)
+    _add_default(APP_LAYOUT, "vertical_flowgraph")
+    _add_default(APP_RERUN, None)
+    _add_default(APP_RUNNING_REFRESH, 2 * 1000)
+    _add_default(APP_STOPPED_REFRESH, 30 * 1000)
+    _add_default(MAX_DICT_ITEMS_TO_SHOW, 100)
+    _add_default(MAX_FILE_LINES_TO_SHOW, 100)
+    _add_default(SELECT_TAB, None)
+    _add_default(TAB_INDEX, 0)
+
+    parser = argparse.ArgumentParser('dashboard')
+    parser.add_argument('cfg', nargs='?')
+    args = parser.parse_args()
+
+    if not args.cfg:
+        raise ValueError('configuration not provided')
+
+    if not get_key(LOADED_CHIPS):
+        # First time through
+
+        with open(args.cfg, 'r') as f:
+            config = json.load(f)
+
+        set_key(MANIFEST_FILE, config["manifest"])
+        set_key(MANIFEST_LOCK, fasteners.InterProcessLock(config["lock"]))
+
+        update_manifest()
+        chip = get_chip("default")
+        for graph_info in config['graph_chips']:
+            file_path = graph_info['path']
+            graph_chip = Chip(design='')
+            graph_chip.read_manifest(file_path)
+            graph_chip.unset('arg', 'step')
+            graph_chip.unset('arg', 'index')
+
+            if graph_info['cwd']:
+                graph_chip.cwd = graph_info['cwd']
+
+            add_chip(os.path.basename(file_path), graph_chip)
+
+        chip_step = chip.get('arg', 'step')
+        chip_index = chip.get('arg', 'index')
+
+        if chip_step and chip_index:
+            set_key(SELECTED_NODE, f'{chip_step}{chip_index}')
+
+    chip = get_chip("default")
+    chip.unset('arg', 'step')
+    chip.unset('arg', 'index')
+
+    if not get_key(SELECTED_JOB):
+        set_key(SELECTED_JOB, "default")
+
+
+def setup():
+    with streamlit.empty():
+        # get width
+        set_key(UI_WIDTH, streamlit_javascript.st_javascript("window.innerWidth"))
+        # replace with a empty container to avoid adding a gap at the top
+        streamlit.empty()
+
+    set_key(NODE_SOURCE, None)
+
+
+def get_chip(job=None):
+    if not job:
+        job = get_key(SELECTED_JOB)
+    return get_key(LOADED_CHIPS)[job]
+
+
+def add_chip(name, chip):
+    streamlit.session_state[LOADED_CHIPS][name] = chip
+
+
+def get_chips():
+    chips = list(get_key(LOADED_CHIPS).keys())
+    chips.remove('default')
+    chips.insert(0, 'default')
+    return chips
+
+
+def get_selected_node():
+    if get_key(NODE_SOURCE) == "flowgraph":
+        return get_key(SELECTED_FLOWGRAPH_NODE)
+
+    if get_key(NODE_SOURCE) == "selector":
+        return get_key(SELECTED_SELECTOR_NODE)
+
+    return get_key(SELECTED_NODE)
+
+
+def get_key(key):
+    return streamlit.session_state[key]
+
+
+def set_key(key, value):
+    changed = value != streamlit.session_state[key]
+    if changed:
+        debug_print("set_key()", key, "changed", streamlit.session_state[key], "->", value)
+        streamlit.session_state[key] = value
+        return True
+    return False
+
+
+def del_key(key):
+    debug_print("del_key()", key)
+    if key in streamlit.session_state:
+        del streamlit.session_state[key]
+
+
+def compute_component_size(minimum, requested_px):
+    ui_width = get_key(UI_WIDTH)
+
+    if ui_width > 0:
+        return min(requested_px / ui_width, minimum)
+
+    return minimum
+
+
+def debug_print(*args):
+    if not _DEBUG:
+        return
+
+    print(*args)
+
+
+def debug_print_state():
+    if not _DEBUG:
+        return
+
+    for n, key in enumerate(sorted(streamlit.session_state.keys())):
+        value = streamlit.session_state[key]
+        print("state", n, key, type(value), value)
+    print()

siliconcompiler/report/dashboard/utils/__init__.py

@@ -0,0 +1,73 @@
+from siliconcompiler import NodeStatus
+from siliconcompiler.flowgraph import _get_flowgraph_nodes
+
+from pathlib import Path
+
+
+def get_chip_cwd(chip, manifest):
+    build_dir = Path(chip.get('option', 'builddir'))
+
+    manifest_path = Path(manifest)
+    for path in manifest_path.parents:
+        if build_dir.name == path.name:
+            return str(path.parent)
+
+    return None
+
+
+def make_node_to_step_index_map(chip, metric_dataframe):
+    '''
+    Returns a map from the name of a node to the associated step, index pair.
+
+    Args:
+        metric_dataframe (pandas.DataFrame) : A dataframe full of all metrics and all
+            nodes of the selected chip
+    '''
+    node_to_step_index_map = {}
+    for step, index in _get_flowgraph_nodes(chip, chip.get('option', 'flow')):
+        node_to_step_index_map[f'{step}{index}'] = (step, index)
+
+    # concatenate step and index
+    metric_dataframe.columns = metric_dataframe.columns.map(lambda x: f'{x[0]}{x[1]}')
+    return node_to_step_index_map, metric_dataframe
+
+
+def make_metric_to_metric_unit_map(metric_dataframe):
+    '''
+    Returns a map from the name of a metric to the associated metric and unit in
+    the form f'{x[0]} ({x[1]})'
+
+    Args:
+        metric_dataframe (pandas.DataFrame) : A dataframe full of all metrics and all
+            nodes of the selected chip.
+    '''
+    metric_to_metric_unit_map = {}
+    for metric, unit in metric_dataframe.index.tolist():
+        if unit != '':
+            metric_to_metric_unit_map[f'{metric} ({unit})'] = metric
+        else:
+            metric_to_metric_unit_map[metric] = metric
+    # concatenate metric and unit
+    metric_dataframe.index = metric_dataframe.index.map(lambda x: f'{x[0]} ({x[1]})'
+                                                        if x[1] else x[0])
+    return metric_to_metric_unit_map, metric_dataframe
+
+
+def is_running(chip):
+    for step, index in _get_flowgraph_nodes(chip, chip.get('option', 'flow')):
+        state = chip.get('record', 'status', step=step, index=index)
+        if not NodeStatus.is_done(state):
+            return True
+    return False
+
+
+def generate_metric_dataframe(chip):
+    from siliconcompiler.report import report
+
+    metric_dataframe = report.make_metric_dataframe(chip)
+    node_to_step_index_map, metric_dataframe = \
+        make_node_to_step_index_map(chip, metric_dataframe)
+    metric_to_metric_unit_map, metric_dataframe = \
+        make_metric_to_metric_unit_map(metric_dataframe)
+
+    return metric_dataframe, node_to_step_index_map, metric_to_metric_unit_map

siliconcompiler/report/dashboard/utils/file_utils.py

@@ -0,0 +1,120 @@
+import gzip
+import os
+from siliconcompiler import utils, sc_open
+
+
+def is_file_is_binary(path, compressed):
+    # Read first chunk and check for non characters
+    try:
+        if compressed:
+            with gzip.open(path, 'rt') as f:
+                f.read(8196)
+        else:
+            with open(path, "r") as f:
+                f.read(8196)
+    except UnicodeDecodeError:
+        return True
+    return False
+
+
+def read_file(path, max_lines):
+    _, compressed_file_extension = os.path.splitext(path.lower())
+    file_info = []
+    honor_max_file = max_lines is not None
+
+    def read_file(fid):
+        for line in fid:
+            file_info.append(line.rstrip())
+            if honor_max_file and len(file_info) >= max_lines:
+                file_info.append('... truncated ...')
+                return
+
+    is_compressed = compressed_file_extension == '.gz'
+    if is_file_is_binary(path, is_compressed):
+        return "Binary file"
+
+    if is_compressed:
+        with gzip.open(path, 'rt') as fid:
+            read_file(fid)
+    else:
+        with sc_open(path) as fid:
+            read_file(fid)
+    return "\n".join(file_info)
+
+
+def get_file_type(ext):
+    if ext in ("v", "vh", "sv", "svh", "vg"):
+        return "verilog"
+    if ext in ("vhdl", "vhd"):
+        return "vhdl"
+    if ext in ("tcl", "sdc", "xdc"):
+        return "tcl"
+    if ext in ("c", "cpp", "cc", "h"):
+        return "cpp"
+    if ext in ("csv",):
+        return "csv"
+    if ext in ("md",):
+        return "markdown"
+    if ext in ("sh",):
+        return "bash"
+    return "log"
+
+
+def get_file_icon(file):
+    if not file:
+        return 'file'
+    ext = utils.get_file_ext(file)
+    file_type = get_file_type(ext)
+    if file.endswith('.pkg.json'):
+        return 'boxes'
+    elif ext in ('png', 'jpg', 'jpeg'):
+        return 'file-image'
+    elif ext == 'json':
+        return 'file-json'
+    elif file_type in ('verilog', 'tcl', 'vhdl', 'cpp', 'bash'):
+        return 'file-code'
+    elif ext in ('log', 'rpt', 'drc', 'warnings', 'errors'):
+        return 'file-text'
+    return 'file'
+
+
+def convert_filepaths_to_select_tree(logs_and_reports):
+    """
+    Converts the logs_and_reports found to the structure
+    required by streamlit_tree_select. Success is predicated on the order of
+    logs_and_reports outlined in report.get_files.
+
+    Args:
+        logs_and_reports (list) : A list of 3-tuples with order of a path name,
+            folder in the..., and files in the....
+    """
+    if not logs_and_reports:
+        return []
+
+    all_files = {}
+    for path_name, folders, files in logs_and_reports:
+        all_files[path_name] = {
+            'files': list(files),
+            'folders': list(folders)
+        }
+
+    def organize_node(base_folder):
+        nodes = []
+
+        for folder in all_files[base_folder]['folders']:
+            path = os.path.join(base_folder, folder)
+            nodes.append({
+                'value': path,
+                'label': folder,
+                'children': organize_node(path)
+            })
+        for file in all_files[base_folder]['files']:
+            nodes.append({
+                'value': os.path.join(base_folder, file),
+                'label': file
+            })
+
+        return nodes
+
+    starting_path_name = logs_and_reports[0][0]
+    return organize_node(starting_path_name)

siliconcompiler/report/dashboard/viewer.py

@@ -0,0 +1,36 @@
+import streamlit
+
+from siliconcompiler.report.dashboard import components
+from siliconcompiler.report.dashboard import layouts
+from siliconcompiler.report.dashboard import state
+from siliconcompiler.report.dashboard import utils
+
+import streamlit_autorefresh
+
+
+if __name__ == "__main__":
+    # opened by running command in siliconcompiler/apps/sc_dashboard.py
+    state.init()
+
+    components.setup_page()
+    state.setup()
+
+    layout = layouts.get_layout(state.get_key(state.APP_LAYOUT))
+    layout()
+
+    reload = False
+    if state.get_key(state.SELECTED_JOB) == 'default':
+        reload = state.set_key(state.IS_RUNNING, utils.is_running(state.get_chip()))
+
+    if state.get_key(state.IS_RUNNING):
+        update_interval = state.get_key(state.APP_RUNNING_REFRESH)
+    else:
+        update_interval = state.get_key(state.APP_STOPPED_REFRESH)
+
+    streamlit_autorefresh.st_autorefresh(interval=update_interval)
+
+    state.debug_print_state()
+
+    if reload or state.update_manifest() or state.get_key(state.APP_RERUN):
+        state.set_key(state.APP_RERUN, None)
+        streamlit.rerun()

siliconcompiler/report/report.py

@@ -1,3 +1,4 @@
+import fnmatch
 import pandas
 import os
 from siliconcompiler import Schema
@@ -104,7 +105,8 @@ def make_manifest_helper(manifest_subsect, modified_manifest_subsect):
 
     def build_leaf(manifest_subsect):
         if manifest_subsect['pernode'] == 'never':
-            if Schema.GLOBAL_KEY in manifest_subsect['node']:
+            if Schema.GLOBAL_KEY in manifest_subsect['node'] and \
+                    Schema.GLOBAL_KEY in manifest_subsect['node'][Schema.GLOBAL_KEY]:
                 value = manifest_subsect['node'][Schema.GLOBAL_KEY][Schema.GLOBAL_KEY]['value']
             else:
                 value = manifest_subsect['node']['default']['default']['value']
@@ -201,7 +203,7 @@ def search_manifest_keys(manifest, key):
     '''
     filtered_manifest = {}
     for dict_key in manifest:
-        if key in dict_key:
+        if fnmatch.fnmatch(dict_key, key):
             filtered_manifest[dict_key] = manifest[dict_key]
         elif isinstance(manifest[dict_key], dict):
             result = search_manifest_keys(manifest[dict_key], key)
@@ -225,8 +227,16 @@ def search_manifest_values(manifest, value):
             result = search_manifest_values(manifest[key], value)
             if result:  # result is non-empty
                 filtered_manifest[key] = result
-        elif isinstance(manifest[key], str) and value in manifest[key]:
-            filtered_manifest[key] = manifest[key]
+        else:
+            if manifest[key] is None:
+                continue
+
+            if isinstance(manifest[key], (list, tuple)):
+                if fnmatch.filter([str(v) for v in manifest[key]], value):
+                    filtered_manifest[key] = manifest[key]
+            else:
+                if fnmatch.fnmatch(str(manifest[key]), value):
+                    filtered_manifest[key] = manifest[key]
     return filtered_manifest
 
 
@@ -251,8 +261,12 @@ def search_manifest(manifest, key_search=None, value_search=None):
     '''
     return_manifest = manifest
     if key_search:
+        if '*' not in key_search or '?' not in key_search:
+            key_search = f'*{key_search}*'
         return_manifest = search_manifest_keys(return_manifest, key_search)
     if value_search:
+        if '*' not in value_search or '?' not in value_search:
+            value_search = f'*{value_search}*'
         return_manifest = search_manifest_values(return_manifest, value_search)
     return return_manifest
 
@@ -286,7 +300,11 @@ def get_metrics_source(chip, step, index):
     '''
     file_to_metric = {}
     tool, task = get_tool_task(chip, step, index)
+    if not chip.valid('tool', tool, 'task', task, 'report'):
+        return file_to_metric
+
     metrics = chip.getkeys('tool', tool, 'task', task, 'report')
+
     for metric in metrics:
         sources = chip.get('tool', tool, 'task', task, 'report', metric, step=step, index=index)
         for source in sources:

siliconcompiler/scheduler/__init__.py

@@ -134,6 +134,10 @@ def _finalize_run(chip, environment):
     filepath = os.path.join(chip.getworkdir(), f"{chip.design}.pkg.json")
     chip.write_manifest(filepath)
 
+    # Update dashboard
+    if chip._dash:
+        chip._dash.update_manifest()
+
     send_messages.send(chip, 'summary', None, None)
 
 
@@ -278,6 +282,11 @@ def _local_process(chip, flow):
     processes = {}
     local_processes = []
     _prepare_nodes(chip, nodes_to_run, processes, local_processes, flow)
+
+    # Update dashboard before run begins
+    if chip._dash:
+        chip._dash.update_manifest()
+
     try:
         _launch_nodes(chip, nodes_to_run, processes, local_processes)
     except KeyboardInterrupt:
@@ -985,6 +994,8 @@ def _check_logfile(chip, step, index, quiet=False, run_func=None):
     Check log file (must be after post-process)
     '''
     if run_func is None:
+        tool, task = get_tool_task(chip, step, index)
+
         log_file = os.path.join(chip.getworkdir(step=step, index=index), f'{step}.log')
         matches = check_logfile(chip, step=step, index=index,
                                 display=not quiet,
@@ -994,13 +1005,27 @@ def _check_logfile(chip, step, index, quiet=False, run_func=None):
             if errors is None:
                 errors = 0
             errors += matches['errors']
-            record_metric(chip, step, index, 'errors', errors, f'{step}.log')
+
+            sources = [f'{step}.log']
+            if chip.valid('tool', tool, 'task', task, 'regex', 'errors'):
+                if chip.get('tool', tool, 'task', task, 'regex', 'errors',
+                            step=step, index=index):
+                    sources.append(f'{step}.errors')
+
+            record_metric(chip, step, index, 'errors', errors, sources)
         if 'warnings' in matches:
             warnings = chip.get('metric', 'warnings', step=step, index=index)
             if warnings is None:
                 warnings = 0
             warnings += matches['warnings']
-            record_metric(chip, step, index, 'warnings', warnings, f'{step}.log')
+
+            sources = [f'{step}.log']
+            if chip.valid('tool', tool, 'task', task, 'regex', 'warnings'):
+                if chip.get('tool', tool, 'task', task, 'regex', 'warnings',
+                            step=step, index=index):
+                    sources.append(f'{step}.warnings')
+
+            record_metric(chip, step, index, 'warnings', warnings, sources)
 
 
 def _executenode(chip, step, index, replay):
@@ -1354,16 +1379,16 @@ def _prepare_nodes(chip, nodes_to_run, processes, local_processes, flow):
 def _check_node_dependencies(chip, node, deps, deps_was_successful):
     had_deps = len(deps) > 0
     step, index = node
-    tool, task = get_tool_task(chip, step, index)
+    tool, _ = get_tool_task(chip, step, index)
 
     # Clear any nodes that have finished from dependency list.
     for in_step, in_index in list(deps):
         in_status = chip.get('record', 'status', step=in_step, index=in_index)
-        if in_status != NodeStatus.PENDING:
+        if NodeStatus.is_done(in_status):
             deps.remove((in_step, in_index))
         if in_status == NodeStatus.SUCCESS:
             deps_was_successful[node] = True
-        if in_status == NodeStatus.ERROR:
+        if NodeStatus.is_error(in_status):
             # Fail if any dependency failed for non-builtin task
             if tool != 'builtin':
                 deps.clear()
@@ -1418,7 +1443,7 @@ def _launch_nodes(chip, nodes_to_run, processes, local_processes):
         _get_callback('pre_run')(chip)
 
     while len(nodes_to_run) > 0 or len(running_nodes) > 0:
-        _process_completed_nodes(chip, processes, running_nodes)
+        changed = _process_completed_nodes(chip, processes, running_nodes)
 
         # Check for new nodes that can be launched.
         for node, deps in list(nodes_to_run.items()):
@@ -1440,6 +1465,9 @@ def _launch_nodes(chip, nodes_to_run, processes, local_processes):
                     if _get_callback('pre_node'):
                         _get_callback('pre_node')(chip, *node)
 
+                    chip.set('record', 'status', NodeStatus.RUNNING, step=node[0], index=node[1])
+                    changed = True
+
                     processes[node].start()
                     del nodes_to_run[node]
                     running_nodes[node] = requested_threads
@@ -1452,11 +1480,16 @@ def _launch_nodes(chip, nodes_to_run, processes, local_processes):
             raise SiliconCompilerError(
                 'Nodes left to run, but no running nodes. From/to may be invalid.', chip=chip)
 
+        if chip._dash and changed:
+            # Update dashboard if the manifest changed
+            chip._dash.update_manifest()
+
         # TODO: exponential back-off with max?
         time.sleep(0.1)
 
 
 def _process_completed_nodes(chip, processes, running_nodes):
+    changed = False
     for node in list(running_nodes.keys()):
         if not processes[node].is_alive():
             step, index = node
@@ -1477,9 +1510,13 @@ def _process_completed_nodes(chip, processes, running_nodes):
 
             chip.set('record', 'status', status, step=step, index=index)
 
+            changed = True
+
             if _get_callback('post_node'):
                 _get_callback('post_node')(chip, *node)
 
+    return changed
+
 
 def _check_nodes_status(chip, flow):
     def success(node):

siliconcompiler/schema/schema_obj.py

@@ -628,7 +628,7 @@ class Schema:
         return copy.deepcopy(cfg)
 
     ###########################################################################
-    def valid(self, *args, default_valid=False, job=None):
+    def valid(self, *args, default_valid=False, job=None, check_complete=False):
         """
         Checks validity of a keypath.
 
@@ -653,7 +653,9 @@ class Schema:
                 cfg = cfg[default]
             else:
                 return False
-        return Schema._is_leaf(cfg)
+        if check_complete:
+            return Schema._is_leaf(cfg)
+        return True
 
     ##########################################################################
     def has_field(self, *args):

siliconcompiler/tools/_common/tcl/sc_pin_constraints.tcl

@@ -1,8 +1,9 @@
-proc sc_collect_pin_constraints { \
-    placement_pins_arg \
-    ordered_pins_arg \
-    sc_side_layer_func \
-    { print_func puts } } {
+proc sc_collect_pin_constraints {
+    placement_pins_arg
+    ordered_pins_arg
+    sc_side_layer_func
+    { print_func puts }
+} {
     upvar 1 $placement_pins_arg placement_pins
     upvar 1 $ordered_pins_arg ordered_pins
 

siliconcompiler/tools/openroad/floorplan.py

@@ -1,4 +1,5 @@
 from siliconcompiler.tools._common import input_provides, add_common_file, get_tool_task
+from siliconcompiler.tools._common.asic import set_tool_task_var
 from siliconcompiler.tools.openroad.openroad import setup as setup_tool
 from siliconcompiler.tools.openroad.openroad import build_pex_corners
 from siliconcompiler.tools.openroad.openroad import post_process as or_post_process
@@ -46,6 +47,10 @@ def setup(chip):
              'script to insert the padring',
              field='help')
 
+    set_tool_task_var(chip, param_key='remove_synth_buffers',
+                      default_value=True,
+                      schelp='remove buffers inserted by synthesis')
+
     snap = chip.get('tool', tool, 'task', task, 'var', 'ifp_snap_strategy',
                     step=step, index=index)[0]
     snaps_allowed = ('none', 'site', 'manufacturing_grid')