yowasp-yosys 0.55.0.3.post946.dev0__py3-none-any.whl → 0.56.0.0.post964__py3-none-any.whl

yowasp_yosys/share/python3/sby_engine_aiger.py

@@ -202,11 +202,13 @@ def aigsmt_trace_callback(task, engine_idx, proc_status, *, run_aigsmt, smtbmc_v
         proc2_status = None
 
         last_prop = []
+        recorded_last = False
         current_step = None
 
         def output_callback2(line):
             nonlocal proc2_status
             nonlocal last_prop
+            nonlocal recorded_last
             nonlocal current_step
 
             smt2_trans = {'\\':'/', '|':'/'}
@@ -218,6 +220,8 @@ def aigsmt_trace_callback(task, engine_idx, proc_status, *, run_aigsmt, smtbmc_v
 
             match = re.match(r"^## [0-9: ]+ .* in step ([0-9]+)\.\.", line)
             if match:
+                last_prop = []
+                recorded_last = False
                 current_step = int(match[1])
                 return line
 
@@ -233,32 +237,33 @@ def aigsmt_trace_callback(task, engine_idx, proc_status, *, run_aigsmt, smtbmc_v
                 cell_name = match[3] or match[2]
                 prop = task.design.hierarchy.find_property(path, cell_name, trans_dict=smt2_trans)
                 prop.status = "FAIL"
-                task.status_db.set_task_property_status(prop, data=dict(source="aigsmt", engine=f"engine_{engine_idx}"))
                 last_prop.append(prop)
                 return line
 
-            match = re.match(r"^## [0-9: ]+ Writing trace to VCD file: (\S+)", line)
+            match = re.match(r"^## [0-9: ]+ Writing trace to (VCD|Yosys witness) file: (\S+)", line)
             if match:
-                tracefile = match[1]
-                trace = os.path.basename(tracefile)[:-4]
+                tracefile = match[2]
+                trace, _ = os.path.splitext(os.path.basename(tracefile))
                 task.summary.add_event(engine_idx=engine_idx, trace=trace, path=tracefile)
-
-            if match and last_prop:
                 for p in last_prop:
                     task.summary.add_event(
                         engine_idx=engine_idx, trace=trace,
-                        type=p.celltype, hdlname=p.hdlname, src=p.location, step=current_step)
-                    p.tracefiles.append(tracefile)
-                last_prop = []
+                        type=p.celltype, hdlname=p.hdlname, src=p.location,
+                        step=current_step, prop=p,
+                    )
+                recorded_last = True
                 return line
 
             return line
 
         def exit_callback2(retcode):
+            nonlocal last_prop, recorded_last
             if proc2_status is None:
                 task.error(f"engine_{engine_idx}: Could not determine aigsmt status.")
             if proc2_status != "FAIL":
                 task.error(f"engine_{engine_idx}: Unexpected aigsmt status.")
+            if len(last_prop) and not recorded_last:
+                task.error(f"engine_{engine_idx}: Found properties without trace.")
 
         proc2.output_callback = output_callback2
         proc2.register_exit_callback(exit_callback2)

yowasp_yosys/share/python3/sby_engine_btor.py

@@ -77,6 +77,7 @@ def run(mode, task, engine_idx, engine):
     common_state.wit_file = None
     common_state.assert_fail = False
     common_state.running_procs = 0
+    common_state.current_step = None
 
     def print_traces_and_terminate():
         if mode == "cover":
@@ -90,6 +91,7 @@ def run(mode, task, engine_idx, engine):
                 proc_status = "FAIL"
             else:
                 task.error(f"engine_{engine_idx}: Engine terminated without status.")
+            task.update_unknown_props(dict(source="btor", engine=f"engine_{engine_idx}"))
         else:
             if common_state.expected_cex == 0:
                 proc_status = "pass"
@@ -100,7 +102,7 @@ def run(mode, task, engine_idx, engine):
             else:
                 task.error(f"engine_{engine_idx}: Engine terminated without status.")
 
-        task.update_status(proc_status.upper())
+        task.update_status(proc_status.upper(), common_state.current_step)
         task.summary.set_engine_status(engine_idx, proc_status)
 
         task.terminate()
@@ -117,9 +119,11 @@ def run(mode, task, engine_idx, engine):
 
     def make_exit_callback(suffix):
         def exit_callback2(retcode):
-            vcdpath = f"engine_{engine_idx}/trace{suffix}.vcd"
-            if os.path.exists(f"{task.workdir}/{vcdpath}"):
-                task.summary.add_event(engine_idx=engine_idx, trace=f'trace{suffix}', path=vcdpath, type="$cover" if mode == "cover" else "$assert")
+            trace = f"trace{suffix}"
+            vcdpath = f"engine_{engine_idx}/{trace}.vcd"
+            trace_path = f"{task.workdir}/{vcdpath}"
+            if os.path.exists(trace_path):
+                task.summary.add_event(engine_idx=engine_idx, trace=trace, path=vcdpath, type="$cover" if mode == "cover" else "$assert")
 
             common_state.running_procs -= 1
             if (common_state.running_procs == 0):
@@ -140,6 +144,7 @@ def run(mode, task, engine_idx, engine):
                     common_state.expected_cex = int(match[1])
                     if common_state.produced_cex != 0:
                         task.error(f"engine_{engine_idx}: Unexpected engine output (property count).")
+                    task.update_unknown_props(dict(source="btor_init", engine=f"engine_{engine_idx}"))
 
             else:
                 task.error(f"engine_{engine_idx}: BTOR solver '{solver_args[0]}' is currently not supported in cover mode.")
@@ -205,6 +210,9 @@ def run(mode, task, engine_idx, engine):
             if solver_args[0] == "btormc":
                 if "calling BMC on" in line:
                     return line
+                match = re.match(r".*at bound k = (\d+).*", line)
+                if match:
+                    common_state.current_step = int(match[1])
                 if "SATISFIABLE" in line:
                     return line
                 if "bad state properties at bound" in line:
@@ -215,6 +223,9 @@ def run(mode, task, engine_idx, engine):
                     return line
 
             elif solver_args[0] == "pono":
+                match = re.match(r".*at bound (\d+).*", line)
+                if match:
+                    common_state.current_step = int(match[1])
                 if line == "unknown":
                     if common_state.solver_status is None:
                         common_state.solver_status = "unsat"

yowasp_yosys/share/python3/sby_engine_smtbmc.py

@@ -184,16 +184,20 @@ def run(mode, task, engine_idx, engine):
 
     proc_status = None
     last_prop = []
+    recorded_last = False
     pending_sim = None
     current_step = None
     procs_running = 1
+    failed_assert = False
 
     def output_callback(line):
         nonlocal proc_status
         nonlocal last_prop
+        nonlocal recorded_last
         nonlocal pending_sim
         nonlocal current_step
         nonlocal procs_running
+        nonlocal failed_assert
 
         if pending_sim:
             sim_proc = sim_witness_trace(procname, task, engine_idx, pending_sim, append=sim_append, inductive=mode == "prove_induction")
@@ -210,7 +214,14 @@ def run(mode, task, engine_idx, engine):
 
         match = re.match(r"^## [0-9: ]+ .* in step ([0-9]+)\.\.", line)
         if match:
+            last_prop = []
+            recorded_last = False
+            if mode == "prove_induction":
+                return line
+            last_step = current_step
             current_step = int(match[1])
+            if current_step != last_step and last_step is not None:
+                task.update_unknown_props(dict(source="smtbmc", engine=f"engine_{engine_idx}", step=last_step))
             return line
 
         match = re.match(r"^## [0-9: ]+ Status: FAILED", line)
@@ -235,11 +246,11 @@ def run(mode, task, engine_idx, engine):
 
         match = re.match(r"^## [0-9: ]+ Assert failed in ([^:]+): (\S+)(?: \((\S+)\))?", line)
         if match:
+            failed_assert = not keep_going
             path = parse_mod_path(match[1])
             cell_name = match[3] or match[2]
             prop = task.design.hierarchy.find_property(path, cell_name, trans_dict=smt2_trans)
             prop.status = "FAIL"
-            task.status_db.set_task_property_status(prop, data=dict(source="smtbmc", engine=f"engine_{engine_idx}"))
             last_prop.append(prop)
             return line
 
@@ -249,39 +260,37 @@ def run(mode, task, engine_idx, engine):
             cell_name = match[3] or match[2]
             prop = task.design.hierarchy.find_property(path, cell_name, trans_dict=smt2_trans)
             prop.status = "PASS"
-            task.status_db.set_task_property_status(prop, data=dict(source="smtbmc", engine=f"engine_{engine_idx}"))
             last_prop.append(prop)
             return line
 
-        if smtbmc_vcd and not task.opt_fst:
-            match = re.match(r"^## [0-9: ]+ Writing trace to VCD file: (\S+)", line)
-            if match:
-                tracefile = match[1]
-                trace = os.path.basename(tracefile)[:-4]
-                engine_case = mode.split('_')[1] if '_' in mode else None
-                task.summary.add_event(engine_idx=engine_idx, trace=trace, path=tracefile, engine_case=engine_case)
-
-            if match and last_prop:
-                for p in last_prop:
-                    task.summary.add_event(
-                        engine_idx=engine_idx, trace=trace,
-                        type=p.celltype, hdlname=p.hdlname, src=p.location, step=current_step)
-                    p.tracefiles.append(tracefile)
-                last_prop = []
-                return line
-        else:
-            match = re.match(r"^## [0-9: ]+ Writing trace to Yosys witness file: (\S+)", line)
-            if match:
-                tracefile = match[1]
+        match = re.match(r"^## [0-9: ]+ Writing trace to (VCD|Yosys witness) file: (\S+)", line)
+        if match:
+            tracefile = match[2]
+            if match[1] == "Yosys witness" and (task.opt_fst or task.opt_vcd_sim):
                 pending_sim = tracefile
+            trace, _ = os.path.splitext(os.path.basename(tracefile))
+            engine_case = mode.split('_')[1] if '_' in mode else None
+            task.summary.add_event(engine_idx=engine_idx, trace=trace, path=tracefile, engine_case=engine_case)
+            for p in last_prop:
+                task.summary.add_event(
+                    engine_idx=engine_idx, trace=trace,
+                    type=p.celltype, hdlname=p.hdlname, src=p.location,
+                    step=current_step, prop=p,
+                )
+            recorded_last = True
+            return line
 
         match = re.match(r"^## [0-9: ]+ Unreached cover statement at ([^:]+): (\S+)(?: \((\S+)\))?", line)
-        if match:
+        if match and not failed_assert:
             path = parse_mod_path(match[1])
             cell_name = match[3] or match[2]
             prop = task.design.hierarchy.find_property(path, cell_name, trans_dict=smt2_trans)
             prop.status = "FAIL"
-            task.status_db.set_task_property_status(prop, data=dict(source="smtbmc", engine=f"engine_{engine_idx}"))
+            task.summary.add_event(
+                engine_idx=engine_idx, trace=None,
+                hdlname=prop.hdlname, src=prop.location,
+                step=current_step, prop=prop,
+            )
 
         return line
 
@@ -292,15 +301,19 @@ def run(mode, task, engine_idx, engine):
             last_exit_callback()
 
     def exit_callback(retcode):
+        nonlocal last_prop, recorded_last
         if proc_status is None:
             task.error(f"engine_{engine_idx}: Engine terminated without status.")
+        if len(last_prop) and not recorded_last:
+            task.error(f"engine_{engine_idx}: Found properties without trace.")
         simple_exit_callback(retcode)
 
     def last_exit_callback():
+        nonlocal current_step
         if mode == "bmc" or mode == "cover":
-            task.update_status(proc_status)
+            task.update_status(proc_status, current_step)
             if proc_status == "FAIL" and mode == "bmc" and keep_going:
-                task.pass_unknown_asserts(dict(source="smtbmc", keep_going=True, engine=f"engine_{engine_idx}"))
+                task.pass_unknown_asserts(dict(source="smtbmc", keep_going=True, engine=f"engine_{engine_idx}", step=current_step))
             proc_status_lower = proc_status.lower() if proc_status == "PASS" else proc_status
             task.summary.set_engine_status(engine_idx, proc_status_lower)
             if not keep_going:
@@ -332,7 +345,7 @@ def run(mode, task, engine_idx, engine):
                 assert False
 
             if task.basecase_pass and task.induction_pass:
-                task.update_status("PASS")
+                task.update_status("PASS", current_step)
                 task.summary.append("successful proof by k-induction.")
                 if not keep_going:
                     task.terminate()