zigzag-dse 3.7.0__tar.gz → 3.7.2__tar.gz

{zigzag_dse-3.7.0/zigzag_dse.egg-info → zigzag_dse-3.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zigzag-dse
-Version: 3.7.0
+Version: 3.7.2
 Summary: ZigZag - Deep Learning Hardware Design Space Exploration
 Author-email: Arne Symons <arne.symons@kuleuven.be>, Linyan Mei <linyan.mei@kuleuven.be>
 License: MIT License
@@ -42,14 +42,14 @@ Requires-Dist: multiprocessing_on_dill
 Requires-Dist: pyyaml
 Requires-Dist: cerberus
 Requires-Dist: seaborn
+Requires-Dist: typeguard
 Provides-Extra: dev
 Requires-Dist: bumpver; extra == "dev"
 Requires-Dist: pip-tools; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Requires-Dist: twine; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
-Requires-Dist: typeguard; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
 
 [![linting: pylint](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/pylint-dev/pylint)
 

{zigzag_dse-3.7.0 → zigzag_dse-3.7.2}/pyproject.toml

@@ -14,7 +14,7 @@ namespaces = true  # true by default
 
 [project]
 name = "zigzag-dse"
-version = "3.7.0"
+version = "3.7.2"
 description = "ZigZag - Deep Learning Hardware Design Space Exploration"
 readme = "README.md"
 authors = [{ name = "Arne Symons", email = "arne.symons@kuleuven.be" }, { name = "Linyan Mei", email = "linyan.mei@kuleuven.be" }]
@@ -34,13 +34,14 @@ dependencies = [
     'multiprocessing_on_dill',
     'pyyaml',
     'cerberus',
-    'seaborn'
+    'seaborn',
+    'typeguard',
 ]
 requires-python = ">=3.11"
 
 
 [project.optional-dependencies]
-dev = ["bumpver", "pip-tools", "build", "twine", 'pytest', 'typeguard', 'ruff']
+dev = ["bumpver", "pip-tools", "build", "twine", 'pytest', 'pre-commit']
 
 [project.urls]
 Homepage = "https://github.com/KULeuven-MICAS/zigzag"
@@ -49,7 +50,7 @@ Homepage = "https://github.com/KULeuven-MICAS/zigzag"
 realpython = "zigzag.__main__:main"
 
 [tool.bumpver]
-current_version = "3.7.0"
+current_version = "3.7.2"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true

zigzag_dse-3.7.2/zigzag/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.7.2"

{zigzag_dse-3.7.0 → zigzag_dse-3.7.2}/zigzag/opt/salsa/state.py

@@ -31,7 +31,6 @@ from copy import deepcopy
 from zigzag.cost_model.cost_model import CostModelEvaluation
 from zigzag.datatypes import LayerDim, UnrollFactorInt
 from zigzag.hardware.architecture.accelerator import Accelerator
-from zigzag.hardware.architecture.memory_hierarchy import MemoryHierarchy
 from zigzag.mapping.spatial_mapping_internal import SpatialMappingInternal
 from zigzag.opt.loma.memory_allocator import MemoryAllocator
 from zigzag.workload.layer_node import LayerNode
@@ -53,7 +52,7 @@ class SalsaState:
         self.accelerator = accelerator
         self.layer = layer
         self.spatial_mapping = spatial_mapping
-        self.memory_hierarchy: MemoryHierarchy = self.accelerator.get_core(layer.core_allocation[0]).memory_hierarchy
+        self.memory_hierarchy = self.accelerator.memory_hierarchy
         self.opt_criterion_name = opt_criterion_name
 
         allocator = MemoryAllocator(self.accelerator, self.layer, self.spatial_mapping, ordering)

zigzag_dse-3.7.2/zigzag/parser/mapping_factory.py

@@ -0,0 +1,101 @@
+import logging
+from typing import Any
+
+from zigzag.datatypes import (
+    LayerDim,
+    LayerOperand,
+    MemoryOperand,
+    OADimension,
+    UnrollFactor,
+)
+from zigzag.mapping.spatial_mapping import (
+    MappingSingleOADim,
+    SpatialMapping,
+    SpatialMappingHint,
+)
+from zigzag.utils import UniqueMessageFilter
+from zigzag.workload.layer_attributes import (
+    LayerTemporalOrdering,
+    MemoryOperandLinks,
+)
+
+logger = logging.getLogger(__name__)
+logger.addFilter(UniqueMessageFilter())
+
+
+class MappingFactory:
+    """Converts validated and normalized user-provided data into mapping-related instances.
+    The mapping for this layer is chosen according to the following priority:
+    1. The name of the layer
+    2. The operation type of the layer (if the layer name is not defined in the mapping)
+    3. The default mapping (if the operation type is not defined in the mapping)
+    """
+
+    def __init__(self, layer_name: str, operation_type: str, mapping_data: list[dict[str, Any]]):
+        """
+        @param Name of the layer for which the Mapping is being constructed.
+        @param operation_type Name of the layer operation for which the Mapping is being constructed.
+        @param mapping_data user-given, validated and normalized mapping data for all operation types.
+        """
+        if layer_name in map(lambda x: x["name"], mapping_data):
+            self.mapping_data: dict[str, Any] = next(filter(lambda x: x["name"] == layer_name, mapping_data))
+        elif operation_type in map(lambda x: x["name"], mapping_data):
+            self.mapping_data: dict[str, Any] = next(filter(lambda x: x["name"] == operation_type, mapping_data))
+        else:
+            self.mapping_data = next(filter(lambda x: x["name"] == "default", mapping_data))
+            logger.warning(
+                "Operator %s not defined in mapping. Using default mapping instead.",
+                operation_type,
+            )
+
+    def create_spatial_mapping(self) -> SpatialMapping:
+        if self.mapping_data["spatial_mapping"] is None:
+            return SpatialMapping.empty()
+
+        user_data: dict[str, list[str]] = self.mapping_data["spatial_mapping"]
+        spatial_mapping_dict: dict[OADimension, MappingSingleOADim] = {}
+
+        for oa_dim_str, unrolling_list in user_data.items():
+            oa_dim = OADimension(oa_dim_str)
+            mapping_this_oa_dim = self.create_mapping_single_oa_dim(unrolling_list)
+            spatial_mapping_dict[oa_dim] = mapping_this_oa_dim
+
+        return SpatialMapping(spatial_mapping_dict)
+
+    def create_mapping_single_oa_dim(self, mapping_data: list[str]) -> MappingSingleOADim:
+        mapping_dict: dict[LayerDim, UnrollFactor] = {}
+
+        for single_unrolling in mapping_data:
+            layer_dim_str = single_unrolling.split(",")[0]
+            unrolling = int(single_unrolling.split(",")[-1])
+            layer_dim = LayerDim(layer_dim_str)
+            mapping_dict[layer_dim] = unrolling
+
+        return MappingSingleOADim(mapping_dict)
+
+    def create_spatial_mapping_hint(self) -> SpatialMappingHint:
+        if "spatial_mapping_hint" not in self.mapping_data or self.mapping_data["spatial_mapping_hint"] is None:
+            return SpatialMappingHint.empty()
+
+        user_data: dict[str, list[str]] = self.mapping_data["spatial_mapping_hint"]
+        mapping_hint_dict: dict[OADimension, set[LayerDim]] = {
+            OADimension(oa_dim_str): {LayerDim(layer_dim_str) for layer_dim_str in hint_list}
+            for oa_dim_str, hint_list in user_data.items()
+        }
+        return SpatialMappingHint(mapping_hint_dict)
+
+    def create_memory_operand_links(self) -> MemoryOperandLinks:
+        user_data: dict[str, str] = self.mapping_data["memory_operand_links"]
+        links_dict = {
+            LayerOperand(layer_op_str): MemoryOperand(mem_op_str) for layer_op_str, mem_op_str in user_data.items()
+        }
+        return MemoryOperandLinks(links_dict)
+
+    def create_temporal_ordering(self) -> LayerTemporalOrdering:
+        """! This attribute lacks support within the MappingValidator. Returns an empty instance in case it is not
+        provided (to be compatible with older code) or raises an error if it is present in the user-provided data.
+        """
+        if "temporal_ordering" not in self.mapping_data or not self.mapping_data["temporal_ordering"]:
+            return LayerTemporalOrdering.empty()
+
+        return LayerTemporalOrdering(self.mapping_data["temporal_ordering"])

{zigzag_dse-3.7.0 → zigzag_dse-3.7.2}/zigzag/parser/mapping_validator.py

@@ -12,12 +12,6 @@ class MappingValidator:
     # Schema for a single operation, UpgradeValidator extrapolates to list of operations
     SCHEMA_SINGLE = {
         "name": {"type": "string", "required": True},
-        "core_allocation": {
-            "type": "list",
-            "schema": {"type": "integer"},
-            "default": [0],
-        },
-        "core_allocation_is_fixed": {"type": "boolean", "default": False},
         "spatial_mapping": {
             "type": "dict",
             "schema": {

{zigzag_dse-3.7.0 → zigzag_dse-3.7.2}/zigzag/parser/workload_factory.py

@@ -5,15 +5,9 @@ from typing import Any
 from zigzag.datatypes import (
     LayerDim,
     LayerOperand,
-    MemoryOperand,
-    OADimension,
     UnrollFactor,
 )
-from zigzag.mapping.spatial_mapping import (
-    MappingSingleOADim,
-    SpatialMapping,
-    SpatialMappingHint,
-)
+from zigzag.parser.mapping_factory import MappingFactory
 from zigzag.parser.workload_validator import WorkloadValidator
 from zigzag.utils import UniqueMessageFilter
 from zigzag.workload.dnn_workload import DNNWorkload
@@ -24,10 +18,8 @@ from zigzag.workload.layer_attributes import (
     LayerEquation,
     LayerOperandPrecision,
     LayerPadding,
-    LayerTemporalOrdering,
-    MemoryOperandLinks,
 )
-from zigzag.workload.layer_node import LayerNode, LayerNodeAttributes
+from zigzag.workload.layer_node import LayerNode, LayerNodeAttributes, MappingAttributes
 
 logger = logging.getLogger(__name__)
 logger.addFilter(UniqueMessageFilter())
@@ -54,10 +46,11 @@ class WorkloadFactory:
 class LayerNodeFactory:
     """Creates a LayerNode instance from a validated and normalized user definition of a single workload layer"""
 
-    def __init__(self, node_data: dict[str, Any], mapping_data: list[dict[str, Any]]):
+    def __init__(self, node_data: dict[str, Any], mapping_data: list[dict[str, Any]] | None):
         """!
         @node_data validated and normalized user-defined data for a single workload layer
-        @mapping_data validated and normalized user-defined data for all mappings
+        @mapping_data validated and normalized user-defined data for all mappings, or None is case no mapping-related
+        instances need to be constructed
         """
         self.node_data = node_data
         self.mapping_data = mapping_data
@@ -66,7 +59,13 @@ class LayerNodeFactory:
 
     def create(self) -> LayerNode:
         node_attr = self.create_node_attr()
-        return LayerNode(layer_id=self.layer_id, node_name=self.node_name, node_attr=node_attr)
+        mapping_attr = self.create_mapping_attr(node_attr.layer_dim_sizes)
+        return LayerNode(
+            layer_id=self.layer_id,
+            node_name=self.node_name,
+            node_attr=node_attr,
+            mapping_attr=mapping_attr,
+        )
 
     def create_node_attr(self) -> LayerNodeAttributes:
         # From node data
@@ -80,16 +79,6 @@ class LayerNodeFactory:
         padding = self.create_padding()
         pr_layer_dim_sizes = self.create_pr_layer_dim_sizes()
 
-        # From mapping data
-        mapping_factory = MappingFactory(self.node_name, layer_type, self.mapping_data)
-        spatial_mapping = mapping_factory.create_spatial_mapping()
-        spatial_mapping_hint = mapping_factory.create_spatial_mapping_hint()
-        core_allocation = mapping_factory.get_core_allocation()
-        core_allocation_is_fixed = mapping_factory.get_core_allocation_is_fixed()
-        memory_operand_links = mapping_factory.create_memory_operand_links()
-        temporal_ordering = mapping_factory.create_temporal_ordering()
-        temporal_ordering.remove_invalid_layer_dims(layer_dim_sizes, self.node_name)
-
         return LayerNodeAttributes(
             layer_type=layer_type,
             equation=equation,
@@ -98,14 +87,27 @@ class LayerNodeFactory:
             dimension_relations=dimension_relations,
             constant_operands=constant_operands,
             input_operand_source=input_operand_source,
+            padding=padding,
+            pr_layer_dim_sizes=pr_layer_dim_sizes,
+        )
+
+    def create_mapping_attr(self, layer_dim_sizes: LayerDimSizes):
+        assert self.mapping_data, "LayerNodeFactory is initialized with empty mapping data"
+        layer_type: str = self.node_data["operator_type"]
+
+        # From mapping data
+        mapping_factory = MappingFactory(self.node_name, layer_type, self.mapping_data)
+        spatial_mapping = mapping_factory.create_spatial_mapping()
+        spatial_mapping_hint = mapping_factory.create_spatial_mapping_hint()
+        memory_operand_links = mapping_factory.create_memory_operand_links()
+        temporal_ordering = mapping_factory.create_temporal_ordering()
+        temporal_ordering.remove_invalid_layer_dims(layer_dim_sizes, self.node_name)
+
+        return MappingAttributes(
             spatial_mapping=spatial_mapping,
             spatial_mapping_hint=spatial_mapping_hint,
-            core_allocation=core_allocation,
-            core_allocation_is_fixed=core_allocation_is_fixed,
             memory_operand_links=memory_operand_links,
             temporal_ordering=temporal_ordering,
-            padding=padding,
-            pr_layer_dim_sizes=pr_layer_dim_sizes,
         )
 
     def create_equation(self) -> LayerEquation:
@@ -183,87 +185,3 @@ class LayerNodeFactory:
         pr_sizes: list[UnrollFactor] = self.node_data["pr_loop_sizes"]
         size_dict = {layer_dim: size for layer_dim, size in zip(pr_layer_dims, pr_sizes)}
         return LayerDimSizes(size_dict)
-
-
-class MappingFactory:
-    """Converts validated and normalized user-provided data into mapping-related instances.
-    The mapping for this layer is chosen according to the following priority:
-    1. The name of the layer
-    2. The operation type of the layer (if the layer name is not defined in the mapping)
-    3. The default mapping (if the operation type is not defined in the mapping)
-    """
-
-    def __init__(self, layer_name: str, operation_type: str, mapping_data: list[dict[str, Any]]):
-        """
-        @param Name of the layer for which the Mapping is being constructed.
-        @param operation_type Name of the layer operation for which the Mapping is being constructed.
-        @param mapping_data user-given, validated and normalized mapping data for all operation types.
-        """
-        if layer_name in map(lambda x: x["name"], mapping_data):
-            self.mapping_data: dict[str, Any] = next(filter(lambda x: x["name"] == layer_name, mapping_data))
-        elif operation_type in map(lambda x: x["name"], mapping_data):
-            self.mapping_data: dict[str, Any] = next(filter(lambda x: x["name"] == operation_type, mapping_data))
-        else:
-            self.mapping_data = next(filter(lambda x: x["name"] == "default", mapping_data))
-            logger.warning(
-                "Operator %s not defined in mapping. Using default mapping instead.",
-                operation_type,
-            )
-
-    def get_core_allocation(self) -> list[int]:
-        return self.mapping_data["core_allocation"]
-
-    def get_core_allocation_is_fixed(self) -> bool:
-        return self.mapping_data["core_allocation_is_fixed"]
-
-    def create_spatial_mapping(self) -> SpatialMapping:
-        if self.mapping_data["spatial_mapping"] is None:
-            return SpatialMapping.empty()
-
-        user_data: dict[str, list[str]] = self.mapping_data["spatial_mapping"]
-        spatial_mapping_dict: dict[OADimension, MappingSingleOADim] = {}
-
-        for oa_dim_str, unrolling_list in user_data.items():
-            oa_dim = OADimension(oa_dim_str)
-            mapping_this_oa_dim = self.create_mapping_single_oa_dim(unrolling_list)
-            spatial_mapping_dict[oa_dim] = mapping_this_oa_dim
-
-        return SpatialMapping(spatial_mapping_dict)
-
-    def create_mapping_single_oa_dim(self, mapping_data: list[str]) -> MappingSingleOADim:
-        mapping_dict: dict[LayerDim, UnrollFactor] = {}
-
-        for single_unrolling in mapping_data:
-            layer_dim_str = single_unrolling.split(",")[0]
-            unrolling = int(single_unrolling.split(",")[-1])
-            layer_dim = LayerDim(layer_dim_str)
-            mapping_dict[layer_dim] = unrolling
-
-        return MappingSingleOADim(mapping_dict)
-
-    def create_spatial_mapping_hint(self) -> SpatialMappingHint:
-        if "spatial_mapping_hint" not in self.mapping_data or self.mapping_data["spatial_mapping_hint"] is None:
-            return SpatialMappingHint.empty()
-
-        user_data: dict[str, list[str]] = self.mapping_data["spatial_mapping_hint"]
-        mapping_hint_dict: dict[OADimension, set[LayerDim]] = {
-            OADimension(oa_dim_str): {LayerDim(layer_dim_str) for layer_dim_str in hint_list}
-            for oa_dim_str, hint_list in user_data.items()
-        }
-        return SpatialMappingHint(mapping_hint_dict)
-
-    def create_memory_operand_links(self) -> MemoryOperandLinks:
-        user_data: dict[str, str] = self.mapping_data["memory_operand_links"]
-        links_dict = {
-            LayerOperand(layer_op_str): MemoryOperand(mem_op_str) for layer_op_str, mem_op_str in user_data.items()
-        }
-        return MemoryOperandLinks(links_dict)
-
-    def create_temporal_ordering(self) -> LayerTemporalOrdering:
-        """! This attribute lacks support within the MappingValidator. Returns an empty instance in case it is not
-        provided (to be compatible with older code) or raises an error if it is present in the user-provided data.
-        """
-        if "temporal_ordering" not in self.mapping_data or not self.mapping_data["temporal_ordering"]:
-            return LayerTemporalOrdering.empty()
-
-        return LayerTemporalOrdering(self.mapping_data["temporal_ordering"])

{zigzag_dse-3.7.0 → zigzag_dse-3.7.2}/zigzag/workload/dummy_node.py

@@ -31,8 +31,6 @@ class DummyNode(LayerNodeABC):
                 }
 
         self.type = node_type
-        # We assume these nodes are mapped on a core with id -1
-        self.core_allocation = -1
         self.runtime = 0
         self.start = None
         self.end = None

{zigzag_dse-3.7.0 → zigzag_dse-3.7.2}/zigzag/workload/layer_attribute.py

@@ -34,3 +34,10 @@ class LayerAttribute(metaclass=ABCMeta):
 
     def __eq__(self, other: object):
         return isinstance(other, LayerAttribute) and self.data == other.data
+
+    def __hash__(self):
+        if isinstance(self.data, dict):
+            return hash(frozenset(self.data.items()))  # type: ignore
+        elif isinstance(self.data, str):
+            return hash(self.data)
+        raise NotImplementedError

{zigzag_dse-3.7.0 → zigzag_dse-3.7.2}/zigzag/workload/layer_attributes.py

@@ -254,6 +254,9 @@ class LayerTemporalOrdering(LayerAttribute):
         static_positions_and_sizes = StaticPositionsAndSizesConstraint(static_positions_and_sizes_dict)
         return [static_positions, static_positions_and_sizes]
 
+    def __hash__(self):
+        return hash(tuple(tuple(x) for x in self.data))
+
 
 class LayerPadding(LayerAttribute):
     DEFAULT = (0, 0)

{zigzag_dse-3.7.0 → zigzag_dse-3.7.2}/zigzag/workload/layer_node.py

@@ -109,18 +109,22 @@ class LayerNodeAttributes:
     layer_dim_sizes: LayerDimSizes
     operand_precision: LayerOperandPrecision
     dimension_relations: list[LayerDimRelation]
-    spatial_mapping: SpatialMapping
-    spatial_mapping_hint: SpatialMappingHint
-    core_allocation: list[int]
-    core_allocation_is_fixed: bool
-    memory_operand_links: MemoryOperandLinks
-    temporal_ordering: LayerTemporalOrdering
     padding: LayerPadding
     constant_operands: list[LayerOperand]
     input_operand_source: InputOperandSource
     pr_layer_dim_sizes: LayerDimSizes | None
 
 
+@dataclass
+class MappingAttributes:
+    """Packs the attributes needed to initialize a LayerNode, related to the mapping"""
+
+    spatial_mapping: SpatialMapping
+    spatial_mapping_hint: SpatialMappingHint
+    memory_operand_links: MemoryOperandLinks
+    temporal_ordering: LayerTemporalOrdering
+
+
 class LayerNode(LayerNodeABC):
     """! Represents a single layer in a workload."""
 
@@ -131,8 +135,6 @@ class LayerNode(LayerNodeABC):
     dimension_relations: list[LayerDimRelation]
     spatial_mapping: SpatialMapping
     spatial_mapping_hint: SpatialMappingHint
-    core_allocation: list[int]
-    core_allocation_is_fixed: bool
     memory_operand_links: MemoryOperandLinks
     temporal_ordering: LayerTemporalOrdering
     padding: LayerPadding
@@ -145,7 +147,7 @@ class LayerNode(LayerNodeABC):
     pr_loop: PrLoop
     pr_layer_dim_sizes: LayerDimSizes | None
 
-    def __init__(self, layer_id: int, node_name: str, node_attr: LayerNodeAttributes):
+    def __init__(self, layer_id: int, node_name: str, node_attr: LayerNodeAttributes, mapping_attr: MappingAttributes):
         """
         To construct each layer node, algorithm equation/dimension/indirect relation are parsed.
         This parser collects information of operand, loop dimension, and loop relevance.
@@ -161,17 +163,16 @@ class LayerNode(LayerNodeABC):
         self.layer_dim_sizes = node_attr.layer_dim_sizes
         self.operand_precision = node_attr.operand_precision
         self.dimension_relations = node_attr.dimension_relations
-        self.spatial_mapping = node_attr.spatial_mapping
-        self.spatial_mapping_hint = node_attr.spatial_mapping_hint
-        self.core_allocation = node_attr.core_allocation
-        self.core_allocation_is_fixed = node_attr.core_allocation_is_fixed
-        self.memory_operand_links = node_attr.memory_operand_links
-        self.temporal_ordering = node_attr.temporal_ordering
         self.padding = node_attr.padding
         self.constant_operands = node_attr.constant_operands
         self.input_operand_source = node_attr.input_operand_source
         pr_layer_dim_sizes = node_attr.pr_layer_dim_sizes
 
+        self.spatial_mapping = mapping_attr.spatial_mapping
+        self.spatial_mapping_hint = mapping_attr.spatial_mapping_hint
+        self.memory_operand_links = mapping_attr.memory_operand_links
+        self.temporal_ordering = mapping_attr.temporal_ordering
+
         # Derived attributes
         self.layer_operands = self.equation.get_contained_operands()
         self.output_operand = self.layer_operands[0]
@@ -254,8 +255,6 @@ class LayerNode(LayerNodeABC):
                 "equation_relations": self.dimension_relations,
                 "loop_dimensions": self.layer_dim_sizes,
                 "operand_precision": self.operand_precision,
-                "core_allocation": self.core_allocation,
-                "core_allocation_is_fixed": self.core_allocation_is_fixed,
                 "user_spatial_mapping": self.spatial_mapping,
                 "memory_operand_links": self.memory_operand_links,
             }
@@ -357,12 +356,6 @@ class LayerNode(LayerNodeABC):
             layer_dim_sizes=self.layer_dim_sizes,
             operand_precision=self.operand_precision,
             dimension_relations=self.dimension_relations,
-            spatial_mapping=self.spatial_mapping,
-            spatial_mapping_hint=self.spatial_mapping_hint,
-            core_allocation=self.core_allocation,
-            core_allocation_is_fixed=self.core_allocation_is_fixed,
-            memory_operand_links=self.memory_operand_links,
-            temporal_ordering=self.temporal_ordering,
             padding=self.padding,
             constant_operands=self.constant_operands,
             input_operand_source=self.input_operand_source,
@@ -370,3 +363,12 @@ class LayerNode(LayerNodeABC):
         )
         # Make sure the new attributes don't simply point to the old instances
         return deepcopy(attributes)
+
+    def extract_mapping_attr(self) -> MappingAttributes:
+        attributes = MappingAttributes(
+            spatial_mapping=self.spatial_mapping,
+            spatial_mapping_hint=self.spatial_mapping_hint,
+            memory_operand_links=self.memory_operand_links,
+            temporal_ordering=self.temporal_ordering,
+        )
+        return deepcopy(attributes)

{zigzag_dse-3.7.0 → zigzag_dse-3.7.2/zigzag_dse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zigzag-dse
-Version: 3.7.0
+Version: 3.7.2
 Summary: ZigZag - Deep Learning Hardware Design Space Exploration
 Author-email: Arne Symons <arne.symons@kuleuven.be>, Linyan Mei <linyan.mei@kuleuven.be>
 License: MIT License
@@ -42,14 +42,14 @@ Requires-Dist: multiprocessing_on_dill
 Requires-Dist: pyyaml
 Requires-Dist: cerberus
 Requires-Dist: seaborn
+Requires-Dist: typeguard
 Provides-Extra: dev
 Requires-Dist: bumpver; extra == "dev"
 Requires-Dist: pip-tools; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Requires-Dist: twine; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
-Requires-Dist: typeguard; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
 
 [![linting: pylint](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/pylint-dev/pylint)
 

{zigzag_dse-3.7.0 → zigzag_dse-3.7.2}/zigzag_dse.egg-info/SOURCES.txt

@@ -186,6 +186,7 @@ zigzag/parser/__init__.py
 zigzag/parser/accelerator_factory.py
 zigzag/parser/accelerator_validator.py
 zigzag/parser/arguments.py
+zigzag/parser/mapping_factory.py
 zigzag/parser/mapping_validator.py
 zigzag/parser/upgraded_validator.py
 zigzag/parser/workload_factory.py

{zigzag_dse-3.7.0 → zigzag_dse-3.7.2}/zigzag_dse.egg-info/requires.txt

@@ -8,6 +8,7 @@ multiprocessing_on_dill
 pyyaml
 cerberus
 seaborn
+typeguard
 
 [dev]
 bumpver
@@ -15,5 +16,4 @@ pip-tools
 build
 twine
 pytest
-typeguard
-ruff
+pre-commit

zigzag_dse-3.7.0/zigzag/__init__.py

@@ -1 +0,0 @@
-__version__ = "3.7.0"