yowasp-yosys 0.55.0.3.post946.dev0__py3-none-any.whl → 0.56.0.141.post974.dev0__py3-none-any.whl

yowasp_yosys/share/python3/sby_core.py

@@ -17,9 +17,11 @@
 #
 
 import os, re, sys, signal, platform, click
+import time
 if os.name == "posix":
     import resource, fcntl
 import subprocess
+from pathlib import Path
 from dataclasses import dataclass, field
 from collections import defaultdict
 from typing import Optional
@@ -43,12 +45,8 @@ signal.signal(signal.SIGINT, force_shutdown)
 signal.signal(signal.SIGTERM, force_shutdown)
 
 def process_filename(filename):
-    if filename.startswith("~/"):
-        filename = os.environ['HOME'] + filename[1:]
-
     filename = os.path.expandvars(filename)
-
-    return filename
+    return Path(filename).expanduser()
 
 def dress_message(workdir, logmessage):
     tm = localtime()
@@ -97,6 +95,7 @@ class SbyProc:
         self.silent = silent
         self.wait = False
         self.job_lease = None
+        self.next_db = 0.0
 
         self.task.update_proc_pending(self)
 
@@ -148,8 +147,8 @@ class SbyProc:
         if self.error_callback is not None:
             self.error_callback(retcode)
 
-    def terminate(self, timeout=False):
-        if (self.task.opt_wait or self.wait) and not timeout:
+    def terminate(self, force=False):
+        if (self.task.opt_wait or self.wait) and not force:
             return
         if self.running:
             if not self.silent:
@@ -175,6 +174,36 @@ class SbyProc:
         if self.finished or self.terminated or self.exited:
             return
 
+        for task in self.task.taskloop.tasks_done:
+            if task.name in self.task.cancelledby:
+                if not self.silent:
+                    self.task.log(f"Cancelled by {task.name!r} task")
+                self.task.cancel()
+                return
+
+        if self.task.status_cancels and time.time() >= self.next_db:
+            tasks_status = self.task.status_db.all_tasks_status()
+            for task_status in tasks_status.values():
+                if (task_status["status"] in ["PASS", "FAIL", "CANCELLED"] and
+                    task_status["name"] in self.task.cancelledby):
+                    if not self.silent:
+                        status_time = time.localtime(task_status["status_created"])
+                        if status_time.tm_yday == time.localtime().tm_yday:
+                            # same day, format time only
+                            time_format = r"%H:%M:%S"
+                        else:
+                            time_format = r"%x %H:%M:%S"
+                        self.task.log(
+                            f'Cancelled by {task_status["name"]!r} task '
+                            f'with status {task_status["status"]!r} '
+                            f'at {time.strftime(time_format, status_time)} '
+                            '(consider calling sby with --statusreset if this seems wrong)'
+                        )
+                    self.task.cancel()
+                    return
+            # don't hit the database every poll
+            self.next_db = time.time() + 10
+
         if not self.running:
             for dep in self.deps:
                 if not dep.finished:
@@ -218,6 +247,10 @@ class SbyProc:
             if self.job_lease:
                 self.job_lease.done()
 
+            if self.terminated:
+                # task already terminated, do not finish
+                return
+
             if not self.silent:
                 self.task.log(f"{click.style(self.info, fg='magenta')}: finished (returncode={self.p.returncode})")
 
@@ -282,6 +315,7 @@ class SbyConfig:
         self.autotune_config = None
         self.files = dict()
         self.verbatim_files = dict()
+        self.cancelledby = list()
         pass
 
     def parse_config(self, f):
@@ -402,6 +436,12 @@ class SbyConfig:
                     import sby_autotune
                     self.autotune_config = sby_autotune.SbyAutotuneConfig()
                     continue
+                
+                if section == "cancelledby":
+                    mode = "cancelledby"
+                    if args is not None:
+                        self.error(f"sby file syntax error: '[cancelledby]' section does not accept any arguments. got {args}")
+                    continue
 
                 if section == "file":
                     mode = "file"
