Warp-Uniform Solvers for Gaussian Outage Approximations in Multi-Antenna Channels

Engineers often need to know how often a multi-antenna wireless link fails. The link has many transmit and receive antennas, and the question is how often the information it can carry, its mutual information, falls below a target rate. The exact answer requires the distribution of a random matrix's eigenvalues, which is intractable for realistic channels. Examples include signals that bounce off two clusters of scatterers, pass through a relay, or reflect off an intelligent reflecting surface (a panel of tunable reflectors). A body of random-matrix work shows that this mutual information is approximately Gaussian once antenna counts are moderately large. The whole outage curve then follows from a mean and a variance, and the error of those two numbers shrinks like $O(1/N)$ in the number of antennas $N$. The catch is that the mean and variance are not closed-form. They come out of coupled fixed-point equations that must be iterated to convergence, separately for every channel configuration. System design means sweeping or optimizing over thousands to millions of configurations: surface phases, relay gains, antenna counts, signal-to-noise ratios (SNRs). In practice that sweep is either done slowly on a CPU or replaced by brute-force Monte Carlo simulation.

This proposal treats the GPU as the obvious engine for such sweeps and addresses a specific obstacle. When one GPU thread solves one configuration's fixed-point equations, threads converge after different numbers of iterations. GPUs execute bundles of 32 threads, called warps, in lockstep, so fast threads sit idle until the slowest one in their warp finishes. This is warp divergence. The central idea is that the analytic structure behind the Gaussian approximation also predicts, per configuration, how many iterations are needed. We can therefore replace data-dependent convergence loops with a fixed, certified number of uniform steps. Every lane of a warp runs identical instructions, and the output still carries an explicit accuracy guarantee that can be compared against the $O(1/N)$ approximation error itself.

Core Claim

The outage probability of a rate $R$ is approximated as

$$P_{\text{out}}(R) \approx \Phi\!\left(\frac{R-\mu(\theta)}{\sigma(\theta)}\right),$$

where $\theta$ collects the configuration (antenna and scatterer counts, correlation matrices, SNR, surface phases), $\mu$ and $\sigma^2$ are the deterministic-equivalent mean and asymptotic variance, and $\Phi$ is the standard normal cumulative distribution. Computing $\mu$ and $\sigma$ requires the fixed point $\delta^\star(\theta)$ of a map $T_\theta$ that is contractive, with contraction factor $\rho(\theta)<1$. Such maps are the kind whose unique convergence is proved for Algorithm 1 in Fundamental Limits of Two-Hop MIMO Channels: An Asymptotic Approach. For such a map, standard contraction arguments guarantee accuracy $\epsilon$ after

$$k(\theta) = \left\lceil \frac{\log\big(\epsilon / \|\delta_0 - T_\theta(\delta_0)\|\big) + \log(1-\rho(\theta))}{\log \rho(\theta)} \right\rceil$$

iterations, where $\delta_0$ is the initial guess. We claim three things. First, a cheap closed-form upper bound on $\rho(\theta)$ can be derived for the double-scattering and two-hop models. Second, a good $\delta_0$ can be taken from the high-SNR or low-SNR asymptotes, which are known analytically, such as the $L\log(\text{SNR})$ scaling in Asymptotic Mutual Information Analysis for Double-scattering MIMO Channels: A New Approach by Gaussian Tools. Third, a Newton step on the underlying cubic (double scattering) or quartic (two-hop) scalar equation shrinks $k(\theta)$ to a small, nearly constant number across realistic parameter ranges.

Together these allow a solver in which every warp runs a fixed iteration count with no early-exit branch, and the accuracy target $\epsilon$ is set well below the $O(1/N)$ approximation error so that numerical error never dominates. What would be new is not "GPU acceleration of a formula." The new part is using the convergence theory of the deterministic equivalent as a scheduling device: a per-configuration iteration certificate that turns divergent loops into uniform, branch-free work.

Research Program

