siliconcompiler 0.34.0__py3-none-any.whl → 0.34.2__py3-none-any.whl

siliconcompiler/remote/client.py

@@ -20,6 +20,7 @@ from siliconcompiler.report.dashboard import DashboardType
 from siliconcompiler.flowgraph import RuntimeFlowgraph
 from siliconcompiler.scheduler.scheduler import Scheduler
 from siliconcompiler.schema import Journal
+from siliconcompiler.utils.logging import get_console_formatter
 
 # Step name to use while logging
 remote_step_name = 'remote'
@@ -298,14 +299,15 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
             nodes_log = f'  {status.title()} ({num_nodes}): '
             log_nodes = []
             for node, _ in nodes:
-                node_len = len(node)
+                node_name = self.__node_information[node]['print']
+                node_len = len(node_name)
 
                 if node_len + line_len + 2 < self.__maxlinelength:
-                    log_nodes.append(node)
+                    log_nodes.append(node_name)
                     line_len += node_len + 2
                 else:
                     if len(log_nodes) == num_nodes - 1:
-                        log_nodes.append(node)
+                        log_nodes.append(node_name)
                     else:
                         log_nodes.append('...')
                     break
@@ -375,7 +377,7 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
             if SCNodeStatus.is_running(stat):
                 self.__logger.info(f'  {stat.title()} ({len(nodes)}):')
                 for node, node_info in nodes:
-                    running_log = f"    {node}"
+                    running_log = f"    {self.__node_information[node]['print']}"
                     if 'elapsed_time' in node_info:
                         running_log += f" ({node_info['elapsed_time']})"
                     self.__logger.info(running_log)
@@ -483,7 +485,8 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
 
         # Run the job on the remote server, and wait for it to finish.
         # Set logger to indicate remote run
-        self.__chip._init_logger(step=self.STEP_NAME, index=None, in_run=True)
+        self.__chip._logger_console.setFormatter(
+            get_console_formatter(self.__chip, True, self.STEP_NAME, None))
 
         # Ask the remote server to start processing the requested step.
         self.__request_run()
@@ -494,7 +497,8 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
         finally:
             # Restore logger
             self.__chip._dash.end_of_run()
