accelforge 0.0.1__py3-none-any.whl

tests/matmul_spatial.mapping.yaml

@@ -0,0 +1,44 @@
+mapping:
+  nodes:
+  - !Storage
+    tensors: [T1, T0, W0]
+    component: MainMemory
+  - !Temporal
+    rank_variable: m
+    tile_shape: 64
+  - !Storage
+    tensors: [T1]
+    component: LocalBuffer
+  - !Spatial
+    rank_variable: n0
+    tile_shape: 8
+    name: 0
+    component: LocalBuffer
+  - !Spatial
+    rank_variable: n0
+    tile_shape: 2
+    name: 1
+    component: LocalBuffer
+  - !Spatial
+    rank_variable: n1
+    tile_shape: 8
+    name: 0
+    component: LocalBuffer
+  - !Temporal
+    rank_variable: n0
+    tile_shape: 1
+  - !Storage
+    tensors: [T0]
+    component: LocalBuffer
+  - !Temporal
+    rank_variable: n1
+    tile_shape: 1
+  - !Storage
+    tensors: [W0]
+    component: LocalBuffer
+  - !Temporal
+    rank_variable: m
+    tile_shape: 1
+  - !Compute
+    einsum: Matmul1
+    compute: MAC

tests/mha.renames.yaml

@@ -0,0 +1,65 @@
+renames:
+  einsums:
+  - name: default
+    tensor_accesses:
+    - name: input
+      source: Inputs & Intermediates
+      expected_count: 1
+    - name: output
+      source: Outputs
+      expected_count: 1
+    - name: weight
+      source: ~(input | output)
+      expected_count: 1
+
+    rank_variables:
+    - name: head
+      source: h
+      expected_count: 1
+    - name: parallel_rank
+      source: (output.rank_variables & weight.rank_variables) - head
+      expected_count: 1
+    - name: reduced_rank
+      source: input.rank_variables & weight.rank_variables - head - output.rank_variables - parallel_rank
+      expected_count: 1
+
+  - name: I
+    tensor_accesses:
+    - name: weight
+      source: Nothing
+    - name: input
+      source: Inputs
+    {% if FFMT | default(false) %}
+    - name: Intermediates
+      source: Nothing
+    {% endif %}
+    rank_variables:
+    - {name: head, source: Nothing.rank_variables}
+    - {name: reduced_rank, source: b, expected_count: 1}
+    - {name: parallel_rank, source: m, expected_count: 1}
+
+  - name: QK
+    tensor_accesses:
+    - name: input
+      source: Q
+      expected_count: 1
+    rank_variables:
+    - {name: parallel_rank, source: m, expected_count: 1}
+
+  - name: AV
+    tensor_accesses:
+    - name: input
+      source: QK
+      expected_count: 1
+    rank_variables:
+    - {name: parallel_rank, source: f, expected_count: 1}
+    # - {name: reduced_rank, source: p, expected_count: 1}
+
+  - name: FFA
+    rank_variables:
+    - {name: head, source: Nothing.rank_variables}
+
+  - name: FFB
+    rank_variables:
+    - {name: head, source: Nothing.rank_variables}
+

tests/mha.workload.yaml