The first component is analytical. For the double-scattering Kronecker model and the two-hop amplify-and-forward and active-surface models, we derive explicit bounds on $\rho(\theta)$. These bounds use the matrix quantities already present in the fixed-point equations: the traces and spectral norms of the correlation matrices, the SNR, and the dimension ratios. We then characterize the region of $\theta$ where plain fixed-point iteration is slow, which we expect to be low SNR and the balanced regime $M=N=L$ where the variance peaks. In that region we switch to a warp-uniform Newton iteration on the scalar polynomial reduction, with a fixed small step count. We also derive the variance and its gradient with respect to $\theta$ by implicit differentiation through the fixed point. Gradients then cost one linear solve rather than backpropagation through a variable number of iterations. This matters for surface-phase optimization of the kind done in URLLC in IRS-Aided MIMO Systems: Finite Blocklength Analysis and Design, which re-evaluates deterministic equivalents at every gradient step.

The second component is the kernel. Configurations are laid out one per lane. The iteration count is either computed per warp as the maximum certified $k(\theta)$ over its 32 lanes, or fixed globally when the Newton regime makes it nearly constant. Loops are fully uniform, and branchless select operations replace any piecewise logic. We profile branch efficiency, warp execution efficiency, register pressure and achieved occupancy with standard GPU profilers. We do this because branchless rewrites can inflate register use and cut occupancy, a limitation the research file flags for this class of reformulation.

The third component is validation. We check accuracy against Monte Carlo at small array sizes, and we check end-to-end usefulness in design loops.

Baselines

The naive reference point is the procedure these papers actually use. Algorithm 1 of Fundamental Limits of Two-Hop MIMO Channels: An Asymptotic Approach is iterated to a tolerance, one configuration at a time on a multi-core CPU. We will parallelize it across cores with the same tolerance and report configurations per second. There is no reported result found on Lacuna for the runtime of this solver or any GPU implementation of it.

The second baseline is the straightforward GPU port: one configuration per thread, with a while loop that exits at tolerance. This is the divergent version, and it isolates exactly what warp divergence costs.

The third baseline is the input-sorting strategy of Accurate Computation of the Logarithm of Modified Bessel Functions on GPUs. That paper sorted inputs so that lanes sharing a code path share a warp, paid a 33% sorting overhead, and still reported median and maximum GPU speedups of 45x and 6150x over third-party libraries. We apply the same idea by sorting configurations on a proxy for convergence difficulty (SNR and dimension ratio) before launch. This is the strongest existing mitigation method in the file, and a documented success, so it is the competitor to beat.

The fourth baseline is brute-force Monte Carlo on the GPU. We draw channel realizations in batches in a GPU framework of the kind PyJama builds on Sionna (PyJama: Differentiable Jamming and Anti-Jamming with NVIDIA Sionna) and form empirical outage estimates. We use $5\times10^5$ realizations per configuration, the count used for validation in the two-hop paper. We found no reported runtime for this on Lacuna.

Two ablations isolate the key ingredient. One is fixed-count plain iteration with a single conservative global $K$ and no certificate and no Newton step. It tests whether certification matters at all. The other is certified counts without the Newton switch, which tests whether the polynomial reduction matters.

All GPU variants run on the same device and the same configuration sets, with the same accuracy target: agreement with a high-precision CPU reference to $10^{-6}$ relative error in $\mu$ and $\sigma$. Each gets the same engineering effort for block size and memory layout. Beating the sorting baseline means higher configurations per second at equal accuracy, measured end to end including all preprocessing. Beating Monte Carlo means matching its outage estimates within Monte Carlo confidence intervals at orders-of-magnitude lower cost.

Why not just…?

