Slice-Orchestrated Distributed Execution

• Slice-orchestrated distributed execution is a paradigm that partitions computational resources into logical slices to optimize parallelism and minimize communication overhead.
• It systematically generates task graphs via index-based slicing, eliminating global data reshuffling and achieving communication volumes near theoretical lower bounds.
• The approach extends to various domains including edge-cloud and SDN, delivering adaptive resource allocation, significant speedups (2–16×), and cost savings up to 23%.

Slice-orchestrated distributed execution is a paradigm that systematically uses "slices"—logical subunits or partitionings of computational or physical resources—as fundamental building blocks for scalable, efficient distributed execution. The concept spans distributed matrix computation, edge-cloud orchestration, network resource slicing, distributed task-driven workflows, and dataflow systems, providing a unified abstraction for coordination, allocation, and communication in large-scale, heterogeneous computing environments. Slice orchestration couples logical partitioning with execution planning, enabling flexible resource sharing, minimizing communication/redeployment costs, and supporting workload-specific performance targets under various constraints.

1. Formal Slicing Abstractions for Distributed Computation

In distributed linear algebra and AI workloads, slicing denotes an index-based tiling or logical partitioning of input and output tensors or matrices across distributed processes. The universal one-sided algorithm for distributed matrix multiplication exemplifies this: matrices $A\in\mathbb{R}^{m\times k}$, $B\in\mathbb{R}^{k\times n}$, $C=AB$ are subdivided into tiles along each dimension to induce a 2D grid of slices per process. Formally, a slice of a matrix $M$ for row-range $R=[r_s,r_e)$ and column-range $S=[s_s,s_e)$ is $M[R,S]$, and overlapping tiles are selected using index arithmetic—i.e., a tile $M(i,j)$ is selected iff $$[i\cdot T_\text{row},(i{+}1)T_\text{row})\cap R\neq\emptyset$$ and $$[j\cdot T_\text{col},(j{+}1)T_\text{col})\cap S\neq\emptyset$$. This slicing abstraction supports arbitrary partitionings, including 1D/2D block, block-cyclic, row/column sharding, and replicated (1.5D/2.5D) layouts, with each slice computed and communicated independently (Brock et al., 10 Oct 2025).

A slice-orchestrated execution enumerates precisely those overlapping tiles necessary for each subprocess’s local computation, generating an explicit task graph or operations list. This method eliminates the need for global reshuffling/redistribution phases, as data movement is determined solely by the index overlap of slices.

2. Communication, Task Generation, and IR Lowering

Slice orchestration in distributed execution decouples logical task generation from underlying topology. Each process composes a list of local compute ops, asynchronous GETs, and, if necessary, one-sided accumulation (ATOMIC_ADD/remote_accumulate). The communication plan leverages one-sided PGAS (Partitioned Global Address Space) calls—such as SHMEM/NVSHMEM—ensuring symmetric-heap buffer transfers occur directly between worker memory spaces, with no need for collective operations (Brock et al., 10 Oct 2025).

Task graphs can be explicitly modeled as bipartite graphs with data and compute vertices, and dependencies are tracked to drive cost-model–guided execution. Scheduling can be performed either greedily or via exhaustive search for small problem parameters; in practice, direct execution with prefetching combined with asynchronous launch achieves nearly peak resource utilization.

Communication volume per process using slice-orchestrated enumeration matches theoretical lower bounds for classical distributed matrix multiplication:

• 2D stationary output ($C$) with no replication: $$V_\mathrm{comm} = \mathcal{O}( (mk + kn)/\sqrt{p} )$$
• 2.5D with replication factor $c$: $$V_\mathrm{comm} = \mathcal{O}( (mk+kn)/(c p^{1/2}) )$$

By strictly composing execution from local slices without global redistributions, slice orchestration automatically satisfies the optimality regimes of classical algorithms (Brock et al., 10 Oct 2025).

3. Slicing in Edge, Cloud, and Wireless Resource Management

The notion of a logical "slice" as a unit of orchestration underpins modern edge-cloud and wireless architectures. In distributed in-network computing (COIN), multi-access edge computing (MEC), and vehicular networks, resources are dynamically partitioned and assigned to "slices," each representing a class of service differentiated by latency, bandwidth, computational load, or reliability constraints.

For example, in hierarchical COIN-MEC architectures, resource management and optimal wireless offloading are decomposed into intra-slice, inter-slice, and offloading decision subproblems, each aligned with their respective control domains. Sophisticated learning-augmented models (e.g., DeepSets-based DeepSets-S) are used to infer near-optimal, permutation-equivariant allocation policies for each slice. These learning policies are trained offline on solutions derived from mixed-integer nonlinear programming and deployed for real-time, distributed inference, achieving allocation accuracies exceeding 95%, optimality within 6.1% of ground truth, and an 86.1% reduction in decision latency. The result is efficient distributed execution with resource isolation and minimal overhead (Rashid et al., 17 Nov 2025).

