Add object caching

Author: amykyta3

pkg-runtime/src/peakrdl_pyral_runtime/dbapi.py

@@ -4,6 +4,7 @@
 from collections import OrderedDict
 import importlib
 import weakref
+from functools import lru_cache
 
 from .model import RALRegister, RALField, RALGroup, RALArray, RegValue
 from .model import AddressableRALNode
@@ -60,7 +61,7 @@ def __init__(self, path: str, origin_module_name: str) -> None:
         # Close the DB connection when this DBAPI gets garbage collected
         weakref.finalize(self, self.db.close)
 
-
+    @lru_cache()
     def get_root(self, offset: int = 0) -> RALGroup:
         """
         Get the root node of a RAL DB
@@ -122,6 +123,7 @@ def get_ref_dbapi(self, ref_dbid: int) -> "DBAPI":
 
         return new_dbapi
 
+    @lru_cache()
     def get_child(self, parent: AddressableRALNode, child_name: str) -> Union[None, RALArray, RALRegister, RALGroup, RALField]:
         """
         Get a single child of a node by name
@@ -141,7 +143,8 @@ def get_child(self, parent: AddressableRALNode, child_name: str) -> Union[None,
 
         return self.build_child(parent, row)
 
-    def get_children(self, parent: AddressableRALNode) -> list[Union[RALArray, RALRegister, RALGroup, RALField]]:
+    @lru_cache()
+    def get_children(self, parent: AddressableRALNode) -> tuple[Union[RALArray, RALRegister, RALGroup, RALField], ...]:
         """
         Get all the children of a node
         """
@@ -152,9 +155,10 @@ def get_children(self, parent: AddressableRALNode) -> list[Union[RALArray, RALRe
         )
         rows = cur.fetchall()
         cur.close()
-        return [self.build_child(parent, row) for row in rows]
+        return tuple([self.build_child(parent, row) for row in rows])
 
-    def regvalue_from_int(self, parent_reg_dbid: int, reg_value: int) -> RegValue:
+    @lru_cache()
+    def get_regvalue_spec(self, parent_reg_dbid: int) -> dict[str, tuple[int, int]]:
         """
         Convert a raw integer value to a field-aware RegValue
         """
@@ -172,6 +176,13 @@ def regvalue_from_int(self, parent_reg_dbid: int, reg_value: int) -> RegValue:
         for row in rows:
             spec[row["name"]] = (row["offset"], row["size"])
 
+        return spec
+
+    def regvalue_from_int(self, parent_reg_dbid: int, reg_value: int) -> RegValue:
+        """
+        Convert a raw integer value to a field-aware RegValue
+        """
+        spec = self.get_regvalue_spec(parent_reg_dbid)
         return RegValue(reg_value, spec)
 
     def build_child(self, parent: AddressableRALNode, row: sqlite3.Row) -> Union[RALArray, RALRegister, RALGroup, RALField]:

pkg-runtime/src/peakrdl_pyral_runtime/hwio/openocd.py

@@ -54,16 +54,16 @@ def _cmd(self, cmd: str) -> str:
         self._sock.sendall(data)
 
         # Get response
-        data = bytearray()
+        rdata = bytearray()
         while True:
             chunk = self._sock.recv(4096)
-            data.extend(chunk)
+            rdata.extend(chunk)
             if chunk.endswith(RPC_TERM):
                 break
 
         # strip trailing RPC_TERM token
-        data = data[:-1]
-        return data.decode("utf-8").strip()
+        rdata = rdata[:-1]
+        return rdata.decode("utf-8").strip()
 
     def _read_impl(self, addr: int, size: int) -> int:
         suffix = SUFFIX_MAP[size]

pkg-runtime/src/peakrdl_pyral_runtime/model/array.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, Any, Union, overload
 from collections.abc import Sequence
+from functools import lru_cache
 
 if TYPE_CHECKING:
     import sqlite3
@@ -36,6 +37,40 @@ def __repr__(self) -> str:
         suffix += "[]" * (len(self._dims) - len(self._resolved_dims))
         return f"<RALArray of {obj_name}: {self._parent.path}.{self._row['name']}{suffix}>"
 
+    @lru_cache()
+    def _get_single_item(self, idx: int) -> "RALChild":
+        dim = self._dims[self._this_dim_idx]
+
+        if idx >= dim or idx < 0:
+            raise IndexError("array index out of range")
+
+        # Update known dimensions
+        resolved_dims = self._resolved_dims.copy()
+        resolved_dims.append(idx)
+
+        if len(resolved_dims) != len(self._dims):
+            # Multi-dimensional array still has unresolved dimensions
+            # Create another array
+            return RALArray(
+                self._parent,
+                self._dbapi,
+                resolved_dims,
+                self._dims,
+                self._row,
+            )
+
+        # All dimensions are known. Create the actual node
+        flat_idx = 0
+        for i, current_idx in enumerate(resolved_dims):
+            sz = 1
+            for j in range(i + 1, len(self._dims)):
+                sz *= self._dims[j]
+            flat_idx += sz * current_idx
+        array_offset = flat_idx * self._row["stride"]
+
+        array_suffix = "".join([f"[{d}]" for d in resolved_dims])
+        return self._dbapi.build_node(self._parent, self._row, array_suffix, array_offset)
+
     @overload
     def __getitem__(self, subscript: int) -> "RALChild": ...
 
@@ -63,44 +98,15 @@ def __getitem__(self, subscript: Any) -> Union["RALChild", list["RALChild"]]:
             # This is consistent with Python's behavior for lists
             start = max(start, 0)
             stop = min(stop, dim)
-            return [self[i] for i in range(start, stop, step)]
+            return [self._get_single_item(i) for i in range(start, stop, step)]
         elif not isinstance(subscript, int):
             raise TypeError("array indices must be integers or slices")
 
-
         # Handle negative subscripts that index from end of array
         if subscript < 0:
             subscript += dim
 
-        if subscript >= dim or subscript < 0:
-            raise IndexError("array index out of range")
-
-        # Update known dimensions
-        resolved_dims = self._resolved_dims.copy()
-        resolved_dims.append(subscript)
-
-        if len(resolved_dims) != len(self._dims):
-            # Multi-dimensional array still has unresolved dimensions
-            # Create another array
-            return RALArray(
-                self._parent,
-                self._dbapi,
-                resolved_dims,
-                self._dims,
-                self._row,
-            )
-
-        # All dimensions are known. Create the actual node
-        flat_idx = 0
-        for i, current_idx in enumerate(resolved_dims):
-            sz = 1
-            for j in range(i + 1, len(self._dims)):
-                sz *= self._dims[j]
-            flat_idx += sz * current_idx
-        array_offset = flat_idx * self._row["stride"]
-
-        array_suffix = "".join([f"[{d}]" for d in resolved_dims])
-        return self._dbapi.build_node(self._parent, self._row, array_suffix, array_offset)
+        return self._get_single_item(subscript)
 
     def __len__(self) -> int:
         return self._dims[self._this_dim_idx]

pkg-runtime/src/peakrdl_pyral_runtime/model/base.py

@@ -58,14 +58,13 @@ def __getattr__(self, name: str) -> Union["RALArray", "RALRegister", "RALGroup",
             raise AttributeError(f"'{repr(self)}' has no attribute '{name}'")
         return child
 
-    def children(self) -> list[Union["RALArray", "RALRegister", "RALGroup", "RALField"]]:
+    def children(self) -> tuple[Union["RALArray", "RALRegister", "RALGroup", "RALField"], ...]:
         """
-        Returns a list of child RAL elements
+        Returns a tuple of child RAL elements
         """
         return self._dbapi.get_children(self)
 
     def _lookup_hwio(self) -> tuple["HWIO", int]:
-        # TODO: Implement HWIO object caching
         if self._hwio is not None:
             # This node has a HWIO bound to it
             if self.parent is None:

test/benchmark/benchmark_ral.py

@@ -5,7 +5,7 @@
 
 from systemrdl.compiler import RDLCompiler
 from peakrdl_pyral.exporter import PyRALExporter
-from peakrdl_pyral_runtime.hwio.demo import DemoHWIO
+from peakrdl_pyral_runtime.hwio import HWIO
 
 this_dir = os.path.normpath(os.path.dirname(__file__))
 
@@ -16,15 +16,21 @@
 e = PyRALExporter()
 e.export(root.top, this_dir)
 
+# Make a dummy HWIO
+class DummyHWIO(HWIO):
+    def _read_impl(self, addr: int, size: int) -> int:
+        return 0
+    def _write_impl(self, addr: int, value: int, size: int) -> None:
+        pass
 
 # Prepare ral
 import structural
 ral = structural.get_ral()
-hwio = DemoHWIO()
+hwio = DummyHWIO()
 ral.attach_hwio(hwio)
 
 def test_func():
     ral.sub2[4].sub[0].r1.read()
 
-result = timeit.timeit("test_func()", globals=globals(), number=100_000)
+result = timeit.timeit("test_func()", globals=globals(), number=200_000)
 print(result)

test/pylint.rc

@@ -96,7 +96,8 @@ disable=
         protected-access,
         duplicate-code,
         unused-argument,
-        consider-using-f-string
+        consider-using-f-string,
+        consider-using-generator
 
 # Enable the message, report, category or checker with the given id(s). You can
 # either give multiple identifier separated by comma (,) or put this option