Turbo-Charged Mapper (TCM) for Accelerators

• Turbo-Charged Mapper (TCM) is a mapping framework for accelerator modeling that exhaustively searches tensor einsum mappings with dataplacement-aware pruning.
• It decomposes mapping into tile shapes, dataflow, and dataplacement, reducing the search space by up to 32 orders of magnitude with optimality-preserving pruning.
• The method’s efficiency, supported by formal optimality guarantees and significant speedups (up to 400×), enables precise evaluation of DNN workloads on complex accelerators.

Searching arXiv for the cited TCM-related papers to ground the article in the relevant literature. Turbo-Charged Mapper (TCM) is a mapper for accelerator modeling and evaluation that is designed to perform a full mapspace search and is guaranteed to find optimal mappings for deep neural network workloads expressed as tensor einsums on accelerators with a spatial array and a memory hierarchy (Gilbert et al., 16 Feb 2026). In this setting, a mapping specifies tile shapes, dataflow, and dataplacement, and the optimization objective is to minimize energy $E$, latency $D$, or the energy-delay product $EDP = E \cdot D$, subject to hardware resource, parallelization, and memory-hierarchy constraints (Gilbert et al., 16 Feb 2026). The defining methodological feature of TCM is the introduction of dataplacement as an explicit mapping concept and the use of exhaustive enumeration with optimality-preserving pruning, which reduces the search space by up to 32 orders of magnitude and makes full mapspace searches feasible in seconds to minutes for the evaluated workloads (Gilbert et al., 16 Feb 2026).

1. Problem formulation and mapping space

TCM addresses the DNN accelerator mapping problem for a workload expressed as tensor einsums and an accelerator architecture with a spatial array and a memory hierarchy. A mapping defines three components: tile shapes, meaning the sizes of tensor tiles along each rank and the number of tiles; dataflow, meaning the ordering of loops in the loop nest between memory levels and compute; and dataplacement, meaning the set and order of storage nodes indicating which tensor tiles reside at each memory level at any point in time (Gilbert et al., 16 Feb 2026).

The formal mapspace factorizes as

$|Mapspace| = |DP| \cdot |DF| \cdot |TS|.$

For large workloads such as GPT-3 attention QK on TPU-like accelerators, the reported typical cardinalities are $|DP| = 16$, $|DF| \approx 10^{15}$, and $|TS| \approx 10^{22}$ (Gilbert et al., 16 Feb 2026). The optimization objectives are to minimize energy $E$, latency $D$, or $EDP = E \cdot D$, under constraints that include on-chip memory capacities, per-level bandwidths, PE and MAC array counts, network capabilities, supported storage-node combinations per tensor and memory level, spatial factorization limits, utilization constraints, and ordering constraints in the memory hierarchy (Gilbert et al., 16 Feb 2026).

These definitions make clear that TCM does not treat accelerator mapping as a single combinatorial object. Instead, it decomposes the problem into structurally distinct dimensions. This decomposition is central to the later pruning rules, because it allows TCM to separate qualitative reuse choices from quantitative tile-size choices.

2. Dataplacement as the central abstraction

In TCM, dataflow is the loop ordering between any two storage nodes and determines the temporal or spatial traversal pattern. Dataplacement is a declarative specification of which tensor tiles are stored at each memory level and in what order storage nodes appear in the LoopTree; in that notation, storage nodes and their ordering encode dataplacement (Gilbert et al., 16 Feb 2026). Dataplacement determines qualitative properties of tiles—described as “what,” “where,” and “when”—and is independent of tile sizes, described as “how big” (Gilbert et al., 16 Feb 2026).

TCM uses dataplacement to augment and generalize dataflow in two specific ways. First, it explicitly sets reuse priority across tensors by positioning storage nodes higher or lower in the hierarchy, thereby exposing lifetimes and required tile shapes. Second, it enables pruning of dataflows and tile shapes by identifying which loops between a pair of storage nodes could provide reuse and which cannot, thereby separating qualitative reuse sources from quantitative tile sizes (Gilbert et al., 16 Feb 2026).

