[network] Clean up Claude output

Author: gilbertmike

accelforge/model/_looptree/reuse/symbolic/_network.py

@@ -94,10 +94,10 @@ def per_loop_transfer_cost(
 class MeshTopologyModel(TopologyModel):
     """Cost model for a mesh network.
 
-    Data travels link-by-link along one axis of the mesh. Multicast delivers a
-    value to every point along the dimension; unicast delivers a distinct value
-    to each point. When the source is physically distributed, data is bound as
-    locally as possible across the physical buffers.
+    Data travels along one axis of the mesh. Multicast delivers a value to every
+    point along the dimension; unicast delivers a distinct value to each point.
+    When the source is physically distributed, data is bound as locally as
+    possible across the physical buffers.
     """
 
     def per_loop_transfer_cost(
@@ -153,23 +153,13 @@ def per_loop_transfer_cost(
 
 
 class AllToAllTopologyModel(TopologyModel):
-    """Cost model for an all-to-all network built around a switch (e.g. NVLink /
-    NVSwitch).
-
-    Every node connects to every other node through a central switch, so any
-    source reaches any destination in a constant number of hops regardless of
-    how far apart they are in the logical fanout. This differs from a mesh in
-    two ways:
-
-    - **Uniform latency.** The longest route is a single switch traversal, so
-      ``max_hops`` is constant rather than growing with the distance
-      (``shape_repeats * stride``) between source and destination.
-    - **No store-and-forward accumulation.** Each destination is reached
-      directly, so the total (energy) cost is linear in the number of
-      destinations rather than quadratic as in a mesh unicast.
-
-    The physical stride is irrelevant here (all nodes are equidistant from the
-    switch), so ``last_fanout`` and physical distribution are not consulted.
+    """Cost model for an all-to-all network using a switch (e.g. NVLink).
+
+    Every node connects to every other node through a switch, so any
+    source reaches any destination in one hop regardless of
+
+    Physical stride is irrelevant, so ``last_fanout`` and physical distribution
+    are not used.
     """
 
     HOPS_PER_TRANSFER = 1
@@ -219,9 +209,7 @@ def per_loop_transfer_cost(
         )
 
 
-# Registry mapping each topology to the model class that costs its data
-# movement. Classes (not instances) are stored because models are stateful and
-# each NetworkAnalyzer needs its own.
+# Registry of topology models
 TOPOLOGY_MODELS: dict[TopologySpec, type[TopologyModel]] = {
     TopologySpec.MESH: MeshTopologyModel,
     TopologySpec.ALL_TO_ALL: AllToAllTopologyModel,

tests/network/input_files/networked/hierarchical_1d_all_to_all.yaml

@@ -26,7 +26,7 @@ arch:
     leak_power: 0
     total_latency: "max_hops"
     actions:
-    - {name: hops, energy: 1, latency: 0, throughput: 1}
+    - {name: hops, energy: 1, latency: 1, throughput: inf}
 
   - !Memory
     name: Scratchpad
@@ -40,9 +40,7 @@ arch:
     spatial:
     - {name: X, fanout: 4}
 
-  # All-to-all switch (NVLink-like): every node is one switch hop from every
-  # other, so unicast and multicast cost the same total hops and max_hops is
-  # constant. Fanout is 4 so this differs observably from a mesh.
+  # All-to-all switch (NVLink-like): every node is one hop from every other
   - !Network
     name: MacArray
     topology: all_to_all

tests/network/test_network.py

@@ -334,9 +334,7 @@ def test_flat(self):
 
 
 class TestModelAllToAll(TestCase):
-    """Full-model evaluation of the 1D hierarchy where MacArray is an all-to-all
-    switch (NVLink-like) instead of a mesh. PeArray remains a mesh, so the two
-    networks can be contrasted within a single run."""
+    """MacArray is an all-to-all switch (NVLink-like). PeArray is a mesh."""
 
     def test_hierarchical_1d_all_to_all(self):
         M = 8
@@ -360,16 +358,13 @@ def test_hierarchical_1d_all_to_all(self):
         result = spec.evaluate_mapping()
 
         # --- MacArray: all-to-all switch ---------------------------------
-        # On a switch every node is one hop away, so unicast (T0, W0) collapses
-        # to the same (MAC_TILE - 1) linear cost as multicast (T1): all equal.
-        # Contrast test_hierarchical_1d, where the mesh makes T0/W0 quadratic
-        # (sum(range(MAC_TILE))).
+        # Every node is one hop away 
         all_to_all = (
             (M / M_TILE)
             * (KN / MAC_TILE)  # number of used Scratchpad
             * M_TILE
             * KN  # temporal for n1 in mapping
-            * (MAC_TILE - 1)  # one switch hop per destination, for every tensor
+            * (MAC_TILE - 1)  # one hop per destination, for every tensor
             * BITS_PER_VALUE
         )
         for tensor in ("T0", "T1", "W0"):
@@ -381,17 +376,6 @@ def test_hierarchical_1d_all_to_all(self):
                 msg=f"unexpected MacArray hops for {tensor}",
             )
 
-        # Guard: a mesh would make the unicast tensors strictly more expensive.
-        mesh_unicast = (
-            (M / M_TILE)
-            * (KN / MAC_TILE)
-            * M_TILE
-            * KN
-            * sum(range(MAC_TILE))  # quadratic on a mesh
-            * BITS_PER_VALUE
-        )
-        self.assertGreater(mesh_unicast, all_to_all)
-
         # --- PeArray: still a mesh ---------------------------------------
         # Unchanged from test_hierarchical_1d, so the mesh formulas hold (now
         # with MAC_TILE = 4, i.e. KN // MAC_TILE = 2).
@@ -422,7 +406,7 @@ def test_hierarchical_1d_all_to_all(self):
 
         # --- Latency ------------------------------------------------------
         # The switch's uniform single-hop routing gives MacArray a constant
-        # latency of 1, versus the mesh PeArray's distance-dependent 2.
+        # latency of 1, versus the mesh PeArray's 2.
         self.assertEqual(
             result.data["Matmul0<SEP>latency<SEP>MacArray"].iloc[0], 1
         )