@@ -436,6 +476,12 @@ class SbyConfig:
             if mode == "autotune":
                 self.autotune_config.config_line(self, line)
                 continue
+            
+            if mode == "cancelledby":
+                taskname = line.strip()
+                if taskname:
+                    self.cancelledby.append(taskname)
+                continue
 
             if mode == "engines":
                 args = line.strip().split()
@@ -529,7 +575,7 @@ class SbyConfig:
                     self.error(f"sby file syntax error: '[files]' section entry expects up to 2 arguments, {len(entries)} specified")
 
                 if len(entries) == 1:
-                    self.files[os.path.basename(entries[0])] = entries[0]
+                    self.files[Path(entries[0]).name] = entries[0]
                 elif len(entries) == 2:
                     self.files[entries[0]] = entries[1]
 
@@ -553,6 +599,7 @@ class SbyTaskloop:
         self.procs_pending = []
         self.procs_running = []
         self.tasks = []
+        self.tasks_done = []
         self.poll_now = False
         self.jobclient = jobclient
 
@@ -605,6 +652,7 @@ class SbyTaskloop:
                     self.tasks.append(task)
                 else:
                     task.exit_callback()
+                    self.tasks_done.append(task)
 
         for task in self.tasks:
             task.exit_callback()
@@ -631,6 +679,8 @@ class SbyTraceSummary:
     path: Optional[str] = field(default=None)
     engine_case: Optional[str] = field(default=None)
     events: dict = field(default_factory=lambda: defaultdict(lambda: defaultdict(list)))
+    trace_ids: dict[str, int] = field(default_factory=lambda: dict())
+    last_ext: Optional[str] = field(default=None)
 
     @property
     def kind(self):
@@ -682,42 +732,62 @@ class SbySummary:
 
         if update_status:
             status_metadata = dict(source="summary_event", engine=engine.engine)
+        if event.step:
+            status_metadata["step"] = event.step
 
+        add_trace = False
         if event.prop:
-            if event.type == "$assert":
+            if event.type is None:
+                event.type = event.prop.celltype
+            elif event.type == "$assert":
                 event.prop.status = "FAIL"
-                if event.path:
-                    event.prop.tracefiles.append(event.path)
-                    if update_status:
-                        self.task.status_db.add_task_property_data(
-                            event.prop,
-                            "trace",
-                            data=dict(path=event.path, step=event.step, **status_metadata),
-                        )
-        if event.prop:
-            if event.type == "$cover":
+                add_trace = True
+            elif event.type == "$cover":
                 event.prop.status = "PASS"
-                if event.path:
-                    event.prop.tracefiles.append(event.path)
-                    if update_status:
-                        self.task.status_db.add_task_property_data(
-                            event.prop,
-                            "trace",
-                            data=dict(path=event.path, step=event.step, **status_metadata),
-                        )
+                add_trace = True
+
+        trace_id = None
+        trace_path = None
+        if event.trace:
+            # get or create trace summary
+            try:
+                trace_summary = engine.traces[event.trace]
+            except KeyError:
+                trace_summary = SbyTraceSummary(event.trace, path=event.path, engine_case=event.engine_case)
+                engine.traces[event.trace] = trace_summary
+
+            if event.path:
+                trace_path = Path(event.path)
+                trace_ext = trace_path.suffix
+                trace_summary.last_ext = trace_ext
+                try:
+                    # use existing tracefile for this extension
+                    trace_id = trace_summary.trace_ids[trace_ext]
+                except KeyError:
+                    # add tracefile to database
+                    trace_id = self.task.status_db.add_task_trace(event.trace, event.path, trace_ext[1:], event.engine_case)
+                    trace_summary.trace_ids[trace_ext] = trace_id
+            elif trace_summary.path:
+                # use existing tracefile for last extension
+                trace_path = Path(trace_summary.path)
+                trace_ext = trace_summary.last_ext
+                trace_id = trace_summary.trace_ids[trace_ext]
+
+            if event.type:
+                by_type = trace_summary.events[event.type]
+                if event.hdlname:
+                    by_type[event.hdlname].append(event)
+
         if event.prop and update_status:
+            # update property status in database
             self.task.status_db.set_task_property_status(
                 event.prop,
-                data=status_metadata
+                trace_id=trace_id,
+                data=status_metadata,
             )
 
-        if event.trace not in engine.traces:
-            engine.traces[event.trace] = SbyTraceSummary(event.trace, path=event.path, engine_case=event.engine_case)
-
-        if event.type:
-            by_type = engine.traces[event.trace].events[event.type]
-            if event.hdlname:
-                by_type[event.hdlname].append(event)
+        if trace_path and add_trace:
+            event.prop.tracefiles.append(str(trace_path))
 
     def set_engine_status(self, engine_idx, status, case=None):
         engine_summary = self.engine_summary(engine_idx)
@@ -759,10 +829,21 @@ class SbySummary:
                     break
                 case_suffix = f" [{trace.engine_case}]" if trace.engine_case else ""
                 if trace.path:
-                    if short:
-                        yield f"{trace.kind}{case_suffix}: {self.task.workdir}/{trace.path}"
-                    else:
-                        yield f"{trace.kind}{case_suffix}: {trace.path}"
+                    # print single preferred trace
+                    preferred_exts = [".fst", ".vcd"]
+                    if trace.last_ext not in preferred_exts: preferred_exts.append(trace.last_ext)
+                    for ext in trace.trace_ids.keys():
+                        if ext not in preferred_exts: preferred_exts.append(ext)
+                    for ext in preferred_exts:
+                        if ext not in trace.trace_ids:
+                            continue
+                        if short:
+                            path = Path(self.task.workdir) / trace.path
+                        else:
+                            path = Path(trace.path)
+                        yield f"{trace.kind}{case_suffix}: {path.with_suffix(ext)}"
+                        if short:
+                            break
                 else:
                     yield f"{trace.kind}{case_suffix}: <{trace.trace}>"
                 produced_traces = True
@@ -785,15 +866,18 @@ class SbySummary:
                             break
 
                         event = same_events[0]
-                        steps = sorted(e.step for e in same_events)
+                        # uniquify steps and ignore events with missing steps
+                        steps = sorted(set(e.step for e in same_events if e.step))
                         if short and len(steps) > step_limit:
                             excess = len(steps) - step_limit
                             steps = [str(step) for step in steps[:step_limit]]
                             omitted_excess = True
                             steps[-1] += f" and {excess} further step{'s' if excess != 1 else ''}"
 
-                        steps = f"step{'s' if len(steps) > 1 else ''} {', '.join(map(str, steps))}"
-                        yield f"  {desc} {event.hdlname} at {event.src} in {steps}"
+                        event_string = f"  {desc} {hdlname} at {event.src}"
+                        if steps:
+                            event_string += f" step{'s' if len(steps) > 1 else ''} {', '.join(map(str, steps))}"
+                        yield event_string
 
             if not produced_traces:
                 yield f"{engine.engine} did not produce any traces"
@@ -801,7 +885,7 @@ class SbySummary:
         if self.unreached_covers is None and self.task.opt_mode == 'cover' and self.task.status != "PASS" and self.task.design:
             self.unreached_covers = []
             for prop in self.task.design.hierarchy:
-                if prop.type == prop.Type.COVER and prop.status == "UNKNOWN":
+                if prop.type == prop.Type.COVER and prop.status in ["UNKNOWN", "FAIL"]:
                     self.unreached_covers.append(prop)
 
         if self.unreached_covers:
@@ -825,12 +909,15 @@ class SbySummary:
 
 
 class SbyTask(SbyConfig):
-    def __init__(self, sbyconfig, workdir, early_logs, reusedir, taskloop=None, logfile=None):
+    def __init__(self, sbyconfig, workdir, early_logs, reusedir, status_cancels=False, taskloop=None, logfile=None, name=None, live_formats=[]):
         super().__init__()
         self.used_options = set()
         self.models = dict()
         self.workdir = workdir
         self.reusedir = reusedir