-            self.__chip._init_logger(in_run=True)
+            self.__chip._logger_console.setFormatter(
+                get_console_formatter(self.__chip, False, None, None))
 
     def __request_run(self):
         '''
@@ -529,7 +533,7 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
         # Redirected POST requests are translated to GETs. This is actually
         # part of the HTTP spec, so we need to manually follow the trail.
         post_params = {
-            'chip_cfg': self.__chip.schema.getdict(),
+            'chip_cfg': self.__chip.getdict(),
             'params': self.__get_post_params(include_job_id=True)
         }
 
@@ -571,7 +575,7 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
             key_type = self.__chip.get(*key, field='type')
 
             if 'dir' in key_type or 'file' in key_type:
-                for _, step, index in self.__chip.schema.get(*key, field=None).getvalues(
+                for _, step, index in self.__chip.get(*key, field=None).getvalues(
                         return_defvalue=False):
                     packages = self.__chip.get(*key, field='package', step=step, index=index)
                     if not isinstance(packages, list):
@@ -650,7 +654,8 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
         return changed
 
     def __ensure_run_loop_information(self):
-        self.__chip._init_logger(step=self.STEP_NAME, index='0', in_run=True)
+        self.__chip._logger_console.setFormatter(
+            get_console_formatter(self.__chip, True, self.STEP_NAME, None))
         if not self.__download_pool:
             self.__download_pool = multiprocessing.Pool()
 
@@ -663,7 +668,7 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
 
         self.__node_information = {}
         runtime = RuntimeFlowgraph(
-            self.__chip.schema.get("flowgraph", self.__chip.get('option', 'flow'), field='schema'),
+            self.__chip.get("flowgraph", self.__chip.get('option', 'flow'), field='schema'),
             from_steps=self.__chip.get('option', 'from'),
             to_steps=self.__chip.get('option', 'to'),
             prune_nodes=self.__chip.get('option', 'prune'))
@@ -674,7 +679,8 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
                 "step": step,
                 "index": index,
                 "imported": done,
-                "fetched": done
+                "fetched": done,
+                "print": f"{step}/{index}"
             }
             self.__node_information[f'{step}{index}'] = node_info
 
@@ -749,7 +755,7 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
     def __schedule_fetch_result(self, node):
         if node:
             self.__node_information[node]["fetched"] = True
-            self.__logger.info(f'    {node}')
+            self.__logger.info(f'    {self.__node_information[node]["print"]}')
         else:
             self.__setup_information_fetched = True
         self.__download_pool.apply_async(Client._fetch_result, (self, node))

siliconcompiler/remote/server.py

@@ -96,7 +96,7 @@ class Server:
 
     def __run_start(self, chip):
         flow = chip.get("option", "flow")
-        nodes = chip.schema.get("flowgraph", flow, field="schema").get_nodes()
+        nodes = chip.get("flowgraph", flow, field="schema").get_nodes()
 
         with self.sc_jobs_lock:
             job_hash = self.sc_chip_lookup[chip]["jobhash"]
@@ -442,7 +442,7 @@ class Server:
         job_hash = chip.get('record', 'remoteid')
 
         runtime = RuntimeFlowgraph(
-            chip.schema.get("flowgraph", chip.get('option', 'flow'), field='schema'),
+            chip.get("flowgraph", chip.get('option', 'flow'), field='schema'),
             from_steps=chip.get('option', 'from'),
             to_steps=chip.get('option', 'to'),
             prune_nodes=chip.get('option', 'prune'))

siliconcompiler/report/dashboard/cli/__init__.py

@@ -23,11 +23,11 @@ class CliDashboard(AbstractDashboard):
         self._logger = logger
         if self._logger and self._dashboard._active:
             # Hijack the console
-            self._logger.removeHandler(self._chip.logger._console)
-            self.__logger_console = self._chip.logger._console
-            self._chip.logger._console = self._dashboard._log_handler
+            self._logger.removeHandler(self._chip._logger_console)
+            self.__logger_console = self._chip._logger_console
+            self._chip._logger_console = self._dashboard._log_handler
             self._logger.addHandler(self._dashboard._log_handler)
-            self._chip._init_logger_formats()
+            self._dashboard._log_handler.setFormatter(self.__logger_console.formatter)
 
     def open_dashboard(self):
         """Starts the dashboard rendering thread if it is not already running."""
@@ -71,9 +71,9 @@ class CliDashboard(AbstractDashboard):
         # Restore logger
         if self.__logger_console:
             self._logger.removeHandler(self._dashboard._log_handler)
-            self._chip.logger._console = self.__logger_console
+            self._chip._logger_console = self.__logger_console
             self._logger.addHandler(self.__logger_console)
-            self._chip._init_logger_formats()
+            self.__logger_console.setFormatter(self._dashboard._log_handler.formatter)
             self.__logger_console = None
 
     def wait(self):

siliconcompiler/report/dashboard/cli/board.py

@@ -750,10 +750,10 @@ class Board(metaclass=BoardSingleton):
                 raise SiliconCompilerError("dummy error")
 
             runtime_flow = RuntimeFlowgraph(
-                chip.schema.get("flowgraph", flow, field='schema'),
+                chip.get("flowgraph", flow, field='schema'),
                 to_steps=chip.get('option', 'to'),
                 prune_nodes=chip.get('option', 'prune'))
-            record = chip.schema.get("record", field='schema')
+            record = chip.get("record", field='schema')
 
             execnodes = runtime_flow.get_nodes()
             lowest_priority = 3 * len(execnodes)  # 2x + 1 is lowest computed, so 3x will be lower
@@ -776,7 +776,7 @@ class Board(metaclass=BoardSingleton):
                         node_outputs.setdefault(in_node, set()).add(node)
 
             flow_entry_nodes = set(
-                chip.schema.get("flowgraph", flow, field="schema").get_entry_nodes())
+                chip.get("flowgraph", flow, field="schema").get_entry_nodes())
 
             running_nodes = set([node for node in nodes if NodeStatus.is_running(nodestatus[node])])
             done_nodes = set([node for node in nodes if NodeStatus.is_done(nodestatus[node])])

siliconcompiler/report/dashboard/web/components/__init__.py

@@ -301,7 +301,7 @@ def manifest_viewer(
             if streamlit.checkbox(
                     'Raw manifest',
                     help='Click here to see the manifest before it was made more readable'):
-                manifest_to_show = chip.schema.getdict()
+                manifest_to_show = chip.getdict()
             else:
                 manifest_to_show = report.make_manifest(chip)
 
@@ -326,7 +326,7 @@ def manifest_viewer(
         streamlit.download_button(
             label='Download',
             file_name='manifest.json',
-            data=json.dumps(chip.schema.getdict(), indent=2),
+            data=json.dumps(chip.getdict(), indent=2),
             mime="application/json",
             use_container_width=True)
 
@@ -494,7 +494,7 @@ def node_viewer(chip, step, index, metric_dataframe, height=None):
 
     metrics_col, records_col, logs_and_reports_col = streamlit.columns(3, gap='small')
 
-    node_name = f'{step}{index}'
+    node_name = f'{step}/{index}'
 
     with metrics_col:
         streamlit.subheader(f'{node_name} metrics')
@@ -504,7 +504,7 @@ def node_viewer(chip, step, index, metric_dataframe, height=None):
                 use_container_width=True,
                 height=height)
     with records_col:
-        streamlit.subheader(f'{step}{index} details')
+        streamlit.subheader(f'{step}/{index} details')
         nodes = {}
         nodes[step + index] = report.get_flowgraph_nodes(chip, step, index)
         streamlit.dataframe(
@@ -512,7 +512,7 @@ def node_viewer(chip, step, index, metric_dataframe, height=None):
             use_container_width=True,
             height=height)
     with logs_and_reports_col:
-        streamlit.subheader(f'{step}{index} files')
+        streamlit.subheader(f'{step}/{index} files')
         node_file_tree_viewer(chip, step, index)
 
 

siliconcompiler/report/dashboard/web/components/flowgraph.py

@@ -45,8 +45,8 @@ def get_nodes_and_edges(chip):
     successful_path = report.get_flowgraph_path(chip)
 
     flow = chip.get('option', 'flow')
-    entry_exit_nodes = chip.schema.get("flowgraph", flow, field="schema").get_entry_nodes() + \
-        chip.schema.get("flowgraph", flow, field="schema").get_exit_nodes()
+    entry_exit_nodes = chip.get("flowgraph", flow, field="schema").get_entry_nodes() + \
+        chip.get("flowgraph", flow, field="schema").get_exit_nodes()
 
     for step, index in node_dependencies:
         # Build node
@@ -60,7 +60,7 @@ def get_nodes_and_edges(chip):
         node_color = NODE_COLORS[node_status]
 
         tool, task = get_tool_task(chip, step, index)
-        node_name = f'{step}{index}'
+        node_name = f'{step}/{index}'
         label = node_name + "\n" + tool + "/" + task
         if tool == 'builtin':
             label = node_name + "\n" + tool
@@ -95,7 +95,7 @@ def get_nodes_and_edges(chip):
                 dashes = True
 
             edges.append(Edge(
-                source=f'{source_step}{source_index}',
+                source=f'{source_step}/{source_index}',
                 target=node_name,
                 dir='up',
                 width=edge_width,

siliconcompiler/report/dashboard/web/components/graph.py

@@ -67,7 +67,7 @@ def settings(metrics, nodes, graph_number):
 
     Args:
         metrics (list) : A list of metrics that are set for all chips given in chips.
-        nodes (list) : A list of nodes given in the form f'{step}{index}'
+        nodes (list) : A list of nodes given in the form f'{step}/{index}'
         graph_number (int) : The number of graphs there are. Used to create
             keys to distinguish selectboxes from each other.
     """
@@ -147,7 +147,7 @@ def graph(metrics, nodes, node_to_step_index_map, graph_number):
 
     labels = {
         "runs": state.get_key(state.GRAPH_JOBS),
-        "nodes": [f'{step}{index}' for step, index in data]
+        "nodes": [f'{step}/{index}' for step, index in data]
     }
 
     if nodes:

siliconcompiler/report/dashboard/web/state.py

@@ -125,7 +125,7 @@ def init():
         chip_index = chip.get('arg', 'index')
 
         if chip_step and chip_index:
-            set_key(SELECTED_NODE, f'{chip_step}{chip_index}')
+            set_key(SELECTED_NODE, f'{chip_step}/{chip_index}')
 
     chip = get_chip("default")
     chip.unset('arg', 'step')

siliconcompiler/report/dashboard/web/utils/__init__.py

@@ -24,9 +24,9 @@ def make_node_to_step_index_map(chip, metric_dataframe):
     '''
     node_to_step_index_map = {}
     if chip.get('option', 'flow'):