@@ -0,0 +1,67 @@
+workload:
+  shape:
+    b: 0 <= b < 2
+    m: 0 <= m < 2
+    p: 0 <= p < 2
+    h: 0 <= h < 2
+    e: 0 <= e < 2
+    f: 0 <= f < 2
+    d: 0 <= d < 4
+    c: 0 <= c < 1
+    j: 0 <= j < 1
+    g: 0 <= g < 1
+
+  einsums:
+  - name: I
+    is_copy_operation: True
+    tensor_accesses:
+    - {name: I_in, projection: [b, m, d]}
+    - {name: I, projection: [b, m, d], output: True}
+
+  - name: V
+    tensor_accesses:
+    - {name: I, projection: [ b, m, d ]}
+    - {name: WV, projection: [ h, e, d ]}
+    - {name: V, projection: [ b, m, h, e ], output: True}
+
+  - name: K
+    tensor_accesses:
+    - {name: I, projection: [ b, m, d ]}
+    - {name: WK, projection: [ h, e, d ]}
+    - {name: K, projection: [ b, m, h, e ], output: True}
+
+  - name: Q
+    tensor_accesses:
+    - {name: I, projection: [ b, m, d ]}
+    - {name: WQ, projection: [ h, e, d ]}
+    - {name: Q, projection: [ b, m, h, e ], output: True}
+
+  - name: QK
+    tensor_accesses:
+    - {name: Q, projection: [ b, m, h, e ]}
+    - {name: K, projection: { B: b, M: p, H: h, E: e }}
+    - {name: QK, projection: [ b, m, p, h ], output: True}
+
+  - name: AV
+    tensor_accesses:
+    - {name: QK, projection: [ b, m, p, h ]}
+    - {name: V, projection: { B: b, M: p, H: h, E: f}}
+    - {name: AV, projection: [ b, m, h, f ], output: True}
+
+  - name: Z
+    tensor_accesses:
+    - {name: AV, projection: [ b, m, h, f ]}
+    - {name: WZ, projection: [ h, f, g ]}
+    - {name: Z, projection: [ b, m, g ], output: True}
+
+  - name: FFA
+    tensor_accesses:
+    - {name: Z, projection: [ b, m, g ]}
+    - {name: WFFA, projection: [ g, c ]}
+    - {name: FFA, projection: [ b, m, c ], output: True}
+
+  - name: FFB
+    tensor_accesses:
+    - {name: FFA, projection: [ b, m, c ]}
+    - {name: WFFB, projection: [ c, j ]}
+    - {name: FFB, projection: [ b, m, j ], output: True}

tests/mha.yaml

@@ -0,0 +1,59 @@
+workload:
+  shape:
+    b: 0 <= b < 2
+    m: 0 <= m < 2
+    h: 0 <= h < 2
+    e: 0 <= e < 2
+    d: 0 <= d < 4
+    c: 0 <= c < 1
+    j: 0 <= j < 1
+    g: 0 <= g < 1
+
+  einsums:
+  - name: V
+    tensor_accesses:
+    - {name: I, projection: [ b, m, d ]}
+    - {name: WV, projection: [ h, e, d ]}
+    - {name: V, projection: [ b, m, h, e ], output: True}
+
+  - name: K
+    tensor_accesses:
+    - {name: I, projection: [ b, m, d ]}
+    - {name: WK, projection: [ h, e, d ]}
+    - {name: K, projection: [ b, m, h, e ], output: True}
+
+  - name: Q
+    tensor_accesses:
+    - {name: I, projection: [ b, m, d ]}
+    - {name: WQ, projection: [ h, e, d ]}
+    - {name: Q, projection: [ b, m, h, e ], output: True}
+
+  - name: QK
+    tensor_accesses:
+    - {name: Q, projection: [ b, m, h, e ]}
+    - {name: K, projection: { B: b, M: P, H: h, E: e }}
+    - {name: QK, projection: [ b, m, P, h ], output: True}
+
+  - name: AV
+    tensor_accesses:
+    - {name: QK, projection: [ b, m, p, h ]}
+    - {name: V, projection: { B: b, M: p, H: h, E: f}}
+    - {name: AV, projection: [ b, m, h, f ], output: True}
+
+  - name: Z
+    tensor_accesses:
+    - {name: AV, projection: [ b, m, h, F ]}
+    - {name: WZ, projection: [ h, F, g ]}
+    - {name: Z, projection: [ b, m, g ], output: True}
+
+  - name: FFA
+    tensor_accesses:
+    - {name: Z, projection: [ b, m, g ]}
+    - {name: WFFA, projection: [ g, c ]}
+    - {name: FFA, projection: [ b, m, c ], output: True}
+
+  - name: FFB
+    tensor_accesses:
+    - {name: FFA, projection: [ b, m, c ]}
+    - {name: WFFB, projection: [ c, j ]}
+    - {name: FFB, projection: [ b, m, j ], output: True}

tests/mha_full.workload.yaml

