DSB Jacobi: Data Stream SVD Processing

• The paper demonstrates how DSB Jacobi updates singular value decompositions in real time with a minimal memory footprint using streaming data.
• The approach leverages parallelized Jacobi rotations, row block partitioning, and FPGA-based pipelined architectures to reduce BRAM usage by 41.5% and increase throughput.
• Empirical results reveal a 23× runtime speedup with high SVD accuracy, making it effective for embedded systems and large-scale signal processing applications.

A Data Stream-Based SVD Processing Algorithm (DSB Jacobi) refers to a family of algorithms and architectures tailored to efficiently compute or update the singular value decomposition (SVD) of matrices arising from streaming, high-throughput sources, and to do so with minimal memory footprint and latency. The central aim is to enable real-time or near-real-time SVD in large-scale signal processing, embedded, or recommendation applications where classic batch-oriented SVD techniques are unsuitable due to computational cost, memory consumption, or unfavorable dataflow characteristics. The DSB Jacobi formalism encompasses both matrix update strategies and hardware-specific pipeline architectures that reorganize Jacobi-style SVD computations to fit data stream and parallel processing paradigms (Du et al., 16 Nov 2025, Brust et al., 2 Sep 2025).

1. Theoretical Foundations: Jacobi SVD and Streaming Updates

The Jacobi algorithm for SVD, particularly in its one-sided Hestenes variant, seeks to iteratively orthogonalize column pairs of a matrix via plane rotations such that, for an $m\times n$ real matrix $A$ ($m\geq n$), there exists an orthogonal $V$ so that $B=AV$ has orthogonal columns. The result is $A=U \Sigma V^T$ with $B=U\Sigma$ and $U, V$ orthogonal, $\Sigma$ diagonal. Jacobi SVD operates via a sequence of $2 \times 2$ rotations—each annihilating off-diagonal entries in $M = B^TB$—with convergence governed by the magnitude of off-diagonal elements and typically quantified via 1- or 2-norms.

In the context of streaming data, such as a matrix sequence $A_k$ updated by low-rank increments, the challenge shifts to maintaining an efficient factorization after each update without full recomputation. The streaming SVD update framework keeps a compact factorization $A_k = Q_k B_k P_k^T$ with $B_k$ upper bidiagonal. For a rank-1 update, $A_{k+1} = A_k + b c^T$, the SVD is incrementally updated via efficient manipulation of $B_k + (Q_k^T b)(P_k^T c)^T$—either by compact Householder-based transformations or through a highly memory- and compute-efficient series of Givens rotations, enabling up-to-date SVD approximations with $\mathcal{O}(n^2)$ cost per update and $\mathcal{O}(n^2)$ memory (Brust et al., 2 Sep 2025).

2. Data Stream-Based Jacobi: Algorithmic Transformation

The DSB Jacobi regime in hardware reorganizes the conventional Jacobi SVD workflow for efficient streaming and parallel execution. The key innovation is the mapping of column-pair orthogonalization into a row-pair processing structure amenable to pipelined and distributed streaming on FPGAs.

Row Block Partitioning and Dataflow

• The matrix $A$ is partitioned by rows into blocks, each corresponding to a Processing Unit (PU).
• Within each block, the PU processes pairs of rows via Jacobi plane rotations, where each iteration ('sweep') covers all row pairs within the block.
• A cyclic, interleaved schedule ensures maximal PU utilization and eliminates contention, as PUs never access the same memory rows simultaneously within a sweep.

Buffering and On-chip Memory

• For each PU, four lightweight BRAMs buffer only the two rows of $U$ (initialized from $A^T$) and $V$ currently in use, time-multiplexed for the duration of Jacobi operations.
• This buffer sharing architecture achieves a 41.5% reduction in on-chip BRAM compared to prior designs employing full-matrix buffering (Du et al., 16 Nov 2025).

3. Parallelization and Pipeline Architectures

DSB Jacobi achieves its low-latency and high-throughput properties through hierarchical and fine-grained parallelism:

• Intra-PU Parallelism: Each PU independently executes parameter generation (e.g., computes $s = \sin \theta$, $c = \cos \theta$ from $a, b, c$ statistics of row pairs), and matrix updates via two fused multiply-accumulate pipelines. These calculations are performed with a single-cycle latency using custom CORDIC or polynomial approximators.
• Inter-PU Scheduling: All PUs operate on disjoint row pairs, managed by a global scheduler and an FSM handshake protocol that dynamically allocates new row pairs as buffers are released.
• Dataflow Interconnects: A ring or crossbar network routes addresses and control signals, maintaining strict pipeline order and maximizing throughput without resource contention.