-        for step, index in chip.schema.get("flowgraph", chip.get('option', 'flow'),
-                                           field="schema").get_nodes():
-            node_to_step_index_map[f'{step}{index}'] = (step, index)
+        for step, index in chip.get("flowgraph", chip.get('option', 'flow'),
+                                    field="schema").get_nodes():
+            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]}')
@@ -57,8 +57,8 @@ def make_metric_to_metric_unit_map(metric_dataframe):
 def is_running(chip):
     if not chip.get('option', 'flow'):
         return False
-    for step, index in chip.schema.get("flowgraph", chip.get('option', 'flow'),
-                                       field="schema").get_nodes():
+    for step, index in chip.get("flowgraph", chip.get('option', 'flow'),
+                                field="schema").get_nodes():
         state = chip.get('record', 'status', step=step, index=index)
         if not NodeStatus.is_done(state):
             return True

siliconcompiler/report/html_report.py

@@ -50,7 +50,7 @@ def _generate_html_report(chip, flow, flowgraph_nodes, results_html):
             metrics=metrics,
             metrics_unit=metrics_unit,
             reports=reports,
-            manifest=chip.schema.getdict(),
+            manifest=chip.getdict(),
             pruned_cfg=pruned_cfg,
             metric_keys=metrics_to_show,
             img_data=img_data,

