Task Mapping Optimization

• Task Mapping Optimization (TMO) is a family of assignment problems that allocates tasks to limited resources across domains like DNN accelerators, GPUs, and robotic systems.
• It employs various algorithmic paradigms such as online sampling, branch-and-bound mapspace search, and greedy remapping to optimize objectives like latency, energy, and throughput.
• TMO applications span heterogeneous computing, accelerator design, robotic sorting, and large-scale parallel systems, achieving measurable performance enhancements.

Task Mapping Optimization (TMO) denotes, in the cited literature, a family of optimization problems in which logical tasks, tensor iterations, processes, destination classes, or spatial activities are assigned to execution resources or spatial receptacles under explicit performance models. The objective varies by domain—minimizing slowest-PE completion time in NoC-based DNN accelerators, minimizing latency, energy, or energy-delay product in accelerator mapspaces, minimizing DAG makespan on heterogeneous systems, maximizing simulator-defined throughput in robotic sorting, or minimizing communication distance on parallel topologies—but the common structure is an assignment problem constrained by hardware, communication, and resource limits (Chen et al., 2024, Gilbert et al., 16 Feb 2026, Wilhelm et al., 27 Feb 2025, Zhang et al., 3 Oct 2025, Deveci et al., 2018).

1. Scope and terminology

In the cited work, the term task mapping is not restricted to one computational abstraction. In heterogeneous DAG scheduling, a mapping is a function $\phi: V \to P$ from tasks to processing units; in process mapping on supercomputers it is a placement of tasks or processes onto coordinates in a machine topology; in GPU tensor compilers it is a mapping from workers to ordered sequences of iteration-space tasks; and in robotic sorting it is a destination-to-chutes assignment encoded as a binary matrix (Wilhelm et al., 27 Feb 2025, Korndörfer et al., 2020, Ding et al., 2022, Zhang et al., 3 Oct 2025).

Domain	Mapping object	Representative formulation
NoC-based DNN accelerator	Uneven task counts across PEs	Minimize slowest-PE finish time (Chen et al., 2024)
Accelerator mapspace search	Full mapping $(dp, df, ts)$	Minimize $L$, $E$, or $E \cdot L$ (Gilbert et al., 16 Feb 2026)
Heterogeneous DAG execution	Task-to-device assignment $\phi$	Minimize makespan $C(\phi)$ (Wilhelm et al., 27 Feb 2025)
GPU tensor programming	Worker-to-task-sequence mapping $f$ and layouts	Minimize end-to-end latency (Ding et al., 2022, Zhang et al., 22 Apr 2025)
Robotic sorting systems	Destination-to-chutes mapping $\theta$	Maximize throughput $F(\theta)$ (Zhang et al., 3 Oct 2025)
Parallel computers	Process-to-processor placement $(dp, df, ts)$0 or $(dp, df, ts)$1	Minimize communication cost or dilation (Deveci et al., 2018, Schulz et al., 2 Apr 2025, Korndörfer et al., 2020)

The term task is therefore domain-relative. In Hidet, the iteration domain is an $(dp, df, ts)$2-dimensional integer grid $(dp, df, ts)$3, and a task mapping is a function $(dp, df, ts)$4 assigning each worker an ordered list of tasks (Ding et al., 2022). In the robotic-sorting formulation, the mapping variable is instead a chute-assignment matrix $(dp, df, ts)$5 subject to coverage constraints over real destinations (Zhang et al., 3 Oct 2025). In the PDE-based robotic-ensemble formulation, the “mapping task” is the identification of an unknown spatial coefficient $(dp, df, ts)$6 in an advection-diffusion-reaction model rather than placement on processors (Elamvazhuthi et al., 2017). This suggests that TMO is better understood as an assignment-and-cost-model paradigm than as a single algorithmic template.

2. Canonical mathematical formulations

A recurrent formulation in hardware mapping minimizes the completion time of the bottleneck resource. Chen et al. define per-PE travel time as

$(dp, df, ts)$7

and then solve

