yowasp-yosys 0.38.0.92.post687.dev0__py3-none-any.whl → 0.39.0.165.post702.dev0__py3-none-any.whl

yowasp_yosys/share/python3/sby_status.py

@@ -0,0 +1,344 @@
+from __future__ import annotations
+
+import sqlite3
+import os
+import time
+import json
+from collections import defaultdict
+from functools import wraps
+from pathlib import Path
+from typing import Any, Callable, TypeVar, Optional, Iterable
+from sby_design import SbyProperty, pretty_path
+
+
+Fn = TypeVar("Fn", bound=Callable[..., Any])
+
+
+def transaction(method: Fn) -> Fn:
+    @wraps(method)
+    def wrapper(self: SbyStatusDb, *args: Any, **kwargs: Any) -> Any:
+        if self._transaction_active:
+            return method(self, *args, **kwargs)
+
+        try:
+            self.log_debug(f"begin {method.__name__!r} transaction")
+            self.db.execute("begin")
+            self._transaction_active = True
+            result = method(self, *args, **kwargs)
+            self.db.execute("commit")
+            self._transaction_active = False
+            self.log_debug(f"comitted {method.__name__!r} transaction")
+            return result
+        except sqlite3.OperationalError as err:
+            self.log_debug(f"failed {method.__name__!r} transaction {err}")
+            self.db.rollback()
+            self._transaction_active = False
+        except Exception as err:
+            self.log_debug(f"failed {method.__name__!r} transaction {err}")
+            self.db.rollback()
+            self._transaction_active = False
+            raise
+        try:
+            self.log_debug(
+                f"retrying {method.__name__!r} transaction once in immediate mode"
+            )
+            self.db.execute("begin immediate")
+            self._transaction_active = True
+            result = method(self, *args, **kwargs)
+            self.db.execute("commit")
+            self._transaction_active = False
+            self.log_debug(f"comitted {method.__name__!r} transaction")
+            return result
+        except Exception as err:
+            self.log_debug(f"failed {method.__name__!r} transaction {err}")
+            self.db.rollback()
+            self._transaction_active = False
+            raise
+
+    return wrapper  # type: ignore
+
+
+class SbyStatusDb:
+    def __init__(self, path: Path, task, timeout: float = 5.0):
+        self.debug = False
+        self.task = task
+        self._transaction_active = False
+
+        setup = not os.path.exists(path)
+
+        self.db = sqlite3.connect(path, isolation_level=None, timeout=timeout)
+        self.db.row_factory = sqlite3.Row
+        self.db.execute("PRAGMA journal_mode=WAL")
+        self.db.execute("PRAGMA synchronous=0")
+
+        if setup:
+            self._setup()
+
+        if task is not None:
+            self.task_id = self.create_task(workdir=task.workdir, mode=task.opt_mode)
+
+    def log_debug(self, *args):
+        if self.debug:
+            if self.task:
+                self.task.log(" ".join(str(arg) for arg in args))
+            else:
+                print(*args)
+
+    @transaction
+    def _setup(self):
+        script = """
+                CREATE TABLE task (
+                    id INTEGER PRIMARY KEY,
+                    workdir TEXT,
+                    mode TEXT,
+                    created REAL
+                );
+                CREATE TABLE task_status (
+                    id INTEGER PRIMARY KEY,
+                    task INTEGER,
+                    status TEXT,
+                    data TEXT,
+                    created REAL,
+                    FOREIGN KEY(task) REFERENCES task(id)
+                );
+                CREATE TABLE task_property (
+                    id INTEGER PRIMARY KEY,
+                    task INTEGER,
+                    src TEXT,
+                    name TEXT,
+                    created REAL,
+                    FOREIGN KEY(task) REFERENCES task(id)
+                );
+                CREATE TABLE task_property_status (
+                    id INTEGER PRIMARY KEY,
+                    task_property INTEGER,
+                    status TEXT,
+                    data TEXT,
+                    created REAL,
+                    FOREIGN KEY(task_property) REFERENCES task_property(id)
+                );
+                CREATE TABLE task_property_data (
+                    id INTEGER PRIMARY KEY,
+                    task_property INTEGER,
+                    kind TEXT,
+                    data TEXT,
+                    created REAL,
+                    FOREIGN KEY(task_property) REFERENCES task_property(id)
+                );
+            """
+        for statement in script.split(";\n"):
+            statement = statement.strip()
+            if statement:
+                self.db.execute(statement)
+
+    @transaction
+    def create_task(self, workdir: str, mode: str) -> int:
+        return self.db.execute(
+            """
+                INSERT INTO task (workdir, mode, created)
+                VALUES (:workdir, :mode, :now)
+            """,
+            dict(workdir=workdir, mode=mode, now=time.time()),
+        ).lastrowid
+
+    @transaction
+    def create_task_properties(
+        self, properties: Iterable[SbyProperty], *, task_id: Optional[int] = None
+    ):
+        if task_id is None:
+            task_id = self.task_id
+        now = time.time()
+        self.db.executemany(
+            """
+                INSERT INTO task_property (name, src, task, created)
+                VALUES (:name, :src, :task, :now)
+            """,
+            [
+                dict(
+                    name=json.dumps(prop.path),
+                    src=prop.location or "",
+                    task=task_id,
+                    now=now,
+                )
+                for prop in properties
+            ],
+        )
+
+    @transaction
+    def set_task_status(
+        self,
+        status: Optional[str] = None,
+        data: Any = None,
+    ):
+        if status is None:
+            status = property.status
+
+        now = time.time()
+        self.db.execute(
+            """
+                INSERT INTO task_status (
+                    task, status, data, created
+                )
+                VALUES (
+                    :task, :status, :data, :now
+                )
+            """,
+            dict(
+                task=self.task_id,
+                status=status,
+                data=json.dumps(data),
+                now=now,
+            ),
+        )
+
+    @transaction
+    def set_task_property_status(
+        self,
+        property: SbyProperty,
+        status: Optional[str] = None,
+        data: Any = None,
+    ):
+        if status is None:
+            status = property.status
+
+        now = time.time()
+        self.db.execute(
+            """
+                INSERT INTO task_property_status (
+                    task_property, status, data, created
+                )
+                VALUES (
+                    (SELECT id FROM task_property WHERE task = :task AND name = :name),
+                    :status, :data, :now
+                )
+            """,
+            dict(
+                task=self.task_id,
+                name=json.dumps(property.path),
+                status=status,
+                data=json.dumps(data),
+                now=now,
+            ),
+        )
+
+    @transaction
+    def add_task_property_data(self, property: SbyProperty, kind: str, data: Any):
+        now = time.time()
+        self.db.execute(
+            """
+                INSERT INTO task_property_data (
+                    task_property, kind, data, created
+                )
+                VALUES (
+                    (SELECT id FROM task_property WHERE task = :task AND name = :name),
+                    :kind, :data, :now
+                )
+            """,
+            dict(
+                task=self.task_id,
+                name=json.dumps(property.path),
+                kind=kind,
+                data=json.dumps(data),
+                now=now,
+            ),
+        )
+
+    @transaction
+    def all_tasks(self):
+        rows = self.db.execute(
+            """
+                SELECT id, workdir, created FROM task
+            """
+        ).fetchall()
+
+        return {row["id"]: dict(row) for row in rows}
+
+    @transaction
+    def all_task_properties(self):
+        rows = self.db.execute(
+            """
+                SELECT id, task, src, name, created FROM task_property
+            """
+        ).fetchall()
+
+        def get_result(row):
+            row = dict(row)
+            row["name"] = tuple(json.loads(row.get("name", "[]")))
+            row["data"] = json.loads(row.get("data", "null"))
+            return row
+
+        return {row["id"]: get_result(row) for row in rows}
+
+    @transaction
+    def all_task_property_statuses(self):
+        rows = self.db.execute(
+            """
+                SELECT id, task_property, status, data, created
+                FROM task_property_status
+            """
+        ).fetchall()
+
+        def get_result(row):
+            row = dict(row)
+            row["data"] = json.loads(row.get("data", "null"))
+            return row
+
+        return {row["id"]: get_result(row) for row in rows}
+
+    @transaction
+    def all_status_data(self):
+        return (
+            self.all_tasks(),
+            self.all_task_properties(),
+            self.all_task_property_statuses(),
+        )
+
+    @transaction
+    def reset(self):
+        self.db.execute("""DELETE FROM task_property_status""")
+        self.db.execute("""DELETE FROM task_property_data""")
+        self.db.execute("""DELETE FROM task_property""")
+        self.db.execute("""DELETE FROM task_status""")
+        self.db.execute("""DELETE FROM task""")
+
+    def print_status_summary(self):
+        tasks, task_properties, task_property_statuses = self.all_status_data()
+        properties = defaultdict(set)
+
+        uniquify_paths = defaultdict(dict)
+
+        def add_status(task_property, status):
+
+            display_name = task_property["name"]
+            if display_name[-1].startswith("$"):
+                counters = uniquify_paths[task_property["src"]]
+                counter = counters.setdefault(display_name[-1], len(counters) + 1)
+                if task_property["src"]:
+                    if counter < 2:
+                        path_based = f"<unnamed at {task_property['src']}>"
+                    else:
+                        path_based = f"<unnamed #{counter} at {task_property['src']}>"
+                else:
+                    path_based = f"<unnamed #{counter}>"
+                display_name = (*display_name[:-1], path_based)
+
+            properties[display_name].add(status)
+
+        for task_property in task_properties.values():
+            add_status(task_property, "UNKNOWN")
+
+        for status in task_property_statuses.values():
+            task_property = task_properties[status["task_property"]]
+            add_status(task_property, status["status"])
+
+        for display_name, statuses in sorted(properties.items()):
+            print(pretty_path(display_name), combine_statuses(statuses))
+
+
+def combine_statuses(statuses):
+    statuses = set(statuses)
+
+    if len(statuses) > 1:
+        statuses.discard("UNKNOWN")
+
+    return ",".join(sorted(statuses))