Two invariants follow from dataplacement. Invariant 1, lifetime monotonicity, states that higher storage nodes have same-or-longer lifetimes than lower ones. Invariant 2, shape monotonicity, states that higher storage nodes have same-or-larger tile shapes along ranks shared with tensors stored below (Gilbert et al., 16 Feb 2026). The GEMM example in the source material illustrates this with the dataplacement order “GLB keep A[m,k] above GLB keep B[k,n] above GLB keep Z[m,n],” where higher placement implies longer lifetime and more reuse for $D$0 than for $D$1 and $D$2 (Gilbert et al., 16 Feb 2026). The convolution example shows a special case involving a “partially relevant” loop directly under a storage node, which yields a line buffer for $D$3 and reduces $D$4 without harming reuse (Gilbert et al., 16 Feb 2026).

This suggests that dataplacement is not merely an implementation detail. Within TCM it functions as the organizing variable that determines which dataflows are equivalent, which loops are non-helpful, and which tile-shape choices are worth exploring.

3. Search procedure, pruning rules, and optimality

TCM performs a full, optimal mapspace search by exhaustively enumerating dataplacements, generating only Pareto-optimal dataflows given a dataplacement, currying the model into a tile-shape-only form, and exploring tile shapes with optimality-preserving pruning (Gilbert et al., 16 Feb 2026). The high-level flow is: enumerate all valid dataplacements obeying hardware constraints; for each dataplacement, generate non-redundant, Pareto-optimal dataflows; curry the model by symbolically compiling access-volume and usage expressions; and finally explore tile shapes one loop bound at a time with partial tile-shape pruning (Gilbert et al., 16 Feb 2026).

Three pruning mechanisms are central. The first is redundant dataflow pruning by equivalence. Loops that lie in the same slot between the same pair of storage nodes can be permuted without changing tile shapes or refetch counts, so only the choice of the single loop immediately under the upper storage node matters, with a special case for partially relevant loops (Gilbert et al., 16 Feb 2026). The second is non-helpful loop pruning by dominance. A loop is pruned if it either does not index into the tensor at the storage node below or indexes into the tensor at the storage node above; in either case it increases cost without increasing useful reuse (Gilbert et al., 16 Feb 2026). The third is partial tile-shape pruning. Criteria $D$5 are derived from the curried expressions and labeled “minimize,” “maximize,” or “cannot compare”; a partial choice dominates another if it is better on all comparable criteria and equal on all “cannot compare” criteria (Gilbert et al., 16 Feb 2026).

The source states the optimality argument in four parts. Dataplacement enumeration is complete within the chosen mapspace. Redundant dataflow pruning preserves equivalence classes. Non-helpful loop pruning removes loops that strictly increase cost without increasing reuse. Partial tile-shape pruning is constructed so that any pruned choice is strictly dominated for all completions of the unknown variables (Gilbert et al., 16 Feb 2026). Accordingly, the best surviving full mapping is optimal in the searched space.

The reported quantitative effect of this structure is substantial. For GPT-3 attention QK, $D$6 collapses to 1 choice per dataplacement after pruning for most slots, and partial tile-shape pruning alone provides up to seven orders of magnitude reduction (Gilbert et al., 16 Feb 2026). Combined, TCM reduces search size by up to 32 orders of magnitude and leaves at most approximately $D$7 non-pruned mappings even for $D$8 (Gilbert et al., 16 Feb 2026).

4. Cost model, architecture model, and compiled evaluation

TCM evaluates mappings with an energy and latency model compiled into sum-of-products and max expressions. The energy-delay product is

$D$9

The energy model across the hierarchy is

$EDP = E \cdot D$0

with memory energy at level $EDP = E \cdot D$1 given by