siliconcompiler/report/report.py

@@ -61,7 +61,7 @@ def get_flowgraph_nodes(chip, step, index):
             value = chip.get('record', key, step=step, index=index)
         if value is not None:
             if key == 'inputnode':
-                value = ", ".join([f'{step}{index}' for step, index in value])
+                value = ", ".join([f'{step}/{index}' for step, index in value])
             if key == 'pythonpackage':
                 value = ", ".join(value)
             nodes[key] = str(value)
@@ -181,7 +181,7 @@ def make_manifest(chip):
         >>> make_manifest(chip)
         Returns tree/json of manifest.
     '''
-    manifest = chip.schema.getdict()
+    manifest = chip.getdict()
     modified_manifest = {}
     make_manifest_helper(manifest, modified_manifest)
     return modified_manifest
@@ -200,7 +200,7 @@ def get_flowgraph_path(chip):
     '''
     flow = chip.get('option', 'flow')
     runtime = RuntimeFlowgraph(
-        chip.schema.get("flowgraph", flow, field='schema'),
+        chip.get("flowgraph", flow, field='schema'),
         from_steps=chip.get('option', 'from'),
         to_steps=chip.get('option', 'to'),
         prune_nodes=chip.get('option', 'prune'))
@@ -363,7 +363,7 @@ def get_chart_selection_options(chips):
         chip = chip_and_chip_name['chip_object']
         nodes_list, _, _, _, chip_metrics, _ = \
             utils._collect_data(chip, format_as_string=False)
