Ratio-Filter Dechirping for Gravitational Waves

• Ratio-Filter Dechirping is an algorithm that decouples FFT-based convolution into a coarse reference stage and a cache-resident short FIR correction.
• It lowers computational cost by reducing FLOP multipliers from ∼20 to ∼11 and shifts operations from O(N log N) to an efficient O(K) per template.
• The method scales across diverse waveform families and hardware platforms, enabling rapid offline and low-latency gravitational-wave searches.

Ratio-Filter Dechirping is an algorithmic restructuring of gravitational-wave matched filtering, targeting the reduction of memory-bandwidth bottlenecks in frequency-domain searches. The method decouples the traditional FFT-based convolution into a coarse reference filtering stage and a short FIR correction, enabling efficient use of processor caches and drastically improving computational throughput for offline and low-latency gravitational-wave analysis (Nitz et al., 25 Jan 2026).

1. Memory-Bandwidth Bottleneck in Standard FFT Searches

Standard matched filtering, exemplified by approaches such as FINDCHIRP, evaluates the statistic

$$Z(\tau)=4\,\Re\int_0^{\infty}\frac{\tilde h^*(f)\,\tilde d(f)}{S_n(f)}\,e^{2\pi i f\tau}\,df$$

using point-wise multiplication in the frequency domain, followed by a large inverse FFT (IFFT). For template durations spanning tens to hundreds of seconds and sample rates in kHz, the FFT block size ($N\sim2^{20}$) often exceeds CPU cache capacities, leading to frequent stalling as cores fetch data from main memory (“Memory Wall”). Empirical benchmarks indicate that FFT throughput declines by up to $5$–$8\times$ when $N\gtrsim10^5$ samples. In full production environments, this effect is exacerbated under heavy core loads. Ratio-Filter Dechirping mitigates these penalties by partitioning the convolution, using a cache-efficient FIR kernel in the second stage that operates entirely within L1/L2 caches, restoring high arithmetic intensity.

2. Mathematical Derivation

Ratio-Filter Dechirping achieves computational efficiency by expressing the target template $\tilde h(f)$ as the product of a coarse reference $\tilde h_{\rm ref}(f)$ and a slowly varying ratio $R(f)$: $$\tilde h(f)=\tilde h_{\rm ref}(f)\,R(f),\qquad R(f)\equiv\frac{\tilde h(f)}{\tilde h_{\rm ref}(f)}$$ Substituting into the matched-filter expression and utilizing the linearity and associativity of the inverse Fourier transform $\mathcal F^{-1}$ yields: $$Z(\tau) =4\,\Re\,\mathcal F^{-1}\Bigl[\tfrac{\tilde h_{\rm ref}^*(f)\,\tilde d(f)}{S_n(f)}\,R(f)\Bigr](\tau) =\bigl(x* r\bigr)(\tau)$$ with

$$x(t)=4\,\Re\,\mathcal F^{-1}\bigl[\tfrac{\tilde h_{\rm ref}^*(f)\,\tilde d(f)}{S_n(f)}\bigr](t)$$

and

$r(t)=\mathcal F^{-1}[R(f)](t)$

Here, $x(t)$ is the coarse SNR time series computed once per reference, and $r(t)$ represents a short FIR kernel. Explicitly, for sampling interval $\Delta t$, the kernel $r(t)$ is discretized as

$r(t)=\sum_{k=0}^{K-1} r_k\,\delta(t-k\Delta t)$

leading to the convolution sum: $z[n]=\sum_{k=0}^{K-1} r_k\,x[n-k]$ where $r_k$ are the inverse Fourier coefficients of $R(f)$.

3. Computational Complexity and Memory Bandwidth

A key advantage of Ratio-Filter Dechirping is its reduction in computational cost and memory bandwidth requirements. Standard FFT-based methods (e.g., FINDCHIRP) require per-template operations on the order of $O(N\log_2 N)$, where $N\sim2^{20}$ samples, and suffer from cache misses and inflated FLOP multipliers (∼20×). In contrast, the dechirped workflow incurs costs $O(K\log K)$, with $K\sim2000$ samples, and performs only $O(K)$ operations per target template since most templates share reference $x(t)$. The effective FLOP multiplier drops to ∼11×.