@@ -0,0 +1,67 @@
+workload:
+  shape:
+    b: 0 <= b < 1
+    m: 0 <= m < 128
+    p: 0 <= p < 128 # = m
+    h: 0 <= h < 8
+    e: 0 <= e < 32
+    f: 0 <= f < 32
+    d: 0 <= d < 256 # = e * h
+    c: 0 <= c < 1024
+    j: 0 <= j < 256
+    g: 0 <= g < 256
+
+  einsums:
+  - name: I
+    is_copy_operation: True
+    tensor_accesses:
+    - {name: I_in, projection: [b, m, d]}
+    - {name: I, projection: [b, m, d], output: True}
+
+  - name: V
+    tensor_accesses:
+    - {name: I, projection: [b, m, d]}
+    - {name: WV, projection: [h, e, d]}
+    - {name: V, projection: [b, m, h, e], output: True}
+
+  - name: K
+    tensor_accesses:
+    - {name: I, projection: [b, m, d]}
+    - {name: WK, projection: [h, e, d]}
+    - {name: K, projection: [b, m, h, e], output: True}
+
+  - name: Q
+    tensor_accesses:
+    - {name: I, projection: [b, m, d]}
+    - {name: WQ, projection: [h, e, d]}
+    - {name: Q, projection: [b, m, h, e], output: True}
+
+  - name: QK
+    tensor_accesses:
+    - {name: Q, projection: [b, m, h, e]}
+    - {name: K, projection: { B: b, M: p, H: h, E: e }}
+    - {name: QK, projection: [b, m, p, h], output: True}
+
+  - name: AV
+    tensor_accesses:
+    - {name: QK, projection: [b, m, p, h]}
+    - {name: V, projection: { B: b, M: p, H: h, E: f}}
+    - {name: AV, projection: [b, m, h, f], output: True}
+
+  - name: Z
+    tensor_accesses:
+    - {name: AV, projection: [b, m, h, f]}
+    - {name: WZ, projection: [h, f, g]}
+    - {name: Z, projection: [b, m, g], output: True}
+
+  - name: FFA
+    tensor_accesses:
+    - {name: Z, projection: [b, m, g]}
+    - {name: WFFA, projection: [g, c]}
+    - {name: FFA, projection: [b, m, c], output: True}
+
+  - name: FFB
+    tensor_accesses:
+    - {name: FFA, projection: [b, m, c]}
+    - {name: WFFB, projection: [c, j]}
+    - {name: FFB, projection: [b, m, j], output: True}

tests/mobilenet.workload.yaml

@@ -0,0 +1,35 @@
+workload:
+  shape:
+    pa0: 0 <= pa0 < 25
+    qa0: 0 <= qa0 < 25
+    pb0: 0 <= pb0 < 25
+    qb0: 0 <= qb0 < 25
+    n0: 0 <= n0 < 2
+    t0: 0 <= t0 < 4
+    n1: 0 <= n1 < 2
+
+  einsums:
+  - name: PiecewiseA0
+    tensor_accesses:
+    - {name: T0, projection: [pa0, qa0, n0]}
+    - {name: WA0, projection: [n0, t0]}
+    - {name: TA0, projection: [pa0, qa0, t0], output: True}
+
+  - name: Depthwise0
+    tensor_accesses:
+    - name: TA0
+      projection:
+        PA0: pb0 + r0
+        QA0: qb0 + s0
+        T0: t0
+    - {name: WAB0, projection: [r0, s0, t0]}
+    - {name: TB0, projection: [pb0, qb0, t0], output: True}
+    shape:
+    - 0 <= r0 < 3
+    - 0 <= s0 < 3
+
+  - name: PiecewiseB0
+    tensor_accesses:
+    - {name: TB0, projection: [pb0, qb0, t0]}
+    - {name: WB0, projection: [t0, n1]}
+    - {name: T1, projection: [pb0, qb0, n1], output: True}

tests/mobilenet_long.workload.yaml