Why not just run Monte Carlo on the GPU and skip the approximation? For a single evaluation this is viable and honest. It becomes prohibitive inside optimization and sweeps, where each configuration needs hundreds of thousands of realizations to resolve low outage probabilities, and where gradients of an empirical tail probability are noisy. The research file cites a Horseshoe Probit Gibbs sampler (GPU-accelerated Gibbs sampling: a case study of the Horseshoe Probit model) whose largest configuration exhausted GPU memory, which shows that brute-force GPU simulation hits memory limits, while the approximation needs two scalars per configuration. An analogy outside wireless is An Evaluation of Intrusive Instrumental Intelligibility Metrics: replacing a nearest-neighbor mutual information estimator with a Gaussian channel model was 100 times faster with essentially the same predictive accuracy ($\rho=0.92$). Our IRS optimization experiment measures this cost directly as wall-clock time to reach a target error probability.

Why not just sort the configurations, as the Bessel-function work did? This is the real threat. Plesner et al. showed that sorting pays off despite its overhead. Sorting, however, needs a key that predicts convergence difficulty, and the natural key is exactly our contraction bound. The question is whether sorting on it beats uniform execution under it. Sorting also has to be redone whenever the configuration set changes, which happens at every gradient step of surface optimization. The experiments compare the two on static sweeps and on dynamic optimization loops. If sorting wins on static sweeps, we will report that and restrict the claim to dynamic settings.

Why not just run every thread for a large fixed number of iterations? This removes divergence trivially, and if a single $K$ were both safe and small, the certificate would add nothing. We expect it to fail in one of two ways. A $K$ chosen for the slow balanced, low-SNR regime wastes most of the work elsewhere. A $K$ chosen for typical cases silently returns inaccurate $\mu$ and $\sigma$ in the hard regime, and those are the configurations where outage is most sensitive, since variance peaks at $M=N=L$ per the double-scattering analysis. The fixed-$K$ ablation measures both the wasted work and the rate of silent failures. If a small safe $K$ turns out to exist, the contribution shrinks to the Newton reduction and the accuracy certificate, and we will say so.

Proposed Experiments

The first experiment tests accuracy on the synthetic double-scattering Kronecker model of Asymptotic Mutual Information Analysis for Double-scattering MIMO Channels: A New Approach by Gaussian Tools and on the two-hop relay and active-surface model of Fundamental Limits of Two-Hop MIMO Channels: An Asymptotic Approach. We sweep antenna counts from 4 to 128, scatterer and surface sizes including values that are not multiples of 32, and SNR across the full range. We report the Kolmogorov–Smirnov distance between the Gaussian outage curve and Monte Carlo. We also confirm that solver error stays at least an order of magnitude below the $O(1/N)$ approximation error at every size. Neither paper gives absolute outage numbers in the file; both report only the $1/N$ error slope, so we reproduce that slope as a sanity check.

The second experiment tests throughput and hardware efficiency. On sweeps of $10^6$ heterogeneous configurations we report configurations per second, branch efficiency, warp execution efficiency, occupancy and registers per thread for every baseline and ablation. We break results down by regime, because the claim predicts the largest gains where iteration counts are most heterogeneous.

The third experiment is the decisive end-to-end test: surface-phase optimization for low-latency links following URLLC in IRS-Aided MIMO Systems: Finite Blocklength Analysis and Design. That setup uses a Gaussian approximation of the mutual information density at finite blocklength and validates it with a WiMAX rate-1/2 LDPC code. We run gradient optimization with implicit-differentiation gradients from our solver, the sorted solver and the divergent solver, and we compare against Monte Carlo-based optimization at matched compute. The metric is wall-clock time to reach a target packet error rate, confirmed by LDPC simulation of the final phases. That paper reports only "several dBm" of power gain from optimization, with no exact figure in the file, so the matched-budget comparison is the relevant number. For context, Bounds on the second-order coding rate of the MIMO Rayleigh block-fading channel reports a roughly 4 dB constant gap between Gaussian-based bounds and practical LDPC performance. Our solver cannot close that gap and does not try to; what we require is that it preserve the slope agreement.

The proposal fails if either of two things happens: sorting matches uniform certified execution in the dynamic optimization loop, or a single small fixed $K$ is both safe and as fast across the sweep.