zigzag-dse 3.2.0__tar.gz → 3.2.1__tar.gz

{zigzag_dse-3.2.0/zigzag_dse.egg-info → zigzag_dse-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zigzag-dse
-Version: 3.2.0
+Version: 3.2.1
 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

{zigzag_dse-3.2.0 → zigzag_dse-3.2.1}/pyproject.toml

@@ -14,7 +14,7 @@ namespaces = true  # true by default
 
 [project]
 name = "zigzag-dse"
-version = "3.2.0"
+version = "3.2.1"
 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" }]
@@ -48,7 +48,7 @@ Homepage = "https://github.com/KULeuven-MICAS/zigzag"
 realpython = "zigzag.__main__:main"
 
 [tool.bumpver]
-current_version = "3.2.0"
+current_version = "3.2.1"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true
@@ -63,4 +63,8 @@ push = false
 "zigzag/__init__.py" = ["{version}"]
 
 
+[tool.ruff]
+line-length = 120
 
+[tool.black]
+line-length = 120

zigzag_dse-3.2.1/tests/main/test_imc/test_aimc.py

@@ -0,0 +1,41 @@
+import pytest
+
+from zigzag.api import get_hardware_performance_zigzag_imc
+
+workloads = (
+    "zigzag/inputs/workload/resnet18.onnx",
+    "zigzag/inputs/workload/resnet18.yaml",
+)
+
+# Expected energy, latency (#cycles), clk time and area for each workload defined above
+ens_lats_clks_areas = {
+    "zigzag/inputs/workload/alexnet.onnx": (6780119394.667442, 9261169.0, 14.07244, 2.3426222152749223),
+    "zigzag/inputs/workload/mobilenetv2.onnx": (2318251910.682223, 10901796.0, 14.07244, 2.3426222152749223),
+    "zigzag/inputs/workload/resnet18.onnx": (4695729577.211851, 5540648.0, 14.07244, 2.3426222152749223),
+    "zigzag/inputs/workload/resnet18.yaml": (4264976904.6396008, 4907495.0, 14.07244, 2.3426222152749223),
+}
+
+
+@pytest.fixture
+def mapping():
+    return "zigzag/inputs/mapping/default_imc.yaml"
+
+
+@pytest.fixture
+def accelerator():
+    return "zigzag/inputs/hardware/aimc.yaml"
+
+
+@pytest.mark.parametrize("workload", workloads)
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
+    (energy, latency, tclk, area, _) = get_hardware_performance_zigzag_imc(workload, accelerator, mapping)
+    (
+        expected_energy,
+        expected_latency,
+        expected_tclk,
+        expected_area,
+    ) = ens_lats_clks_areas[workload]
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore
+    assert tclk == pytest.approx(expected_tclk)  # type: ignore
+    assert area == pytest.approx(expected_area)  # type: ignore

zigzag_dse-3.2.1/tests/main/test_imc/test_dimc.py

@@ -0,0 +1,41 @@
+import pytest
+
+from zigzag.api import get_hardware_performance_zigzag_imc
+
+workloads = (
+    "zigzag/inputs/workload/resnet18.onnx",
+    "zigzag/inputs/workload/resnet18.yaml",
+)
+
+# Expected energy, latency (#cycles), clk time and area for each workload defined above
+ens_lats_clks_areas = {
+    "zigzag/inputs/workload/alexnet.onnx": (6811036226.435776, 9458913.0, 3.75708, 0.8566212024),
+    "zigzag/inputs/workload/mobilenetv2.onnx": (2884847085.7898636, 20453908.0, 3.75708, 0.8566212024),
+    "zigzag/inputs/workload/resnet18.onnx": (4726170712.825855, 6337728.0, 3.75708, 0.8566212024),
+    "zigzag/inputs/workload/resnet18.yaml": (4268285089.3547516, 5789229.0, 3.75708, 0.8566212024),
+}
+
+
+@pytest.fixture
+def mapping():
+    return "zigzag/inputs/mapping/default_imc.yaml"
+
+
+@pytest.fixture
+def accelerator():
+    return "zigzag/inputs/hardware/dimc.yaml"
+
+
+@pytest.mark.parametrize("workload", workloads)
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
+    (energy, latency, tclk, area, _) = get_hardware_performance_zigzag_imc(workload, accelerator, mapping)
+    (
+        expected_energy,
+        expected_latency,
+        expected_tclk,
+        expected_area,
+    ) = ens_lats_clks_areas[workload]
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore
+    assert tclk == pytest.approx(expected_tclk)  # type: ignore
+    assert area == pytest.approx(expected_area)  # type: ignore

{zigzag_dse-3.2.0 → zigzag_dse-3.2.1}/tests/main/test_origin/test_ascend_like.py

@@ -25,9 +25,9 @@ def accelerator():
 
 
 @pytest.mark.parametrize("workload", workloads)
-def test_api(workload: str, accelerator: str, mapping: str):
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
     (energy, latency, _) = get_hardware_performance_zigzag(workload, accelerator, mapping)
     (expected_energy, expected_latency) = ens_lats[workload]
     print(f"'{workload}': ({energy}, {latency}),")
-    assert energy == pytest.approx(expected_energy)
-    assert latency == pytest.approx(expected_latency)
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

{zigzag_dse-3.2.0 → zigzag_dse-3.2.1}/tests/main/test_origin/test_edge_tpu_like.py

@@ -25,9 +25,9 @@ def accelerator():
 
 
 @pytest.mark.parametrize("workload", workloads)
-def test_api(workload: str, accelerator: str, mapping: str):
-    (energy, latency, cmes) = get_hardware_performance_zigzag(workload, accelerator, mapping)
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
+    (energy, latency, _) = get_hardware_performance_zigzag(workload, accelerator, mapping)
     (expected_energy, expected_latency) = ens_lats[workload]
     print(f"'{workload}': ({energy}, {latency}),")
-    assert energy == pytest.approx(expected_energy)
-    assert latency == pytest.approx(expected_latency)
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

{zigzag_dse-3.2.0 → zigzag_dse-3.2.1}/tests/main/test_origin/test_meta_prototype_like.py

@@ -25,9 +25,9 @@ def accelerator():
 
 
 @pytest.mark.parametrize("workload", workloads)
-def test_api(workload: str, accelerator: str, mapping: str):
-    (energy, latency, cmes) = get_hardware_performance_zigzag(workload, accelerator, mapping)
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
+    (energy, latency, _) = get_hardware_performance_zigzag(workload, accelerator, mapping)
     (expected_energy, expected_latency) = ens_lats[workload]
     print(f"'{workload}': ({energy}, {latency}),")
-    assert energy == pytest.approx(expected_energy)
-    assert latency == pytest.approx(expected_latency)
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

{zigzag_dse-3.2.0 → zigzag_dse-3.2.1}/tests/main/test_origin/test_tesla_npu_like.py

@@ -25,9 +25,9 @@ def accelerator():
 
 
 @pytest.mark.parametrize("workload", workloads)
-def test_api(workload: str, accelerator: str, mapping: str):
-    (energy, latency, cmes) = get_hardware_performance_zigzag(workload, accelerator, mapping)
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
+    (energy, latency, _) = get_hardware_performance_zigzag(workload, accelerator, mapping)
     (expected_energy, expected_latency) = ens_lats[workload]
     print(f"'{workload}': ({energy}, {latency}),")
-    assert energy == pytest.approx(expected_energy)
-    assert latency == pytest.approx(expected_latency)
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

{zigzag_dse-3.2.0 → zigzag_dse-3.2.1}/tests/main/test_origin/test_tpu_like.py

@@ -9,8 +9,8 @@ workloads = (
 
 # Expected energy and latency for each workload defined above
 ens_lats = {
-    "zigzag/inputs/workload/resnet18.onnx": (1795904402.5120003, 4158539.0),
-    "zigzag/inputs/workload/resnet18.yaml": (2296490149.296, 4906975.0),
+    "zigzag/inputs/workload/resnet18.onnx": (1871436380.6559997, 4158539.0),
+    "zigzag/inputs/workload/resnet18.yaml": (2615172831.3759995, 6136285.0),
 }
 
 
@@ -25,9 +25,9 @@ def accelerator():
 
 
 @pytest.mark.parametrize("workload", workloads)
-def test_api(workload: str, accelerator: str, mapping: str):
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
     (energy, latency, _) = get_hardware_performance_zigzag(workload, accelerator, mapping)
     (expected_energy, expected_latency) = ens_lats[workload]
-    print(f"{workload}: ({energy}, {latency}),")
-    assert energy == pytest.approx(expected_energy)
-    assert latency == pytest.approx(expected_latency)
+    print(f"'{workload}': ({energy}, {latency}),")
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

zigzag_dse-3.2.1/tests/main/test_with_exploit_data_locality/test_ascend_like.py

@@ -0,0 +1,34 @@
+import pytest
+from zigzag.api import get_hardware_performance_zigzag_with_exploit_data_locality
+
+workloads = (
+    "zigzag/inputs/workload/resnet18.onnx",
+    "zigzag/inputs/workload/resnet18.yaml",
+)
+
+# Expected energy and latency for each workload defined above
+ens_lats = {
+    "zigzag/inputs/workload/alexnet.onnx": (5649553476, 8605524),
+    "zigzag/inputs/workload/mobilenetv2.onnx": (1880536921, 6472147),
+    "zigzag/inputs/workload/resnet18.onnx": (1711355797, 3567658),
+    "zigzag/inputs/workload/resnet18.yaml": (2246606942, 4638794),
+}
+
+
+@pytest.fixture
+def mapping():
+    return "zigzag/inputs/mapping/ascend_like.yaml"
+
+
+@pytest.fixture
+def accelerator():
+    return "zigzag/inputs/hardware/ascend_like.yaml"
+
+
+@pytest.mark.parametrize("workload", workloads)
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
+    (energy, latency, _) = get_hardware_performance_zigzag_with_exploit_data_locality(workload, accelerator, mapping)
+    (expected_energy, expected_latency) = ens_lats[workload]
+    print(f"'{workload}': ({energy}, {latency}),")
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

zigzag_dse-3.2.1/tests/main/test_with_exploit_data_locality/test_edge_tpu_like.py

@@ -0,0 +1,34 @@
+import pytest
+from zigzag.api import get_hardware_performance_zigzag_with_exploit_data_locality
+
+workloads = (
+    "zigzag/inputs/workload/resnet18.onnx",
+    "zigzag/inputs/workload/resnet18.yaml",
+)
+
+# Expected energy and latency for each workload defined above
+ens_lats = {
+    "zigzag/inputs/workload/alexnet.onnx": (5568602396.684999, 8134431),
+    "zigzag/inputs/workload/mobilenetv2.onnx": (735250234.1699998, 2417321.0),
+    "zigzag/inputs/workload/resnet18.onnx": (1783299827.71, 3156625.0),
+    "zigzag/inputs/workload/resnet18.yaml": (2115121959.8699996, 3855157.0),
+}
+
+
+@pytest.fixture
+def mapping():
+    return "zigzag/inputs/mapping/edge_tpu_like.yaml"
+
+
+@pytest.fixture
+def accelerator():
+    return "zigzag/inputs/hardware/edge_tpu_like.yaml"
+
+
+@pytest.mark.parametrize("workload", workloads)
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
+    (energy, latency, _) = get_hardware_performance_zigzag_with_exploit_data_locality(workload, accelerator, mapping)
+    (expected_energy, expected_latency) = ens_lats[workload]
+    print(f"'{workload}': ({energy}, {latency}),")
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

zigzag_dse-3.2.1/tests/main/test_with_exploit_data_locality/test_meta_prototype_like.py

@@ -0,0 +1,34 @@
+import pytest
+from zigzag.api import get_hardware_performance_zigzag_with_exploit_data_locality
+
+workloads = (
+    "zigzag/inputs/workload/resnet18.onnx",
+    "zigzag/inputs/workload/resnet18.yaml",
+)
+
+# Expected energy and latency for each workload defined above
+ens_lats = {
+    "zigzag/inputs/workload/alexnet.onnx": (5679636177, 8279493),
+    "zigzag/inputs/workload/mobilenetv2.onnx": (901087682, 2596085),
+    "zigzag/inputs/workload/resnet18.onnx": (1730188945, 3231087),
+    "zigzag/inputs/workload/resnet18.yaml": (2264057101, 3984645),
+}
+
+
+@pytest.fixture
+def mapping():
+    return "zigzag/inputs/mapping/meta_prototype_like.yaml"
+
+
+@pytest.fixture
+def accelerator():
+    return "zigzag/inputs/hardware/meta_prototype.yaml"
+
+
+@pytest.mark.parametrize("workload", workloads)
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
+    (energy, latency, _) = get_hardware_performance_zigzag_with_exploit_data_locality(workload, accelerator, mapping)
+    (expected_energy, expected_latency) = ens_lats[workload]
+    print(f"'{workload}': ({energy}, {latency}),")
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

zigzag_dse-3.2.1/tests/main/test_with_exploit_data_locality/test_tesla_npu_like.py

@@ -0,0 +1,34 @@
+import pytest
+from zigzag.api import get_hardware_performance_zigzag_with_exploit_data_locality
+
+workloads = (
+    "zigzag/inputs/workload/resnet18.onnx",
+    "zigzag/inputs/workload/resnet18.yaml",
+)
+
+# Expected energy and latency for each workload defined above
+ens_lats = {
+    "zigzag/inputs/workload/alexnet.onnx": (6039993369, 8373281),
+    "zigzag/inputs/workload/mobilenetv2.onnx": (930699349, 1955657),
+    "zigzag/inputs/workload/resnet18.onnx": (1724869587, 3247768),
+    "zigzag/inputs/workload/resnet18.yaml": (2220200680, 3924484),
+}
+
+
+@pytest.fixture
+def mapping():
+    return "zigzag/inputs/mapping/tesla_npu_like.yaml"
+
+
+@pytest.fixture
+def accelerator():
+    return "zigzag/inputs/hardware/tesla_npu_like.yaml"
+
+
+@pytest.mark.parametrize("workload", workloads)
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
+    (energy, latency, _) = get_hardware_performance_zigzag_with_exploit_data_locality(workload, accelerator, mapping)
+    (expected_energy, expected_latency) = ens_lats[workload]
+    print(f"'{workload}': ({energy}, {latency}),")
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

zigzag_dse-3.2.1/tests/main/test_with_exploit_data_locality/test_tpu_like.py

@@ -0,0 +1,34 @@
+import pytest
+from zigzag.api import get_hardware_performance_zigzag_with_exploit_data_locality
+
+workloads = (
+    "zigzag/inputs/workload/resnet18.onnx",
+    "zigzag/inputs/workload/resnet18.yaml",
+)
+
+# Expected energy and latency for each workload defined above
+ens_lats = {
+    "zigzag/inputs/workload/alexnet.onnx": (5475639039, 8963572),
+    "zigzag/inputs/workload/mobilenetv2.onnx": (952681462, 21868059),
+    "zigzag/inputs/workload/resnet18.onnx": (1735241704.2240005, 3998241.0),
+    "zigzag/inputs/workload/resnet18.yaml": (2302362179.968, 5736497.0),
+}
+
+
+@pytest.fixture
+def mapping():
+    return "zigzag/inputs/mapping/tpu_like.yaml"
+
+
+@pytest.fixture
+def accelerator():
+    return "zigzag/inputs/hardware/tpu_like.yaml"
+
+
+@pytest.mark.parametrize("workload", workloads)
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
+    (energy, latency, _) = get_hardware_performance_zigzag_with_exploit_data_locality(workload, accelerator, mapping)
+    (expected_energy, expected_latency) = ens_lats[workload]
+    print(f"'{workload}': ({energy}, {latency}),")
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

zigzag_dse-3.2.1/tests/main/test_with_mix_spatial_mapping/test_ascend_like.py

@@ -0,0 +1,37 @@
+import pytest
+
+from zigzag.api import get_hardware_performance_zigzag_with_mix_spatial_mapping
+
+# Test case for when spatial_mapping is provided, while spatial_mapping_hint is not provided.
+
+workloads = (
+    "zigzag/inputs/workload/resnet18.onnx",
+    "zigzag/inputs/workload/resnet18.yaml",
+)
+
+# Expected energy and latency for each workload defined above
+ens_lats = {
+    "zigzag/inputs/workload/alexnet.onnx": (5664863934, 8479644),
+    "zigzag/inputs/workload/mobilenetv2.onnx": (920740293, 3814440),
+    "zigzag/inputs/workload/resnet18.onnx": (1680938520, 3697986),
+    "zigzag/inputs/workload/resnet18.yaml": (2286320480, 4418088),
+}
+
+
+@pytest.fixture
+def mapping():
+    return "zigzag/inputs/mapping/ascend_like_mixed.yaml"
+
+
+@pytest.fixture
+def accelerator():
+    return "zigzag/inputs/hardware/ascend_like.yaml"
+
+
+@pytest.mark.parametrize("workload", workloads)
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
+    (energy, latency, _) = get_hardware_performance_zigzag_with_mix_spatial_mapping(workload, accelerator, mapping)
+    (expected_energy, expected_latency) = ens_lats[workload]
+    print(f"'{workload}': ({energy}, {latency}),")
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

zigzag_dse-3.2.1/tests/main/test_with_mix_spatial_mapping/test_edge_tpu_like.py

@@ -0,0 +1,37 @@
+import pytest
+
+from zigzag.api import get_hardware_performance_zigzag_with_mix_spatial_mapping
+
+# Test case for when both spatial_mapping and spatial_mapping_hint are provided.
+
+workloads = (
+    "zigzag/inputs/workload/resnet18.onnx",
+    "zigzag/inputs/workload/resnet18.yaml",
+)
+
+# Expected energy and latency for each workload defined above
+ens_lats = {
+    "zigzag/inputs/workload/alexnet.onnx": (6159980160, 8337351),
+    "zigzag/inputs/workload/mobilenetv2.onnx": (742114179, 2421959),
+    "zigzag/inputs/workload/resnet18.onnx": (1735517944, 4055269),
+    "zigzag/inputs/workload/resnet18.yaml": (2029477205, 4738407),
+}
+
+
+@pytest.fixture
+def mapping():
+    return "zigzag/inputs/mapping/edge_tpu_like_mixed.yaml"
+
+
+@pytest.fixture
+def accelerator():
+    return "zigzag/inputs/hardware/edge_tpu_like.yaml"
+
+
+@pytest.mark.parametrize("workload", workloads)
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
+    (energy, latency, _) = get_hardware_performance_zigzag_with_mix_spatial_mapping(workload, accelerator, mapping)
+    (expected_energy, expected_latency) = ens_lats[workload]
+    print(f"'{workload}': ({energy}, {latency}),")
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

zigzag_dse-3.2.1/tests/main/test_with_mix_spatial_mapping/test_meta_prototype_like.py

@@ -0,0 +1,37 @@
+import pytest
+
+from zigzag.api import get_hardware_performance_zigzag_with_mix_spatial_mapping
+
+# Test case for when an incomplete spatial_mapping is provided and spatial_mapping_hint is also provided.
+
+workloads = (
+    "zigzag/inputs/workload/resnet18.onnx",
+    "zigzag/inputs/workload/resnet18.yaml",
+)
+
+# Expected energy and latency for each workload defined above
+ens_lats = {
+    "zigzag/inputs/workload/alexnet.onnx": (5681909132.480001, 8279495.0),
+    "zigzag/inputs/workload/mobilenetv2.onnx": (909647916.68, 2602479.0),
+    "zigzag/inputs/workload/resnet18.onnx": (1751779924.0000002, 3234867.0),
+    "zigzag/inputs/workload/resnet18.yaml": (2259198622.68, 3884859.0),
+}
+
+
+@pytest.fixture
+def mapping():
+    return "zigzag/inputs/mapping/meta_prototype_like_mixed.yaml"
+
+
+@pytest.fixture
+def accelerator():
+    return "zigzag/inputs/hardware/meta_prototype.yaml"
+
+
+@pytest.mark.parametrize("workload", workloads)
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
+    (energy, latency, _) = get_hardware_performance_zigzag_with_mix_spatial_mapping(workload, accelerator, mapping)
+    (expected_energy, expected_latency) = ens_lats[workload]
+    print(f"'{workload}': ({energy}, {latency}),")
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

zigzag_dse-3.2.1/tests/main/test_with_mix_spatial_mapping/test_tesla_npu_like.py

@@ -0,0 +1,37 @@
+import pytest
+
+from zigzag.api import get_hardware_performance_zigzag_with_mix_spatial_mapping
+
+# Test case for when only spatial_mapping_hint is provided.
+
+workloads = (
+    "zigzag/inputs/workload/resnet18.onnx",
+    "zigzag/inputs/workload/resnet18.yaml",
+)
+
+# Expected energy and latency for each workload defined above
+ens_lats = {
+    "zigzag/inputs/workload/alexnet.onnx": (6006136982.778, 8290892.0),
+    "zigzag/inputs/workload/mobilenetv2.onnx": (947736166.5380002, 1857838.0),
+    "zigzag/inputs/workload/resnet18.onnx": (1604556365.552, 2828301.0),
+    "zigzag/inputs/workload/resnet18.yaml": (2094141825.5040002, 3480232.0),
+}
+
+
+@pytest.fixture
+def mapping():
+    return "zigzag/inputs/mapping/tesla_npu_like_mixed.yaml"
+
+
+@pytest.fixture
+def accelerator():
+    return "zigzag/inputs/hardware/tesla_npu_like.yaml"
+
+
+@pytest.mark.parametrize("workload", workloads)
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621
+    (energy, latency, _) = get_hardware_performance_zigzag_with_mix_spatial_mapping(workload, accelerator, mapping)
+    (expected_energy, expected_latency) = ens_lats[workload]
+    print(f"'{workload}': ({energy}, {latency}),")
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

zigzag_dse-3.2.1/tests/main/test_with_mix_spatial_mapping/test_tpu_like.py

@@ -0,0 +1,37 @@
+import pytest
+
+from zigzag.api import get_hardware_performance_zigzag_with_mix_spatial_mapping
+
+# Test case for when more non-existent dimensions are provided in spatial_mapping_hint.
+
+workloads = (
+    "zigzag/inputs/workload/resnet18.onnx",
+    "zigzag/inputs/workload/resnet18.yaml",
+)
+
+# Expected energy and latency for each workload defined above
+ens_lats = {
+    "zigzag/inputs/workload/alexnet.onnx": (5589583403, 8671208),
+    "zigzag/inputs/workload/mobilenetv2.onnx": (932571650, 7304307),
+    "zigzag/inputs/workload/resnet18.onnx": (1759424218.3160002, 4495469.0),
+    "zigzag/inputs/workload/resnet18.yaml": (2191903732.78, 4845353.0),
+}
+
+
+@pytest.fixture
+def mapping():
+    return "zigzag/inputs/mapping/tpu_like_mixed.yaml"
+
+
+@pytest.fixture
+def accelerator():
+    return "zigzag/inputs/hardware/tpu_like.yaml"
+
+
+@pytest.mark.parametrize("workload", workloads)
+def test_api(workload: str, accelerator: str, mapping: str):  # pylint: disable=W0621  # pylint: disable=W0621
+    (energy, latency, _) = get_hardware_performance_zigzag_with_mix_spatial_mapping(workload, accelerator, mapping)
+    (expected_energy, expected_latency) = ens_lats[workload]
+    print(f"'{workload}': ({energy}, {latency}),")
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

{zigzag_dse-3.2.0 → zigzag_dse-3.2.1}/zigzag/__init__.py

@@ -1,3 +1,3 @@
-__version__ = "3.2.0"
+__version__ = "3.2.1"
 
 # from . import visualization as visualization

{zigzag_dse-3.2.0 → zigzag_dse-3.2.1}/zigzag/__main__.py

@@ -1,5 +1,4 @@
 from datetime import datetime
-from zigzag.stages import *
 
 from zigzag.stages.CostModelStage import CostModelStage
 from zigzag.stages.MainStage import MainStage
@@ -9,7 +8,7 @@ from zigzag.stages.WorkloadStage import WorkloadStage
 from zigzag.stages.AcceleratorParserStage import AcceleratorParserStage
 from zigzag.stages.reduce_stages import MinimalLatencyStage
 from zigzag.stages.save_stages import SimpleSaveStage
-from zigzag.stages.LomaStage import LomaStage
+from zigzag.stages.temporal_mapping_generator_stage import TemporalMappingGeneratorStage
 from zigzag.parser.arguments import get_arg_parser
 
 
@@ -36,14 +35,14 @@ def main():
             WorkloadStage,  # Iterates through the different layers in the workload
             SpatialMappingConversionStage,  # Generates multiple spatial mappings (SM)
             MinimalLatencyStage,  # Reduces all CMEs, returning minimal latency one
-            LomaStage,  # Generates multiple temporal mappings (TM)
+            TemporalMappingGeneratorStage,  # Generates multiple temporal mappings (TM)
             CostModelStage,  # Evaluates generated SM and TM through cost model
         ],
         accelerator_path=args.accelerator,  # required by AcceleratorParserStage
         onnx_model_path=args.model,  # required by ONNXModelParserStage
         mapping_path=args.mapping,  # required by ONNXModelParserStage
         dump_folder=f"outputs/{datetime.now()}",  # Output folder
-        loma_lpf_limit=6,  # required by LomaStage
+        loma_lpf_limit=6,  # required by TemporalMappingGeneratorStage
         loma_show_progress_bar=True,  # shows a progress bar while iterating over temporal mappings
     )