$(dp, df, ts)$8

Under equalized finish time $(dp, df, ts)$9, the closed-form assignment becomes

$L$0

so the ideal rule is $L$1 (Chen et al., 2024).

In heterogeneous DAG mapping, the objective is makespan minimization under computation and communication delays. With $L$2 defined as the maximum over predecessors and $L$3, the global objective is

$L$4

A related MILP-based model expresses per-task execution time on device $L$5 as

$L$6

and defines device-local compute and communication aggregates whose maximum yields the makespan surrogate $L$7 (Wilhelm et al., 27 Feb 2025, Wilhelm et al., 2022).

In topology-aware process mapping, the dominant objective is weighted communication distance. One formulation minimizes

$L$8

with $L$9 taken as mesh or torus distance; another uses

$E$0

under an $E$1-balance constraint on block weights; and the 3-D-topology workflow measures quality through “dilation”,

$E$2

These objectives make locality explicit and separate mapping quality from pure workload balance (Deveci et al., 2018, Schulz et al., 2 Apr 2025, Korndörfer et al., 2020).

In accelerator mapspace search, the mapping itself is a composite object. TCM defines a full mapping as $E$3, where dataplacement $E$4 specifies which tensor tiles are held at which memory levels and in what order, dataflow $E$5 is a loop ordering consistent with $E$6, and tile shapes $E$7 choose tiling factors. The optimized objectives are latency $E$8, energy $E$9, or energy-delay product $E \cdot L$0, with

$E \cdot L$1

and

$E \cdot L$2

This formulation makes data reuse, bandwidth limits, and memory capacity first-class constraints (Gilbert et al., 16 Feb 2026).

3. Algorithmic paradigms

One major TMO paradigm is measurement-driven online balancing. In the NoC-based DNN accelerator method, exact $E \cdot L$3 would require a full profiling run, so the authors introduce a sampling window of $E \cdot L$4 tasks per PE. The measured average

$E \cdot L$5

is then substituted into

$E \cdot L$6

with fallback to row-major mapping when $E \cdot L$7 (Chen et al., 2024). The distinctive feature is not exhaustive search but ratio correction using dynamic congestion information.

A second paradigm is exact or guaranteed-optimal mapspace search by aggressive pruning. TCM introduces “dataplacement” as a new concept and then eliminates redundant and suboptimal mappings through redundant-dataflow pruning, non-helpful-loop pruning, tile-shape pruning, and partial-tile-shape pruning. The high-level algorithm is branch and bound over dataplacements, nonredundant dataflows, and divisibility-consistent tile shapes, with model currying so that $E \cdot L$8 are symbolically resolved once and tile shapes are then evaluated numerically at high speed (Gilbert et al., 16 Feb 2026).

A third paradigm is decomposition-based greedy remapping for large heterogeneous DAGs. The series-parallel method first constructs a forest of decomposition trees for general DAGs in $E \cdot L$9 time and $\phi$0 space, then forms a candidate set $\phi$1 containing single-task subgraphs and decomposition-induced subgraphs, and finally performs globally evaluated best-improvement remapping. Each candidate move is assessed by recomputing the deterministic makespan model $\phi$2 in $\phi$3 time, and the greedy loop terminates because $\phi$4 strictly decreases (Wilhelm et al., 27 Feb 2025).

A fourth paradigm appears in compiler-oriented TMO, where the mapping problem is embedded into program synthesis. In Hidet, task mappings are built from the atomic primitives $\phi$5 and $\phi$6 and their composition; this replaces a purely loop-oriented scheduling interface with explicit computation assignment and ordering (Ding et al., 2022). Hexcute goes further by converting task mapping and layout synthesis into a type-inference problem over thread-value layouts $\phi$7 and shared-memory layouts $\phi$8. Constraint propagation, anchor selection, and limited DFS enumeration over legal copy instructions together synthesize a mapping that is both functionally correct and latency-oriented (Zhang et al., 22 Apr 2025).