@@ -0,0 +1,64 @@
+workload:
+  shape:
+    p0: 0 <= p0 < 7
+    q0: 0 <= q0 < 7
+    n0: 0 <= n0 < 2
+    t0: 0 <= t0 < 4
+    n1: 0 <= n1 < 2
+    p1: 0 <= p1 < 7
+    q1: 0 <= q1 < 7
+    p2: 0 <= p2 < 7
+    q2: 0 <= q2 < 7
+    t1: 0 <= t1 < 4
+    n2: 0 <= n2 < 2
+
+  einsums:
+  - name: PiecewiseA0
+    tensor_accesses:
+    - {name: T0, projection: [p0, q0, n0]}
+    - {name: WA0, projection: [n0, t0]}
+    - {name: TA0, projection: [p0, q0, t0], output: True}
+
+  - name: Depthwise0
+    tensor_accesses:
+    - name: TA0
+      projection:
+        P0: p1 + r0
+        Q0: q1 + s0
+        T0: t0
+    - {name: WAB0, projection: [r0, s0, t0]}
+    - {name: TB0, projection: [p1, q1, t0], output: True}
+    shape:
+    - 0 <= r0 < 3
+    - 0 <= s0 < 3
+
+  - name: PiecewiseB0
+    tensor_accesses:
+    - {name: TB0, projection: [p1, q1, t0]}
+    - {name: WB0, projection: [t0, n1]}
+    - {name: T1, projection: [p1, q1, n1], output: True}
+
+  - name: PiecewiseA1
+    tensor_accesses:
+    - {name: T1, projection: [p1, q1, n1]}
+    - {name: WA1, projection: [n1, t1]}
+    - {name: TA1, projection: [p1, q1, t1], output: True}
+
+  - name: Depthwise1
+    tensor_accesses:
+    - name: TA1
+      projection:
+        P1: p2 + r1
+        Q1: q2 + s1
+        T1: t1
+    - {name: WAB1, projection: [r1, s1, t1]}
+    - {name: TB1, projection: [p2, q2, t1], output: True}
+    shape:
+    - 0 <= r1 < 3
+    - 0 <= s1 < 3
+
+  - name: PiecewiseB2
+    tensor_accesses:
+    - {name: TB1, projection: [p2, q2, t1]}
+    - {name: WB1, projection: [t1, n2]}
+    - {name: T2, projection: [p2, q2, n2], output: True}

tests/pmappingcache.py

@@ -0,0 +1,24 @@
+from collections.abc import Iterable
+from pathlib import Path
+
+from accelforge.util._picklecache import PickleCache
+
+
+TEST_PmappingGroup_DIR = Path(__file__).parent / "tmp" / "pmapping_cache"
+
+
+def make_pmapping_pickle_cache(config_names: Iterable[str]) -> PickleCache:
+    """
+    Return a `PickleCache` using path generated by `make_pmapping_pickle_path`.
+    """
+    return PickleCache(make_pmapping_pickle_path(config_names))
+
+
+def make_pmapping_pickle_path(config_names: Iterable[str]) -> Path:
+    """
+    Creates a path to a file in `TEST_PmappingGroup_DIR` with a file name that is
+    `config_names` joined using "---" as separators.
+    """
+    pickle_name = "---".join(sorted(config_names)) + ".pkl"
+    pickle_path = TEST_PmappingGroup_DIR / pickle_name
+    return pickle_path

tests/processing_stage.arch.yaml

@@ -0,0 +1,40 @@
+arch:
+  nodes:
+  - !Memory
+    name: main_memory
+    attributes:
+      _size: 1e9
+      _datawidth: 8
+    tensors: {keep: All}
+    actions:
+    - {name: read, arguments: {_energy: 0}}
+    - {name: write, arguments: {_energy: 0}}
+    - {name: leak, arguments: {_energy: 0}}
+
+  - !ProcessingStage
+    name: ProcessingStage
+    attributes:
+      _datawidth: 8
+      _direction: up_and_down
+    tensors: {keep: All}
+    actions:
+    - {name: read, arguments: {_energy: 100}}
+    - {name: write, arguments: {_energy: 0}}
+    - {name: leak, arguments: {_energy: 0}}
+
+  - !Memory
+    name: LocalBuffer
+    attributes:
+      _size: 1e9
+      _datawidth: 8
+    tensors: {keep: All}
+    actions:
+    - {name: read, arguments: {_energy: 0}}
+    - {name: write, arguments: {_energy: 0}}
+    - {name: leak, arguments: {_energy: 0}}
+
+  - !Compute
+    name: mac
+    actions:
+    - {name: compute, arguments: {_energy: 0.0}}
+    - {name: leak, arguments: {_energy: 0}}

tests/snowcat.arch.yaml