-        nodes.update(set([f'{step}{index}' for step, index in nodes_list]))
+        nodes.update(set([f'{step}/{index}' for step, index in nodes_list]))
         metrics.update(set(chip_metrics))
     return nodes, metrics
 

siliconcompiler/report/summary_table.py

@@ -44,7 +44,7 @@ def _show_summary_table(chip, flow, flowgraph_nodes, show_all_indices):
 
     # trim labels to column width
     column_labels = []
-    labels = [f'{step}{index}' for step, index in nodes_to_show]
+    labels = [f'{step}/{index}' for step, index in nodes_to_show]
     if labels:
         column_width = min([column_width, max([len(label) for label in labels])])
 
@@ -85,7 +85,7 @@ def _show_summary_table(chip, flow, flowgraph_nodes, show_all_indices):
             info_list.append(f"partname : {fpga_partname}")
 
     libraries = set()
-    for val, step, index in chip.schema.get('asic', 'logiclib', field=None).getvalues():
+    for val, step, index in chip.get('asic', 'logiclib', field=None).getvalues():
         if not step or (step, index) in flowgraph_nodes:
             libraries.update(val)
     if libraries:

siliconcompiler/report/utils.py

@@ -6,7 +6,7 @@ from siliconcompiler.flowgraph import RuntimeFlowgraph
 
 
 def _find_summary_image(chip, ext='png'):