+        self.status_cancels = status_cancels
+        self.name = name
+        self.live_formats = live_formats
         self.status = "UNKNOWN"
         self.total_time = 0
         self.expect = list()
@@ -942,35 +1029,44 @@ class SbyTask(SbyConfig):
         raise SbyAbort(logmessage)
 
     def makedirs(self, path):
-        if self.reusedir and os.path.isdir(path):
+        path = Path(path)
+        if self.reusedir and path.is_dir():
             rmtree(path, ignore_errors=True)
-        if not os.path.isdir(path):
-            os.makedirs(path)
+        path.mkdir(parents=True, exist_ok=True)
 
-    def copy_src(self):
-        self.makedirs(self.workdir + "/src")
+    def copy_src(self, linkmode=False):
+        outdir = Path(self.workdir) / "src"
+        self.makedirs(outdir)
 
         for dstfile, lines in self.verbatim_files.items():
-            dstfile = self.workdir + "/src/" + dstfile
-            self.log(f"Writing '{dstfile}'.")
+            dstfile = outdir / dstfile
+            self.log(f"Writing '{dstfile.absolute()}'.")
+            dstfile.parent.mkdir(parents=True, exist_ok=True)
 
             with open(dstfile, "w") as f:
                 for line in lines:
                     f.write(line)
 
         for dstfile, srcfile in self.files.items():
-            if dstfile.startswith("/") or dstfile.startswith("../") or ("/../" in dstfile):
+            dstfile = Path(dstfile)
+            if dstfile.is_absolute() or ".." in dstfile.parts:
                 self.error(f"destination filename must be a relative path without /../: {dstfile}")
-            dstfile = self.workdir + "/src/" + dstfile
+            dstfile = outdir / dstfile
 
             srcfile = process_filename(srcfile)
 
-            basedir = os.path.dirname(dstfile)
-            if basedir != "" and not os.path.exists(basedir):
-                os.makedirs(basedir)
+            basedir = dstfile.parent
+            basedir.mkdir(parents=True, exist_ok=True)
+
+            if linkmode:
+                verb = "Link"
+            else:
+                verb = "Copy"
+            self.log(f"{verb} '{srcfile.absolute()}' to '{dstfile.absolute()}'.")
 
-            self.log(f"Copy '{os.path.abspath(srcfile)}' to '{os.path.abspath(dstfile)}'.")
-            if os.path.isdir(srcfile):
+            if linkmode:
+                os.symlink(srcfile.resolve(), dstfile)
+            elif srcfile.is_dir():
                 copytree(srcfile, dstfile, dirs_exist_ok=True)
             else:
                 copyfile(srcfile, dstfile)
@@ -999,12 +1095,12 @@ class SbyTask(SbyConfig):
             self.__dict__["opt_" + option_name] = default_value
 
     def make_model(self, model_name):
-        if not os.path.isdir(f"{self.workdir}/model"):
-            os.makedirs(f"{self.workdir}/model")
+        modeldir = Path(self.workdir) / "model"
+        modeldir.mkdir(exist_ok=True)
 
         if model_name == "prep":
-            with open(f"""{self.workdir}/model/design_prep.ys""", "w") as f:
-                print(f"# running in {self.workdir}/model/", file=f)
+            with open(modeldir / "design_prep.ys", "w") as f:
+                print(f"# running in {modeldir}/", file=f)
                 print(f"""read_rtlil design.il""", file=f)
                 if not self.opt_skip_prep:
                     print("scc -select; simplemap; select -clear", file=f)
@@ -1020,7 +1116,10 @@ class SbyTask(SbyConfig):
                     if self.opt_mode in ["bmc", "prove"]:
                         print("chformal -live -fair -cover -remove", file=f)
                     if self.opt_mode == "cover":
-                        print("chformal -live -fair -remove", file=f)
+                        if self.opt_cover_assert:
+                            print("chformal -live -fair -remove", file=f)
+                        else:
+                            print("chformal -live -fair -assert -remove", file=f)
                     if self.opt_mode == "live":
                         print("chformal -assert2assume", file=f)
                         print("chformal -cover -remove", file=f)