Below is a comparison matrix derived from Table I:

Method	Leading Cost	FLOP Multiplier
Standard FFT	$O(N\log_2N)$	∼20
GstLAL (SVD)	$O(NR)$	100–500
SPIIR (IIR)	$O(NC)$	100–200
MBTA	$O(\sum N_i\log T_i)+O(NM)$	∼15
Ratio-Filter	$\mathbf{O(N\log_2K)}$	$\mathbf{\sim11}$

Benchmarks (Fig. 1) report an $8\times$ speedup for offline filtering and $>10\times$ in low-latency streaming, attributed to the FIR kernel’s cache residency and efficient IFFT block processing.

4. Workflow and Implementation

The reference-template paradigm underpins the Ratio-Filter Dechirping workflow. Reference filters are selected to capture the main phase evolution; residuals $R(f)$ are sufficiently smooth to be implemented as short FIRs. The data flow is outlined as:

1. Preprocessing
   • Generate coarse reference templates $\tilde h_{\rm ref}(f)$
   • Compute $x_{\mathrm{ref}}(t)$ via IFFT
   • For each target template, calculate $R(f)$ and corresponding $r_k$ via inverse FFT, truncating to $K$ taps
2. Online Filtering
   • For data chunks, load $x_{\mathrm{ref}}(t)$ (cache-resident)
   • Apply FIR convolution for each target template:

   $z_{ij}[t] = \sum_{k=0}^{K-1} r_{ij}[k]\, x_i[t-k]$

• Detect peaks in $z_{ij}[t]$

Empirical data (Table II) for $K=251$ taps examining a batch of 100 templates demonstrates that 80% of loop time is spent in the cache-resident IFFT, with total filtering complete in ∼2 s, compared to ∼16 s for the standard FFT (per 100 templates).

5. Template Families and Matching Performance

Ratio-Filter Dechirping generalizes across diverse waveform families:

• For binary neutron star templates exhibiting finite-size effects, kernel lengths of $K\approx200$ achieve $99\%$ match fidelity (Fig. 3).
• For templates incorporating eccentricity, precession, and higher modes, a single 251-tap FIR filter recovers mismatches $<10^{-3}$ even when match to the reference drops to ∼$0.6$ (Fig. 4).
• This suggests robustness across high-dimensional parameter spaces, with negligible degradation in sensitivity for dense template banks.

6. Parameter-Space Generalization and Hardware Acceleration

Coarse reference banks can be constructed along arbitrary waveform dimensions: mass, spin, eccentricity, tidal deformability. Provided local coverage, the ratio $R(f)$ remains smooth, ensuring kernel compactness. For higher-mode templates, separate $(\ell,m)$ ratio filters or complete-mode inclusion are supported; FIR cost remains low.

Ratio-Filter Dechirping is well suited for GPU architectures and SIMD instruction sets. Short kernels maximize arithmetic intensity (high FLOPs per byte) and leverage GPU shared memory for multi-template computations. Reference SNR time series $x_i[t]$ is reused, promoting optimal cache usage. Beyond CPU implementations, the method is amenable to FPGA or ASIC acceleration, where memory-local kernels and streaming SNR can further enhance performance.

A plausible implication is that the reduction in computational cost enables the expansion of matched-filter searches into regions previously limited by computing budgets, notably for eccentric or subsolar-mass signal detection.

7. Context and Research Significance

The Ratio-Filter Dechirping methodology, as detailed in "Beyond FINDCHIRP: Breaking the memory wall and optimal FFTs for Gravitational-Wave Matched-Filter Searches with Ratio-Filter Dechirping" (Nitz et al., 25 Jan 2026), directly addresses the dominant bottleneck in gravitational-wave matched filtering: memory bandwidth. By algorithmically restructuring template convolution, the approach enables efficient scaling to long-duration templates and dense parameter spaces, facilitating both offline and low-latency searches. Integrability with current CPU, GPU, and hardware-accelerated infrastructures suggests durable relevance for next-generation gravitational-wave observatories and other time-series analysis contexts.