A similar two-stage slicing is realized in vehicular edge-cloud networks with the TAWS (Two-timescAle netWork Slicing) algorithm, where a central controller orchestrates large-timescale slice deployment/resource reservation via reinforcement learning, while local edge controllers perform small-timescale convex resource allocation per slice. This decoupling enables responsive execution under bursty, stochastic loads, with cost savings up to 23% relative to slice-oblivious heuristics (Wu et al., 2022).

4. Slicing as a Programming and Task-Orchestration Abstraction

Slice orchestration is applied within distributed task-based programming models, such as COMPSs and Dask, via mechanisms like SplIter (Barcelo et al., 2023). Rather than mapping one task per data block—which couples task and block granularities and incurs overheads at high concurrency—SplIter constructs "partitions" or "slices" as logical groups of pre-localized blocks on each worker. Iteration, dependency modeling, and scheduling are performed at the slice level, decoupling block size from task granularity. This transaction reduces the number of tasks to the order of the number of worker cores, thereby minimizing scheduler/invocation overhead. No data movement or reshaping is introduced; slicing operations query metadata to group blocks already co-located on each backend.

Empirical performance gains are substantial: a one-line API transition to SplIter delivers speedups of 2–16× on memory-bound, iterative, and compute-bound workloads, with lower overhead than intra-framework rechunking or block migration (Barcelo et al., 2023).

Framework	Baseline Time	+SplIter Time	Relative Speedup
COMPSs (histogram)	35 s	5 s	7×
Dask (histogram)	80 s	5 s	16×
COMPSs (k-Means)	280 s	30 s	≈9×
Dask (k-Means)	450 s	35 s	≈12×

Optimal slice counts align with the total available processing cores, maximizing locality and core utilization.

5. Functional and Application Slicing in Distributed SDN and Dataflow Systems

Slice-oriented orchestration generalizes beyond resource or data partitioning to encompass logical separation of functions or application components. Hydra, a distributed SDN controller architecture, demonstrates that functional slicing—partitioning along applications or event handlers, rather than only topology—enables the decoupling of latency-sensitive, compute-intensive, and real-time SDN functions. Placement of functional slices is optimized via multilevel graph partitioning, balancing resource constraints and inter-slice communication to minimize critical path latency, meet deadlines, and maintain responsiveness under scale (Chang et al., 2016).

This paradigm is also reflected in application-centric abstractions such as AppSlice, where each application is described as a tuple of compute and network requirements per function and overall end-to-end service constraints. The AppSlice runtime dynamically instantiates, monitors, and adapts resource allocations for each application slice (across edge, cloud, and 5G network resources), optimizing both placement and allocation via feedback-driven adaptive algorithms. The outcome is dynamic, SLA-compliant orchestration of distributed execution, maintaining application-level accuracy and resource efficiency under fluctuating workloads (Sankaradas et al., 2021).

6. Slicing in DNN Model Partitioning and Inference Distribution

In deep learning, slice orchestration manifests in model partitioning—explicitly selecting split points ("slices") within neural network graphs to partition workload between edge and server. The SLICER framework operationalizes this by (1) adaptively choosing the deepest admissible split point under memory/latency constraints and (2) applying a three-stage, training-free compression codec to intermediate features at the split: asymmetric top-K filtering, magnitude splitting, and adaptive bit quantization. This approach achieves deterministic control over traffic patterns, uplink bandwidth, and server utilization, while remaining model-agnostic and requiring no retraining. Empirically, uplink volumes are reduced by up to 10× and server GPU time by up to 4.4×, with minimal impact on accuracy (Sung et al., 3 Nov 2025).

Benchmark (Model)	Uplink Reduction	Server Time Reduction	Top-1 Accuracy Drop
ResNet-50	10×	—	0.07 pp
Llama2-7B	—	4.4×	<2 pp

The inference workflow for slice-orchestrated model execution thus separates compute across physical locations, with intermediate data transferred as compressed slices, enabling scalable, low-latency distributed inference.

7. General Principles and Implications

Slice-orchestrated distributed execution provides a principled foundation for unifying partitioning, orchestration, and execution across different distributed domains. Key properties include:

• Universal partitioning support: General slicing enables any problem partition (data, task, functional, network, or compute), obviating the need for per-topology/algorithm custom code.
• Locality and communication optimality: Scheduling is minimized to enumerated, strictly necessary communications; theoretical lower bounds for communication volume are achieved (Brock et al., 10 Oct 2025).
• Decoupled granularity control: Logical slices can be coarser than underlying data blocks or finer than application boundaries, matching task granularity with system resources (Barcelo et al., 2023).
• Adaptive resource utilization: Slice-level resource allocation and dynamic adjustment mechanisms ensure resource efficiency under time-varying load, with closed-loop coupling between performance and allocation (Sankaradas et al., 2021, Wu et al., 2022).
• Extensibility: The paradigm generalizes to edge-cloud-5G integration, functional decomposition in SDN, and training-free DNN serving.

A plausible implication is that as distributed systems become more heterogeneous and dynamic, slice-orchestrated execution will serve as a dominant abstraction for achieving both high resource utilization and SLA compliance across increasingly complex, multitenant, and geo-distributed architectures.