Sweep-Based Execution Methods

• Sweep-based execution is a method that processes tasks in ordered sweeps, exploiting acyclic dependency graphs to enhance memory efficiency and parallelism.
• It is applied in numerical PDE solvers, computational geometry, optimization, and multi-robot control, demonstrating improvements in scalability and resource management.
• Variants such as serial, parallel, external-memory, and hierarchical sweeps address challenges like cyclic dependencies and enable high-performance computation in large-scale systems.

Sweep-based execution refers to a family of algorithmic methodologies in which the computational workflow is cast as a series of ordered "sweeps" across a domain, data structure, or decomposed workspace. The primary motivation is to harness or impose a dependency structure—often acyclic and spatial or temporal in nature—to enable memory-efficient, order-optimal, parallel, or otherwise scalable computation. Architectures employing sweep-based execution are pervasive in numerical PDEs, optimization, computational geometry, statistical linear algebra, external-memory algorithms, stochastic simulation, and multi-robot coverage control.

1. Conceptual Foundations and General Principles

Sweep-based execution exploits the inherent partial ordering in a computational dependency graph, typically a Directed Acyclic Graph (DAG), to process tasks in a manner that minimizes idle time, redundant work, or resource contention. The sweep is most effective when:

• Each operation depends only on data from a localized "upwind" or causal neighborhood (finite stencils, adjacencies).
• The execution domain can be partitioned so that tasks within the sweep become ready sequentially as predecessor information is computed.
• The computation benefits from in-place updates, minimizes global synchronization, or exhibits locality in data movement.

Fundamental examples include:

• Discrete-ordinates transport sweeps for the Boltzmann equation (Adams et al., 2019, Peter et al., 2022, Vermaak et al., 2020, Haut et al., 2018)
• Plane-sweep and distribution-sweep methods in computational geometry (Trencséni et al., 2012, Ajwani et al., 2013)
• SOR/ILU preconditioners and direct solvers using multi-frontal sweeps on structured matrices (Tavakoli, 2010)
• The sweep operator in regression/ANOVA for blockwise Schur complements (James et al., 2024)
• Multi-agent sweep schedules in multi-robot coverage (Feng et al., 2023, Jamshidpey et al., 2024)

Key variants of sweep-based execution include serial (single-threaded), parallel with domain decomposition, external-memory (out-of-core), nested or hierarchical sweeping, randomized or adaptive sweep scheduling, and task-based distributed sweep management.

2. Sweep-Based Execution in PDEs and Scientific Computing

Structured and Semi-Structured Transport Sweeps

In solvers for the Sₙ Boltzmann equation and related transport PDEs, the computation of the angular flux is naturally lower-triangular after discretization, allowing a sequential (or pipelined parallel) sweep through the spatial cells for each angle and energy group. The main execution dependency is defined by the spatial upwind relation induced by the streaming operator.

For semi-structured grids partitioned into regular blocks, provably optimal parallel sweep schedules can be constructed. These schedules minimize pipeline-filling and draining idle stages, and when combined with optimal domain and task decomposition, enable parallel efficiency exceeding 60–70% at >106 ranks. The minimal stage count S_opt in 2D and 3D can be written as:

$$S_{\text{opt}} = N_{\text{tasks}} + (P_x + \delta_x - 2) + (P_y + \delta_y - 2) + \omega_z (P_z + \delta_z - 2)$$

where $P_u$ are partition counts, $\omega_u$ are overloads, and $\delta_u$ captures parity effects (Adams et al., 2019).

Curved Meshes and Cyclic Dependencies

On high-order meshes or when the sweep DAG exhibits cycles (e.g., due to mesh curvature or complex boundary conditions), the dependency graph is no longer acyclic. Sweep-based methods employ feedback arc set removal to break cycles—removing a minimal (weighted) set of edges and lagging their dependencies—and perform a forward sweep in the resulting topological order. Lagged updates are addressed by iterative correction (outer source iterations), with practical penalty being a modest increase in iteration count (Haut et al., 2018, Vermaak et al., 2020).