yowasp_yosys/share/python3/smtio.py

@@ -79,6 +79,20 @@ def except_hook(exctype, value, traceback):
 sys.excepthook = except_hook
 
 
+def recursion_helper(iteration, *request):
+    stack = [iteration(*request)]
+
+    while stack:
+        top = stack.pop()
+        try:
+            request = next(top)
+        except StopIteration:
+            continue
+
+        stack.append(top)
+        stack.append(iteration(*request))
+
+
 hex_dict = {
     "0": "0000", "1": "0001", "2": "0010", "3": "0011",
     "4": "0100", "5": "0101", "6": "0110", "7": "0111",
@@ -100,6 +114,7 @@ class SmtModInfo:
         self.clocks = dict()
         self.cells = dict()
         self.asserts = dict()
+        self.assumes = dict()
         self.covers = dict()
         self.maximize = set()
         self.minimize = set()
@@ -127,6 +142,7 @@ class SmtIo:
         self.recheck = False
         self.smt2cache = [list()]
         self.smt2_options = dict()
+        self.smt2_assumptions = dict()
         self.p = None
         self.p_index = solvers_index
         solvers_index += 1
@@ -298,10 +314,22 @@ class SmtIo:
         return stmt
 
     def unroll_stmt(self, stmt):
+        result = []
+        recursion_helper(self._unroll_stmt_into, stmt, result)
+        return result.pop()
+
+    def _unroll_stmt_into(self, stmt, output, depth=128):
         if not isinstance(stmt, list):
-            return stmt
+            output.append(stmt)
+            return
 
-        stmt = [self.unroll_stmt(s) for s in stmt]
+        new_stmt = []
+        for s in stmt:
+            if depth:
+                yield from self._unroll_stmt_into(s, new_stmt, depth - 1)
+            else:
+                yield s, new_stmt
+        stmt = new_stmt
 
         if len(stmt) >= 2 and not isinstance(stmt[0], list) and stmt[0] in self.unroll_decls:
             assert stmt[1] in self.unroll_objs
@@ -330,12 +358,19 @@ class SmtIo:
                     decl[2] = list()
 
                 if len(decl) > 0:
-                    decl = self.unroll_stmt(decl)
+                    tmp = []
+                    if depth:
+                        yield from self._unroll_stmt_into(decl, tmp, depth - 1)
+                    else:
+                        yield decl, tmp
+
+                    decl = tmp.pop()
                     self.write(self.unparse(decl), unroll=False)
 
-            return self.unroll_cache[key]
+            output.append(self.unroll_cache[key])
+            return
 
-        return stmt
+        output.append(stmt)
 
     def p_thread_main(self):
         while True:
@@ -569,6 +604,12 @@ class SmtIo:
             else:
                 self.modinfo[self.curmod].covers["%s_c %s" % (self.curmod, fields[2])] = fields[3]
 
+        if fields[1] == "yosys-smt2-assume":
+            if len(fields) > 4:
+                self.modinfo[self.curmod].assumes["%s_u %s" % (self.curmod, fields[2])] = f'{fields[4]} ({fields[3]})'
+            else:
+                self.modinfo[self.curmod].assumes["%s_u %s" % (self.curmod, fields[2])] = fields[3]
+
         if fields[1] == "yosys-smt2-maximize":
             self.modinfo[self.curmod].maximize.add(fields[2])
 
@@ -752,8 +793,13 @@ class SmtIo:
         return stmt
 
     def check_sat(self, expected=["sat", "unsat", "unknown", "timeout", "interrupted"]):
+        if self.smt2_assumptions:
+            assume_exprs = " ".join(self.smt2_assumptions.values())
+            check_stmt = f"(check-sat-assuming ({assume_exprs}))"
+        else:
+            check_stmt = "(check-sat)"
         if self.debug_print:
-            print("> (check-sat)")
+            print(f"> {check_stmt}")
         if self.debug_file and not self.nocomments:
             print("; running check-sat..", file=self.debug_file)
             self.debug_file.flush()
@@ -767,7 +813,7 @@ class SmtIo:
                     for cache_stmt in cache_ctx:
                         self.p_write(cache_stmt + "\n", False)
 
-            self.p_write("(check-sat)\n", True)
+            self.p_write(f"{check_stmt}\n", True)
 
             if self.timeinfo:
                 i = 0
@@ -835,7 +881,7 @@ class SmtIo:
 
         if self.debug_file:
             print("(set-info :status %s)" % result, file=self.debug_file)
-            print("(check-sat)", file=self.debug_file)
+            print(check_stmt, file=self.debug_file)
             self.debug_file.flush()
 
         if result not in expected:
@@ -912,6 +958,48 @@ class SmtIo:
     def bv2int(self, v):
         return int(self.bv2bin(v), 2)
 
+    def get_raw_unsat_assumptions(self):
+        self.write("(get-unsat-assumptions)")
+        exprs = set(self.unparse(part) for part in self.parse(self.read()))
+        unsat_assumptions = []
+        for key, value in self.smt2_assumptions.items():
+            # normalize expression
+            value = self.unparse(self.parse(value))
+            if value in exprs:
+                exprs.remove(value)
+                unsat_assumptions.append(key)
+        return unsat_assumptions
+
+    def get_unsat_assumptions(self, minimize=False):
+        if not minimize:
+            return self.get_raw_unsat_assumptions()
+        required_assumptions = {}
+
+        while True:
+            candidate_assumptions = {}
+            for key in self.get_raw_unsat_assumptions():
+                if key not in required_assumptions:
+                    candidate_assumptions[key] = self.smt2_assumptions[key]
+
+            while candidate_assumptions:
+
+                candidate_key, candidate_assume = candidate_assumptions.popitem()
+
+                self.smt2_assumptions = {}
+                for key, assume in candidate_assumptions.items():
+                    self.smt2_assumptions[key] = assume
+                for key, assume in required_assumptions.items():
+                    self.smt2_assumptions[key] = assume
+                result = self.check_sat()
+
+                if result == 'unsat':
+                    candidate_assumptions = None
+                else:
+                    required_assumptions[candidate_key] = candidate_assume
+
+            if candidate_assumptions is not None:
+                return list(required_assumptions)
+
     def get(self, expr):
         self.write("(get-value (%s))" % (expr))
         return self.parse(self.read())[0][1]

yowasp_yosys/share/quicklogic/qlf_k6n10f/bram_types_sim.v

@@ -1,5 +1,5 @@
 // **AUTOGENERATED FILE** **DO NOT EDIT**
-// Generated by ../yosys-src/techlibs/quicklogic/qlf_k6n10f/generate_bram_types_sim.py at 2024-02-27 08:47:46.596631+00:00
+// Generated by ../yosys-src/techlibs/quicklogic/qlf_k6n10f/generate_bram_types_sim.py at 2024-04-04 02:33:31.959107+00:00
 `timescale 1ns /10ps
 
 module TDP36K_BRAM_A_X1_B_X1_nonsplit (