@@ -1045,7 +1144,7 @@ class SbyTask(SbyConfig):
             return [proc]
 
         if model_name == "base":
-            with open(f"""{self.workdir}/model/design.ys""", "w") as f:
+            with open(modeldir / "design.ys", "w") as f:
                 print(f"# running in {self.workdir}/src/", file=f)
                 for cmd in self.script:
                     print(cmd, file=f)
@@ -1067,7 +1166,7 @@ class SbyTask(SbyConfig):
 
             def instance_hierarchy_callback(retcode):
                 if self.design == None:
-                    with open(f"{self.workdir}/model/design.json") as f:
+                    with open(modeldir / "design.json") as f:
                         self.design = design_hierarchy(f)
                         self.status_db.create_task_properties([
                             prop for prop in self.design.properties_by_path.values()
@@ -1083,8 +1182,8 @@ class SbyTask(SbyConfig):
             return [proc]
 
         if re.match(r"^smt2(_syn)?(_nomem)?(_stbv|_stdt)?$", model_name):
-            with open(f"{self.workdir}/model/design_{model_name}.ys", "w") as f:
-                print(f"# running in {self.workdir}/model/", file=f)
+            with open(modeldir / f"design_{model_name}.ys", "w") as f:
+                print(f"# running in {modeldir}/", file=f)
                 print(f"""read_rtlil design_prep.il""", file=f)
                 print("hierarchy -smtcheck", file=f)
                 print("delete */t:$print", file=f)
@@ -1117,8 +1216,8 @@ class SbyTask(SbyConfig):
             return [proc]
 
         if re.match(r"^btor(_syn)?(_nomem)?$", model_name):
-            with open(f"{self.workdir}/model/design_{model_name}.ys", "w") as f:
-                print(f"# running in {self.workdir}/model/", file=f)
+            with open(modeldir / f"design_{model_name}.ys", "w") as f:
+                print(f"# running in {modeldir}/", file=f)
                 print(f"""read_rtlil design_prep.il""", file=f)
                 print("hierarchy -simcheck", file=f)
                 print("delete */t:$print", file=f)
@@ -1153,8 +1252,8 @@ class SbyTask(SbyConfig):
             return [proc]
 
         if model_name == "aig":
-            with open(f"{self.workdir}/model/design_aiger.ys", "w") as f:
-                print(f"# running in {self.workdir}/model/", file=f)
+            with open(modeldir / "design_aiger.ys", "w") as f:
+                print(f"# running in {modeldir}/", file=f)
                 print("read_rtlil design_prep.il", file=f)
                 print("delete */t:$print", file=f)
                 print("hierarchy -simcheck", file=f)
@@ -1180,7 +1279,7 @@ class SbyTask(SbyConfig):
                 self,
                 "aig",
                 self.model("prep"),
-                f"""cd {self.workdir}/model; {self.exe_paths["yosys"]} -ql design_aiger.log design_aiger.ys"""
+                f"""cd {modeldir}; {self.exe_paths["yosys"]} -ql design_aiger.log design_aiger.ys"""
             )
             proc.checkretcode = True
 
@@ -1191,8 +1290,8 @@ class SbyTask(SbyConfig):
                 self,
                 model_name,
                 self.model("aig"),
-                f"""cd {self.workdir}/model; {self.exe_paths["abc"]} -c 'read_aiger design_aiger.aig; fold{" -s" if self.opt_aigfolds else ""}; strash; write_aiger design_aiger_fold.aig'""",
-                logfile=open(f"{self.workdir}/model/design_aiger_fold.log", "w")
+                f"""cd {modeldir}; {self.exe_paths["abc"]} -c 'read_aiger design_aiger.aig; fold{" -s" if self.opt_aigfolds else ""}; strash; write_aiger design_aiger_fold.aig'""",
+                logfile=open(f"{modeldir}/design_aiger_fold.log", "w")
             )
             proc.checkretcode = True
 