A fifth paradigm is hierarchical or geometric partitioning for communication minimization. Recursive geometric bisection simultaneously partitions the task graph and processor coordinate space; hierarchical multisection recursively partitions the communication graph according to a hardware hierarchy $\phi$9 and then assigns final blocks lexicographically to PEs. Both methods exploit structure in the topology rather than treating placement as an unstructured combinatorial search (Deveci et al., 2018, Schulz et al., 2 Apr 2025).

4. Major application domains

In heterogeneous computing systems, TMO is primarily a makespan-minimization problem over compute heterogeneity, communication costs, and occasionally streamability. The MILP framework for data-intensive heterogeneous systems models each logical task by input-memory, computation, and output-memory nodes, accounts for bus bandwidths through $C(\phi)$0, and incorporates parallelizable fractions $C(\phi)$1 and streamability factors $C(\phi)$2 for FPGA-style pipelines (Wilhelm et al., 2022). The series-parallel decomposition method targets CPUs, GPUs, FPGAs, and AI units, and explicitly emphasizes that streaming aspects of FPGAs are generally not considered by many prior task-mapping approaches (Wilhelm et al., 27 Feb 2025).

In accelerator modeling and tensor compilers, TMO becomes deeply entangled with the memory hierarchy and low-level execution semantics. TCM optimizes dataplacement, dataflow, and tile shapes for DNN accelerators; Hidet defines task mappings as programmable computation assignment and ordering; and Hexcute jointly synthesizes task mappings and memory layouts for copy, mma, elementwise, and reduce operators. In this subfield, the distinction between scheduling, placement, and layout is intentionally blurred, because the choice of thread-value layout or memory layout is itself part of the mapping decision (Gilbert et al., 16 Feb 2026, Ding et al., 2022, Zhang et al., 22 Apr 2025).

In robotic and physical systems, TMO acquires a spatial or logistical interpretation. In robotic sorting systems, the decision variable is a destination-to-chutes mapping $C(\phi)$3, and mapping quality is interdependent with robot target assignment, path planning, chute closures, and downstream human processing. The throughput objective is evaluated only through simulation, making the problem a black-box combinatorial optimization (Zhang et al., 3 Oct 2025). In the PDE-based robotic-ensemble formulation of Elamvazhuthi et al., the mapping stage is a convex inverse problem over the relaxed admissible set

$C(\phi)$4

followed by a bilinear optimal control problem for coverage; this broadens TMO from resource placement to spatial inference and control (Elamvazhuthi et al., 2017).

In large-scale parallel computing, TMO is frequently called process mapping. The central goal is to place frequently communicating tasks near one another in mesh, torus, or hierarchical topologies, with explicit concern for sparse allocations, wrap-around effects, bisection bandwidth, and link congestion heuristics (Deveci et al., 2018). Shared-memory hierarchical multisection emphasizes homogeneous hardware hierarchies and $C(\phi)$5-balanced partitions, while the 3-D-topology workflow treats mapping as an explicit optimization stage between trace extraction and trace-driven simulation (Schulz et al., 2 Apr 2025, Korndörfer et al., 2020).

5. Evaluation criteria and empirical findings

Reported gains are strongly domain-specific, because the evaluation targets differ: latency, energy, EDP, throughput, makespan improvement $C(\phi)$6, dilation, communication time, or end-to-end runtime. The following summary therefore compares methods only within their native formulations.

Representative system	Reported metric	Reported outcome
Travel time-based NoC mapping (Chen et al., 2024)	Single-layer and full-network speedup	Up to 12.1%; 10.37% vs. row-major; 8.17% with sampling window 10
TCM (Gilbert et al., 16 Feb 2026)	Search-space reduction and optimality	Up to 32 orders of magnitude; feasible runtime $C(\phi)$7 min; prior works 21% higher EDP even at $C(\phi)$8 runtime
SP-decomposition TMO (Wilhelm et al., 27 Feb 2025)	Makespan improvement and runtime	$C(\phi)$9–25% on SP graphs; milliseconds instead of seconds/minutes
Hidet (Ding et al., 2022)	End-to-end inference speed and tuning	Up to 1.48x, 1.22x on average; tuning time reduced by 20x and 11x
Hexcute (Zhang et al., 22 Apr 2025)	Mixed-type kernel and end-to-end speedup	1.7-11.28$f$0; up to 2.91$f$1
WAANSO (Wang et al., 2020)	Energy and performance	19% energy efficiency improvement; 65.86% performance improvement

