siliconcompiler 0.33.1__py3-none-any.whl → 0.33.2__py3-none-any.whl

siliconcompiler/_metadata.py

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

siliconcompiler/apps/utils/replay.py

@@ -18,6 +18,7 @@ import siliconcompiler
 from siliconcompiler.apps._common import UNSET_DESIGN
 from siliconcompiler import SiliconCompilerError
 from siliconcompiler import utils
+from siliconcompiler.record import RecordTime
 
 
 def make_bytes(data):
@@ -127,11 +128,10 @@ def main():
     path = os.path.abspath(args['file'])
     os.makedirs(os.path.dirname(path), exist_ok=True)
 
-    starttimes = set()
-    for starttime, step, index in chip.schema.get('history', jobname, 'record', 'starttime',
-                                                  field=None).getvalues():
-        starttimes.add(datetime.strptime(starttime, '%Y-%m-%d %H:%M:%S'))
-    starttime = min(starttimes).strftime('%Y-%m-%d %H:%M:%S')
+    record_schema = chip.schema.get('history', jobname, 'record', field="schema")
+    starttime = datetime.fromtimestamp(
+        record_schema.get_earliest_time(RecordTime.START)).strftime(
+            '%Y-%m-%d %H:%M:%S')
 
     with io.StringIO() as fd:
         fd.write(utils.get_file_template('replay/requirements.txt').render(

siliconcompiler/core.py

@@ -1729,7 +1729,11 @@ class Chip:
                 error = True
                 self.logger.error(f'No executable or run() function specified for {tool}/{task}')
 
-        if not error and not _check_flowgraph_io(self, nodes=nodes):
+        runtime_full = RuntimeFlowgraph(
+            self.schema.get("flowgraph", flow, field='schema'),
+            to_steps=self.get('option', 'to'),
+            prune_nodes=self.get('option', 'prune'))
+        if not error and not _check_flowgraph_io(self, nodes=runtime_full.get_nodes()):
             error = True
 
         return not error

siliconcompiler/data/templates/replay/replay.sh.j2

@@ -9,6 +9,7 @@ CD_WORK="{{ work_dir }}"
 PRINT=""
 CMDPREFIX=""
 SKIPEXPORT=0
+DONODE={{ node_only }}
 while [[ $# -gt 0 ]]; do
     case $1 in
         --which)
@@ -40,6 +41,11 @@ while [[ $# -gt 0 ]]; do
             shift
             shift
             ;;
+        --node)
+            DONODE=1
+            shift
+            shift
+            ;;
         -h|--help)
             echo "Usage: $0"
             echo "  Options:"
@@ -49,7 +55,8 @@ while [[ $# -gt 0 ]]; do
             echo "    --command         print the execution command"
             echo "    --skipcd          do not change directory into replay directory"
             echo "    --skipexports     do not export environmental variables"
-            echo "    --cmdprefix <cmd> prefix to add to the replay command, such as gdb"
+            echo "    --cmdprefix <cmd> prefix to add to the replay command, such as dgb"
+            echo "    --node            execute entire node"
             echo "    -h,--help         print this help"
             exit 0
             ;;
@@ -87,6 +94,16 @@ case $PRINT in
         ;;
 esac
 
+if [ $DONODE == 1 ]; then
+python3 -m siliconcompiler.scheduler.run_node \
+    -cfg "{{ cfg_file }}" \
+    -builddir "${PWD}/../../../../" \
+    -step "{{ step }}" \
+    -index "{{ index }}" \
+    -cwd "$PWD" \
+    -replay
+{% if cmds|length > 0 %}else
 # Command execution
 $CMDPREFIX \{% for cmd in cmds %}
 {% if not loop.first %}  {% endif %}{{ cmd }}{% if not loop.last %} \{% endif %}{% endfor %}
+{% endif %}fi

siliconcompiler/metric.py

@@ -44,6 +44,25 @@ class MetricSchema(BaseSchema):
 
         return self.set(metric, value, step=step, index=str(index))
 
+    def record_tasktime(self, step, index, record):
+        """
+        Record the task time for this node
+
+        Args:
+            step (str): step to record
+            index (str/int): index to record
+            record (:class:`RecordSchema`): record to lookup data in
+        """
+        start_time, end_time = [
+            record.get_recorded_time(step, index, RecordTime.START),
+            record.get_recorded_time(step, index, RecordTime.END)
+        ]
+
+        if start_time is None or end_time is None:
+            return False
+
+        return self.record(step, index, "tasktime", end_time-start_time, unit="s")
+
     def record_totaltime(self, step, index, flow, record):
         """
         Record the total time for this node

siliconcompiler/package/git.py

@@ -81,4 +81,4 @@ def clone_from_git(chip, package, path, ref, url, data_path):
     chip.logger.info(f'Checking out {ref}')
     repo.git.checkout(ref)
     for submodule in repo.submodules:
-        submodule.update(init=True)
+        submodule.update(recursive=True, init=True, force=True)

siliconcompiler/record.py

@@ -30,13 +30,25 @@ class RecordTool(Enum):
 
 
 class RecordSchema(BaseSchema):
-    __TIMEFORMAT = "%Y-%m-%d %H:%M:%S"
+    __TIMEFORMAT = "%Y-%m-%d %H:%M:%S.%f"
 
     def __init__(self):
         super().__init__()
 
         schema_record(self)
 
+    def _from_dict(self, manifest, keypath, version=None):
+        ret = super()._from_dict(manifest, keypath, version)
+
+        # Correct for change specification
+        if version and version < (0, 50, 4):
+            for timekey in RecordTime:
+                start_param = self.get(timekey.value, field=None)
+                for value, step, index in start_param.getvalues():
+                    start_param.set(f"{value}.000000", step=step, index=index)
+
+        return ret
+
     def clear(self, step, index, keep=None):
         '''
         Clear all saved metrics for a given step and index
@@ -275,6 +287,44 @@ class RecordSchema(BaseSchema):
             record_time+"+0000",
             RecordSchema.__TIMEFORMAT+"%z").timestamp()
 
+    def get_earliest_time(self, type):
+        '''
+        Returns the earliest recorded time.
+
+        Args:
+            type (:class:`RecordTime`): type of time to record
+        '''
+        type = RecordTime(type)
+        record_param = self.get(type.value, field=None)
+
+        times = set()
+        for _, step, index in record_param.getvalues():
+            times.add(self.get_recorded_time(step, index, type))
+
+        if not times:
+            return None
+
+        return min(times)
+
+    def get_latest_time(self, type):
+        '''
+        Returns the last recorded time.
+
+        Args:
+            type (:class:`RecordTime`): type of time to record
+        '''
+        type = RecordTime(type)
+        record_param = self.get(type.value, field=None)
+
+        times = set()
+        for _, step, index in record_param.getvalues():
+            times.add(self.get_recorded_time(step, index, type))
+
+        if not times:
+            return None
+
+        return max(times)
+
     def record_tool(self, step, index, info, type):
         '''
         Record information about the tool used during this record.
@@ -320,11 +370,13 @@ def schema_record(schema):
                         'x86_64',
                         '(x86_64, rv64imafdc)'],
                'starttime': ['start time',
-                             '\"2021-09-06 12:20:20\"',
-                             'Time is reported in the ISO 8601 format YYYY-MM-DD HR:MIN:SEC'],
+                             '\"2021-09-06 12:20:20.000000\"',
+                             'Time is recorded with the format YYYY-MM-DD HR:MIN:SEC.MICROSEC for '
+                             'UTC'],
                'endtime': ['end time',
-                           '\"2021-09-06 12:20:20\"',
-                           'Time is reported in the ISO 8601 format YYYY-MM-DD HR:MIN:SEC'],
+                           '\"2021-09-06 12:20:20.000000\"',
+                           'Time is recorded with the format YYYY-MM-DD HR:MIN:SEC.MICROSEC for '
+                           'UTC'],
                'region': ['cloud region',
                           '\"US Gov Boston\"',
                           """Recommended naming methodology:

siliconcompiler/remote/client.py

@@ -10,10 +10,12 @@ import tarfile
 import tempfile
 import multiprocessing
 
-from siliconcompiler import utils, SiliconCompilerError, NodeStatus
+import os.path
+
+from siliconcompiler import utils, SiliconCompilerError
 from siliconcompiler import NodeStatus as SCNodeStatus
 from siliconcompiler._metadata import default_server
-from siliconcompiler.remote import JobStatus
+from siliconcompiler.remote import JobStatus, NodeStatus
 from siliconcompiler.report.dashboard import DashboardType
 from siliconcompiler.flowgraph import RuntimeFlowgraph
 from siliconcompiler.schema import JournalingSchema
@@ -310,19 +312,29 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
         try:
             # Decode response JSON, if possible.
             job_info = json.loads(info['message'])
-        except json.JSONDecodeError as e:
-            self.__logger.warning(f"Job is still running: {e}")
+            if "null" in job_info:
+                job_info[None] = job_info["null"]
+                del job_info["null"]
+        except json.JSONDecodeError:
+            self.__logger.warning(f"Job is still running: {info['message']}")
             return completed, starttimes, True
 
         nodes_to_log = {}
         for node, node_info in job_info.items():
             status = node_info['status']
-            nodes_to_log.setdefault(status, []).append((node, node_info))
+
+            if status == NodeStatus.UPLOADED:
+                status = SCNodeStatus.PENDING
 
             if SCNodeStatus.is_done(status):
                 # collect completed
                 completed.append(node)
 
+            if not node:
+                continue
+
+            nodes_to_log.setdefault(status, []).append((node, node_info))
+
             if self.__node_information and node in self.__node_information:
                 self.__chip.set('record', 'status', status,
                                 step=self.__node_information[node]["step"],
@@ -580,6 +592,22 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
             raise SiliconCompilerError('Job canceled by user keyboard interrupt')
 
     def __import_run_manifests(self, starttimes):
+        if not self.__setup_information_loaded:
+            if self.__setup_information_fetched:
+                manifest = os.path.join(self.__chip.getworkdir(), f'{self.__chip.design}.pkg.json')
+                if os.path.exists(manifest):
+                    try:
+                        JournalingSchema(self.__chip.schema).read_journal(manifest)
+                        self.__setup_information_loaded = True
+                        changed = True
+                    except:  # noqa E722
+                        # Import may fail if file is still getting written
+                        pass
+
+        if not self.__setup_information_loaded:
+            # Dont do anything until this has been loaded
+            return
+
         changed = False
         for _, node_info in self.__node_information.items():
             if node_info["imported"]:
@@ -599,7 +627,7 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
                     pass
             elif self.__chip.get('record', 'status',
                                  step=node_info["step"], index=node_info["index"]) \
-                    == NodeStatus.SKIPPED:
+                    == SCNodeStatus.SKIPPED:
                 node_info["imported"] = True
                 changed = True
 
@@ -618,6 +646,9 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
             check_info = self.__check()
             self.__check_interval = check_info['progress_interval']
 
+        self.__setup_information_fetched = False
+        self.__setup_information_loaded = False
+
         self.__node_information = {}
         runtime = RuntimeFlowgraph(
             self.__chip.schema.get("flowgraph", self.__chip.get('option', 'flow'), field='schema'),
@@ -666,6 +697,11 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
                 # Update dashboard if active
                 self.__chip._dash.update_manifest({"starttimes": starttimes})
 
+            if None in completed:
+                completed.remove(None)
+                if not self.__setup_information_fetched:
+                    self.__schedule_fetch_result(None)
+
             nodes_to_fetch = []
             for node in completed:
                 if not self.__node_information[node]["fetched"]:
@@ -681,7 +717,6 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
         for node, node_info in self.__node_information.items():
             if not node_info["fetched"]:
                 self.__schedule_fetch_result(node)
-        self.__schedule_fetch_result(node)
 
         self._finalize_loop()
 
@@ -700,11 +735,12 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
         self.__import_run_manifests({})
 
     def __schedule_fetch_result(self, node):
-        self.__node_information[node]["fetched"] = True
+        if node:
+            self.__node_information[node]["fetched"] = True
+            self.__logger.info(f'    {node}')
+        else:
+            self.__setup_information_fetched = True
         self.__download_pool.apply_async(Client._fetch_result, (self, node))
-        if node is None:
-            node = 'final result'
-        self.__logger.info(f'    {node}')
 
     def _fetch_result(self, node):
         '''

siliconcompiler/remote/server.py

@@ -1,6 +1,7 @@
 # Copyright 2020 Silicon Compiler Authors. All Rights Reserved.
 
 from aiohttp import web
+import copy
 import threading
 import json
 import logging as log
@@ -12,7 +13,8 @@ import sys
 import fastjsonschema
 from pathlib import Path
 from fastjsonschema import JsonSchemaException
-import io
+
+import os.path
 
 from siliconcompiler import Chip, Schema
 from siliconcompiler.schema import utils as schema_utils
@@ -20,8 +22,10 @@ from siliconcompiler._metadata import version as sc_version
 from siliconcompiler.schema import SCHEMA_VERSION as sc_schema_version
 from siliconcompiler.remote.schema import ServerSchema
 from siliconcompiler.remote import banner, JobStatus
-from siliconcompiler.scheduler.slurm import get_configuration_directory
+from siliconcompiler import NodeStatus as SCNodeStatus
+from siliconcompiler.remote import NodeStatus
 from siliconcompiler.flowgraph import RuntimeFlowgraph
+from siliconcompiler.scheduler.taskscheduler import TaskScheduler
 
 
 # Compile validation code for API request bodies.
@@ -81,7 +85,61 @@ class Server:
         self.schema = ServerSchema()
 
         # Set up a dictionary to track running jobs.
+        self.sc_jobs_lock = threading.Lock()
         self.sc_jobs = {}
+        self.sc_chip_lookup = {}
+
+        # Register callbacks
+        TaskScheduler.register_callback("pre_run", self.__run_start)
+        TaskScheduler.register_callback("pre_node", self.__node_start)
+        TaskScheduler.register_callback("post_node", self.__node_end)
+
+    def __run_start(self, chip):
+        flow = chip.get("option", "flow")
+        nodes = chip.schema.get("flowgraph", flow, field="schema").get_nodes()
+
+        with self.sc_jobs_lock:
+            job_hash = self.sc_chip_lookup[chip]["jobhash"]
+
+        start_tar = os.path.join(self.nfs_mount, job_hash, f'{job_hash}_None.tar.gz')
+        start_status = NodeStatus.SUCCESS
+        with tarfile.open(start_tar, "w:gz") as tf:
+            start_manifest = os.path.join(chip.getworkdir(), f"{chip.design}.pkg.json")
+            tf.add(start_manifest, arcname=os.path.relpath(start_manifest, self.nfs_mount))
+
+        with self.sc_jobs_lock:
+            job_name = self.sc_chip_lookup[chip]["name"]
+
+            self.sc_jobs[job_name][None]["status"] = start_status
+
+            for step, index in nodes:
+                name = f"{step}{index}"
+                if name not in self.sc_jobs[job_name]:
+                    continue
+                self.sc_jobs[job_name][name]["status"] = \
+                    chip.get('record', 'status', step=step, index=index)
+
+    def __node_start(self, chip, step, index):
+        with self.sc_jobs_lock:
+            job_name = self.sc_chip_lookup[chip]["name"]
+            self.sc_jobs[job_name][f"{step}{index}"]["status"] = NodeStatus.RUNNING
+
+    def __node_end(self, chip, step, index):
+        with self.sc_jobs_lock:
+            job_hash = self.sc_chip_lookup[chip]["jobhash"]
+            job_name = self.sc_chip_lookup[chip]["name"]
+
+        chip = copy.deepcopy(chip)
+        chip.cwd = os.path.join(chip.get('option', 'builddir'), '..')
+        with tarfile.open(os.path.join(self.nfs_mount,
+                                       job_hash,
+                                       f'{job_hash}_{step}{index}.tar.gz'),
+                          mode='w:gz') as tf:
+            chip._archive_node(tf, step=step, index=index, include="*")
+
+        with self.sc_jobs_lock:
+            self.sc_jobs[job_name][f"{step}{index}"]["status"] = \
+                chip.get('record', 'status', step=step, index=index)
 
     def run(self):
         if not os.path.exists(self.nfs_mount):
@@ -226,9 +284,6 @@ class Server:
         # Remove 'remote' JSON config value to run locally on compute node.
         chip.set('option', 'remote', False)
 
-        # Write JSON config to shared compute storage.
-        os.makedirs(os.path.join(job_root, 'configs'), exist_ok=True)
-
         # Run the job with the configured clustering option. (Non-blocking)
         job_proc = threading.Thread(target=self.remote_sc,
                                     args=[
@@ -258,31 +313,13 @@ class Server:
         job_hash = job_params['job_hash']
         node = job_params['node'] if 'node' in job_params else None
 
-        resp = web.StreamResponse(
-            status=200,
-            reason='OK',
-            headers={
-                'Content-Type': 'application/x-tar',
-                'Content-Disposition': f'attachment; filename="{job_hash}_{node}.tar.gz"'
-            },
-        )
-        await resp.prepare(request)
-
         zipfn = os.path.join(self.nfs_mount, job_hash, f'{job_hash}_{node}.tar.gz')
-        if not node:
-            with tarfile.open(zipfn, 'w:gz') as tar:
-                text = "Done"
-                metadata_file = io.BytesIO(text.encode('ascii'))
-                tarinfo = tarfile.TarInfo(f'{job_hash}/done')
-                tarinfo.size = metadata_file.getbuffer().nbytes
-                tar.addfile(tarinfo=tarinfo, fileobj=metadata_file)
+        if not os.path.exists(zipfn):
+            return web.json_response(
+                {'message': 'Could not find results for the requested job/node.'},
+                status=404)
 
-        with open(zipfn, 'rb') as zipf:
-            await resp.write(zipf.read())
-
-        await resp.write_eof()
-
-        return resp
+        return web.FileResponse(zipfn)
 
     ####################
     async def handle_delete_job(self, request):
@@ -300,9 +337,10 @@ class Server:
         job_hash = job_params['job_hash']
 
         # Determine if the job is running.
-        for job in self.sc_jobs:
-            if job_hash in job:
-                return self.__response("Error: job is still running.", status=400)
+        with self.sc_jobs_lock:
+            for job in self.sc_jobs:
+                if job_hash in job:
+                    return self.__response("Error: job is still running.", status=400)
 
         # Delete job hash directory, only if it exists.
         # TODO: This assumes no malicious input.
@@ -342,16 +380,17 @@ class Server:
 
         # Determine if the job is running.
         # TODO: Return information about individual flowgraph nodes.
-        if jobname in self.sc_jobs:
-            resp = {
-                'status': JobStatus.RUNNING,
-                'message': 'Job is currently running on the server.',
-            }
-        else:
-            resp = {
-                'status': JobStatus.COMPLETED,
-                'message': 'Job has no running steps.',
-            }
+        with self.sc_jobs_lock:
+            if jobname in self.sc_jobs:
+                resp = {
+                    'status': JobStatus.RUNNING,
+                    'message': self.sc_jobs[jobname],
+                }
+            else:
+                resp = {
+                    'status': JobStatus.COMPLETED,
+                    'message': 'Job has no running steps.',
+                }
         return web.json_response(resp)
 
     ####################
@@ -402,18 +441,39 @@ class Server:
         # Assemble core job parameters.
         job_hash = chip.get('record', 'remoteid')
 
+        runtime = RuntimeFlowgraph(
+            chip.schema.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'))
+
+        nodes = {}
+        nodes[None] = {
+            "status": SCNodeStatus.PENDING
+        }
+        for step, index in runtime.get_nodes():
+            status = chip.get('record', 'status', step=step, index=index)
+            if not status:
+                status = SCNodeStatus.PENDING
+            if SCNodeStatus.is_done(status):
+                status = NodeStatus.UPLOADED
+            nodes[f"{step}{index}"] = {
+                "status": status
+            }
+
         # Mark the job run as busy.
         sc_job_name = self.job_name(username, job_hash)
-        self.sc_jobs[sc_job_name] = 'busy'
+        with self.sc_jobs_lock:
+            self.sc_chip_lookup[chip] = {
+                "name": sc_job_name,
+                "jobhash": job_hash
+            }
+            self.sc_jobs[sc_job_name] = nodes
 
         build_dir = os.path.join(self.nfs_mount, job_hash)
         chip.set('option', 'builddir', build_dir)
         chip.set('option', 'remote', False)
 
-        job_cfg_dir = get_configuration_directory(chip)
-        os.makedirs(job_cfg_dir, exist_ok=True)
-        chip.write_manifest(f"{job_cfg_dir}/chip{chip.get('option', 'jobname')}.json")
-
         if self.get('option', 'cluster') == 'slurm':
             # Run the job with slurm clustering.
             chip.set('option', 'scheduler', 'name', 'slurm')
@@ -421,25 +481,10 @@ class Server:
         # Run the job.
         chip.run()
 
-        # Archive each task.
-        runtime = RuntimeFlowgraph(
-            chip.schema.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'))
-        for (step, index) in runtime.get_nodes():
-            chip.cwd = os.path.join(chip.get('option', 'builddir'), '..')
-            tf = tarfile.open(os.path.join(self.nfs_mount,
-                                           job_hash,
-                                           f'{job_hash}_{step}{index}.tar.gz'),
-                              mode='w:gz')
-            chip._archive_node(tf, step=step, index=index)
-            tf.close()
-
-        # (Email notifications can be sent here using your preferred API)
-
         # Mark the job hash as being done.
-        self.sc_jobs.pop(sc_job_name)
+        with self.sc_jobs_lock:
+            self.sc_jobs.pop(sc_job_name)
+            self.sc_chip_lookup.pop(chip)
 
     ####################
     def __auth_password(self, username, password):

siliconcompiler/report/dashboard/cli/board.py

@@ -751,7 +751,6 @@ class Board(metaclass=BoardSingleton):
 
             runtime_flow = RuntimeFlowgraph(
                 chip.schema.get("flowgraph", flow, field='schema'),
-                args=(chip.get('arg', 'step'), chip.get('arg', 'index')),
                 to_steps=chip.get('option', 'to'),
                 prune_nodes=chip.get('option', 'prune'))
             record = chip.schema.get("record", field='schema')

siliconcompiler/scheduler/__init__.py

@@ -152,6 +152,9 @@ def _local_process(chip, flow):
     from_nodes = []
     extra_setup_nodes = {}
 
+    chip.schema = JournalingSchema(chip.schema)
+    chip.schema.start_journal()
+
     if chip.get('option', 'clean') or not chip.get('option', 'from'):
         load_nodes = list(chip.schema.get("flowgraph", flow, field="schema").get_nodes())
     else:
@@ -236,8 +239,7 @@ def _local_process(chip, flow):
                 mark_pending(step, index)
             elif (step, index) in extra_setup_nodes:
                 # import old information
-                JournalingSchema(chip.schema).import_journal(
-                    schema=extra_setup_nodes[(step, index)])
+                chip.schema.import_journal(schema=extra_setup_nodes[(step, index)])
 
     # Ensure pending nodes cause following nodes to be run
     for step, index in nodes:
@@ -250,6 +252,10 @@ def _local_process(chip, flow):
         if chip.get('record', 'status', step=step, index=index) == NodeStatus.PENDING:
             clean_node_dir(chip, step, index)
 
+    chip.write_manifest(os.path.join(chip.getworkdir(), f"{chip.get('design')}.pkg.json"))
+    chip.schema.stop_journal()
+    chip.schema = chip.schema.get_base_schema()
+
     # Check validity of setup
     chip.logger.info("Checking manifest before running.")
     check_ok = chip.check_manifest()
@@ -604,9 +610,10 @@ def _executenode(chip, step, index, replay):
         send_messages.send(chip, "begin", step, index)
 
         try:
-            task_class.generate_replay_script(
-                os.path.join(workdir, "replay.sh"),
-                workdir)
+            if not replay:
+                task_class.generate_replay_script(
+                    os.path.join(workdir, "replay.sh"),
+                    workdir)
             ret_code = task_class.run_task(
                 workdir,
                 chip.get('option', 'quiet', step=step, index=index),