One-Sweep or Multi-Sweep IMEX Integrators

In stiff multiphysics contexts, sweep-based execution underpins semi-implicit-explicit (IMEX/SIMEX) time-integration schemes that guarantee one sweep per stage. For gray thermal radiative transfer, each Runge–Kutta stage consists of a single angular transport sweep (block lower triangular system solve), followed by a separate low-order (moment) solve, with nonlinear couplings frozen per stage—yielding stable, accurate integration with minimal sweeps (Southworth et al., 2024).

3. Sweep-Based Strategies in Computational Geometry and Data Analysis

Plane-Sweep and Distribution-Sweep

Plane-sweep algorithms operate by conceptually moving a hyperplane through the data space (often along the principal axis of the data, determined via PCA), incrementally building solutions (e.g., Delaunay triangulations) and offloading results that no longer require in-memory processing. The plane-sweep incremental approach provides an $O(n\log n + n\,f(d))$ runtime and $O(\delta)$ memory usage, where $\delta$ is the data "thickness" along the sweep direction. This methodology enables tractable out-of-core computations for hundreds of millions of points (Trencséni et al., 2012).

Distribution-sweep methods generalize by partitioning the computational domain into slabs (or higher-dimensional regions), performing parallel sweeps within each, coordinating via prefix/max operations to synchronize cross-boundary information. Parallel distribution sweeping achieves optimal PEM model I/O complexity and demonstrates superior cache and DRAM traffic efficiency relative to traditional plane-sweep or divide-and-conquer algorithms in both theory and practice (Ajwani et al., 2013).

4. Sweep-Based Execution in Optimization, Linear Algebra, and Statistical Computing

The Sweep Operator and Partial Inversion

The sweep operator is a specialized in-place matrix transformation for symmetric matrices, effecting a sequence of blockwise Schur complements (partial inversions) along designated pivots. Algebraically, the $i$-th sweep $S_i(A)$ transforms $A$ by updating all off-pivot entries according to the Schur complement relative to index $i$, sets the pivot to $-1/A_{ii}$, and preserves symmetry. Sweeping a set $K$ of indices corresponds to inverting the $K\times K$ block and updating the Schur complement on the complementary submatrix; a full sweep produces $-(A^{-1})$. The sweep operator is commutative and involutive on each index.

Sweep-based execution is fundamental in the efficient implementation of regression and ANOVA, as it enables incremental model updates, efficient submodel selection, and direct sums-of-squares partitioning without separate inversion or factorization steps (James et al., 2024).

5. Sweep-Based Execution in Stochastic Simulation and Control

Deterministic Sweep Markov Chains

In deterministic-sweep Markov chain Monte Carlo, the state updates proceed by cycling through $K$ transition kernels (e.g., coordinate-wise Gibbs, or block Gibbs), with each sweep consisting of $K$ ordered kernel applications. The sweep schedule introduces deterministic dependencies, improving mixing and enabling variance reduction via control variates and Poisson-equation-based estimators. Asymptotic variance of sweep-based estimators is provably lower than for random-scan orders, and optimal sweep-dependent control variate weights are computable via partial inverses (Moore–Penrose pseudo-inverse) of explicit moments (Berg et al., 2019).

Sweep-Based Scheduling for Multi-Robot Coverage

In multi-robot and swarm robotics, sweep-based execution is operationalized by defining a time-parameterized frontier and distributing agents along it so that as the sweep progresses, all workspace points are covered (e.g., for coverage, intrusion detection, or search). This entails solving for time-dependent robot trajectories subject to probabilistic sensing degradation and coverage constraints, often via reductions to max-flow/circulation with demands in DAGs that encode the generalized sweep frontiers. The reduction is computationally tractable and can scale to environments with $>$10⁵ vertices, yielding exact and optimal allocations (Feng et al., 2023, Jamshidpey et al., 2024).

6. Task-Based and Hierarchical Sweep-Based Execution