$EDP = E \cdot D$2

and total energy

$EDP = E \cdot D$3

where $EDP = E \cdot D$4 (Gilbert et al., 16 Feb 2026). In the curried form, for a storage node $EDP = E \cdot D$5 of tensor $EDP = E \cdot D$6 at level $EDP = E \cdot D$7,

$EDP = E \cdot D$8

$EDP = E \cdot D$9

$|Mapspace| = |DP| \cdot |DF| \cdot |TS|.$0

Latency is modeled per level as $|Mapspace| = |DP| \cdot |DF| \cdot |TS|.$1, with compute latency $|Mapspace| = |DP| \cdot |DF| \cdot |TS|.$2, and overall latency

$|Mapspace| = |DP| \cdot |DF| \cdot |TS|.$3

(Gilbert et al., 16 Feb 2026).

The hardware model targets spatial accelerators with hierarchical buffers and arrays, including TPU-V4i-like and NVDLA-like systems. It includes DRAM, GLB, local buffers, register files, MAC arrays with input multicast and output reduction networks, optional components such as quantization units and networks, and heterogeneous engines (Gilbert et al., 16 Feb 2026). Supported operations include GEMM, conv2d including depthwise, attention operators such as Q, K, V, QK, and AV, feed-forward GEMMs, and pointwise convolutions (Gilbert et al., 16 Feb 2026).

A further feature is currying. For each dataplacement and dataflow pair, TCM symbolically compiles a tile-shape-only model. The reported runtime behavior is that partial compilation occurs tens of times and accounts for less than $|Mapspace| = |DP| \cdot |DF| \cdot |TS|.$4 of runtime, whereas tile-shape evaluations occur millions of times and account for less than $|Mapspace| = |DP| \cdot |DF| \cdot |TS|.$5 of runtime (Gilbert et al., 16 Feb 2026). The curried model yields a $|Mapspace| = |DP| \cdot |DF| \cdot |TS|.$6 speedup relative to Timeloop C++ and a $|Mapspace| = |DP| \cdot |DF| \cdot |TS|.$7 speedup relative to a plain Python model (Gilbert et al., 16 Feb 2026).

A plausible implication is that TCM’s practical performance depends not only on pruning the discrete search space but also on reducing the marginal cost of each remaining candidate evaluation.

5. Empirical results and comparison with prior mappers

The evaluation covers GPT-3 6.7B decoder-layer workloads, including Q, K, V projections, attention QK and AV, output projection $|Mapspace| = |DP| \cdot |DF| \cdot |TS|.$8, and feedforward FFA and FFB, as well as MobileNetV3 depthwise and pointwise workloads (Gilbert et al., 16 Feb 2026). The hardware targets include a TPU-V4i-like architecture with a 128 MB GLB, 4 PEs, 4 MB local buffer per PE, and a $|Mapspace| = |DP| \cdot |DF| \cdot |TS|.$9 MAC array, and an NVDLA-like architecture with a 64 kB GLB and a $|DP| = 16$0 MAC array (Gilbert et al., 16 Feb 2026).

The reported pruning rates for GPT-3 workloads are between $|DP| = 16$1 for tile shape and $|DP| = 16$2 for dataflow, yielding overall reductions up to $|DP| = 16$3; across all evaluated einsums, the reduction range is $|DP| = 16$4 to $|DP| = 16$5, leaving $|DP| = 16$6 to $|DP| = 16$7 viable mappings (Gilbert et al., 16 Feb 2026). Runtime is reported as seconds to minutes, with the specific example of GPT-3 6.7B QK on TPU-V4i-like taking approximately $|DP| = 16$8 seconds (Gilbert et al., 16 Feb 2026).

