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

zigzag_dse-3.3.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include zigzag/inputs/workload/*.onnx
+recursive-include zigzag/cacti *

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zigzag-dse
-Version: 3.2.0
+Version: 3.3.0
 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
@@ -41,6 +41,7 @@ Requires-Dist: tqdm
 Requires-Dist: multiprocessing_on_dill
 Requires-Dist: pyyaml
 Requires-Dist: cerberus
+Requires-Dist: seaborn
 Provides-Extra: dev
 Requires-Dist: bumpver; extra == "dev"
 Requires-Dist: pip-tools; extra == "dev"

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

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

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

@@ -0,0 +1,45 @@
+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/resnet18.onnx": (4696819238.427852, 5553018.0, 14.07244, 2.2878123152749223),
+    "zigzag/inputs/workload/resnet18.yaml": (
+        4264976904.6396008,
+        4907495.0,
+        14.07244,
+        2.2878123152749223,
+    ),
+}
+
+
+@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]
+    print(f"'{workload}': ({energy}, {latency}, {tclk}, {area}),")
+    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.3.0/tests/main/test_imc/test_dimc.py

@@ -0,0 +1,45 @@
+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/resnet18.onnx": (4727682330.905855, 6365842.0, 3.75708, 0.8018113023999999),
+    "zigzag/inputs/workload/resnet18.yaml": (
+        4268285089.3547516,
+        5789229.0,
+        3.75708,
+        0.8018113023999999,
+    ),
+}
+
+
+@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]
+    print(f"'{workload}': ({energy}, {latency}, {tclk}, {area}),")
+    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.3.0}/tests/main/test_origin/test_ascend_like.py

@@ -9,7 +9,7 @@ workloads = (
 
 # Expected energy and latency for each workload defined above
 ens_lats = {
-    "zigzag/inputs/workload/resnet18.onnx": (1860963861.6800003, 3698589.0),
+    "zigzag/inputs/workload/resnet18.onnx": (1860725512.0800002, 3734111.0),
     "zigzag/inputs/workload/resnet18.yaml": (2411783423.28, 4779709.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)
+    assert energy == pytest.approx(expected_energy)  # type: ignore
+    assert latency == pytest.approx(expected_latency)  # type: ignore

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

@@ -9,7 +9,7 @@ workloads = (
 
 # Expected energy and latency for each workload defined above
 ens_lats = {
-    "zigzag/inputs/workload/resnet18.onnx": (1902637139.1499994, 3333310.0),
+    "zigzag/inputs/workload/resnet18.onnx": (1903376014.3499994, 3333310.0),
     "zigzag/inputs/workload/resnet18.yaml": (2413348670.67, 4268451.0),
 }
 
@@ -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.3.0}/tests/main/test_origin/test_meta_prototype_like.py

@@ -9,7 +9,7 @@ workloads = (
 
 # Expected energy and latency for each workload defined above
 ens_lats = {
-    "zigzag/inputs/workload/resnet18.onnx": (1869036158.08, 3366695.0),
+    "zigzag/inputs/workload/resnet18.onnx": (1870400796.8, 3614956.0),
     "zigzag/inputs/workload/resnet18.yaml": (2418511845.2400002, 4130645.0),
 }
 
@@ -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.3.0}/tests/main/test_origin/test_tesla_npu_like.py

@@ -9,7 +9,7 @@ workloads = (
 
 # Expected energy and latency for each workload defined above
 ens_lats = {
-    "zigzag/inputs/workload/resnet18.onnx": (1863716799.84, 3380242.0),
+    "zigzag/inputs/workload/resnet18.onnx": (1865018192.8319998, 3876369.0),
     "zigzag/inputs/workload/resnet18.yaml": (2374655424.176, 4066942.0),
 }
 
@@ -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.3.0}/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": (1871930384.8159997, 4159004.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.3.0/tests/main/test_with_exploit_data_locality/test_ascend_like.py

@@ -0,0 +1,32 @@
+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/resnet18.onnx": (1711117447.5200002, 3603174.0),
+    "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.3.0/tests/main/test_with_exploit_data_locality/test_edge_tpu_like.py

@@ -0,0 +1,32 @@
+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/resnet18.onnx": (1784038702.91, 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.3.0/tests/main/test_with_exploit_data_locality/test_meta_prototype_like.py

@@ -0,0 +1,32 @@
+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/resnet18.onnx": (1731553583.8400002, 3479347.0),
+    "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.3.0/tests/main/test_with_exploit_data_locality/test_tesla_npu_like.py

@@ -0,0 +1,32 @@
+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/resnet18.onnx": (1726170979.8719997, 3743894.0),
+    "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.3.0/tests/main/test_with_exploit_data_locality/test_tpu_like.py

@@ -0,0 +1,32 @@
+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/resnet18.onnx": (1735735708.3840003, 3998705.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.3.0/tests/main/test_with_mix_spatial_mapping/test_ascend_like.py

@@ -0,0 +1,35 @@
+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/resnet18.onnx": (1680986460.6400003, 3829493.0),
+    "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.3.0/tests/main/test_with_mix_spatial_mapping/test_edge_tpu_like.py

@@ -0,0 +1,35 @@
+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/resnet18.onnx": (1738892454.2700002, 4247189.0),
+    "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.3.0/tests/main/test_with_mix_spatial_mapping/test_meta_prototype_like.py

@@ -0,0 +1,35 @@
+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/resnet18.onnx": (1753144562.7200003, 3483127.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.3.0/tests/main/test_with_mix_spatial_mapping/test_tesla_npu_like.py

@@ -0,0 +1,35 @@
+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/resnet18.onnx": (1605857758.544, 3324427.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.3.0/tests/main/test_with_mix_spatial_mapping/test_tpu_like.py

@@ -0,0 +1,35 @@
+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/resnet18.onnx": (1763016528.7640002, 4688029.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.3.0}/zigzag/__init__.py

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

{zigzag_dse-3.2.0 → zigzag_dse-3.3.0}/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
     )