@@ -0,0 +1,36 @@
+variables:
+tech_node: 7e-9
+
+arch:
+  nodes:
+  - !Memory
+    name: MainMemory
+    component_class: DRAM
+    attributes:
+      size: 9999999999999
+      area: 1
+    tensors: {keep: ~Intermediates, may_keep: Intermediates}
+    actions:
+    - {name: read, arguments: {_energy: 1}}
+    - {name: write, arguments: {_energy: 1}}
+    - {name: leak, arguments: {_energy: 0}}
+
+  - !Memory
+    name: GlobalBuffer
+    component_class: SRAM
+    attributes:
+      size: 9999999999999
+      area: 1
+    tensors: {keep: All}
+    actions:
+    - {name: read, arguments: {_energy: 0}}
+    - {name: write, arguments: {_energy: 0}}
+    - {name: leak, arguments: {_energy: 0}}
+
+  - !Compute
+    name: MAC
+    component_class: intmac
+    attributes: {area: 1}
+    actions:
+    - {name: compute, arguments: {_energy: 0}}
+    - {name: leak, arguments: {_energy: 0}}

tests/test_ffm_join_pmappings.py

@@ -0,0 +1,106 @@
+from pathlib import Path
+import pickle
+import unittest
+
+from accelforge.frontend import Spec
+from accelforge.mapper.FFM._make_pmappings.make_pmappings import make_pmappings
+from accelforge.mapper.FFM._join_pmappings.compatibility_util import (
+    join_compatibilities,
+    pmappings2untiled_compatibilities,
+)
+from accelforge.mapper.FFM._join_pmappings.join_pmappings import join_pmappings
+
+from pmappingcache import make_pmapping_pickle_cache
+
+
+PARENT_DIR = Path(__file__).parent
+
+
+class TestPreJoin(unittest.TestCase):
+    def test_mha_full(self):
+        config_names = ["snowcat.arch", "mha_full.workload", "mha.renames"]
+        paths = [PARENT_DIR / f"{config_name}.yaml" for config_name in config_names]
+        spec = Spec.from_yaml(*paths)
+        flattened_arch = spec._get_flattened_architecture()
+
+        pmapping_cache = make_pmapping_pickle_cache(config_names)
+        pmapping_groups, decompress_data = pmapping_cache.get(
+            lambda: make_pmappings(spec, flattened_arch)
+        )
+
+        untiled_compats = pmappings2untiled_compatibilities(pmapping_groups)
+        einsum2important_compats = join_compatibilities(untiled_compats, spec)
+
+        for einsum, compats in untiled_compats.items():
+            before_size = sum(
+                len(pm.mappings.data.index) for pm in pmapping_groups[einsum]
+            )
+            after_size = sum(
+                len(pm.mappings.data.index) for pm in einsum2pruned_pmappings[einsum]
+            )
+
+            print(
+                f"{einsum} has {len(einsum2important_compats[einsum])}"
+                f"/{len(compats)} compatibilities left and "
+                f"{after_size}/{before_size} pmappings left."
+            )
+
+
+class TestJoin(unittest.TestCase):
+    def test_mha(self):
+        spec = Spec.from_yaml(
+            PARENT_DIR / "four_level.arch.yaml",
+            PARENT_DIR / "mha.workload.yaml",
+            PARENT_DIR / "mha.renames.yaml",
+        )
+
+        flattened_arch = spec._get_flattened_architecture()
+        pmapping_groups, decompress_data = make_pmappings(spec, flattened_arch)
+        mappings = join_pmappings(
+            pmapping_groups, spec, flattened_arch, drop_valid_reservations=False
+        )
+
+    def test_mha_full(self):
+        config_names = ["snowcat.arch", "mha_full.workload", "mha.renames"]
+        paths = [PARENT_DIR / f"{config_name}.yaml" for config_name in config_names]
+        spec = Spec.from_yaml(*paths)
+        flattened_arch = spec._get_flattened_architecture()
+
+        pmapping_cache = make_pmapping_pickle_cache(config_names)
+        pmapping_groups, decompress_data = pmapping_cache.get(
+            lambda: make_pmappings(spec, flattened_arch)
+        )
+
+        mappings = join_pmappings(pmapping_groups, spec, flattened_arch)
+
+    def test_mha_full_with_prejoin_pruning(self):
+        config_names = ["snowcat.arch", "mha_full.workload", "mha.renames"]
+        paths = [PARENT_DIR / f"{config_name}.yaml" for config_name in config_names]
+        spec = Spec.from_yaml(*paths)
+        flattened_arch = spec._get_flattened_architecture()
+
+        pmapping_cache = make_pmapping_pickle_cache(config_names)
+        pmapping_groups, decompress_data = pmapping_cache.get(
+            lambda: make_pmappings(spec, flattened_arch)
+        )
+
+        untiled_compats = pmappings2untiled_compatibilities(pmapping_groups)
+        einsum2important_compats = join_compatibilities(untiled_compats, spec)
+
+        mappings = join_pmappings(einsum2pruned_pmappings, spec, flattened_arch)
+
+    def test_mobilenet(self):
+        config_names = [
+            "snowcat.arch",
+            "mobilenet_long.workload",
+        ]
+        paths = [PARENT_DIR / f"{config_name}.yaml" for config_name in config_names]
+        spec = Spec.from_yaml(*paths)
+        flattened_arch = spec._get_flattened_architecture()
+
+        pmapping_cache = make_pmapping_pickle_cache(config_names)
+        pmapping_groups, decompress_data = pmapping_cache.get(
+            lambda: make_pmappings(spec)
+        )
+
+        mappings = join_pmappings(pmapping_groups, spec, flattened_arch)