@@ -1205,25 +1304,39 @@ class SbyTask(SbyConfig):
             self.models[model_name] = self.make_model(model_name)
         return self.models[model_name]
 
-    def terminate(self, timeout=False):
+    def terminate(self, timeout=False, cancel=False):
         if timeout:
             self.timeout_reached = True
         for proc in list(self.procs_running):
-            proc.terminate(timeout=timeout)
+            proc.terminate(timeout or cancel)
         for proc in list(self.procs_pending):
-            proc.terminate(timeout=timeout)
+            proc.terminate(timeout or cancel)
+        if timeout:
+            self.update_unknown_props(dict(source="timeout"))
+            
+    def cancel(self):
+        self.terminate(cancel=True)
+        self.update_status("CANCELLED")
 
     def proc_failed(self, proc):
         # proc parameter used by autotune override
         self.status = "ERROR"
         self.terminate()
 
+    def update_unknown_props(self, data):
+        for prop in self.design.hierarchy:
+            if prop.status != "UNKNOWN":
+                continue
+            if ((prop.type == prop.Type.ASSERT and self.opt_mode in ["bmc", "prove"]) or
+                (prop.type == prop.Type.COVER and self.opt_mode == "cover")):
+                self.status_db.set_task_property_status(prop, data=data)
+
     def pass_unknown_asserts(self, data):
         for prop in self.design.pass_unknown_asserts():
             self.status_db.set_task_property_status(prop, data=data)
 
-    def update_status(self, new_status):
-        assert new_status in ["PASS", "FAIL", "UNKNOWN", "ERROR"]
+    def update_status(self, new_status, step = None):
+        assert new_status in ["PASS", "FAIL", "UNKNOWN", "ERROR", "CANCELLED"]
         self.status_db.set_task_status(new_status)
 
         if new_status == "UNKNOWN":
@@ -1236,7 +1349,10 @@ class SbyTask(SbyConfig):
             assert self.status != "FAIL"
             self.status = "PASS"
             if self.opt_mode in ("bmc", "prove") and self.design:
-                self.pass_unknown_asserts(dict(source="task_status"))
+                data = {"source": "task_status"}
+                if step:
+                    data["step"] = step
+                self.pass_unknown_asserts(data)
 
         elif new_status == "FAIL":
             assert self.status != "PASS"
@@ -1245,6 +1361,9 @@ class SbyTask(SbyConfig):
         elif new_status == "ERROR":
             self.status = "ERROR"
 
+        elif new_status == "CANCELLED":
+            self.status = "CANCELLED"
+
         else:
             assert 0
 
@@ -1263,7 +1382,7 @@ class SbyTask(SbyConfig):
             self.used_options.add("expect")
 
         for s in self.expect:
-            if s not in ["PASS", "FAIL", "UNKNOWN", "ERROR", "TIMEOUT"]:
+            if s not in ["PASS", "FAIL", "UNKNOWN", "ERROR", "TIMEOUT", "CANCELLED"]:
                 self.error(f"Invalid expect value: {s}")
 
         if self.opt_mode != "live":
@@ -1294,6 +1413,9 @@ class SbyTask(SbyConfig):
         self.handle_bool_option("skip_prep", False)
 
         self.handle_bool_option("assume_early", True)
+        
+        if self.opt_mode == "cover":
+            self.handle_bool_option("cover_assert", False)
 
     def setup_status_db(self, status_path=None):
         if hasattr(self, 'status_db'):
@@ -1306,9 +1428,9 @@ class SbyTask(SbyConfig):
             except FileNotFoundError:
                 status_path = f"{self.workdir}/status.sqlite"
 
-        self.status_db = SbyStatusDb(status_path, self)
+        self.status_db = SbyStatusDb(status_path, self, live_formats=self.live_formats)
 
-    def setup_procs(self, setupmode):
+    def setup_procs(self, setupmode, linkmode=False):
         self.handle_non_engine_options()
         if self.opt_smtc is not None:
             for engine_idx, engine in self.engine_list():
