Merge pull request #260 from krcb197/255-use-the-compiler-overlap-features

Improve the support for overlapping register and fields

Author: krcb197

pyproject.toml

@@ -8,7 +8,7 @@ dynamic = ["version"]
 # Callable is broken in python 3.9.0 and 3.9.1 so these need to be excluded
 requires-python = ">=3.9.2"
 dependencies = [
-    "systemrdl-compiler>=1.29.3", # this is needed to make sure all the latest type checking
+    "systemrdl-compiler>=1.31.0", # this is needed for the latest overlappign register features
     "jinja2",
     "typing-extensions;python_version<'3.11'",
     # the batched fucntion was adopted into the standard python library at 3.13

src/peakrdl_python/__about__.py

@@ -17,4 +17,4 @@
 
 Variables that describes the peakrdl-python Package
 """
-__version__ = "2.2.0"
+__version__ = "2.3.0"

src/peakrdl_python/exporter.py

@@ -46,7 +46,7 @@
     get_memory_max_entry_value_hex_string, get_memory_width_bytes, \
     get_field_default_value, get_enum_values, get_properties_to_include, \
     HideNodeCallback, hide_based_on_property, \
-    full_slice_accessor, ShowUDPCallback
+    full_slice_accessor, ShowUDPCallback, simulator_field_definition
 from .unique_component_iterator import UniqueComponents
 from .unique_component_iterator import PeakRDLPythonUniqueRegisterComponents
 from .unique_component_iterator import PeakRDLPythonUniqueMemoryComponents
@@ -675,16 +675,17 @@ def __export_simulator(self, *,
                 raise TypeError(f'node should be a register, got {type(node)}')
             reg_addr = node.absolute_address
             if reg_addr in reg_dict:
+                if not node.has_overlaps:
+                    raise RuntimeError('A non-overlaping node should not have a duplicate address')
                 existing_entry = reg_dict[reg_addr]
-                # if the entry is already list simply append to it
-                if isinstance(existing_entry, list):
-                    existing_entry.append(node)
-                elif isinstance(existing_entry, RegNode):
-                    reg_dict[reg_addr] = [existing_entry, node]
-                else:
-                    raise TypeError(f'exiting entry of unexpected type: {type(existing_entry)}')
+                if not isinstance(existing_entry, list):
+                    raise RuntimeError('A overlapping entry should have been made as list')
+                existing_entry.append(node)
             else:
-                reg_dict[reg_addr] = node
+                if node.has_overlaps:
+                    reg_dict[reg_addr] = [node,]
+                else:
+                    reg_dict[reg_addr] = node
 
 
         context = {
@@ -696,7 +697,8 @@ def __export_simulator(self, *,
             'asyncoutput': asyncoutput,
             'skip_lib_copy': skip_lib_copy,
             'legacy_block_access': legacy_block_access,
-            'list': list
+            'list': list,
+            'simulator_field_definition': simulator_field_definition,
         }
 
         module_name = top_block.inst_name

src/peakrdl_python/sim_lib/field.py

@@ -20,7 +20,8 @@
 """
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
-from typing import Optional
+from typing import Optional, Union
+from enum import Enum, auto
 
 from ..lib.utility_functions import swap_msb_lsb_ordering
 
@@ -33,19 +34,8 @@
 
 # pylint: disable=too-many-instance-attributes,too-many-arguments
 
-
-@dataclass
-class FieldDefinition:
-    """
-    Class for an entry in the list of memories in the simulator
-    """
-    high: int
-    low: int
-    msb: int
-    lsb: int
-    inst_name: str
-
-class Field(Base):
+#pylint:disable-next=too-few-public-methods
+class _FieldBase(Base):
     """
     class for all fields
 
@@ -58,7 +48,7 @@ class for all fields
                  '__bitmask', '__inverse_bitmask',
                  '__msb0', '__lsb0',
                  '__parent_register','__parent_width',
-                 '__read_callback', '__write_callback']
+                 '_read_callback', '_write_callback']
 
     def __init__(self, *, low: int, high: int, msb: int, lsb: int,
                  parent_register: 'BaseRegister', parent_width: int, inst_name: str):
@@ -94,30 +84,8 @@ def __init__(self, *, low: int, high: int, msb: int, lsb: int,
         parent_max_value = (2 ** parent_width) - 1
         self.__inverse_bitmask = parent_max_value ^ self.__bitmask
 
-        self.__read_callback: Optional[FieldReadCallback] = None
-        self.__write_callback: Optional[FieldWriteCallback] = None
-
-    @property
-    def read_callback(self) -> Optional[FieldReadCallback]:
-        """
-        Callback made during each read operation
-        """
-        return self.__read_callback
-
-    @read_callback.setter
-    def read_callback(self, callback: Optional[FieldReadCallback]) -> None:
-        self.__read_callback = callback
-
-    @property
-    def write_callback(self) -> Optional[FieldWriteCallback]:
-        """
-        Callback made during each write operation
-        """
-        return self.__write_callback
-
-    @write_callback.setter
-    def write_callback(self, callback: Optional[FieldWriteCallback]) -> None:
-        self.__write_callback = callback
+        self._write_callback: Optional[FieldWriteCallback] = None
+        self._read_callback: Optional[FieldReadCallback] = None
 
     @property
     def __width(self) -> int:
@@ -149,6 +117,89 @@ def value(self, value: int) -> None:
             self.__parent_register.value = value
         else:
             # do a read, modify write
-            reg_value = self.__parent_register.read()
+            reg_value = self.__parent_register.value
             self.__parent_register.value = (reg_value & self.__inverse_bitmask) | \
                                            (value << self.__low)
+
+class ReadOnlyField(_FieldBase):
+    """
+    Simulation of a read-only field
+    """
+    __slots__: list[str] = []
+
+    @property
+    def read_callback(self) -> Optional[FieldReadCallback]:
+        """
+        Callback made during each read operation
+        """
+        return self._read_callback
+
+    @read_callback.setter
+    def read_callback(self, callback: Optional[FieldReadCallback]) -> None:
+        self._read_callback = callback
+
+
+class WriteOnlyField(_FieldBase):
+    """
+    Simulation of a write-only field
+    """
+    __slots__:list[str] = []
+
+
+
+
+    @property
+    def write_callback(self) -> Optional[FieldWriteCallback]:
+        """
+        Callback made during each write operation
+        """
+        return self._write_callback
+
+    @write_callback.setter
+    def write_callback(self, callback: Optional[FieldWriteCallback]) -> None:
+        self._write_callback = callback
+
+class ReadWriteField(ReadOnlyField, WriteOnlyField):
+    """
+    Simulation of a read/write field
+    """
+    __slots__:list[str] = []
+
+
+Field = Union[ReadOnlyField, WriteOnlyField, ReadWriteField]
+
+
+class FieldType(Enum):
+    """
+    types of register field to be simulated based on the software access
+    """
+    READONLY = auto()
+    WRITEONLY = auto()
+    READWRITE = auto()
+
+
+_class_type_map: dict[FieldType, Union[type[ReadOnlyField],
+                                       type[WriteOnlyField],
+                                       type[ReadWriteField]]] = {
+    FieldType.READONLY: ReadOnlyField,
+    FieldType.WRITEONLY: WriteOnlyField,
+    FieldType.READWRITE: ReadWriteField}
+
+@dataclass
+class FieldDefinition:
+    """
+    Class for an entry in the list of memories in the simulator
+    """
+    high: int
+    low: int
+    msb: int
+    lsb: int
+    inst_name: str
+    field_type: FieldType
+
+    @property
+    def class_type(self) -> Union[type[ReadOnlyField], type[WriteOnlyField], type[ReadWriteField]]:
+        """
+        Classtype to be used base on the fieldtype
+        """
+        return _class_type_map[self.field_type]

src/peakrdl_python/sim_lib/register.py

@@ -19,13 +19,23 @@
 peakrdl-python tool. It provides a set of base classes used by the autogenerated code
 """
 from abc import ABC, abstractmethod
-from typing import Optional
+from typing import Optional, Union
+import sys
+from collections.abc import Iterator
 
 from .memory import Memory
 from .base import Base
-from .field import FieldDefinition, Field
+from .field import FieldDefinition, ReadOnlyField, WriteOnlyField, ReadWriteField
 from ._callbacks import RegisterReadCallback,RegisterWriteCallback
 
+# pylint: disable=duplicate-code
+if sys.version_info >= (3, 10):
+    # type guarding was introduced in python 3.10
+    from typing import TypeGuard
+else:
+    from typing_extensions import TypeGuard
+# pylint: enable=duplicate-code
+
 # pylint: disable=too-many-arguments
 
 class BaseRegister(Base, ABC):
@@ -46,13 +56,13 @@ def __init__(self, *,
         self._width = width
         self._readable = readable
         self._writable = writable
-        self.fields = [Field(low=field_def.low,
-                             high=field_def.high,
-                             msb=field_def.msb,
-                             lsb=field_def.lsb,
-                             inst_name=field_def.inst_name,
-                             parent_register=self,
-                             parent_width=width) for field_def in fields]
+        self.fields = tuple(field_def.class_type(low=field_def.low,
+                                                 high=field_def.high,
+                                                 msb=field_def.msb,
+                                                 lsb=field_def.lsb,
+                                                 inst_name=field_def.inst_name,
+                                                 parent_register=self,
+                                                 parent_width=width) for field_def in fields)
         self.__read_callback: Optional[RegisterReadCallback] = None
         self.__write_callback: Optional[RegisterWriteCallback] = None
 
@@ -85,7 +95,7 @@ def _action_read_callback(self) -> None:
             # pylint: disable-next=not-callable
             self.read_callback(value=self.value)
 
-        for field in self.fields:
+        for field in self.readable_fields:
             if field.read_callback is not None:
                 field.read_callback(value=field.value)
 
@@ -96,7 +106,7 @@ def _action_write_callback(self) -> None:
             # pylint: disable-next=not-callable
             self.write_callback(value=self.value)
 
-        for field in self.fields:
+        for field in self.writable_fields:
             if field.write_callback is not None:
                 field.write_callback(value=field.value)
 
@@ -135,6 +145,28 @@ def value(self) -> int:
     def value(self, value:int) -> None:
         ...
 
+    @property
+    def writable_fields(self) -> Iterator[Union[WriteOnlyField, ReadWriteField]]:
+        """
+        Iterator of the Writable fields
+        """
+        def is_writable(field: Union[WriteOnlyField, ReadWriteField, ReadOnlyField]) -> \
+                TypeGuard[Union[WriteOnlyField, ReadWriteField]]:
+            return isinstance(field, (WriteOnlyField, ReadWriteField))
+
+        return filter(is_writable, self.fields)
+
+    @property
+    def readable_fields(self) -> Iterator[Union[ReadOnlyField, ReadWriteField]]:
+        """
+        Iterator of the Readable fields
+        """
+        def is_readable(field: Union[WriteOnlyField, ReadWriteField, ReadOnlyField]) -> \
+                TypeGuard[Union[ReadOnlyField, ReadWriteField]]:
+            return isinstance(field, (ReadOnlyField, ReadWriteField))
+
+        return filter(is_readable, self.fields)
+
 
 class Register(BaseRegister):
     """

src/peakrdl_python/sim_lib/simulator.py

@@ -137,8 +137,8 @@ def memory_for_address_with_exception(self, address: int) -> MemoryEntry:
         return memory_entry
 
     def _read(self, addr: int,
-             width: int, # pylint: disable=unused-argument
-             accesswidth: int) -> int: # pylint: disable=unused-argument
+              width: int,  # pylint: disable=unused-argument
+              accesswidth: int) -> int:  # pylint: disable=unused-argument
         """
         function to simulate a device read, this needs to match the protocol for the callbacks
         """

src/peakrdl_python/systemrdl_node_utility_functions.py

@@ -35,6 +35,7 @@
 from systemrdl.rdltypes.user_enum import UserEnumMeta
 
 from .lib.utility_functions import calculate_bitmask
+from .sim_lib.field import FieldType
 
 class HideNodeCallback(Protocol):
     """
@@ -480,3 +481,22 @@ def full_slice_accessor(node: AddressableNode) -> str:
     if dimensions is None:
         raise RuntimeError('array node should have dimensions')
     return '[' + ','.join([':' for _ in range(len(dimensions))]) + ']'
+
+def simulator_field_definition(node: FieldNode) -> str:
+    """
+    Based on whether the field is readable and/or writeable, returns the value of the FieldType
+    to use
+    """
+    if not isinstance(node, FieldNode):
+        raise TypeError(f'This should only be called on an FieldNode, got {type(node)}')
+
+    if node.is_sw_readable and node.is_sw_writable:
+        return FieldType.READWRITE.name
+
+    if node.is_sw_readable and not node.is_sw_writable:
+        return FieldType.READONLY.name
+
+    if not node.is_sw_readable and node.is_sw_writable:
+        return FieldType.WRITEONLY.name
+
+    raise RuntimeError('Encountered a field node that was neither readable or writable')

src/peakrdl_python/templates/addrmap_simulation.py.jinja

@@ -27,7 +27,7 @@ from typing import Union
 from {{ peakrdl_python_sim_lib(depth=lib_depth) }}.register import Register, MemoryRegister
 from {{ peakrdl_python_sim_lib(depth=lib_depth) }}.memory import Memory
 from {{ peakrdl_python_sim_lib(depth=lib_depth) }}.simulator import MemoryEntry
-from {{ peakrdl_python_sim_lib(depth=lib_depth) }}.field import FieldDefinition
+from {{ peakrdl_python_sim_lib(depth=lib_depth) }}.field import FieldDefinition, FieldType
 {% if asyncoutput -%}
 from {{ peakrdl_python_sim_lib(depth=lib_depth) }}.simulator import AsyncSimulator{% if legacy_block_access %}Legacy{% endif %} as Simulator{% if legacy_block_access %}Legacy{% endif %}
 {% else %}
@@ -39,7 +39,7 @@ from {{ peakrdl_python_sim_lib(depth=lib_depth) }}.simulator import Simulator{%
                                          fields=[
 
                                                 {%- for field in node.fields() -%}
-                                                FieldDefinition(high={{field.high}}, low={{field.low}}, msb={{field.msb}}, lsb={{field.lsb}}, inst_name='{{field.inst_name}}'),
+                                                FieldDefinition(high={{field.high}}, low={{field.low}}, msb={{field.msb}}, lsb={{field.lsb}}, inst_name='{{field.inst_name}}', field_type=FieldType.{{simulator_field_definition(field)}}),
                                                 {%- endfor %}
                                                 ])
 {%- endmacro %}