stream-dse 2.2.0__tar.gz → 2.3.0__tar.gz

{stream_dse-2.2.0/stream_dse.egg-info → stream_dse-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stream-dse
-Version: 2.2.0
+Version: 2.3.0
 Summary: Stream - Multi-core accelerator design space exploration with layer-fused scheduling
 Author-email: Arne Symons <arne.symons@kuleuven.be>, Linyan Mei <linyan.mei@kuleuven.be>
 License: MIT License
@@ -32,8 +32,7 @@ Classifier: Programming Language :: Python
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: zigzag-dse==3.9.1
-Requires-Dist: six
+Requires-Dist: zigzag-dse==3.10.0
 Requires-Dist: cerberus
 Requires-Dist: ortools>=9.15
 Requires-Dist: pydantic<2.12,>=2.0
@@ -46,6 +45,24 @@ Provides-Extra: exact
 Requires-Dist: islpy; extra == "exact"
 Provides-Extra: torch
 Requires-Dist: torch>=2.4; extra == "torch"
+Provides-Extra: accelforge
+Requires-Dist: numpy>=2.2.0; extra == "accelforge"
+Requires-Dist: pandas>=2.2.0; extra == "accelforge"
+Requires-Dist: tqdm>=4.67.0; extra == "accelforge"
+Requires-Dist: pydantic_core>=2.33.0; extra == "accelforge"
+Requires-Dist: ruamel.yaml>=0.18.0; extra == "accelforge"
+Requires-Dist: islpy>=2025; extra == "accelforge"
+Requires-Dist: jinja2>=3.1.0; extra == "accelforge"
+Requires-Dist: sympy>=1.14.0; extra == "accelforge"
+Requires-Dist: symengine>=0.14.0; extra == "accelforge"
+Requires-Dist: numba>=0.61.2; extra == "accelforge"
+Requires-Dist: matplotlib>=3.10.0; extra == "accelforge"
+Requires-Dist: plotly>=6.1.0; extra == "accelforge"
+Requires-Dist: pydot>=4.0.0; extra == "accelforge"
+Requires-Dist: platformdirs>=4.3.0; extra == "accelforge"
+Requires-Dist: joblib>=1.5.1; extra == "accelforge"
+Requires-Dist: requests>=2.33.1; extra == "accelforge"
+Requires-Dist: hwcomponents==1.0.114; extra == "accelforge"
 Provides-Extra: dev
 Requires-Dist: bumpver; extra == "dev"
 Requires-Dist: pip-tools; extra == "dev"

{stream_dse-2.2.0 → stream_dse-2.3.0}/pyproject.toml

@@ -21,7 +21,7 @@ namespaces = true
 
 [project]
 name = "stream-dse"
-version = "2.2.0"
+version = "2.3.0"
 description = "Stream - Multi-core accelerator design space exploration with layer-fused scheduling"
 readme = "README.md"
 authors = [{ name = "Arne Symons", email = "arne.symons@kuleuven.be" }, { name = "Linyan Mei", email = "linyan.mei@kuleuven.be" }]
@@ -32,9 +32,7 @@ classifiers = [
 ]
 keywords = ["stream", "multi-core", "accelerator", "layer-fused", "scheduling", "zigzag", "dse", "design-space-exploration", "machine-learning", "deep-learning", "mapping"]
 dependencies = [
-    "zigzag-dse==3.9.1",
-    # zigzag's mapping validator imports six without declaring it
-    "six",
+    "zigzag-dse==3.10.0",
     "cerberus",
     "ortools>=9.15",
     "pydantic>=2.0,<2.12",
@@ -60,6 +58,29 @@ exact = ["islpy"]
 # torch.export frontend (stream/frontends/torch_export.py). Optional: the conversion is torch-free and
 # unit-tested without it; torch is only needed to lower a real ExportedProgram. Heavy, so opt-in.
 torch = ["torch>=2.4"]
+# AccelForge core-cost backend (stream/stages/estimation/accelforge/). AccelForge itself cannot be listed: its own
+# requirements include hwcomponents-cacti (HP CACTI licence, no sale for compensation), -neurosim (CC BY-NC 4.0) and
+# -library (needs both), none of which the backend uses. This extra lists what AccelForge imports; AccelForge itself
+# is installed with --no-deps (docs/source/accelforge.md).
+accelforge = [
+    "numpy>=2.2.0",
+    "pandas>=2.2.0",
+    "tqdm>=4.67.0",
+    "pydantic_core>=2.33.0",
+    "ruamel.yaml>=0.18.0",
+    "islpy>=2025",
+    "jinja2>=3.1.0",
+    "sympy>=1.14.0",
+    "symengine>=0.14.0",
+    "numba>=0.61.2",
+    "matplotlib>=3.10.0",
+    "plotly>=6.1.0",
+    "pydot>=4.0.0",
+    "platformdirs>=4.3.0",
+    "joblib>=1.5.1",
+    "requests>=2.33.1",
+    "hwcomponents==1.0.114",
+]
 dev = ["bumpver", "pip-tools", "build", "twine", "pre-commit", "pytest", "pytest-timeout", "hypothesis"]
 # The AIE codegen dialects (xdsl-aie, snax-mlir) cannot be an extra: they are direct-reference
 # (git) installs that PyPI forbids in package metadata. Install them after `pip install stream-dse`
@@ -89,6 +110,8 @@ timing = "stream.profiling:TimingInstrumentation"
 [project.entry-points."stream.core_cost_backends"]
 aie = "stream.stages.estimation.core_cost_backends:AIE_BACKEND"
 zigzag = "stream.stages.estimation.core_cost_backends:ZIGZAG_BACKEND"
+# Never chosen by the priority rule (priority -10): SolveOptions(stage_options={"core_cost_backend": "accelforge"}).
+accelforge = "stream.stages.estimation.accelforge.backend:ACCELFORGE_BACKEND"
 
 # Code generation backends: the entry-point name is the backend's `name`, its object a CodegenBackend
 # that `claims` the accelerators it emits code for and returns the per-group codegen `stage()`.
@@ -125,7 +148,7 @@ generic = "stream.stages.generation.mapping_generators:GENERIC_MAPPING"
 Homepage = "https://github.com/KULeuven-MICAS/stream"
 
 [tool.bumpver]
-current_version = "2.2.0"
+current_version = "2.3.0"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true

stream_dse-2.3.0/stream/__init__.py

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

{stream_dse-2.2.0 → stream_dse-2.3.0}/stream/opt/allocation/constraint_optimization/families/traffic.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Any
 
 from stream.hardware.ports import READ, WRITE, Port, PortKey
 from stream.opt.allocation.constraint_optimization.utils import active_fraction, get_active_latency
-from stream.stages.estimation.core_cost_backends import CoreCostBackend, port_traffic, select_backend
+from stream.stages.estimation.core_cost_backends import discover_backends, entry_backend, port_traffic
 from stream.workload.workload import ComputationNode, InEdge, TransferNode
 
 if TYPE_CHECKING:
@@ -124,13 +124,13 @@ def node_traffic(ctx: FormulationContext) -> list[NodeTraffic]:
     """The top-level port traffic of each node from its cost backend, on each core it runs on, at a port of the
     memory that core holds the operand in."""
     traffic: list[NodeTraffic] = []
-    backends: dict[Core, CoreCostBackend] = {}
+    backends = discover_backends()
     accelerator = ctx.space.accelerator
     for node in ctx.space.ssc_nodes:
         fraction = active_fraction(node, ctx.space.ssis)
         for core in placed_cores(ctx, node):
-            backend = backends.setdefault(core, select_backend(core))
-            for operand, direction, bits in port_traffic(backend, ctx.space.cost_lut.get_cost(node, core)):
+            entry = ctx.space.cost_lut.get_cost(node, core)
+            for operand, direction, bits in port_traffic(entry_backend(entry, core, backends), entry):
                 port = accelerator.ports.port_for(core, direction, operand, accelerator.memory_holding(core, operand))
                 if port is not None:
                     traffic.append(NodeTraffic(port, bits * fraction, ctx.space.slot_of[node]))

{stream_dse-2.2.0 → stream_dse-2.3.0}/stream/opt/allocation/constraint_optimization/layouts.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 
 from stream.cost_model.layout import Layout, Rate, transfer_stream
 from stream.hardware.ports import READ, WRITE
-from stream.stages.estimation.core_cost_backends import contiguous_axes, select_backend
+from stream.stages.estimation.core_cost_backends import contiguous_axes, entry_backend
 from stream.workload.workload import ComputationNode, InEdge, OutEdge, Tensor, TransferNode
 
 if TYPE_CHECKING:
@@ -68,7 +68,8 @@ class CopyLayouts:
         if (found := self._needs.get((node, index))) is None:
             found = frozenset()
             for core in self.space.cost_lut.get_cores(node):
-                axes = contiguous_axes(select_backend(core), self.space.cost_lut.get_cost(node, core))
+                entry = self.space.cost_lut.get_cost(node, core)
+                axes = contiguous_axes(entry_backend(entry, core), entry)
                 if axes:
                     found = axes[index]
                     break

stream_dse-2.3.0/stream/stages/estimation/accelforge/__init__.py

@@ -0,0 +1 @@
+"""AccelForge as an optional core-cost backend: Stream nodes as Einsums and ZigZag cores as arches."""

stream_dse-2.3.0/stream/stages/estimation/accelforge/arch.py

@@ -0,0 +1,140 @@
+"""ZigZag compute cores as AccelForge arches, with Stream's own energies and a 1 Hz clock so AccelForge's seconds are
+Stream's cycles; a memory operand maps to a rename (``I1``: ``input``, ``I2``: ``weight``, ``O``: ``output``). See
+``docs/source/accelforge.md`` for what does not carry over."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+
+import stream.stages.estimation.accelforge.library  # noqa: F401
+
+# isort: split
+from accelforge import Spec
+from accelforge.frontend.arch import Action, Arch, Compute, Container, Memory, Spatial, TensorHolderAction, Tensors
+from stream.datatypes import ELEMENT_BITS
+from stream.stages.estimation.accelforge.tree import (
+    CLOCK_HZ,
+    COMPUTE,
+    PJ,
+    UNBOUNDED_SIZE_BITS,
+    Port,
+    component_name,
+    depth,
+    layout,
+    one_value_periods,
+    ports,
+    zigzag_core,
+)
+from stream.stages.estimation.accelforge.workload import NOTHING, PARTIAL_SUMS, ROLE_OF_OPERAND
+
+if TYPE_CHECKING:
+    from zigzag.hardware.architecture.memory_level import MemoryLevel
+
+    from accelforge.frontend.workload import Workload
+    from stream.hardware.architecture.backends import ZigZagCoreBackend
+    from stream.hardware.architecture.core import Core
+
+ROLES = " | ".join(ROLE_OF_OPERAND.values())
+
+
+def explicit_spec(arch: Arch, workload: Workload) -> Spec:
+    """A spec of ``arch`` and ``workload`` that uses only the arch's explicit values, never a component model."""
+    spec = Spec(arch=arch, workload=workload)
+    spec.config.component_models = []
+    spec.config.use_installed_component_models = False
+    return spec
+
+
+def core_to_arch(core: Core, *, free_memory_order: bool = False) -> Arch:
+    """The AccelForge arch of a ZigZag compute core: memories outermost first, a fanout per array dimension below the
+    memories serving it, a MAC compute leaf. An operand's top memory is unbounded, as ZigZag's LOMA treats it;
+    ``free_memory_order`` lets different tensors' storage nest in any order, as ZigZag does."""
+    zigzag = zigzag_core(core)
+    array = zigzag.operational_array
+    dims, order, placed = layout(zigzag)
+    accumulator = (getattr(core, "operand_precision", None) or {}).get("accumulator")
+    nodes: list[Memory | Container | Compute] = []
+    memories: list[Memory] = []  # root first
+    for fanouts_above in range(len(order) + 1):
+        for level in (level for level in placed if depth(level, order) == fanouts_above):
+            copies = math.prod(size for dim, size in order[:fanouts_above] if dim in level.served_dimensions)
+            units = math.prod(size for dim, size in dims if dim in level.served_dimensions)
+            memory = _memory(zigzag, level, copies, units, accumulator)
+            memory.tensors.force_memory_hierarchy_order = not free_memory_order
+            nodes.append(memory)
+            memories.append(memory)
+        if fanouts_above < len(order):
+            nodes.append(_fanout(*order[fanouts_above]))
+    outermost = memories[0]  # it keeps every tensor no rename names too, such as a third input
+    outermost.tensors.keep = f"{outermost.tensors.keep} | ~({ROLES})"
+    nodes.append(_compute(COMPUTE, array.unit.energy_cost * PJ, CLOCK_HZ))
+    return Arch(nodes=nodes)
+
+
+def _memory(zigzag: ZigZagCoreBackend, level: MemoryLevel, copies: int, units: int, accumulator: str | None) -> Memory:
+    """A memory serving ``units`` array units per instance, ``copies`` times over dimensions it should serve."""
+    hierarchy = zigzag.memory_hierarchy
+    operands = [str(operand) for operand in level.operands]
+    tops = {str(op) for op in level.operands if hierarchy.get_memory_levels(op)[-1] is level}
+    instance = level.memory_instance
+    read, write, separate = ports(level, instance.r_cost, instance.w_cost)
+    size = math.inf if tops or instance.size >= UNBOUNDED_SIZE_BITS else instance.size
+    if copies > 1:
+        size = size // copies if math.isfinite(size) else size
+        read, write = (
+            Port(p.bits_per_action, p.pj_per_action, p.actions_per_cycle / copies, p.word_bits) for p in (read, write)
+        )
+    bits_per_value = {}
+    if accumulator and "O" in operands and "O" not in tops:
+        bits_per_value = {PARTIAL_SUMS: ELEMENT_BITS[accumulator]}
+    roles = [ROLE_OF_OPERAND[op] for op in operands]
+    innermost = {str(op) for op in level.operands if hierarchy.get_memory_levels(op)[0] is level}
+    one_value = [ROLE_OF_OPERAND[op] for op in operands if units == 1 and op in innermost]
+    partial_sum_bits = bits_per_value.get(PARTIAL_SUMS)
+    return Memory(
+        name=component_name(level.name),
+        size=size,
+        leak_power=0,
+        area=0,
+        separate_read_write_ports=separate,
+        bits_per_value=bits_per_value,
+        actions=[
+            _memory_action(name, port, *one_value_periods(port, roles, one_value, partial_sum_bits))
+            for name, port in (("read", read), ("write", write))
+        ],
+        tensors=Tensors(
+            keep=" | ".join(roles) or NOTHING,
+            may_keep=NOTHING,
+        ),
+    )
+
+
+def _memory_action(
+    name: str, port: Port, values_per_action: Mapping[str, str] | None = None, throughput_scale: str | float = 1
+) -> TensorHolderAction:
+    return TensorHolderAction(
+        name=name,
+        energy=port.pj_per_action * PJ,
+        throughput=port.actions_per_cycle * CLOCK_HZ,
+        throughput_scale=throughput_scale,
+        latency=0,
+        bits_per_action=port.bits_per_action,
+        values_per_action=dict(values_per_action or {}),
+    )
+
+
+def _fanout(dim: object, size: int) -> Container:
+    """A fanout of ``size`` along the operational-array dimension ``dim``."""
+    spatial = Spatial(name=str(dim), fanout=size)
+    return Container(name=f"array_{dim}", spatial=[spatial])
+
+
+def _compute(name: str, energy_j: float, throughput: float) -> Compute:
+    return Compute(
+        name=name,
+        leak_power=0,
+        area=0,
+        actions=[Action(name="compute", energy=energy_j, throughput=throughput, latency=0)],
+    )

stream_dse-2.3.0/stream/stages/estimation/accelforge/backend.py

@@ -0,0 +1,220 @@
+"""The ``accelforge`` core-cost backend: AccelForge's single-Einsum mapper costs a node on a ZigZag compute core at the
+extent and with the work per point Stream's ZigZag estimator costs it. At priority -10 it is chosen only by name, with
+the ``core_cost_backend`` stage option; ``core_cost_options["accelforge"]`` gives it :class:`AccelForgeOptions`. See
+``docs/source/accelforge.md``."""
+
+from __future__ import annotations
+
+import dataclasses
+import functools
+import importlib.metadata
+import importlib.util
+import logging
+import math
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from xdsl.ir.affine import AffineDimExpr
+
+from stream.cost_model.core_cost import CoreCostEntry
+from stream.datatypes import ELEMENT_BITS
+from stream.hardware.ports import OUTPUT, READ_BY_DATAPATH, WRITE_BY_DATAPATH, input_role
+from stream.stages.estimation.accelforge.tree import COMPUTE, PJ, zigzag_core
+from stream.stages.estimation.accelforge.workload import (
+    ZIGZAG_INPUTS,
+    UnsupportedConversion,
+    describe,
+    tensor_name,
+)
+from stream.stages.estimation.core_cost_backends import ZIGZAG_BACKEND
+from stream.workload.utils import is_mac_operator_type, operand_inputs
+
+if TYPE_CHECKING:
+    from stream.hardware.architecture.core import Core
+    from stream.stages.estimation.core_cost_backends import ContiguousAxes, CoreCostContext, PortTraffic
+    from stream.stages.estimation.zigzag_cost_estimator import ZigZagCostEstimator
+    from stream.workload.node import ComputationNode
+
+logger = logging.getLogger(__name__)
+
+NAME = "accelforge"
+MODEL_REVISION = 1
+"""Bumped whenever a change here or in the converters changes what an entry holds, so cached entries are recomputed."""
+
+
+class AccelForgeEstimationError(RuntimeError):
+    """AccelForge could not cost a node it can express on a core it claims."""
+
+
+@dataclass(frozen=True)
+class AccelForgeOptions:
+    """``memory_order``: ``free`` (falling back to ``forced`` where AccelForge rejects its own template) or ``forced``;
+    ``imperfect_spatial_loops``: let a fanout unroll part of a dim it does not divide."""
+
+    memory_order: str = "free"
+    imperfect_spatial_loops: bool = False
+
+    @classmethod
+    def parse(cls, options: Mapping[str, Any]) -> AccelForgeOptions:
+        try:
+            parsed = cls(**options)
+        except TypeError as error:
+            raise ValueError(f"core_cost_options[{NAME!r}]: {error}") from None
+        if parsed.memory_order not in ("free", "forced"):
+            raise ValueError(f"core_cost_options[{NAME!r}]: memory_order must be 'free' or 'forced'")
+        return parsed
+
+
+@dataclass(frozen=True)
+class MappedNode:
+    """AccelForge's best mapping of a node, in its units (cycles, J, actions), and how the search went."""
+
+    latency: float
+    energy_j: float
+    actions: Mapping[tuple[str, str, str], float]
+    """Action counts by (component, tensor, action); compute has tensor ``"None"``."""
+    bits_per_action: Mapping[tuple[str, str], float]
+    spatial_unrolling: Mapping[int, int]
+    temporal_cycles: int
+    top_storage: Mapping[str, str]
+    """Per tensor, the outermost component storing it in the mapping."""
+    units: int
+    mapping: tuple[str, ...]
+    memory_order: str
+    fallback: str | None
+    wall_s: float
+
+
+@functools.cache
+def accelforge_installed() -> bool:
+    """Whether accelforge can be imported, found without importing it."""
+    return importlib.util.find_spec("accelforge") is not None
+
+
+class AccelForgeBackend:
+    """Claims the ZigZag compute cores the arch converter accepts, when accelforge is installed."""
+
+    name = NAME
+    priority = -10
+
+    def claims(self, core: Core) -> bool:
+        if not accelforge_installed():
+            return False
+        try:
+            zigzag_core(core)
+        except UnsupportedConversion:
+            return False
+        return True
+
+    def make(self, context: CoreCostContext) -> AccelForgeEstimator:
+        options = AccelForgeOptions.parse(context.core_cost_options.get(NAME, {}))
+        return AccelForgeEstimator(ZIGZAG_BACKEND.make(context), options)
+
+    def cache_identity(self, options: Mapping[str, Any]) -> dict[str, Any]:
+        """The options, the converters' revision and AccelForge's version."""
+        version = importlib.metadata.version(NAME) if accelforge_installed() else None
+        return {**dataclasses.asdict(AccelForgeOptions.parse(options)), "model_revision": MODEL_REVISION, NAME: version}
+
+    def port_traffic(self, entry: CoreCostEntry) -> PortTraffic:
+        return tuple(entry.metadata.get("port_traffic", ()))
+
+    def contiguous_axes(self, entry: CoreCostEntry) -> ContiguousAxes:
+        """Per operand, the axes AccelForge's spatial loops unroll widest over the array, as ZigZag's rule reads its
+        own spatial mapping."""
+        unrolled: dict[int, int] = entry.metadata.get("spatial_unrolling", {})
+        if entry.layer is None:
+            return ()
+        needs: list[frozenset[int]] = []
+        for access in entry.layer.operand_mapping:
+            factors = {
+                axis: unrolled.get(result.position, 1)
+                for axis, result in enumerate(access.results)
+                if isinstance(result, AffineDimExpr)
+            }
+            widest = max(factors.values(), default=1)
+            needs.append(frozenset(axis for axis, f in factors.items() if f == widest and f > 1))
+        return tuple(needs)
+
+
+@dataclass
+class AccelForgeEstimator:
+    zigzag: ZigZagCostEstimator
+    """The run's ZigZag estimator: it sizes the nodes and costs those no Einsum can express."""
+    options: AccelForgeOptions
+
+    def estimate(self, node: ComputationNode, core: Core) -> CoreCostEntry:
+        """AccelForge's cost of ``node`` on ``core``; ZigZag's, recording why, for a node no Einsum can express."""
+        try:
+            einsum = describe(node, tuple(self.zigzag.create_layer_dim_sizes(node).data.values()))
+        except UnsupportedConversion as refusal:
+            logger.warning(
+                "AccelForge cannot express %s, so ZigZag costs it on core %s: %s", node.name, core.id, refusal
+            )
+            entry = self.zigzag.estimate(node, core)
+            return dataclasses.replace(entry, metadata={**entry.metadata, "accelforge_refused": str(refusal)})
+        from stream.stages.estimation.accelforge.mapper import map_node  # noqa: PLC0415 -- accelforge is optional
+
+        try:
+            mapped = map_node(einsum, core, self.options.memory_order, self.options.imperfect_spatial_loops)
+        except Exception as error:
+            raise AccelForgeEstimationError(
+                f"AccelForge could not cost node {node.name} on core {core.id} ({core.core_type}): "
+                f"{type(error).__name__}: {error}"
+            ) from error
+        return self.entry(node, core, mapped)
+
+    def entry(self, node: ComputationNode, core: Core, mapped: MappedNode) -> CoreCostEntry:
+        """The entry of ``mapped``, with each point of ``node`` costing the operations and cycles of the operators it
+        expands into, as Stream's ZigZag estimator charges them."""
+        ops, cycles_per_point = self.zigzag.work_per_op(node)
+        macs = mapped.actions.get((COMPUTE, "None", "compute"), 0.0)
+        compute = mapped.temporal_cycles * cycles_per_point
+        metadata = {
+            "backend": NAME,
+            "mapping": mapped.mapping,
+            "mapper_wall_s": mapped.wall_s,
+            "memory_order": mapped.memory_order,
+            "spatial_unrolling": dict(mapped.spatial_unrolling),
+            "port_traffic": port_traffic(node, core, mapped),
+        }
+        if mapped.fallback:
+            metadata["memory_order_fallback"] = mapped.fallback
+        return CoreCostEntry(
+            energy_total=mapped.energy_j / PJ + macs * core.operational_array.unit.energy_cost * (ops - 1),
+            latency_total=max(mapped.latency, compute),
+            ideal_cycle=float(math.ceil(math.ceil(macs / mapped.units) * cycles_per_point)),
+            ideal_temporal_cycle=float(compute),
+            layer=node,
+            metadata=metadata,
+        )
+
+
+def port_traffic(node: ComputationNode, core: Core, mapped: MappedNode) -> PortTraffic:
+    """Bits each operand a ZigZag core serves moves between its top memory, its outermost storage in the mapping,
+    and the datapath below. Partial sums, which AccelForge keeps there at the output's precision, move at the core's
+    accumulator precision, as ZigZag prices them."""
+    operands = [(tensor, input_role(k)) for k, tensor in enumerate(operand_inputs(node)[:ZIGZAG_INPUTS], start=1)]
+    operands.append((node.outputs[0], OUTPUT))
+    accumulator = (getattr(core, "operand_precision", None) or {}).get("accumulator")
+    traffic: list[tuple[str, str, float]] = []
+    for tensor, role in operands:
+        name = tensor_name(tensor)
+        if (top := mapped.top_storage.get(name)) is None:
+            continue
+        reads, writes = (
+            mapped.actions.get((top, name, a), 0.0) * mapped.bits_per_action[top, a] for a in ("read", "write")
+        )
+        if role == OUTPUT and accumulator and is_mac_operator_type(node.type) and reads:
+            ratio = ELEMENT_BITS[accumulator] / tensor.operand_type.bitwidth
+            # Every partial sum read back was written by an earlier pass: those writes, not the last pass's, widen too
+            reads, writes = reads * ratio, writes + min(reads, writes) * (ratio - 1)
+        traffic.extend(
+            (role, direction, bits)
+            for direction, bits in ((READ_BY_DATAPATH, reads), (WRITE_BY_DATAPATH, writes))
+            if bits
+        )
+    return tuple(traffic)
+
+
+ACCELFORGE_BACKEND = AccelForgeBackend()

stream_dse-2.3.0/stream/stages/estimation/accelforge/library.py

@@ -0,0 +1,32 @@
+"""AccelForge, imported and run without changing the process: :func:`contained` undoes what its code does to the root
+logger (its dependency ``hwcomponents`` calls ``logging.basicConfig`` and its root-level ``logging.info`` calls add a
+handler), the warning filters and the environment. It searches in one process, so ties between equally good mappings
+break the same way every run. The modules that build or run AccelForge objects import this first."""
+
+import logging
+import os
+import warnings
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+
+@contextmanager
+def contained() -> Iterator[None]:
+    """Run AccelForge code, its own dependencies' deprecation warnings silenced, then restore the root logger's
+    handlers and level and remove the environment variables it set."""
+    handlers, level, environment = list(logging.root.handlers), logging.root.level, set(os.environ)
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", module=r"accelforge\.")
+        try:
+            yield
+        finally:
+            logging.root.handlers[:] = handlers
+            logging.root.setLevel(level)
+            for name in set(os.environ) - environment:
+                del os.environ[name]
+
+
+with contained():
+    from accelforge.util.parallel import set_n_parallel_jobs
+
+    set_n_parallel_jobs(1)