@@ -1329,7 +1451,7 @@ class SbyTask(SbyConfig):
         if self.reusedir:
             rmtree(f"{self.workdir}/model", ignore_errors=True)
         else:
-            self.copy_src()
+            self.copy_src(linkmode)
 
         if setupmode:
             self.retcode = 0
@@ -1400,7 +1522,7 @@ class SbyTask(SbyConfig):
             else:
                 self.log("summary: " + click.style(line, fg="green" if self.status in self.expect else "red", bold=True))
 
-        assert self.status in ["PASS", "FAIL", "UNKNOWN", "ERROR", "TIMEOUT"]
+        assert self.status in ["PASS", "FAIL", "UNKNOWN", "ERROR", "TIMEOUT", "CANCELLED"]
 
         if self.status in self.expect:
             self.retcode = 0
@@ -1410,6 +1532,7 @@ class SbyTask(SbyConfig):
             if self.status == "UNKNOWN": self.retcode = 4
             if self.status == "TIMEOUT": self.retcode = 8
             if self.status == "ERROR": self.retcode = 16
+            if self.status == "CANCELLED": self.retcode = 32
 
     def write_summary_file(self):
         with open(f"{self.workdir}/{self.status}", "w") as f:

yowasp_yosys/share/python3/sby_design.py

@@ -111,6 +111,10 @@ class SbyProperty:
     def celltype(self):
         return f"${str(self.type).lower()}"
 
+    @property
+    def kind(self):
+        return str(self.type)
+
     @property
     def hdlname(self):
         return pretty_path(self.path).rstrip()

yowasp_yosys/share/python3/sby_engine_abc.py

@@ -18,6 +18,7 @@
 
 import re, getopt
 import json
+import os
 from sby_core import SbyProc
 from sby_engine_aiger import aigsmt_exit_callback, aigsmt_trace_callback
 
@@ -173,18 +174,25 @@ def run(mode, task, engine_idx, engine):
                     aiger_props.append(task.design.properties_by_path.get(tuple(path)))
 
         if keep_going:
-            match = re.match(r"Writing CEX for output ([0-9]+) to engine_[0-9]+/(.*)\.aiw", line)
+            match = re.match(r"Writing CEX for output ([0-9]+) to (engine_[0-9]+/(.*)\.aiw)", line)
             if match:
                 output = int(match[1])
+                tracefile = match[2]
+                name = match[3]
+                trace, _ = os.path.splitext(name)
+                task.summary.add_event(engine_idx=engine_idx, trace=trace, path=tracefile)
                 prop = aiger_props[output]
                 if prop:
                     prop.status = "FAIL"
-                    task.status_db.set_task_property_status(prop, data=dict(source="abc pdr",  engine=f"engine_{engine_idx}"))
+                    task.summary.add_event(
+                        engine_idx=engine_idx, trace=trace,
+                        hdlname=prop.hdlname, src=prop.location, prop=prop,
+                    )
                 disproved.add(output)
                 proc_status = "FAIL"
                 proc = aigsmt_trace_callback(task, engine_idx, proc_status,
                     run_aigsmt=run_aigsmt, smtbmc_vcd=smtbmc_vcd, smtbmc_append=smtbmc_append, sim_append=sim_append,
-                    name=match[2],
+                    name=name,
                 )
                 proc.register_exit_callback(exit_callback)
                 procs_running += 1
@@ -198,7 +206,10 @@ def run(mode, task, engine_idx, engine):
             prop = aiger_props[output]
             if prop:
                 prop.status = "PASS"
-                task.status_db.set_task_property_status(prop, data=dict(source="abc pdr",  engine=f"engine_{engine_idx}"))
+                task.summary.add_event(
+                    engine_idx=engine_idx, trace=None,
+                    hdlname=prop.hdlname, src=prop.location, prop=prop,
+                )
             proved.add(output)
 
         match = re.match(r"^Simulation of [0-9]+ frames for [0-9]+ rounds with [0-9]+ restarts did not assert POs.", line)