Additional studies reinforce the importance of topology-aware placement. Recursive geometric and ordering strategies on parallel computers reduced communication time up to 75% relative to MiniGhost’s default mapping on 128K cores of a Cray XK7 with sparse allocation, and reduced communication time up to 31% for E3SM/HOMME on 32K cores of an IBM BlueGene/Q with contiguous allocation (Deveci et al., 2018). In the 3-D-topology study, CG on torus reduced MPI point-to-point cost from approximately $f$2 s with sweep to approximately $f$3 s with Peano or PaCMap, while AMG and LULESH showed little end-to-end sensitivity because non-blocking MPI hid communication latency (Korndörfer et al., 2020).

Robotic sorting provides a different empirical profile. In Setup 3, throughput was $f$4 for Cluster Greedy, $f$5 for Min-dist Greedy, $f$6 for EA, and $f$7 for EA w/ Greedy init, with corresponding recirculation rates of $f$8, $f$9, $\theta$0, and $\theta$1 (Zhang et al., 3 Oct 2025). The key point is that mapping quality in this setting is measured operationally, not through a closed-form surrogate.

6. Limitations, misconceptions, and emerging directions

A recurrent misconception is that “balanced” mapping means equal task counts or distance-based placement. The travel-time formulation shows the opposite: row-major mapping had unevenness $\theta$2 end-to-end, distance-based mapping increased imbalance to $\theta$3, while travel-time mapping reduced $\theta$4 to $\theta$5 in the post-run case and $\theta$6 with sampling window $\theta$7 (Chen et al., 2024). Uneven allocation can therefore be the correct solution when per-resource service times differ.

Another misconception is that communication-cost proxies are universally predictive. The 3-D-topology study found that pre-simulation dilation strongly correlates with simulated MPI and network-model times on homogeneous mesh and torus systems, but on the heterogeneous HAEC Box it must be augmented to account for wireless versus optical hops (Korndörfer et al., 2020). Likewise, the shared-memory hierarchical process-mapping model explicitly notes that $\theta$8 ignores network congestion and contention (Schulz et al., 2 Apr 2025). This suggests that the fidelity of the cost model, rather than the optimizer alone, often determines whether a mapping transfers to execution.

Many TMO methods are explicitly static. The series-parallel decomposition approach is “strictly static—dynamic or runtime variability is not handled,” and the heterogeneous-system MILPs are positioned for early exploration, compile-time scheduling, or evaluation of heuristics rather than online adaptation (Wilhelm et al., 27 Feb 2025, Wilhelm et al., 2022). In RSS, the mapping is also static, and the authors note that jointly optimizing TMO with target assignment and MAPF remains open (Zhang et al., 3 Oct 2025). In black-box settings the evaluation cost can dominate the search itself: each RSS evaluation takes $\theta$9 seconds, and EA with $F(\theta)$0 evaluations runs in $F(\theta)$1 sec of simulation (Zhang et al., 3 Oct 2025).

A plausible implication is that TMO is moving toward richer notions of task relevance and semantic conditioning. An adjacent example is GaussLite, which conditions 3D Gaussian Splatting representation density on a natural-language task specification and allocates seeding density, gradient flow, and scaling by task relevance; however, the provided material explicitly states that the technical sections needed to extract the Task Mapping Optimization formulation were unavailable (Thomas et al., 29 Jun 2026). Within the available literature, the dominant trajectory is clearer: TMO increasingly integrates communication structure, memory hierarchy, decomposition structure, and executable cost models rather than treating assignment as a standalone combinatorial subroutine.