Merge pull request #96 from krcb197/73-split-the-auto-generated-test-file-into-one-file-per-addr

73 split the auto generated test file into one file per addr

Author: krcb197

setup.py

@@ -28,7 +28,7 @@
                     ]
                     },
     install_requires=[
-        "systemrdl-compiler>=1.21.0",
+        "systemrdl-compiler>=1.24.0",
         "autopep8",
         "pylint",
         "coverage",

src/peakrdl_python/__about__.py

@@ -1,4 +1,4 @@
 """
 Variables that describes the PeakRDL Python Package
 """
-__version__ = "0.5.0"
+__version__ = "0.6.0"

src/peakrdl_python/_node_walkers.py

@@ -0,0 +1,74 @@
+"""
+Node walkers to be used in the generated of the output code
+"""
+from typing import Optional, List, Union, Iterator
+
+from systemrdl import RDLListener, WalkerAction # type: ignore
+from systemrdl.node import RegNode, MemNode, FieldNode, AddrmapNode, RegfileNode # type: ignore
+
+
+class AddressMaps(RDLListener):
+    """
+    class intended to be used as part of the walker/listener protocol to find all the desendent
+    address maps
+    """
+    def __init__(self) -> None:
+        super().__init__()
+        self.__address_maps: List[AddrmapNode] = []
+
+    def enter_Addrmap(self, node: AddrmapNode) -> Optional[WalkerAction]:
+        self.__address_maps.append(node)
+        return WalkerAction.Continue
+
+    def __iter__(self) -> Iterator[AddrmapNode]:
+        return self.__address_maps.__iter__()
+
+
+class OwnedbyAddressMap(RDLListener):
+    """
+    class intended to be used as part of the walker/listener protocol to find all the items owned
+    by an address map but not the descendents of any address map
+    """
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.registers: List[RegNode] = []
+        self.fields: List[RegNode]  = []
+        self.memories: List[RegNode]  = []
+        self.addr_maps: List[AddrmapNode]  = []
+        self.reg_files: List[RegfileNode] = []
+
+    def enter_Reg(self, node: RegNode) -> Optional[WalkerAction]:
+        self.registers.append(node)
+        return WalkerAction.Continue
+
+    def enter_Mem(self, node: MemNode) -> Optional[WalkerAction]:
+        self.memories.append(node)
+        return WalkerAction.Continue
+
+    def enter_Field(self, node: FieldNode) -> Optional[WalkerAction]:
+        self.fields.append(node)
+        return WalkerAction.Continue
+
+    def enter_Addrmap(self, node: AddrmapNode) -> Optional[WalkerAction]:
+        self.addr_maps.append(node)
+        return WalkerAction.SkipDescendants
+
+    def enter_Regfile(self, node: RegfileNode) -> Optional[WalkerAction]:
+        self.reg_files.append(node)
+        return WalkerAction.Continue
+
+    @property
+    def nodes(self) -> List[Union[RegNode, MemNode, FieldNode, AddrmapNode, RegfileNode]]:
+        """
+        All the nodes owned by the address map, including:
+        - address maps
+        - register files
+        - registers
+        - memories
+        - fields
+
+        Returns: list of nodes
+
+        """
+        return self.addr_maps + self.reg_files + self.memories + self.registers + self.fields

src/peakrdl_python/exporter.py

@@ -9,6 +9,7 @@
 
 import autopep8 # type: ignore
 import jinja2 as jj
+from systemrdl import RDLWalker # type: ignore
 
 from systemrdl.node import RootNode, Node, RegNode, AddrmapNode, RegfileNode # type: ignore
 from systemrdl.node import FieldNode, MemNode, AddressableNode # type: ignore
@@ -28,6 +29,8 @@
 
 from .safe_name_utility import get_python_path_segments, safe_node_name
 
+from ._node_walkers import AddressMaps, OwnedbyAddressMap
+
 from .__about__ import __version__
 
 file_path = os.path.dirname(__file__)
@@ -115,78 +118,145 @@ def export(self, node: Node, path: str,
 
         # If it is the root node, skip to top addrmap
         if isinstance(node, RootNode):
-            node = node.top
+            top_block = node.top
+        else:
+            top_block = node
 
         package_path = os.path.join(path, node.inst_name)
         self._create_empty_package(package_path=package_path,
                                    skip_test_case_generation=skip_test_case_generation)
 
-        modules = [node]
+        self._build_node_type_table(top_block)
+
+        context = {
+            'print': print,
+            'type': type,
+            'top_node': top_block,
+            'systemrdlFieldNode': FieldNode,
+            'systemrdlRegNode': RegNode,
+            'systemrdlRegfileNode': RegfileNode,
+            'systemrdlAddrmapNode': AddrmapNode,
+            'systemrdlMemNode': MemNode,
+            'systemrdlAddressableNode': AddressableNode,
+            'systemrdlSignalNode': SignalNode,
+            'asyncoutput': asyncoutput,
+            'OnWriteType': OnWriteType,
+            'OnReadType': OnReadType,
+            'PropertyReference': PropertyReference,
+            'isinstance': isinstance,
+            'uses_enum' : uses_enum(top_block),
+            'uses_memory' : uses_memory(top_block),
+            'get_fully_qualified_type_name': self._lookup_type_name,
+            'get_array_dim': get_array_dim,
+            'get_dependent_component': get_dependent_component,
+            'get_dependent_enum': self._get_dependent_enum,
+            'get_enum_values': get_enum_values,
+            'get_fully_qualified_enum_type': self._fully_qualified_enum_type,
+            'get_field_bitmask_hex_string': get_field_bitmask_hex_string,
+            'get_field_inv_bitmask_hex_string': get_field_inv_bitmask_hex_string,
+            'get_field_max_value_hex_string': get_field_max_value_hex_string,
+            'get_reg_max_value_hex_string': get_reg_max_value_hex_string,
+            'get_table_block': get_table_block,
+            'get_reg_writable_fields': get_reg_writable_fields,
+            'get_reg_readable_fields': get_reg_readable_fields,
+            'get_memory_max_entry_value_hex_string': get_memory_max_entry_value_hex_string,
+            'get_array_typecode': get_array_typecode,
+            'get_memory_width_bytes': get_memory_width_bytes,
+            'get_field_default_value': get_field_default_value,
+            'raise_template_error' : self._raise_template_error,
+            'get_python_path_segments' : get_python_path_segments,
+            'safe_node_name' : safe_node_name,
+            'version' : __version__
+        }
+
+        context.update(self.user_template_context)
+
+        template = self.jj_env.get_template("addrmap.py.jinja")
+        module_fqfn = os.path.join(package_path,
+                                   'reg_model',
+                                   top_block.inst_name + '.py')
+        if autoformatoutputs is True:
+            module_code_str = autopep8.fix_code(template.render(context))
+            with open(module_fqfn, "w", encoding='utf-8') as fid:
+                fid.write(module_code_str)
+        else:
+            stream = template.stream(context)
+            stream.dump(module_fqfn, encoding='utf-8')
 
-        for block in modules:
+        if not skip_test_case_generation:
 
-            self._build_node_type_table(block)
+            # make the top level base class for all the other test, this is what instantes
+            # the register model
+            template = self.jj_env.get_template("baseclass_tb.py.jinja")
+            module_tb_fqfn = os.path.join(package_path,
+                                          'tests',
+                                          '_' + top_block.inst_name + '_test_base.py')
 
             context = {
-                'print': print,
-                'type': type,
-                'top_node': block,
-                'systemrdlFieldNode': FieldNode,
-                'systemrdlRegNode': RegNode,
-                'systemrdlRegfileNode': RegfileNode,
-                'systemrdlAddrmapNode': AddrmapNode,
-                'systemrdlMemNode': MemNode,
-                'systemrdlAddressableNode': AddressableNode,
-                'systemrdlSignalNode': SignalNode,
+                'top_node': top_block,
                 'asyncoutput': asyncoutput,
-                'OnWriteType': OnWriteType,
-                'OnReadType': OnReadType,
-                'PropertyReference': PropertyReference,
-                'isinstance': isinstance,
-                'uses_enum' : uses_enum(block),
-                'uses_memory' : uses_memory(block),
-                'get_fully_qualified_type_name': self._lookup_type_name,
-                'get_array_dim': get_array_dim,
-                'get_dependent_component': get_dependent_component,
-                'get_dependent_enum': self._get_dependent_enum,
-                'get_enum_values': get_enum_values,
-                'get_fully_qualified_enum_type': self._fully_qualified_enum_type,
-                'get_field_bitmask_hex_string': get_field_bitmask_hex_string,
-                'get_field_inv_bitmask_hex_string': get_field_inv_bitmask_hex_string,
-                'get_field_max_value_hex_string': get_field_max_value_hex_string,
-                'get_reg_max_value_hex_string': get_reg_max_value_hex_string,
-                'get_table_block': get_table_block,
-                'get_reg_writable_fields': get_reg_writable_fields,
-                'get_reg_readable_fields': get_reg_readable_fields,
-                'get_memory_max_entry_value_hex_string': get_memory_max_entry_value_hex_string,
-                'get_array_typecode': get_array_typecode,
-                'get_memory_width_bytes': get_memory_width_bytes,
-                'get_field_default_value': get_field_default_value,
-                'raise_template_error' : self._raise_template_error,
-                'get_python_path_segments' : get_python_path_segments,
-                'safe_node_name' : safe_node_name,
-                'version' : __version__
+                'version': __version__
             }
 
-            context.update(self.user_template_context)
-
-            template = self.jj_env.get_template("addrmap.py.jinja")
-            module_fqfn = os.path.join(package_path,
-                                       'reg_model',
-                                       block.inst_name + '.py')
             if autoformatoutputs is True:
-                module_code_str = autopep8.fix_code(template.render(context))
-                with open(module_fqfn, "w", encoding='utf-8') as fid:
-                    fid.write(module_code_str)
+                module_tb_code_str = autopep8.fix_code(template.render(context))
+                with open(module_tb_fqfn, "w", encoding='utf-8') as fid:
+                    fid.write(module_tb_code_str)
             else:
                 stream = template.stream(context)
-                stream.dump(module_fqfn, encoding='utf-8')
+                stream.dump(module_tb_fqfn, encoding='utf-8')
+
+            # make the tests themselves
+            template = self.jj_env.get_template("addrmap_tb.py.jinja")
+
+            blocks = AddressMaps()
+            # running the walker populated the blocks with all the address maps in within the
+            # top block, including the top_block itself
+            RDLWalker(unroll=True).walk(top_block, blocks, skip_top=False)
+
+            for block in blocks:
+                owned_elements = OwnedbyAddressMap()
+                # running the walker populated the blocks with all the address maps in within the
+                # top block, including the top_block itself
+                RDLWalker(unroll=True).walk(block, owned_elements, skip_top=True)
+
+                fq_block_name = '_'.join(block.get_path_segments(array_suffix = '_{index:d}_'))
 
-            if not skip_test_case_generation:
-                template = self.jj_env.get_template("addrmap_tb.py.jinja")
                 module_tb_fqfn = os.path.join(package_path,
                                               'tests',
-                                              'test_' + block.inst_name + '.py')
+                                              'test_' + fq_block_name + '.py')
+
+                context = {
+                    'top_node': top_block,
+                    'block' : block,
+                    'fq_block_name' : fq_block_name,
+                    'owned_elements': owned_elements,
+                    'systemrdlFieldNode': FieldNode,
+                    'systemrdlSignalNode': SignalNode,
+                    'systemrdlRegNode': RegNode,
+                    'systemrdlMemNode': MemNode,
+                    'systemrdlRegfileNode': RegfileNode,
+                    'systemrdlAddrmapNode': AddrmapNode,
+                    'isinstance': isinstance,
+                    'get_python_path_segments': get_python_path_segments,
+                    'safe_node_name': safe_node_name,
+                    'uses_memory': (len(owned_elements.memories) > 0),
+                    'get_field_bitmask_hex_string': get_field_bitmask_hex_string,
+                    'get_field_inv_bitmask_hex_string': get_field_inv_bitmask_hex_string,
+                    'get_field_max_value_hex_string': get_field_max_value_hex_string,
+                    'get_field_default_value': get_field_default_value,
+                    'get_reg_max_value_hex_string': get_reg_max_value_hex_string,
+                    'get_reg_writable_fields': get_reg_writable_fields,
+                    'get_reg_readable_fields': get_reg_readable_fields,
+                    'get_memory_max_entry_value_hex_string': get_memory_max_entry_value_hex_string,
+                    'get_enum_values': get_enum_values,
+                    'get_array_typecode': get_array_typecode,
+                    'get_memory_width_bytes': get_memory_width_bytes,
+                    'asyncoutput': asyncoutput,
+                    'uses_enum': uses_enum(block),
+                    'version': __version__
+                }
+
                 if autoformatoutputs is True:
                     module_tb_code_str = autopep8.fix_code(template.render(context))
                     with open(module_tb_fqfn, "w", encoding='utf-8') as fid:
@@ -195,7 +265,7 @@ def export(self, node: Node, path: str,
                     stream = template.stream(context)
                     stream.dump(module_tb_fqfn, encoding='utf-8')
 
-        return [m.inst_name for m in modules]
+        return top_block.inst_name
 
     def _lookup_type_name(self, node: Node) -> str:
         """