Hierarchical and nested sweep strategies further extend sweep-based execution.

• In external-memory decision diagram manipulation, nested sweeping coordinates multiple sweeps (outer and inner) to support multi-variable quantification and relational product operations—avoiding random I/O by streaming arcs between sweeps and prioritizing levels for processing. This hierarchical scheduling produces order-of-magnitude speedups against single-variable or purely breadth-/depth-first external algorithms (Sølvsten et al., 2024).
• In radiative transfer–chemistry coupling, hierarchical sub-timestep sweeping (e.g., the Subsweep framework) permits per-cell temporal adaptivity by scheduling grid cells at different sub-timestep levels and orchestrating a hierarchy of partial sweeps per global step. This matches local timescales, localizes computation, and avoids the inefficiency of a globally small timestep (Peter et al., 2024).

7. Scalability, Parallelization, and Practical Impact

Sweep-based execution demonstrates outstanding scalability and resource efficiency in numerous domains:

• Parallel transport sweeps have been deployed at $>10^5$ to $10^6$ cores for full-core nuclear simulations, maintaining $>$60% efficiency (Adams et al., 2019, Vermaak et al., 2020).
• Out-of-core sweep methods for large geometric tasks process datasets beyond RAM limitation with $O(\delta)$ memory and $\sim$linear runtime, as in genome-scale Delaunay tessellations (Trencséni et al., 2012).
• Radiative transfer sweep solvers operate with computational cost $O(N_{\text{cell}}\cdot N_{\text{dir}})$, decoupled from the number of sources, enabling large-scale cosmological simulations (Peter et al., 2022, Peter et al., 2024).
• Sweep-based domain decomposition in relaxation and ILU preconditioners achieves almost no convergence-rate penalty even in massively parallel settings and introduces favorable cache behaviors (Tavakoli, 2010).

A critical limitation is the requirement for an underlying, sufficiently acyclic, or at least near–acyclic, dependency structure. With increasing cyclicity (curved meshes, reflecting boundaries, nonmonotone sweep schedules) the cost of cycle-removal and lagged update iterations or the overhead for synchronization/buffering increases, yet by appropriate reductions (feedback arc set, multi-frontal solve, lagging), practical efficiency is maintained.

• "Optimal Allocation of Many Robot Guards for Sweep-Line Coverage" (Feng et al., 2023)
• "Provably Optimal Parallel Transport Sweeps on Semi-Structured Grids" (Adams et al., 2019)
• "An Efficient Sweep-based Solver for the $S_{N}$ Equations on High-Order Meshes" (Haut et al., 2018)
• "Massively Parallel Transport Sweeps on Meshes with Cyclic Dependencies" (Vermaak et al., 2020)
• "Plane-Sweep Incremental Algorithm: Computing Delaunay Tessellations of Large Datasets" (Trencséni et al., 2012)
• "Empirical Evaluation of the Parallel Distribution Sweeping Framework on Multicore Architectures" (Ajwani et al., 2013)
• "Parallelizing Sequential Sweeping on Structured Grids -- Fully Parallel SOR/ILU preconditioners for Structured n-Diagonal Matrices" (Tavakoli, 2010)
• "One-sweep moment-based semi-implicit-explicit integration for gray thermal radiation transport" (Southworth et al., 2024)
• "Multi-UAV Uniform Sweep Coverage in Unknown Environments: A Self-organizing Nervous System (SoNS)-Based Random Exploration" (Jamshidpey et al., 2024)
• "Multi-variable Quantification of BDDs in External Memory using Nested Sweeping (Extended Paper)" (Sølvsten et al., 2024)
• "Subsweep: Extensions to the Sweep method for radiative transfer" (Peter et al., 2024)
• "The Sweep Method for radiative Transfer in Arepo" (Peter et al., 2022)
• "Projection matrices and the sweep operator" (James et al., 2024)
• "Control variates and Rao-Blackwellization for deterministic sweep Markov chains" (Berg et al., 2019)