tests/test_ffm_make_pmappings.py

@@ -0,0 +1,82 @@
+from pathlib import Path
+import unittest
+
+from accelforge.frontend import Spec, Workload
+
+from accelforge.mapper import Metrics
+from accelforge.mapper.FFM import make_pmappings
+from accelforge.mapper.FFM._make_pmappings.make_pmappings import make_pmappings
+from accelforge.mapper.FFM._join_pmappings.pmapping_dataframe import nameloop2col
+
+from pmappingcache import make_pmapping_pickle_cache
+
+
+PARENT_DIR = Path(__file__).parent
+
+
+class TestPmappingExploration(unittest.TestCase):
+    def test_mha(self):
+        spec = Spec.from_yaml(
+            PARENT_DIR / "four_level.arch.yaml",
+            PARENT_DIR / "mha.workload.yaml",
+            PARENT_DIR / "mha.renames.yaml",
+        )
+        spec.mapper.ffm.metrics = Metrics.ENERGY | Metrics.LATENCY
+        pmappings = make_pmappings(spec, ["Q"])
+
+    def test_mha_full(self):
+        config_names = ["snowcat.arch", "mha_full.workload", "mha.renames"]
+        paths = [PARENT_DIR / f"{config_name}.yaml" for config_name in config_names]
+        spec = Spec.from_yaml(*paths)
+
+        pmapping_cache = make_pmapping_pickle_cache(config_names)
+
+        pmapping_groups, decompress_data = pmapping_cache.set(make_pmappings(spec))
+        for per_einsum_pmappings in pmapping_groups.values():
+            for pmapping_group in per_einsum_pmappings:
+                for (
+                    resource,
+                    levels,
+                ) in pmapping_group.mappings.right_reservations.items():
+                    for level in levels:
+                        self.assertTrue(
+                            nameloop2col(resource, level)
+                            in pmapping_group.mappings.data.columns,
+                            f"{resource} at {level} not in {pmapping_group.mappings.data.columns}. Compatibility: {pmapping_group.compatibility}",
+                        )
+
+    def test_mha_with_tags(self):
+        spec = Spec.from_yaml(
+            PARENT_DIR / "four_level.arch.yaml",
+            PARENT_DIR / "mha.workload.yaml",
+            PARENT_DIR / "mha.renames.yaml",
+        )
+
+        pmapping_groups, decompress_data = make_pmappings(spec, einsum_names=["Q"])
+
+    def test_conv_with_snowcat(self):
+        spec = Spec.from_yaml(
+            PARENT_DIR / "snowcat.arch.yaml",
+            PARENT_DIR / "mobilenet_long.workload.yaml",
+        )
+        config_names = [
+            "snowcat.arch",
+            "mobilenet_long.workload",
+        ]
+        paths = [PARENT_DIR / f"{config_name}.yaml" for config_name in config_names]
+        spec = Spec.from_yaml(*paths)
+
+        pmapping_cache = make_pmapping_pickle_cache(config_names)
+
+        pmapping_groups, decompress_data = pmapping_cache.set(make_pmappings(spec))
+        for per_einsum_pmappings in pmapping_groups.values():
+            for pmapping_group in per_einsum_pmappings:
+                print(pmapping_group.compatibility)
+
+
+class TestInitialDeltaGeneration(unittest.TestCase):
+    def test_mobilenet_long(self):
+        workload = Workload.from_yaml(
+            Path(__file__).parent / "mobilenet_long.workload.yaml"
+        )
+        choices = get_initial_delta_choices("Dwise0", workload)