4. FPGA Realization and Resource Utilization

The DSB Jacobi framework is exemplified by its instantiation on FPGAs, where architectural optimizations are paramount:

• Each PU is composed of four dual-port BRAMs, tightly controlled for simultaneous read/write during rotation and update phases.
• Parameter generators compute statistical quantities for Jacobi rotation ($a, b, c$ per row pair) and realize the angle $\theta$ required for orthogonalization.
• The global scheduler orchestrates pipeline stages and maintains real-time flow between memory, computation, and writeback.
• In benchmarked implementations (e.g., $PU_{32}$ on XCKU060 at 200 MHz), the design demonstrates 170K LUTs, 291K FFs, and a total of 304 BRAM blocks (a 41.5% reduction vs. prior hardware Jacobi SVDs), with each PU using two DSP chains for MAC operations (Du et al., 16 Nov 2025).

5. Performance Metrics and Comparative Analysis

Empirical evaluation demonstrates that DSB Jacobi markedly increases computational efficiency in large-scale SVD computation and processing of streaming data:

Metric	DSB Jacobi (FPGA, 32 PUs)	Fully Parallel BCV Jacobi ([14])
4096×4096 SVD Time	0.261 s	6.03 s
Throughput	3.8 matrices/s	<0.2 matrices/s
BRAM Usage	304 blocks	520 blocks
Wall-clock Speedup	23×	1×

DSB Jacobi achieves a 23× reduction in wall-clock runtime and 41.5% less BRAM, matching or exceeding batch Hestenes‐Jacobi SVD in accuracy ($\|A-U\Sigma V^T\|<10^{-9}$, $\|U^TU-I\|<10^{-4}$, $\|V^TV-I\|<10^{-14}$). These properties greatly enhance suitability for embedded and edge/deployment scenarios where memory and latency constraints are severe (Du et al., 16 Nov 2025).

In the pure algorithmic domain, stream-update SVD approaches based on Givens rotations deliver costs of $\mathcal{O}(n^2)$ per update (with $\sim$10 flops per rotation and storage cost of $\sim 4n^2$ for applied rotations), outperforming both standard LAPACK bidiagonalization and classic incremental SVD approaches for high-rank, large-scale streams (Brust et al., 2 Sep 2025).

6. Trade-offs, Bottlenecks, and Future Directions

• Matrix Size: On-chip BRAM sets an upper bound (e.g., $n \approx 4096$). Larger matrices necessitate external DRAM buffering or hierarchical block-diagonalization.
• Arithmetic Precision: Fixed-point processing can further reduce hardware resource usage, but may incur additional Jacobi sweeps for convergence.
• Pipeline Hazards: BRAM access arbitration and param_gen computation latency (e.g., arctan, sqrt via CORDIC) may become critical paths; careful scheduling and deep pipelining mitigate such risks.
• Scalability versus Orthogonality: Increasing the number of sweeps (NumOfConv) enhances orthogonality and SVD fidelity but at the expense of throughput. Optimal sweep count is typically 8–12 for high orthogonality (Du et al., 16 Nov 2025).
• Algorithmic Extensions: Future enhancements may include hierarchical block-Jacobi, mixed-precision refinement, and dynamic PU allocation to adjust to workload or resource fluctuations.

7. Relation to Broader Data Stream SVD Techniques

DSB Jacobi aligns conceptually with incremental SVD and online matrix factorization efforts, but distinctively emphasizes hardware harmony and strict memory discipline. While compact Householder or Givens-based updates in the streaming setting (as in (Brust et al., 2 Sep 2025)) optimize for limited fill-in and computational cost, DSB Jacobi embodies these principles at the architecture level through tailored pipeline decomposition. Givens-based update pipelines, in particular, provide both the minimal per-step flop count and natural primitive for Jacobi-style diagonalization, yielding low-latency updates with robust SVD accuracy over evolving datasets.

A plausible implication is that as low-rank streaming data becomes increasingly central in real-time analytics, signal processing, and recommendation systems, DSB Jacobi architectures and algorithms will underpin scalable, low-power deployments where classical SVD or even software incremental SVD is no longer feasible due to data growth or hardware constraints (Du et al., 16 Nov 2025, Brust et al., 2 Sep 2025).