-    for nodes in reversed(chip.schema.get(
+    for nodes in reversed(chip.get(
             "flowgraph", chip.get('option', 'flow'), field="schema").get_execution_order()):
         for step, index in nodes:
             layout_img = chip.find_result(ext, step=step, index=index)
@@ -17,7 +17,7 @@ def _find_summary_image(chip, ext='png'):
 
 def _find_summary_metrics(chip, metrics_map):
     metrics = {}
-    for nodes in reversed(chip.schema.get(
+    for nodes in reversed(chip.get(
             "flowgraph", chip.get('option', 'flow'), field="schema").get_execution_order()):
         for step, index in nodes:
             for name, metric_info in metrics_map.items():
@@ -45,7 +45,7 @@ def _collect_data(chip, flow=None, flowgraph_nodes=None, format_as_string=True):
 
     if not flowgraph_nodes:
         runtime = RuntimeFlowgraph(
-            chip.schema.get("flowgraph", flow, field='schema'),
+            chip.get("flowgraph", flow, field='schema'),
             from_steps=chip.get('option', 'from'),
             to_steps=chip.get('option', 'to'),
             prune_nodes=chip.get('option', 'prune'))
@@ -70,7 +70,7 @@ def _collect_data(chip, flow=None, flowgraph_nodes=None, format_as_string=True):
     reports = {}
 
     # Build ordered list of nodes in flowgraph
-    for level_nodes in chip.schema.get("flowgraph", flow, field="schema").get_execution_order():
+    for level_nodes in chip.get("flowgraph", flow, field="schema").get_execution_order():
         nodes.extend(sorted(level_nodes))
     nodes = [node for node in nodes if node in flowgraph_nodes]
     for (step, index) in nodes:
@@ -147,7 +147,7 @@ def _get_flowgraph_path(chip, flow, nodes_to_execute, only_include_successful=Fa
     to_search = []
     # Start search with any successful leaf nodes.
     flowgraph_steps = list(map(lambda node: node[0], nodes_to_execute))
-    runtime = RuntimeFlowgraph(chip.schema.get("flowgraph", flow, field='schema'),
+    runtime = RuntimeFlowgraph(chip.get("flowgraph", flow, field='schema'),
                                from_steps=flowgraph_steps,
                                to_steps=flowgraph_steps)
     end_nodes = runtime.get_exit_nodes()

siliconcompiler/scheduler/docker.py

@@ -112,6 +112,8 @@ class DockerSchedulerNode(SchedulerNode):
             chip.collect()
 
     def run(self):
+        self._init_run_logger()
+
         try:
             client = docker.from_env()
             client.version()
@@ -124,13 +126,6 @@ class DockerSchedulerNode(SchedulerNode):
         workdir = self.chip.getworkdir()
         start_cwd = os.getcwd()
 
-        # Remove handlers from logger
-        for handler in self.logger.handlers.copy():
-            self.logger.removeHandler(handler)
-
-        # Reinit logger
-        self.chip._init_logger(step=self.step, index=self.index, in_run=True)
-
         # Change working directory since the run may delete this folder
         os.makedirs(workdir, exist_ok=True)
         os.chdir(workdir)
@@ -162,8 +157,7 @@ class DockerSchedulerNode(SchedulerNode):
             builddir = f'{cwd}/build'
 
             local_cfg = os.path.join(start_cwd, 'sc_docker.json')
-            job = self.chip.get('option', 'jobname')
-            cfg = f'{builddir}/{self.chip.design}/{job}/{self.step}/{self.index}/sc_docker.json'
+            cfg = f'{builddir}/{self.name}/{self.jobname}/{self.step}/{self.index}/sc_docker.json'
 
             user = None
 
@@ -215,7 +209,7 @@ class DockerSchedulerNode(SchedulerNode):
                 volumes=volumes,
                 labels=[
                     "siliconcompiler",
-                    f"sc_node:{self.chip.design}:{self.step}{self.index}"
+                    f"sc_node:{self.name}:{self.step}:{self.index}"
                 ],
                 user=user,
                 detach=True,

siliconcompiler/scheduler/run_node.py

@@ -7,6 +7,7 @@ import tarfile
 import os.path
 
 from siliconcompiler import Chip, Schema
+from siliconcompiler.package import Resolver
 from siliconcompiler.scheduler.schedulernode import SchedulerNode
 from siliconcompiler import __version__
 
@@ -95,19 +96,14 @@ def main():
         chip.set('record', 'remoteid', args.remoteid)
 
     if args.unset_scheduler:
-        for vals, step, index in chip.schema.get('option', 'scheduler', 'name',
-                                                 field=None).getvalues():
+        for _, step, index in chip.get('option', 'scheduler', 'name',
+                                       field=None).getvalues():
             chip.unset('option', 'scheduler', 'name', step=step, index=index)
 
-    # Init logger to ensure consistent view
-    chip._init_logger(step=args.step,
-                      index=args.index,
-                      in_run=True)
-
     if args.cachemap:
         for cachepair in args.cachemap:
             package, path = cachepair.split(':')
-            chip.get("package", field="schema")._set_cache(package, path)
+            Resolver.set_cache(chip, package, path)
 
     # Populate cache
     for resolver in chip.get('package', field='schema').get_resolvers().values():

siliconcompiler/scheduler/scheduler.py

@@ -21,7 +21,8 @@ from siliconcompiler.scheduler import send_messages
 class Scheduler:
     def __init__(self, chip):
         self.__chip = chip
-        self.__logger = self.__chip.logger
+        self.__logger = chip.logger
+        self.__name = chip.design
 
         flow = self.__chip.get("option", "flow")
         if not flow:
@@ -30,7 +31,7 @@ class Scheduler:
         if flow not in self.__chip.getkeys("flowgraph"):
             raise ValueError("flow is not defined")
 
-        self.__flow = self.__chip.schema.get("flowgraph", flow, field="schema")
+        self.__flow = self.__chip.get("flowgraph", flow, field="schema")
         from_steps = self.__chip.get('option', 'from')
         to_steps = self.__chip.get('option', 'to')
         prune_nodes = self.__chip.get('option', 'prune')
@@ -51,23 +52,13 @@ class Scheduler:
             to_steps=to_steps,
             prune_nodes=self.__chip.get('option', 'prune'))
 
-        self.__flow_runtime_no_prune = RuntimeFlowgraph(
-            self.__flow,
-            from_steps=from_steps,
-            to_steps=to_steps)
-
         self.__flow_load_runtime = RuntimeFlowgraph(
             self.__flow,
             to_steps=from_steps,
             prune_nodes=prune_nodes)
 
-        self.__flow_something = RuntimeFlowgraph(
-            self.__flow,
-            from_steps=set([step for step, _ in self.__flow.get_entry_nodes()]),
-            prune_nodes=prune_nodes)
-
-        self.__record = self.__chip.schema.get("record", field="schema")
-        self.__metrics = self.__chip.schema.get("metric", field="schema")
+        self.__record = self.__chip.get("record", field="schema")
+        self.__metrics = self.__chip.get("metric", field="schema")
 
         self.__tasks = {}
 
@@ -103,7 +94,7 @@ class Scheduler:
         self.__chip.schema.record_history()
 
         # Record final manifest
-        filepath = os.path.join(self.__chip.getworkdir(), f"{self.__chip.design}.pkg.json")
+        filepath = os.path.join(self.__chip.getworkdir(), f"{self.__name}.pkg.json")
         self.__chip.write_manifest(filepath)
 
         send_messages.send(self.__chip, 'summary', None, None)
@@ -206,7 +197,7 @@ class Scheduler:
 
             manifest = os.path.join(self.__chip.getworkdir(step=step, index=index),
                                     'outputs',
-                                    f'{self.__chip.design}.pkg.json')
+                                    f'{self.__name}.pkg.json')
             if os.path.exists(manifest):
                 # ensure we setup these nodes again
                 try:
@@ -217,7 +208,8 @@ class Scheduler:
         # Setup tools for all nodes to run
         for layer_nodes in self.__flow.get_execution_order():
             for step, index in layer_nodes:
-                node_kept = self.__tasks[(step, index)].setup()
+                with self.__tasks[(step, index)].runtime():
+                    node_kept = self.__tasks[(step, index)].setup()
                 if not node_kept and (step, index) in extra_setup_nodes:
                     # remove from previous node data
                     del extra_setup_nodes[(step, index)]
@@ -242,12 +234,13 @@ class Scheduler:
                 if self.__record.get("status", step=step, index=index) != NodeStatus.SUCCESS:
                     continue
 
-                if self.__tasks[(step, index)].requires_run():
-                    # This node must be run
-                    self.__mark_pending(step, index)
-                elif (step, index) in extra_setup_nodes:
-                    # import old information
-                    Journal.access(extra_setup_nodes[(step, index)]).replay(self.__chip.schema)
+                with self.__tasks[(step, index)].runtime():
+                    if self.__tasks[(step, index)].requires_run():
+                        # This node must be run
+                        self.__mark_pending(step, index)
+                    elif (step, index) in extra_setup_nodes:
+                        # import old information
+                        Journal.access(extra_setup_nodes[(step, index)]).replay(self.__chip.schema)
 
         self.__print_status("After requires run")
 
@@ -267,7 +260,8 @@ class Scheduler:
         # Clean nodes marked pending
         for step, index in self.__flow_runtime.get_nodes():
             if NodeStatus.is_waiting(self.__record.get('status', step=step, index=index)):
-                self.__tasks[(step, index)].clean_directory()
+                with self.__tasks[(step, index)].runtime():
+                    self.__tasks[(step, index)].clean_directory()
 
     def __check_display(self):
         '''