The strongest comparative claim concerns optimality under equal or larger time budgets. For GPT-3 QK on TPU-V4i-like, with a TCM runtime budget $|DP| = 16$9 s, Timeloop random sampling yields best EDP $|DF| \approx 10^{15}$0 optimal at $|DF| \approx 10^{15}$1 and $|DF| \approx 10^{15}$2 optimal even after $|DF| \approx 10^{15}$3 (more than $|DF| \approx 10^{15}$4 hours); Timeloop+Hint yields $|DF| \approx 10^{15}$5 at $|DF| \approx 10^{15}$6 and $|DF| \approx 10^{15}$7 at $|DF| \approx 10^{15}$8; and LOMA yields $|DF| \approx 10^{15}$9 at $|TS| \approx 10^{22}$0 and $|TS| \approx 10^{22}$1 at $|TS| \approx 10^{22}$2, that is, $|TS| \approx 10^{22}$3 higher than optimal (Gilbert et al., 16 Feb 2026). TCM completes and returns the optimal mapping at $|TS| \approx 10^{22}$4 (Gilbert et al., 16 Feb 2026).

The comparison to prior work is framed in terms of search strategy, space decoupling, guarantees, and scalability. Prior mappers are described as relying on heuristics or metaheuristics such as random sampling, GA, Bayesian optimization, or MCMC, whereas TCM performs a full, optimal search with pruning that provably preserves optimality (Gilbert et al., 16 Feb 2026). The paper also states that prior approaches often center on dataflow alone and implicitly assume dataplacement, thereby missing “uneven” placements that give higher reuse to select tensors (Gilbert et al., 16 Feb 2026).

6. Scope, limitations, implementation, and terminological ambiguity

TCM searches mapping choices within a fixed workload and architecture. Algorithmic changes such as lowering transformations, fusion beyond what is modeled, or alternative computation graphs are outside scope (Gilbert et al., 16 Feb 2026). The method is designed for einsum-structured operators and assumes hierarchical memories with well-defined storage-node ordering; non-einsum operators, dynamic control flow, irregular sparsity, non-hierarchical memories, or highly dynamic NoC contention may require extensions (Gilbert et al., 16 Feb 2026). The source also notes that full-array utilization constraints are not universally optimal, and TCM keeps only optimal constraints implied by the objective and hardware limits (Gilbert et al., 16 Feb 2026).

Implementation availability is explicit: TCM is integrated into AccelForge and available at https://accelergy-project.github.io/accelforge/ (Gilbert et al., 16 Feb 2026). This places the method within a concrete software framework rather than as a purely analytical proposal.

The term “Turbo-Charged Mapper” is, however, not uniformly used across fields. In topological data analysis, “Parallel Mapper” studies a provably correct parallel algorithm for Mapper, and the accompanying technical narrative presents it as relevant to a hypothetical TCM goal of dramatically speeding up Mapper construction, while also stating that “Turbo-Charged Mapper (TCM)” is not cited or discussed in that paper (Hajij et al., 2017). In genomics, the TreQ-CG workflow is explicitly described as a Turbo‑Charged Mapper because it clusters redundant reads, maps one representative per cluster, and propagates mappings, reducing total processing to 11%–59% of baseline mapping time on human reads and yielding speed-ups up to approximately 8.9 with Stampy on human whole-genome sequencing (Mahmud et al., 2014). In communications, “Turbo-Charged Mapper” is used for a joint detector–demapper–decoder turbo receiver for coded DPSK in Markov–Middleton impulsive noise, with a reported 4.5 dB gain over a conventional MAP-based PSK-IN receiver and a gap of around 1 dB to theoretical bounds (Chen et al., 2024).

For accelerator modeling and evaluation, however, the formal and titled use of TCM denotes the 2026 mapper based on dataplacement-aware exhaustive search with optimality-preserving pruning (Gilbert et al., 16 Feb 2026). The broader acronym ambiguity is therefore a matter of nomenclature rather than method: the accelerator TCM is a specific optimization framework, whereas the other uses refer to unrelated attempts to “turbo-charge” mapping or demapping in different technical domains.