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

siliconcompiler/scheduler/schedulernode.py

@@ -1,3 +1,4 @@
+import contextlib
 import logging
 import os
 import shutil
@@ -11,9 +12,10 @@ from logging.handlers import QueueHandler
 from siliconcompiler import utils, sc_open
 from siliconcompiler import Schema
 from siliconcompiler import NodeStatus
+from siliconcompiler.utils.logging import get_console_formatter, SCInRunLoggerFormatter
+from siliconcompiler.schema import utils as schema_utils
 
-from siliconcompiler.tools._common import input_file_node_name, record_metric
-
+from siliconcompiler.package import Resolver
 from siliconcompiler.record import RecordTime, RecordTool
 from siliconcompiler.schema import Journal
 from siliconcompiler.scheduler import send_messages
@@ -25,7 +27,8 @@ class SchedulerNode:
         self.__index = index
         self.__chip = chip
 
-        self.__design = self.__chip.design
+        self.__name = self.__chip.design
+        self.__topmodule = self.__chip.top(step=step, index=index)
 
         self.__job = self.__chip.get('option', 'jobname')
         self.__record_user_info = self.__chip.get("option", "track",
@@ -49,22 +52,25 @@ class SchedulerNode:
         self.__workdir = self.__chip.getworkdir(jobname=self.__job,
                                                 step=self.__step, index=self.__index)
         self.__manifests = {
-            "input": os.path.join(self.__workdir, "inputs", f"{self.__design}.pkg.json"),
-            "output": os.path.join(self.__workdir, "outputs", f"{self.__design}.pkg.json")
+            "input": os.path.join(self.__workdir, "inputs", f"{self.__name}.pkg.json"),
+            "output": os.path.join(self.__workdir, "outputs", f"{self.__name}.pkg.json")
         }
         self.__logs = {
-            "sc": os.path.join(self.__workdir, f"sc_{self.__step}{self.__index}.log"),
+            "sc": os.path.join(self.__workdir, f"sc_{self.__step}_{self.__index}.log"),
             "exe": os.path.join(self.__workdir, f"{self.__step}.log")
         }
         self.__replay_script = os.path.join(self.__workdir, "replay.sh")
 
         self.set_queue(None, None)
-        self.init_state()
-
-    def init_state(self, assign_runtime=False):
         self.__setup_schema_access()
-        if assign_runtime:
-            self.__task.set_runtime(self.__chip, step=self.__step, index=self.__index)
+
+    @contextlib.contextmanager
+    def runtime(self):
+        prev_task = self.__task
+        with self.__task.runtime(self.__chip, step=self.__step, index=self.__index) as runtask:
+            self.__task = runtask
+            yield
+        self.__task = prev_task
 
     @staticmethod
     def init(chip):
@@ -102,8 +108,16 @@ class SchedulerNode:
         return self.__index
 
     @property
-    def design(self):
-        return self.__design
+    def name(self):
+        return self.__name
+
+    @property
+    def topmodule(self):
+        return self.__topmodule
+
+    @property
+    def jobname(self):
+        return self.__job
 
     @property
     def workdir(self):
@@ -137,24 +151,40 @@ class SchedulerNode:
 
     @property
     def threads(self):
-        self.__task.set_runtime(self.__chip, step=self.__step, index=self.__index)
-        thread_count = self.__task.get("task", self.__task.task(), "threads",
-                                       step=self.__step, index=self.__index)
-        self.__task.set_runtime(None)
+        with self.__task.runtime(self.__chip, step=self.__step, index=self.__index) as task:
+            thread_count = task.get("threads")
         return thread_count
 
     def set_queue(self, pipe, queue):
         self.__pipe = pipe
         self.__queue = queue
 
+        # Reinit
+        self.__setup_schema_access()
+
     def __setup_schema_access(self):
         flow = self.__chip.get('option', 'flow')
         self.__flow = self.__chip.get("flowgraph", flow, field="schema")
 
         tool = self.__flow.get(self.__step, self.__index, 'tool')
-        self.__task = self.__chip.schema.get("tool", tool, field="schema")
-        self.__record = self.__chip.schema.get("record", field="schema")
-        self.__metrics = self.__chip.schema.get("metric", field="schema")
+        task = self.__flow.get(self.__step, self.__index, 'task')
+        self.__task = self.__chip.get("tool", tool, "task", task, field="schema")
+        self.__record = self.__chip.get("record", field="schema")
+        self.__metrics = self.__chip.get("metric", field="schema")
+
+    def _init_run_logger(self):
+        self.__chip._logger_console.setFormatter(
+            get_console_formatter(self.__chip, True, self.__step, self.__index))
+        self.logger.setLevel(
+            schema_utils.translate_loglevel(self.__chip.get('option', 'loglevel',
+                                            step=self.__step, index=self.__index)))
+
+        if self.__queue:
+            formatter = self.__chip._logger_console.formatter
+            self.logger.removeHandler(self.__chip._logger_console)
+            self.__chip._logger_console = QueueHandler(self.__queue)
+            self.__chip._logger_console.setFormatter(formatter)
+            self.logger.addHandler(self.__chip._logger_console)
 
     def halt(self, msg=None):
         if msg:
@@ -164,36 +194,33 @@ class SchedulerNode:
         try:
             self.__chip.schema.write_manifest(self.__manifests["output"])
         except FileNotFoundError:
-            self.logger.error(f"Failed to write manifest for {self.__step}{self.__index}.")
+            self.logger.error(f"Failed to write manifest for {self.__step}/{self.__index}.")
 
-        self.logger.error(f"Halting {self.__step}{self.__index} due to errors.")
+        self.logger.error(f"Halting {self.__step}/{self.__index} due to errors.")
         send_messages.send(self.__chip, "fail", self.__step, self.__index)
         sys.exit(1)
 
     def setup(self):
-        self.__task.set_runtime(self.__chip, step=self.__step, index=self.__index)
-
-        # Run node setup.
-        self.logger.info(f'Setting up node {self.__step}{self.__index} with '
-                         f'{self.__task.tool()}/{self.__task.task()}')
-        setup_ret = None
-        try:
-            setup_ret = self.__task.setup()
-        except Exception as e:
-            self.logger.error(f'Failed to run setup() for {self.__step}{self.__index} '
-                              f'with {self.__task.tool()}/{self.__task.task()}')
-            self.__task.set_runtime(None)
-            raise e
-
-        self.__task.set_runtime(None)
+        with self.__task.runtime(self.__chip, step=self.__step, index=self.__index) as task:
+            # Run node setup.
+            self.logger.info(f'Setting up node {self.__step}/{self.__index} with '
+                             f'{task.tool()}/{task.task()}')
+            setup_ret = None
+            try:
+                setup_ret = task.setup()
+            except Exception as e:
+                self.logger.error(f'Failed to run setup() for {self.__step}/{self.__index} '
+                                  f'with {task.tool()}/{task.task()}')
+                raise e
 
-        if setup_ret is not None:
-            self.logger.warning(f'Removing {self.__step}{self.__index} due to {setup_ret}')
-            self.__record.set('status', NodeStatus.SKIPPED, step=self.__step, index=self.__index)
+            if setup_ret is not None:
+                self.logger.warning(f'Removing {self.__step}/{self.__index} due to {setup_ret}')
+                self.__record.set('status', NodeStatus.SKIPPED,
+                                  step=self.__step, index=self.__index)
 
-            return False
+                return False
 
-        return True
+            return True
 
     def check_previous_run_status(self, previous_run):
         # Assume modified if flow does not match
@@ -230,7 +257,7 @@ class SchedulerNode:
         self.logger.setLevel(log_level)
         if set(previous_run.__chip.get("record", "inputnode",
                                        step=self.__step, index=self.__index)) != set(sel_inputs):
-            self.logger.warning(f'inputs to {self.__step}{self.__index} has been modified from '
+            self.logger.warning(f'inputs to {self.__step}/{self.__index} has been modified from '
                                 'previous run')
             return False
 
@@ -240,7 +267,7 @@ class SchedulerNode:
 
     def check_values_changed(self, previous_run, keys):
         def print_warning(key):
-            self.logger.warning(f'[{",".join(key)}] in {self.__step}{self.__index} has been '
+            self.logger.warning(f'[{",".join(key)}] in {self.__step}/{self.__index} has been '
                                 'modified from previous run')
 
         for key in sorted(keys):
@@ -267,7 +294,7 @@ class SchedulerNode:
         use_hash = self.__hash and previous_run.__hash
 
         def print_warning(key, reason):
-            self.logger.warning(f'[{",".join(key)}] ({reason}) in {self.__step}{self.__index} has '
+            self.logger.warning(f'[{",".join(key)}] ({reason}) in {self.__step}/{self.__index} has '
                                 'been modified from previous run')
 
         def get_file_time(path):
@@ -314,8 +341,7 @@ class SchedulerNode:
     def get_check_changed_keys(self):
         all_keys = set()
 
-        all_keys.update(self.__task.get('task', self.__task.task(), 'require',
-                                        step=self.__step, index=self.__index))
+        all_keys.update(self.__task.get('require'))
 
         tool_task_prefix = ('tool', self.__task.tool(), 'task', self.__task.task())
         for key in ('option', 'threads', 'prescript', 'postscript', 'refdir', 'script',):
@@ -353,7 +379,6 @@ class SchedulerNode:
                 self.logger.debug("Input manifest failed to load")
                 return True
             previous_node = SchedulerNode(chip, self.__step, self.__index)
-            previous_node.init_state(assign_runtime=True)
         else:
             # No manifest found so assume rerun is needed
             self.logger.debug("Previous run did not generate input manifest")
@@ -368,62 +393,61 @@ class SchedulerNode:
                 self.logger.debug("Output manifest failed to load")
                 return True
             previous_node_end = SchedulerNode(chip, self.__step, self.__index)
-            previous_node_end.init_state(assign_runtime=True)
         else:
             # No manifest found so assume rerun is needed
             self.logger.debug("Previous run did not generate output manifest")
             return True
 
-        self.init_state(assign_runtime=True)
-
-        if not self.check_previous_run_status(previous_node_end):
-            self.__task.set_runtime(None)
-            self.logger.debug("Previous run state failed")
-            return True
+        with self.runtime():
+            if previous_node_end:
+                with previous_node_end.runtime():
+                    if not self.check_previous_run_status(previous_node_end):
+                        self.logger.debug("Previous run state failed")
+                        return True
 
-        # Generate key paths to check
-        try:
-            value_keys, path_keys = self.get_check_changed_keys()
-            previous_value_keys, previous_path_keys = previous_node.get_check_changed_keys()
-            value_keys.update(previous_value_keys)
-            path_keys.update(previous_path_keys)
-        except KeyError:
-            self.__task.set_runtime(None)
-            self.logger.debug("Failed to acquire keys")
-            return True
+            if previous_node:
+                with previous_node.runtime():
+                    # Generate key paths to check
+                    try:
+                        value_keys, path_keys = self.get_check_changed_keys()
+                        previous_value_keys, previous_path_keys = \
+                            previous_node.get_check_changed_keys()
+                        value_keys.update(previous_value_keys)
+                        path_keys.update(previous_path_keys)
+                    except KeyError:
+                        self.logger.debug("Failed to acquire keys")
+                        return True
 
-        self.__task.set_runtime(None)
-        if self.check_values_changed(previous_node, value_keys.union(path_keys)):
-            self.logger.debug("Key values changed")
-            return True
+                    if self.check_values_changed(previous_node, value_keys.union(path_keys)):
+                        self.logger.debug("Key values changed")
+                        return True
 
-        if self.check_files_changed(previous_node, previous_node_time, path_keys):
-            self.logger.debug("Files changed")
-            return True
+                    if self.check_files_changed(previous_node, previous_node_time, path_keys):
+                        self.logger.debug("Files changed")
+                        return True
 
         return False
 
     def setup_input_directory(self):
-        in_files = set(self.__task.get('task', self.__task.task(), 'input',
-                                       step=self.__step, index=self.__index))
+        in_files = set(self.__task.get('input'))
 
         for in_step, in_index in self.__record.get('inputnode',
                                                    step=self.__step, index=self.__index):
             if NodeStatus.is_error(self.__record.get('status', step=in_step, index=in_index)):
-                self.halt(f'Halting step due to previous error in {in_step}{in_index}')
+                self.halt(f'Halting step due to previous error in {in_step}/{in_index}')
 
             output_dir = os.path.join(
                 self.__chip.getworkdir(step=in_step, index=in_index), "outputs")
             if not os.path.isdir(output_dir):
-                self.halt(f'Unable to locate outputs directory for {in_step}{in_index}: '
+                self.halt(f'Unable to locate outputs directory for {in_step}/{in_index}: '
                           f'{output_dir}')
 
             for outfile in os.scandir(output_dir):
-                if outfile.name == f'{self.__design}.pkg.json':
+                if outfile.name == f'{self.__name}.pkg.json':
                     # Dont forward manifest
                     continue
 
-                new_name = input_file_node_name(outfile.name, in_step, in_index)
+                new_name = self.__task.compute_input_file_node_name(outfile.name, in_step, in_index)
                 if self.__enforce_inputfiles:
                     if outfile.name not in in_files and new_name not in in_files:
                         continue
@@ -451,8 +475,7 @@ class SchedulerNode:
         '''
         error = False
 
-        required_inputs = self.__task.get('task', self.__task.task(), 'input',
-                                          step=self.__step, index=self.__index)
+        required_inputs = self.__task.get('input')
 
         input_dir = os.path.join(self.__workdir, 'inputs')
 
@@ -460,11 +483,10 @@ class SchedulerNode:
             path = os.path.join(input_dir, filename)
             if not os.path.exists(path):
                 self.logger.error(f'Required input {filename} not received for '
-                                  f'{self.__step}{self.__index}.')
+                                  f'{self.__step}/{self.__index}.')
                 error = True
 
-        all_required = self.__task.get('task', self.__task.task(), 'require',
-                                       step=self.__step, index=self.__index)
+        all_required = self.__task.get('require')
         for item in all_required:
             keypath = item.split(',')
             if not self.__chip.valid(*keypath):
@@ -525,15 +547,8 @@ class SchedulerNode:
         to the filesystem to communicate updates between processes.
         '''
 
-        # Setup chip
-        self.__chip._init_codecs()
-        self.__chip._init_logger(self.__step, self.__index, in_run=True)
-
-        if self.__queue:
-            self.logger.removeHandler(self.logger._console)
-            self.logger._console = QueueHandler(self.__queue)
-            self.logger.addHandler(self.logger._console)
-            self.__chip._init_logger_formats()
+        # Setup logger
+        self._init_run_logger()
 
         self.__chip.set('arg', 'step', self.__step)
         self.__chip.set('arg', 'index', self.__index)
@@ -543,7 +558,7 @@ class SchedulerNode:
         journal.start()
 
         # Must be after journaling to ensure journal is complete
-        self.init_state(assign_runtime=True)
+        self.__setup_schema_access()
 
         # Make record of sc version and machine
         self.__record.record_version(self.__step, self.__index)
@@ -555,40 +570,44 @@ class SchedulerNode:
         # Start wall timer
         self.__record.record_time(self.__step, self.__index, RecordTime.START)
 
-        # Setup run directory
-        self.__task.setup_work_directory(self.__workdir, remove_exist=not self.__replay)
-
         cwd = os.getcwd()
-        os.chdir(self.__workdir)
+        with self.runtime():
+            # Setup run directory
+            self.__task.setup_work_directory(self.__workdir, remove_exist=not self.__replay)
 
-        # Attach siliconcompiler file log handler
-        self.__chip._add_file_logger(self.__logs["sc"])
+            os.chdir(self.__workdir)
 
-        # Select the inputs to this node
-        sel_inputs = self.__task.select_input_nodes()
-        if not self.__is_entry_node and not sel_inputs:
-            self.halt(f'No inputs selected for {self.__step}{self.__index}')
-        self.__record.set("inputnode", sel_inputs, step=self.__step, index=self.__index)
+            # Attach siliconcompiler file log handler
+            file_log = logging.FileHandler(self.__logs["sc"])
+            file_log.setFormatter(
+                SCInRunLoggerFormatter(self.__chip, self.__job, self.__step, self.__index))
+            self.logger.addHandler(file_log)
 
-        if self.__hash:
-            self.__hash_files_pre_execute()
+            # Select the inputs to this node
+            sel_inputs = self.__task.select_input_nodes()
+            if not self.__is_entry_node and not sel_inputs:
+                self.halt(f'No inputs selected for {self.__step}/{self.__index}')
+            self.__record.set("inputnode", sel_inputs, step=self.__step, index=self.__index)
 
-        # Forward data
-        if not self.__replay:
-            self.setup_input_directory()
+            if self.__hash:
+                self.__hash_files_pre_execute()
 
-        # Write manifest prior to step running into inputs
-        self.__chip.write_manifest(self.__manifests["input"])
+            # Forward data
+            if not self.__replay:
+                self.setup_input_directory()
 
-        # Check manifest
-        if not self.validate():
-            self.halt("Failed to validate node setup. See previous errors")
+            # Write manifest prior to step running into inputs
+            self.__chip.write_manifest(self.__manifests["input"])
 
-        try:
-            self.execute()
-        except Exception as e:
-            utils.print_traceback(self.logger, e)
-            self.halt()
+            # Check manifest
+            if not self.validate():
+                self.halt("Failed to validate node setup. See previous errors")
+
+            try:
+                self.execute()
+            except Exception as e:
+                utils.print_traceback(self.logger, e)
+                self.halt()
 
         # return to original directory
         os.chdir(cwd)
@@ -597,7 +616,7 @@ class SchedulerNode:
         journal.stop()
 
         if self.__pipe:
-            self.__pipe.send(self.__chip.get("package", field="schema").get_path_cache())
+            self.__pipe.send(Resolver.get_cache(self.__chip))
 
     def execute(self):
         self.logger.info(f'Running in {self.__workdir}')
@@ -614,12 +633,17 @@ class SchedulerNode:
             # copy inputs to outputs and skip execution
             for in_step, in_index in self.__record.get('inputnode',
                                                        step=self.__step, index=self.__index):
+                required_outputs = set(self.__task.get('output'))
                 in_workdir = self.__chip.getworkdir(step=in_step, index=in_index)
                 for outfile in os.scandir(f"{in_workdir}/outputs"):
-                    if outfile.name == f'{self.__design}.pkg.json':
+                    if outfile.name == f'{self.__name}.pkg.json':
                         # Dont forward manifest
                         continue
 
+                    if outfile.name not in required_outputs:
+                        # Dont forward non-required outputs
+                        continue
+
                     if outfile.is_file() or outfile.is_symlink():
                         utils.link_symlink_copy(outfile.path,
                                                 f'outputs/{outfile.name}')
@@ -716,7 +740,7 @@ class SchedulerNode:
         if errors and not self.__chip.get('option', 'continue',
                                           step=self.__step, index=self.__index):
             self.halt(f'{self.__task.tool()}/{self.__task.task()} reported {errors} '
-                      f'errors during {self.__step}{self.__index}')
+                      f'errors during {self.__step}/{self.__index}')
 
         if self.__error:
             self.halt()
@@ -747,9 +771,8 @@ class SchedulerNode:
 
         checks = {}
         matches = {}
-        for suffix in self.__task.getkeys('task', self.__task.task(), 'regex'):
-            regexes = self.__task.get('task', self.__task.task(), 'regex', suffix,
-                                      step=self.__step, index=self.__index)
+        for suffix in self.__task.getkeys('regex'):
+            regexes = self.__task.get('regex', suffix)
             if not regexes:
                 continue
 
@@ -814,17 +837,16 @@ class SchedulerNode:
 
         for metric in ("errors", "warnings"):
             if metric in matches:
-                errors = self.__metrics.get(metric, step=self.__step, index=self.__index)
-                if errors is None:
-                    errors = 0
-                errors += matches[metric]
+                value = self.__metrics.get(metric, step=self.__step, index=self.__index)
+                if value is None:
+                    value = 0
+                value += matches[metric]
 
                 sources = [os.path.basename(self.__logs["exe"])]
-                if self.__task.get('task', self.__task.task(), 'regex', metric,
-                                   step=self.__step, index=self.__index):
+                if self.__task.get('regex', metric):
                     sources.append(f'{self.__step}.{metric}')
 
-                record_metric(self.__chip, self.__step, self.__index, metric, errors, sources)
+                self.__task.record_metric(metric, value, source_file=sources)
 
     def __hash_files_pre_execute(self):
         for task_key in ('refdir', 'prescript', 'postscript', 'script'):
@@ -833,8 +855,7 @@ class SchedulerNode:
                                    allow_cache=True, verbose=False)
 
         # hash all requirements
-        for item in set(self.__task.get('task', self.__task.task(), 'require',
-                                        step=self.__step, index=self.__index)):
+        for item in set(self.__task.get('require')):
             args = item.split(',')
             sc_type = self.__chip.get(*args, field='type')
             if 'file' in sc_type or 'dir' in sc_type:
@@ -850,8 +871,7 @@ class SchedulerNode:
                                step=self.__step, index=self.__index, check=False, verbose=False)
 
         # hash all requirements
-        for item in set(self.__task.get('task', self.__task.task(), 'require',
-                                        step=self.__step, index=self.__index)):
+        for item in set(self.__task.get('require')):
             args = item.split(',')
             sc_type = self.__chip.get(*args, field='type')
             if 'file' in sc_type or 'dir' in sc_type:
@@ -883,8 +903,7 @@ class SchedulerNode:
 
         outputs = set(outputs)
 
-        output_files = set(self.__task.get('task', self.__task.task(), 'output',
-                                           step=self.__step, index=self.__index))
+        output_files = set(self.__task.get('output'))
 
         missing = output_files.difference(outputs)
         excess = outputs.difference(output_files)
@@ -906,7 +925,7 @@ class SchedulerNode:
         if not os.path.exists(copy_from):
             return
 
-        self.logger.info(f'Importing {self.__step}{self.__index} from {source}')
+        self.logger.info(f'Importing {self.__step}/{self.__index} from {source}')
         shutil.copytree(
             copy_from, self.__workdir,
             dirs_exist_ok=True,
@@ -917,16 +936,15 @@ class SchedulerNode:
             # delete file as it might be a hard link
             os.remove(self.__replay_script)
 
-            self.__task.set_runtime(self.__chip, step=self.__step, index=self.__index)
-            self.__task.generate_replay_script(self.__replay_script, self.__workdir)
-            self.__task.set_runtime(None)
+            with self.runtime():
+                self.__task.generate_replay_script(self.__replay_script, self.__workdir)
 
         for manifest in self.__manifests.values():
             if os.path.exists(manifest):
                 schema = Schema.from_manifest(manifest)
                 # delete file as it might be a hard link
                 os.remove(manifest)
-                schema.set('option', 'jobname', self.__chip.get('option', 'jobname'))
+                schema.set('option', 'jobname', self.__job)
                 schema.write_manifest(manifest)
 
     def clean_directory(self):

siliconcompiler/scheduler/send_messages.py

@@ -66,7 +66,7 @@ def send(chip, msg_type, step, index):
     msg = MIMEMultipart()
 
     if step and index:
-        subject = f'SiliconCompiler : {chip.design} | {jobname} | {step}{index} | {msg_type}'
+        subject = f'SiliconCompiler : {chip.design} | {jobname} | {step} | {index} | {msg_type}'
     else:
         subject = f'SiliconCompiler : {chip.design} | {jobname} | {msg_type}'
 
@@ -92,7 +92,7 @@ def send(chip, msg_type, step, index):
                     msg.attach(img_attach)
 
             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'))
@@ -110,7 +110,7 @@ def send(chip, msg_type, step, index):
                 metric_keys=metrics_to_show)
         else:
             # Attach logs
-            for log in (f'sc_{step}{index}.log', f'{step}.log'):
+            for log in (f'sc_{step}_{index}.log', f'{step}.log'):
                 log_file = f'{chip.getworkdir(step=step, index=index)}/{log}'
                 if os.path.exists(log_file):
                     with sc_open(log_file) as f:

siliconcompiler/scheduler/slurm.py

@@ -36,10 +36,10 @@ class SlurmSchedulerNode(SchedulerNode):
 
         collect = False
         flow = chip.get('option', 'flow')
-        entry_nodes = chip.schema.get("flowgraph", flow, field="schema").get_entry_nodes()
+        entry_nodes = chip.get("flowgraph", flow, field="schema").get_entry_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'))
@@ -65,7 +65,7 @@ class SlurmSchedulerNode(SchedulerNode):
 
     @staticmethod
     def get_job_name(jobhash, step, index):
-        return f'{jobhash}_{step}{index}'
+        return f'{jobhash}_{step}_{index}'
 
     @staticmethod
     def get_runtime_file_name(jobhash, step, index, ext):
@@ -93,6 +93,8 @@ class SlurmSchedulerNode(SchedulerNode):
         finishes processing this step, and it sets the active/error bits.
         '''
 
+        self._init_run_logger()
+
         if shutil.which('sinfo') is None:
             raise RuntimeError('slurm is not available or installed on this machine')