FaCTz: Fast Critical-Point and Topology-Aware GPU Compression for Scientific Vector Fields

FaCTz: Fast Critical-Point and Topology-Aware GPU Compression for Scientific Vector Fields Mingze Xia∗ , Yuxiao Li† , Sheng Di‡ , Jiannan Tian★, Baixi Sun‡ Boyi Zhang⋄ , Bei Wang◦ , Hanqi Guo† , Xin Liang∗ ∗ Oregon State University

† The Ohio State University

★Oakland University

⋄ University of Kentucky

arXiv:2608.10586v1 [cs.DC] 11 Aug 2026

Abstract Error-bounded lossy compression is essential for storing and transferring the vector-field data produced by large-scale scientific simulations. Although it enforces a user-specified error bound to limit numerical distortion, it does not preserve the field’s topology: small admissible perturbations can create or eliminate critical points on which downstream feature analysis depends. Existing GPU compressors achieve high throughput but are topology-agnostic, whereas the only compressor with provable critical-point preservation (cpSZ) runs on the CPU at throughput far below the data-generation rates of modern GPU-based systems. We observe that, although preserving critical points is inherently a coupled and sequential constraint, it can be reformulated into independent parallel tasks, either on a per-block basis or, speculatively, on a per-point basis. We present FaCTz, the first GPU-based error-bounded lossy compressor that guarantees critical-point preservation. FaCTz provides a block-wise mode optimized for throughput and a speculative per-point mode optimized for compression ratio. Across three vectorfield datasets, FaCTz preserves every critical point while achieving throughput of up to 60 GB/s, approximately two orders of magnitude (up to ∼ 640×) faster than the multithreaded CPU implementation of cpSZ. Its speculative mode further improves the compression ratio by approximately a factor of two over the throughput-oriented mode.

‡ Argonne National Laboratory ◦ University of Utah

In contrast, error-bounded lossy compression guarantees that every reconstructed value remains within a user-specified error bound of the original while delivering substantially higher compression ratios [4, 8]. A pointwise error bound, however, does not necessarily preserve the information that scientific users care about. For vector-field data, the quantities of interest are often topological: the critical points where the vector field vanishes, together with the flow structures anchored to them, form the foundation of feature extraction, vortex detection, and separation/attachment analysis [15, 22, 23, 36]. Even a small perturbation that satisfies the prescribed error bound can alter the sign pattern within a cell, thereby creating or destroying a critical point. As a result, the reconstructed field satisfies the numerical error bound while encoding a different topology, potentially leading to incorrect scientific conclusions in downstream analyses. Consequently, although bounding the pointwise error is necessary, it is not sufficient for topology-aware analysis of vector fields. Preserving topology during compression is therefore essential to maintaining the integrity of subsequent scientific analyses. This requirement exposes three fundamental gaps that no existing compressor addresses (§2.4). G1. State-of-the-art GPU compressors [6, 17, 18, 31, 35, 45, 47] are topology-agnostic and can readily corrupt critical points.

Keywords: lossy compression, error-bounded compression, GPU, vector fields, critical points, topology preservation, scientific data

G2. The only compressor that provably preserves critical points, cpSZ [28], achieves only ∼ 0.1–0.2 GB/s even when using 128 CPU threads.

1

G3. Critical-point preservation itself appears inherently difficult to parallelize because the admissible error at one point depends on the values of its neighbors.

Introduction

Modern scientific simulations running on GPU-accelerated supercomputers generate data at rates that far exceed the available bandwidth for storage and transfer. A single highresolution simulation of fluids, combustion, or plasma systems can routinely produce terabytes of vector-field data in a single run [20, 52]. Even on leadership-class systems, transferring these datasets remains time-consuming, and the gap between computational throughput and I/O bandwidth continues to widen [5, 11, 21]. Lossless compression achieves only modest compression ratios on floating-point data, typically well below 2× [32, 40].

Our key insight is that critical-point preservation can be decomposed into independent parallel tasks in two complementary ways, each targeting a different point in the throughput– compression-ratio tradeoff. First, partitioning the field into small blocks enables independent computation of a conservative error bound that preserves all critical points within each block, allowing the blocks to be compressed in parallel without cross-block dependencies. Second, tighter per-point error bounds are obtained through a hierarchical speculative kernel that progressively enlarges each point’s admissible

PPoPP ’27, TBD, TBD

error bound until the topological constraint is nearly violated, then retreats to the last valid bound. This approach trades some throughput for a substantially higher compression ratio. Together, these strategies transform an inherently sequential, dependency-laden constraint into one well suited to massively parallel GPU execution. We embody this insight in FaCTz (Fast Critical-point and Topology-aware Compression), the first GPU compressor for scientific vector fields that guarantees critical-point preservation under error-bounded lossy compression, thereby closing G1–G3. FaCTz provides two complementary operating modes: a block-wise mode optimized for throughput and a speculative per-point mode optimized for compression ratio. The main contributions are: C1. We formulate critical-point preservation as a parallelizable constraint, enabling the first GPU-based errorbounded compressor for vector fields with guaranteed critical-point preservation (§3). C2. We instantiate this formulation in FaCTz through two complementary parallel strategies: a block-wise commonbound scheme and a hierarchical speculative per-point scheme, exposing a tunable throughput–compressionratio tradeoff (§3). C3. We develop a high-throughput CUDA implementation and present the key engineering techniques that enable its performance (§4). C4. We evaluate FaCTz against state-of-the-art GPU compressors (cuSZ, cuSZ-i, cuSZp, and cuZFP) and the CPUbased cpSZ on three vector-field datasets, comparing compression ratio, PSNR, compression and decompression throughput, and critical-point preservation (§5).

2

Background and Motivation

FaCTz builds on three ingredients: the way error-bounded lossy compressors discard information (§2.1), what defines a critical point in a 2D vector field (§2.2), and how cpSZ turns the two into a preservation guarantee (§2.3). We review them, then draw out the observations that motivate a topologypreserving GPU compressor (§2.4). 2.1

Error-Bounded Lossy Compression

Error-bounded lossy compressors [1, 7, 24, 29, 31, 34, 54] keep every reconstructed value 𝑥˜𝑖 within a user-specified error bound 𝜖 of the original, |𝑥˜𝑖 − 𝑥𝑖 | ≤ 𝜖. FaCTz follows the dominant prediction-based design of SZ [7, 29, 54]: a predictor (a Lorenzo or interpolation stencil) estimates each value from already-decoded neighbors, the residual is quantized into an integer bin sized by 𝜖 (the only lossy step), and the codes are entropy-coded losslessly. Reconstructing each value in place before predicting the next keeps encoder and decoder in lockstep, so error never drifts. The guarantee is pointwise: it bounds each value’s error but says nothing

Xia et al.

about relationships among values, which is what topological features depend on. 2.2

Critical Points in 2D Vector Fields

We consider 2D vector fields sampled at the vertices of a simplicial (triangular) mesh, where each vertex carries a two-component vector (𝑢, 𝑣) and the field is reconstructed by piecewise-linear interpolation over each cell. A critical point is a location where the vector field vanishes (i.e., the interpolated 𝑢 and 𝑣 are both 0). Under the piecewise-linear assumption, the critical point of a cell is found by solving a linear system in barycentric coordinates:   𝜇  𝑢 0 𝑢 1 𝑢 2  0  𝜇 = 0 and 𝜇0 + 𝜇 1 + 𝜇 2 = 1, (1) 𝑣 0 𝑣 1 𝑣 2  1  𝜇 2  

where (𝜇0, 𝜇1, 𝜇2 ) are the barycentric coordinates and (𝑢𝑖 , 𝑣𝑖 ) are the vector components at the three vertices of the cell. By Cramer’s rule the barycentric solution is 𝑚𝑘 𝜇𝑘 = , 𝑚𝑘 = 𝑢𝑘+1𝑣𝑘+2 −𝑢𝑘+2𝑣𝑘+1, 𝑚 = 𝑚 0 +𝑚 1 +𝑚 2, (2) 𝑚 with indices taken modulo 3; each 𝑚𝑘 is thus the 2 × 2 determinant of the vectors at the other two vertices. A critical point exists within the cell if and only if 0 ≤ 𝜇𝑘 ≤ 1 for all 𝑘 ∈ {0, 1, 2}, i.e. every 𝑚𝑘 shares the sign of 𝑚 with |𝑚𝑘 | ≤ |𝑚|. Figure 1 illustrates cells with and without a critical point. Beyond mere existence, each critical point has a type (source, sink, saddle) determined by the eigenvalues of the Jacobian of the linear field over the cell [16, 43]. Concretely, the eigenvalues of the Jacobian 𝐽 solve the characteristic equation 𝜆 2 − tr(𝐽 ) 𝜆 + det(𝐽 ) = 0, so with discriminant Δ = tr2 (𝐽 ) − 4 det(𝐽 ) the type is fixed by three signs: det(𝐽 ) < 0 gives a saddle; det(𝐽 ) > 0 gives a source when tr(𝐽 ) > 0 and a sink when tr(𝐽 ) < 0, which spirals when Δ < 0 (complex eigenvalues) and is a plain node when Δ ≥ 0. Preserving a point’s type thus amounts to preserving the signs of det(𝐽 ), tr(𝐽 ), and Δ. Type matters downstream: feature extraction, vortex detection, and separatrix tracing all classify and connect critical points by type, so a type change is as damaging as a spurious or missing point. Accordingly, we say a compressor preserves critical points when the reconstructed field satisfies all of the following with respect to the original: (P1) every original critical point survives, in the same cell (no loss of position); (P2) no new critical point appears where the original had none (no spurious points); and (P3) every preserved critical point retains its type (e.g., a source never becomes a saddle). FaCTz enforces P1–P3 jointly, on top of the pointwise error bound of §2.1. 2.3

Critical-Point-Preserving Lossy Compression

cpSZ [28, 30] is the reference method for P1–P3 and the starting point for FaCTz. It keeps the SZ pipeline of §2.1 and

FaCTz: Fast Critical-Point and Topology-Aware GPU Compression for Scientific Vector Fields 𝜇 = (0.3, 0.3, 0.4)

𝜇 = (−0.5, 0.6, 0.9)

(𝑢 2 , 𝑣2 )

(𝑢 2 , 𝑣2 )

(𝑢 0 , 𝑣0 ) (𝑢 1 , 𝑣1 )

(𝑢 0 , 𝑣0 ) (𝑢 1 , 𝑣1 )

(a) 0 ≤ 𝜇𝑘 ≤ 1

PPoPP ’27, TBD, TBD original

P2

P3

(b) some 𝜇𝑘 ∉ [0, 1]

Figure 1. A piecewise-linear cell in a triangular mesh contains a critical point iff the barycentric solution of Eq. (1) satisfies 0 ≤ 𝜇𝑘 ≤ 1 for all 𝑘. Left: a critical point exists; right: none. The right cell’s linear field still vanishes at the ★, but a negative 𝜇𝑘 places that zero outside the cell. Therefore, the current cell contains no critical point, and the neighboring cells must be examined separately.

saddle

adds one stage in front of it: before a vertex is quantized, cpSZ derives from the sign conditions of Eq. (1) a safe error bound, the sufficient but not necessary bound on the perturbation of that vertex under which no incident triangle can change its critical-point signature. Quantization then runs under the per-vertex minimum of that bound instead of the user’s 𝜖, so preservation costs compression ratio rather than correctness. cpSZ derives the bound in two ways, which differ in whether the derivation is coupled to compression. The decoupled (offline) variant makes a separate first pass that computes every vertex’s bound from the original field, then compresses in a second pass; the bounds are independent of one another, but they must be conservative enough to hold whatever the neighbors decompress to. The coupled (online) variant folds the derivation into the compression sweep, deriving each vertex’s bound against neighbors that have already been reconstructed. That is tighter and compresses better, but it makes the bound at one vertex depend on decisions at earlier ones, which serializes the sweep. FaCTz keeps this distinction and resolves the parallelism obstacle in each: its block-wise mode follows the decoupled route (§3.3) and its speculative mode the coupled one (§3.4). Motivating Observations

O1: Topology-agnostic GPU compressors corrupt critical points, even at tight error bounds. Because compressors such as cuSZ, cuSZp, and cuZFP quantize each value independently of any topological constraint, admissible pervalue perturbations flip the sign structure of Eq. (1) and thereby violate P1–P3 (Figure 2). At the error bounds that yield useful compression they corrupt topology, losing and spuriously creating critical points (§5.2); recovering it (when possible at all) demands a near-lossless bound at which the compression ratio collapses to barely above 1× (Table 2). High pointwise fidelity thus coexists with topological corruption unless compression is all but abandoned. Implication:

lost spurious

sink

(a) original data

2.4

P1

(b) ZFP decompressed data

Figure 2. A pointwise error bound does not protect topology. (a) Original field versus (b) its ZFP reconstructed data. Top: vectormagnitude rendering with critical points marked; Bottom: lineintegral-convolution (LIC) view of the flow. The magnitude fields look nearly identical, yet the reconstruction has lost three original critical points and introduced a spurious one, which corrupts the topology despite high pointwise fidelity (O1).

a pointwise error bound is necessary but not sufficient; the topological constraint must be built into the compressor. O2: The only critical-point-preserving compressor is CPU-bound. cpSZ provably preserves critical points but runs on the CPU at only ∼ 0.1–0.2 GB/s even when parallelized across 128 threads (§5.4). GPU simulations emit vector-field snapshots orders of magnitude faster, so inserting cpSZ into the pipeline turns compression into the bottleneck rather than a remedy. Implication: topology-preserving compression must itself run on the GPU, at a throughput commensurate with data generation. O3: No single operating point serves every deployment. Whether storage footprint or wall-clock time is the binding constraint varies across workflows. An in-situ pipeline racing alongside the simulation prioritizes throughput, whereas archival storage and wide-area data transfer prioritize compression ratio. A topology-preserving compressor should therefore expose a tunable trade-off rather than commit to a single operating point. Design implication: FaCTz provides two configurations: a throughput-oriented block-wise mode and a ratio-oriented speculative mode (§3).

3

Design

This section presents FaCTz’s design: the two-mode architecture and shared backbone (§3.1), the critical-point signature both modes enforce (§3.2), and the two ways FaCTz turns it into a safe error bound, an analytic block-wise mode (§3.3) and a speculative per-point mode (§3.4).

PPoPP ’27, TBD, TBD

Xia et al.

topology-aware

(𝑈 , 𝑉 ) vector field Block-wise: analytic safe bound; CP cells exact

Speculative: verify signature, back off per point

shared SZ backbone: predict + quantize → specials → Huffman / ANS

compressed stream

Figure 3. FaCTz pipeline: a mode-specific, topology-aware frontend (block-wise or speculative) precedes the shared SZ backbone, so the critical-point check happens before entropy coding.

3.1

Overview

FaCTz reuses a standard SZ-style backbone (prediction, errorcontrolled quantization with in-place reconstruction, specialvalue collection, and lossless entropy coding) but replaces its frontend with a mode-specific, topology-aware error-control stage that decides, before any value is committed, how much error each vertex may absorb without altering the field’s critical points (Figure 3). Whereas SZ-style backbones entropycode with Huffman [19], we additionally integrate an optional ANS coder (via nvCOMP) for higher throughput (§5.5). The two configurations do not share a frontend; they differ in when and how to resolve the topological constraint, which places them at opposite ends of the speed-ratio spectrum. The block-wise mode (§3.3) resolves it analytically and ahead of time, deriving a conservative safe bound per vertex under which an ordinary Lorenzo predictor compresses; the speculative per-point mode (§3.4) resolves it online, verifying at each vertex that the candidate reconstruction keeps every signature intact and backing off the bound only on failure. Both check critical points before entropy coding and provide a deterministic preservation guarantee (§3.5). 3.2

The Critical-Point Signature

Both modes rest on one primitive: deciding whether perturbing the vertex vectors changes the critical-point signature of a triangle. For a cell with vertex vectors (𝑢𝑖 , 𝑣𝑖 ), the signature records (i) whether a critical point lies inside—i.e., whether the barycentric solution of Eq. (1) satisfies 0 ≤ 𝜇𝑘 ≤ 1—and (ii) if so, its type, given by the eigenstructure of the cell’s Jacobian. Preserving P1–P3 (§2.2) over the whole field is exactly preserving the signature of every triangle. On a regular grid triangulated in the usual way, an interior vertex is shared by up to six triangles, so the error admissible at a vertex is coupled to all of them: a change is safe only if it preserves the signature of every incident cell. This manyto-one coupling (one vertex, up to six constraints) is why critical-point preservation resists naive parallelization, and the two modes handle it differently. Evaluating a signature exactly needs the barycentric solution of Eq. (1) and a Jacobian eigen-classification, most robustly in double precision, costly on GPUs whose FP64

throughput is a fraction of FP32’s. FaCTz therefore tests each triangle in two tiers: a single-precision interval filter that conservatively proves the field cannot vanish in the triangle (so its signature cannot change) settles the common case, and only the few ambiguous triangles fall through to the exact test. Because most triangles lie far from a critical point, this filter removes the bulk of the double-precision work; it is what makes the per-point verification of §3.4 affordable. 3.3

Block-Wise Mode: Analytic Safe Bounds

The block-wise mode computes, ahead of prediction, a pervertex error bound that is guaranteed safe, in four steps: 1. Per-triangle safe bound. For each triangle we derive a conservative relative bound from the sign conditions of Eq. (1), following the critical-point-preserving error analysis of Liang et al. [28]: a closed-form sufficient bound (not a searched, and not necessarily the maximal feasible, value) under which no admissible perturbation can flip the cell’s signature. 2. Per-vertex minimum. Each vertex takes the minimum bound over its (up to six) incident triangles, discharging the coupling of §3.2. 3. Absolute bound and quantization. The relative bound is scaled by |𝑈 | and |𝑉 | to yield separate absolute bounds for the two components, discretized into integer error-bound IDs. 4. Tile common bound. Within each 32 × 32 vertex tile we take the minimum ID separately for 𝑈 and 𝑉 , yielding two per-tile common bounds eb𝑈 and eb𝑉 (the components are not forced to share one bound). A single common bound per tile lets the Lorenzo predictor and quantizer run without per-vertex bound bookkeeping. Step 1 is derived as follows. Each sign condition of Eq. (1) is the sign of a 2 × 2 determinant 𝐷 of the cell’s vector components (one of the barycentric numerators 𝑚𝑘 or the orientation 𝑚 of Eq. (2)), a signed sum of degree-two products of the values. Writing 𝐷 = 𝑃+ − 𝑃 − , where 𝑃+ and 𝑃 − collect the magnitudes of its positive and negative product terms, a value-range-relative perturbation of size 𝜉 keeps every value within 𝑣 (1 ± 𝜉) and hence moves each degree-two product by at most a factor of (1 ± 𝜉) 2 ; the sign of 𝐷 cannot flip while 𝑃+ (1 − 𝜉) 2 ≥ 𝑃 − (1 + 𝜉) 2 , yielding the closed-form safe bound √ √ 𝑃+ − 𝑃 − (3) 𝜉 safe (𝐷) = √ √ . 𝑃+ + 𝑃 − The per-triangle bound of step 1 is the minimum of 𝜉 safe over the determinant-sign conditions that keep the cell critical√ point-free [28]; the · arises because each determinant term is a product of two perturbed values. Triangles that already contain a critical point (or are degenerate) return a safe relative bound of zero, so all three of their vertices (both components) receive error-bound ID 0 and are recorded in a

FaCTz: Fast Critical-Point and Topology-Aware GPU Compression for Scientific Vector Fields

zero-EB mask/value side stream that restores their original values on decompression. A positive analytic bound therefore protects every triangle that has no critical point (P2), and exact storage secures P1 and P3. Because the per-vertex bound is derived before tiling and the tile minimum only ever shrinks it, correctness does not depend on triangles staying within a tile. Bound derivation is thus a fixed-stencil pass with no cross-tile dependence, making the block-wise mode embarrassingly parallel (§4 gives the CUDA patch layout).

3.4

Speculative Per-Point Mode: Parallel Verify-and-Back-Off

The speculative mode keeps the user’s full error bound wherever topology allows and tightens it only where a critical point would otherwise change, which is why it reaches a higher ratio. FaCTz breaks the sequential dependence of cpSZ’s coupled variant (§2.3) with a dyadic multiresolution schedule that exposes wide parallelism at every level while keeping the encoder and decoder in lockstep. Multiresolution schedule. Over the same mesh (no downsampled copies are built), an anchor kernel first stores the vertices on a stride-𝑠 0 Cartesian lattice losslessly (default 𝑠 0 = 16); these anchors are never predicted and serve as exact starting points, with a sentinel eliding the degenerate (𝑈 , 𝑉 ) = (0, 0) case. Prediction then densifies the grid over log2 𝑠 0 levels, halving the step at each level down to 1. Each level fills the vertices lying halfway between the previous level’s points in three ordered phases (Figure 4): horizontal vertices, predicted from the two committed neighbors at ±step along the row (𝑥ˆ = 12 (𝑥 𝐿 + 𝑥 𝑅 )); then vertical vertices (𝑥ˆ = 12 (𝑥𝑇 + 𝑥 𝐵 )); then center vertices, from a 2D Lorenzo stencil (𝑥ˆ = 𝑥𝑇 + 𝑥 𝐿 − 𝑥𝑇 𝐿 at offset −step). One anchor kernel plus three phases per level is 1 + 3 log2 𝑠 0 kernel launches (13 at the default 𝑠 0 =16). Where the parallelism comes from. Within a single phase, every target vertex is spaced 2 × step from the next and reads only already-committed neighbors (anchors or coarserlevel points), never another target of the same phase. No two threads in a phase therefore touch a shared triangle, so the phase is embarrassingly parallel: FaCTz maps one thread to each target vertex and keeps hundreds of thousands of vertices in flight (Figure 4). The phases themselves are not parallel with one another: the horizontal and vertical phases each read only the coarser level, but the center phase reads the horizontal and vertical vertices it sits between, so it must run after both. FaCTz therefore issues the three phases as three ordered kernel launches per level (horizontal, vertical, then center), and the levels coarse-to-fine. Each committed value is written in place, so the next level reads the decompressed value and the decompressor, replaying the identical 13-launch schedule, reconstructs bit-for-bit.

(a) horizontal committed

PPoPP ’27, TBD, TBD

(b) vertical horizontal

(c) center vertical

center

Figure 4. FaCTz-S parallel schedule for one refinement level: (a) horizontal targets, predictor 12 (𝑥 𝐿 +𝑥 𝑅 ), and (b) vertical, 12 (𝑥𝑇 +𝑥 𝐵 ), are mutually independent; (c) center, 𝑥𝑇 +𝑥 𝐿 −𝑥𝑇 𝐿 , then reads both. Gray vertices are already committed; arrows indicate stencil.

Algorithm 1 summarizes the end-to-end pipeline. At each target vertex the mode runs deferred-commit speculation: it forms candidate reconstructions for 𝑈 and 𝑉 at the current bound, then checks the signatures of all (up to six) incident triangles. A triangle’s signature encodes both whether it contains a critical point and, if so, its type: the signs of the barycentric numerators together with those of det(𝐽 ), tr(𝐽 ), and Δ (§2.2). Unlike the block-wise mode, the speculative mode preserves these type signs directly through an analogous safe bound. According to [28], the determinant and trace signs give a bound of the Eq. (3) form, but the discriminant Δ is quadratic in the perturbation 𝜉; the same sign-margin argument then yields the safe bound as a root of that quadratic, √︁  𝜉 type = 𝐿 2 − 4𝑄Δ − 𝐿 /2𝑄, (4) where 𝐿 and 𝑄 are the first- and second-order sensitivities of Δ to 𝜉 (recovering the linear bound |Δ|/𝐿 of Eq. (3) as 𝑄 → 0). This lets a critical-point-bearing cell keep a positive bound instead of being stored exactly. If every signature is unchanged, it commits the candidate reconstruction and quantization codes. If any check fails, it decrements the errorbound ID of both components and retries, down to eb = 0. Bounds live on a logarithmic grid, so the ID is the log of the bound it encodes and one decrement tightens that bound by a fixed factor (Algorithm 1). If even the exact candidate fails (a degenerate configuration), the vertex’s (𝑈 , 𝑉 ) pair is stored as a raw special value. Committing a candidate is the first write-back, so a failed attempt costs nothing to undo: the retry is a purely local, deferred commit rather than a block-wide rollback. This dependency-ordered schedule makes the speculative mode slower than block-wise, but by letting most vertices keep the full requested bound (§3.5 proves preservation) it reaches a substantially higher ratio. 3.5 Correctness Let 𝜎 (𝑇 ; 𝑥) denote the critical-point signature of triangle 𝑇 evaluated on a field 𝑥 (§3.2). By construction, P1–P3 hold

PPoPP ’27, TBD, TBD

Algorithm 1 FaCTz-S: end-to-end speculative compression Require: field (𝑈 , 𝑉 ) on device; relative bound 𝜏; anchor stride 𝑠 0 Ensure: compressed stream (device-resident) 1: 𝜖 ← 𝜏 · range(𝑈 , 𝑉 )  ⊲ absolute bound 2: eb(id) ← ebmin 𝛽 id ; idmax ← log𝛽 (𝜖/ebmin ) ⊲ bounds on a logarithmic grid, so the stored id is the log of the bound 3: store every 𝑠 0 -th vertex exactly (anchors) ⊲ one kernel 4: for step = 𝑠 0 /2, 𝑠 0 /4, . . . , 1 do ⊲ log2 𝑠 0 levels 5: for phase ∈ {horizontal, vertical, center} do ⊲ one kernel each; launch = global barrier 6: for all target vertices of the phase in parallel do 7: 𝜎𝑇 ← Signature(𝑇 ) for each incident triangle 𝑇 (§3.2) 8: for id = idmax down to 0 do ⊲ each step down tightens the bound by 𝛽 ˜ 𝑣) ˜ ← predict from committed neigh9: candidate (𝑢, bors (±step), quantize at bound eb(id) 10: if Signature(𝑇 ) = 𝜎𝑇 for every incident 𝑇 then ˜ 𝑣), ˜ codes (𝑞𝑢 , 𝑞 𝑣 ), and id; break 11: commit (𝑢, 12: if nothing committed: mark vertex raw (exact (𝑢, 𝑣)) 13: compact raw/anchor values: bit-mask → prefix scan → side stream 14: entropy-code the four streams 𝑞𝑈 , 𝑞𝑉 and id𝑈 , id𝑉 (ANS) 15: return coded blobs + raw side stream + header

˜ = 𝜎 (𝑇 ; 𝑥) for every triangle 𝑇 , where 𝑥˜ is the iff 𝜎 (𝑇 ; 𝑥) decompressed data; this is what both modes prove. Block-wise mode. Eq. (3) is a sufficient bound: if every vertex of a critical-point-free triangle 𝑇 carries relative error at most 𝜉 safe (𝐷) for each determinant 𝐷 in 𝑇 ’s signature, then 𝑃+ (1 − 𝜉) 2 ≥ 𝑃 − (1 + 𝜉) 2 still holds, no determinant sign can ˜ = 𝜎 (𝑇 ; 𝑥). The mode enforces this hypotheflip, and 𝜎 (𝑇 ; 𝑥) sis: each vertex is quantized under the minimum of 𝜉 safe over its incident triangles, and the per-tile reduction only tightens that bound, so every critical-point-free triangle keeps its signature (P2); critical-point-bearing and degenerate triangles are stored exactly (eb = 0), preserving theirs verbatim (P1, P3). Speculative mode. Write the schedule of §3.4 as a sequence ˜ where 𝑠 is of states 𝑥 = 𝑥 (0) → 𝑥 (1) → · · · → 𝑥 (𝑠 ) = 𝑥, the total number of steps. For a vertex at one specific step 𝑖, our algorithm will either keep the original value of the vertex as it is or issue a commit that changes its value. For any triangle T in the grid, at most one vertex is modified at one step due to the carefully designed parallel schedule (see Figure 4). If the original value is kept for a vertex, we have 𝜎 (𝑇 ; 𝑥 (𝑖 ) ) = 𝜎 (𝑇 ; 𝑥 (𝑖 −1) ) trivially for all its incident triangles, as nothing has been changed. If one commit is issued, 𝜎 (𝑇 ; 𝑥 (𝑖 ) ) = 𝜎 (𝑇 ; 𝑥 (𝑖 −1) ) is also ensured for all its incident triangles, as our verification admits the commit only if such condition holds (line 10 in Algorithm 1). Every step ˜ = therefore preserves every signature, and we have 𝜎 (𝑇 ; 𝑥) 𝜎 (𝑇 ; 𝑥) for all 𝑇 by induction on 𝑖. This guarantees that the decompressed field 𝑥˜ has the same signatures on all triangles as the original data 𝑥 and thus the same critical points.

Xia et al.

Both guarantees are deterministic (zero lost, spurious, or type-changed points), and the decompressor needs no side information beyond the committed codes and raw specials.

4

Implementation

We implement FaCTz in CUDA. For the lossless backend, we reuse mature components: the Lorenzo prediction kernels and the GPU Huffman codec from cuSZ [45, 46], and the ANS coder from NVIDIA nvCOMP 5 [38]. Our additions are the topology-aware frontends, error-bound-aware extensions to the Lorenzo kernels (per-element and per-tile bound variants), and the whole-pipeline orchestration. Both modes default to the ANS coder. Fields are kept as structure-ofarrays: 𝑈 and 𝑉 occupy separate row-major buffers and produce independent quantization and error-bound-ID streams throughout. 4.1

Block-Wise Mode

The block-wise compressor runs entirely on the device as four stages: (1) error-bound derivation, (2) special classification with per-tile bound reduction, (3) Lorenzo prediction and quantization under the per-tile uniform bound, and (4) entropy coding. Stage 1 is a 32×16-thread kernel that stages a vertex patch and its two-vertex halo in shared memory (𝑥-padded to avoid bank conflicts), computes the per-triangle safe bound, and min-reduces it over each vertex’s incident cells. Stage 2 is a single fused kernel that replaces four earlier passes: it detects degenerate points (𝑈 = 𝑉 = 0) and zerobound (exact) vertices, rewrites their IDs, emits bit-packed masks with __ballot_sync, and warp/block-min-reduces the IDs to one common bound per 32 × 32 tile, all in a single sweep of the field, removing three full-field re-reads and the intermediate arrays they need. The tile-uniform bound pays off twice: it shrinks the error-bound side channel from 𝑛 symbols to 𝑛/1024 (stored raw), and it lets the tile use a parallel prefix-sum Lorenzo instead of the sequential row-scan variant, which we measure at roughly 8× faster. Exact zerobound values are gathered into side streams by populationcounting the bit-masks and a CUB exclusive scan [37], so no per-element flag array is ever materialized. 4.2

Speculative Mode

The speculative mode issues the 13-launch schedule (§3.4) with 256 threads per block, 1 thread per target vertex handling both components. The speculate–verify–back-off loop uses no shared memory, reading neighbors from global memory over a ±step stencil, and applies the two-tier signature test (§3.2). Raw and anchor values are stream-compacted with a bit-mask plus a CUB exclusive scan before coding. Critical-point predicates use double precision in this mode (the block-wise mode’s analytic bound runs in single precision), making the topological decision never a source of error itself.

FaCTz: Fast Critical-Point and Topology-Aware GPU Compression for Scientific Vector Fields

Table 1. Vector-field datasets. Each vertex stores (𝑢, 𝑣) as float32, so the raw size is #vertices × 8 bytes. Dataset

Resolution

#Vertices

Raw size

#Critical pts

Ocean DT-10K DT-20K

2400 × 3600 10000 × 10000 20000 × 20000

8.64 M 100 M 400 M

66 MB 763 MB 2.98 GB

20,929 11,500 228

4.3

Entropy Backend and 𝑈 /𝑉 Concurrency

We drive both coders through thin bridges over the vendored kernels. Because 𝑈 and 𝑉 are coded independently, these bridges overlap their work: the two Huffman codebooks are built concurrently on separate host threads and the two histograms run on separate CUDA streams, while the two encode passes are then issued serially, since one parallel Huffman encode already saturates the GPU. The ANS path adds the byte-plane transform of Figure 5 before coding: because most zigzag-mapped residuals are small, the highbyte plane is almost entirely zeros and compresses to nearly nothing, which raises the ratio. The four planes (the low and high bytes of 𝑈 and 𝑉 ) are compressed together as a single four-plane nvCOMP ANS batch. low byte → ANS

quant 𝑞 4097 4095 4098 4096 4300 4094

2

𝑞 − 𝑟 , zig-zag 2

1

4

0

408

1

4

0

152

the transform-based cuZFP [31]. We additionally compare against CPU cpSZ as the topology-preserving reference [28]. Only FaCTz and cpSZ preserve critical points; the others are topology-agnostic and included to quantify the ratio, quality, and throughput FaCTz trades for its guarantee. FaCTz configurations. FaCTz runs in two modes, blockwise (FaCTz-B) and speculative per-point (FaCTz-S), and each mode pairs with either a Huffman (H) or an ANS (A) entropy coder, giving four configurations: FaCTz-B-H, FaCTzB-A, FaCTz-S-H, and FaCTz-S-A. Coding is lossless, so the coder changes only ratio and throughput, never fidelity or topology. Unless a coder is named we use the ANS coder for both, FaCTz-B-A and FaCTz-S-A, and write FaCTz-B and FaCTz-S for these defaults. Metrics. For quality we report rate-distortion performance. The rate is the bit-rate, 32/compression ratio for float32 data. Distortion has two faces: we measure pointwise fidelity by PSNR and topological fidelity by the P1/P2/P3 violation counts (lost, spurious, and type-changed critical points) relative to the original field. For performance we report compression and decompression throughput as GPU end-to-end throughput, the input size divided by the wall-clock from the input field resident on the device to the output blobs ready on the device.

3

high byte → ANS ≈ 0 B 3

0

0

0

0

1

0

5.2 Figure 5. ANS frontend: a 16-bit quantization code (radius 𝑟 ) is zig-zag mapped, then split into low- and high-byte planes coded independently.

5

Evaluation

In this section, we evaluate FaCTz on three vector-field datasets, measuring its topology preservation, fidelity, compression ratio, and throughput against state-of-the-art GPU and CPU compressors on a GPU cluster [2]. 5.1

PPoPP ’27, TBD, TBD

Experimental Setup

Platform. All experiments run on a single NVIDIA A100SXM4 GPU in a dual-socket host with two AMD EPYC 7742 processors. We compile with CUDA 12.6. Datasets. We evaluate on three 2D vector fields, each with two float32 components (𝑢, 𝑣) per vertex on a triangular mesh (Table 1). DT-10K and DT-20K are 2D decaying turbulence fields generated with the Basilisk solver [39] from random band-limited initialization, at 10000 × 10000 and 20000 × 20000 resolution. Ocean is a smaller 2400 × 3600 ocean-current field. Baselines. We compare FaCTz against a broad set of GPU error-bounded compressors: cuSZ [45] and its interpolationpredictor variant cuSZ-i [35], the ultra-fast cuSZp [18], and

Topology Preservation and Fidelity

The central claim is that FaCTz preserves critical points that topology-agnostic compressors sacrifice, and does so without giving up fidelity. We extract the critical points of the original and reconstructed fields with FTK [14] and count P1–P3 violations. Figure 6 plots, for each dataset, PSNR (top) and the number of critical-point violations P1 + P2 + P3 (bottom) against bit-rate, for FaCTz and every GPU baseline. FaCTz-B and FaCTz-S sit at exactly zero violations across the whole bit-rate range and every error bound, on all datasets. No baseline does, and their failure splits in two ways. The prediction-based cuSZ and cuSZp reduce topology error only by spending more bits: their curves fall as bit-rate rises, but flatten out well above zero and reach acceptable topology only near lossless, where the compression ratio is negligible. The transform-based cuZFP and the interpolation-based cuSZ-i are worse and, tellingly, almost bit-rate-independent: they inject tens of thousands of spurious critical points no matter how many bits they spend. cuZFP still reports ≈ 55,000 violations on Ocean at 129 dB PSNR. High pointwise fidelity therefore does not imply topological correctness, and no baseline buys that correctness with more storage (O1). The top row shows the converse is cheap for FaCTz: FaCTz-B is near-lossless (the highest-PSNR curve on every dataset) and FaCTz-S stays within the fidelity band of the strongest baselines, so the topological guarantee costs little PSNR.

PPoPP ’27, TBD, TBD

Xia et al.

PSNR (dB)

150

# violations

Ocean

104

DT-10K

Table 2. Comparison at each method’s topology-preserving bound: the loosest setting and error bound giving zero critical-point violations, with the compression ratio (CR) and GPU end-to-end throughput there. FaCTz preserves topology at every bound.

DT-20K

100 50 Dataset

Compressor

Set.

eb

CR

Comp. (GB/s)

Decomp. (GB/s)

Ocean

cuSZa cuSZ-ia cuSZp nvCOMP Zstdc FaCTz-B FaCTz-S

n/a n/a rel – – –

n/a n/a 5e−9 – – –

n/a n/a 2.00× 1.60× 2.36× 6.01×

n/a n/a 39.1 3.9 36.0 29.4

n/a n/a 29.0 5.7 63.9 72.8

DT-10K

cuSZa cuSZ-ia cuSZp nvCOMP Zstdc FaCTz-B FaCTz-S

n/a n/a rel – – –

n/a n/a 1e−8 – – –

n/a n/a 1.37× 1.08× 5.98× 12.99×

n/a n/a 88.6 4.3 47.0 45.2

n/a n/a 133.5 28.6 133.2 85.8

DT-20K

cuSZ cuSZ-ib cuSZp nvCOMP Zstdc FaCTz-B FaCTz-S

rel n/a rel – – –

5e−8 3.36× n/a n/a 5e−8 1.50× – 1.09× – 6.67× – 16.63×

58.3 n/a 123.0 4.5 60.1 41.5

42.9 n/a 275.5 35.8 139.2 89.4

102 100 0 0

10

20 0

10

20 0

10

20

Bit-rate FaCTz-S

FaCTz-B

cuSZ

cuSZ-i

cuSZp

cuZFP

Figure 6. Fidelity and topology versus bit-rate, one column per dataset. Top: PSNR. Bottom: critical-point violations (P1 + P2 + P3). FaCTz-B and FaCTz-S hold at zero violations across all bit-rates and datasets; no baseline does. cuSZ-i is N/A on DT-20K. cuZFP is fixedrate and is run at bit-rates matching cuSZ’s. Bit-rate = 32/ratio.

5.3

Comparison with GPU State-of-the-Art

§5.2 compared all methods across the full rate range. We now adopt a stricter and, for topology, more honest criterion: each method is compared only at the error bound where it actually preserves every critical point. At any looser bound the baseline corrupts topology (§5.2) and the comparison is meaningless; only at its topology-preserving bound do the baseline and FaCTz deliver the same guarantee. Table 2 reports, for each baseline and dataset, the loosest such bound, found by sweeping the relative and absolute bounds downward from 10−5 in half-decade steps (1 and 5 per decade) and finally testing the limiting case eb = 0, and the compression ratio there, against FaCTz’s two modes, which preserve topology at every bound. cuZFP is omitted: its only CUDA mode is fixed-rate and never preserves all critical points, and preservation is reachable only through ZFP’s CPU-only near-lossless and reversible modes. The table also includes a GPU lossless compressor, nvCOMP’s Zstd [38], as the trivial end of the same spectrum: it preserves every critical point by construction, so its ratio is the floor any topology-preserving lossy compressor must beat to be worth using. That floor is low, 1.08–1.60× at 3.9–4.5 GB/s compression, whereas FaCTz delivers the same guarantee at 2.4–16.6× and roughly an order of magnitude higher throughput. The table makes the cost of the topological guarantee stark for the baselines. On the DT-10K and Ocean fields, cuSZ and cuSZ-i never preserve topology at any bound down to 0: once the bound is tight enough to matter, cuSZ misses every critical point in the field, and cuSZ-i’s spline predictor never yields a topology-preserving reconstruction. The methods that do preserve (cuSZp on every field, and cuSZ only on

a Never preserves all critical points: we swept both absolute and relative

bounds down to 5 × 10 −12 without recovering the full set (cuSZ-i crashed on these grids). b cuSZ-i’s spline predictor cannot run on the 20000×20000 grid (a known upstream limit at large 2D sizes), so it is N/A there. c GPU lossless compressor: it preserves topology by construction (eb = 0), so its ratio is the incompressible floor for this data.

EB

EP

LP

HF

Ocean DT-10K DT-20K 0 20 40 60 80 100 Share of compression kernel time (%) Figure 7. Per-stage compression-kernel time of FaCTz-B-H (the Huffman path) at 𝜏 = 0.1, normalized per dataset. Blue stages (EB, EP) are critical-point-specific; the SZ backbone (LP, HF) is the rest.

DT-20K) require a near-lossless bound, and their compression ratio there collapses to 1.4–3.4×. FaCTz, in contrast, preserves every critical point while still compressing substantially (FaCTz-B at 2.4–6.7× and FaCTz-S at 6.0–16.6× across the three fields), a far higher ratio than any baseline reaches for the identical guarantee, and entirely on the GPU. Throughput in context. FaCTz is slower than the topologyagnostic GPU compressors at any fixed bound, which is expected as it performs work they omit entirely: every candidate reconstruction is checked against the critical-point signatures of its incident triangles, and the block-wise mode additionally derives an analytic safe bound for every triangle.

Ocean

DT-10K

PPoPP ’27, TBD, TBD

DT-20K

101 100 10−1

0.1 0.05 0.01 0.005 0.001 FaCTz-S

0.1 0.05 0.01 0.005 0.001 0.1 0.05 0.01 0.005 0.001 Error bound τ FaCTz-B cpSZ online cpSZ offline

15 10 5 0

Compression ratio

Comp. throughput (GB/s)

FaCTz: Fast Critical-Point and Topology-Aware GPU Compression for Scientific Vector Fields

Figure 8. GPU versus CPU cpSZ across error bounds, one panel per dataset: compression throughput (grouped bars, left log axis) and compression ratio (lines, right axis) for FaCTz-S, FaCTz-B, and our OpenMP-parallel CPU cpSZ in its online and offline modes.

But a fair speed reference must also preserve topology, and no GPU baseline does so at a useful ratio (§5.4). A per-stage breakdown of FaCTz-B (Figure 7) localizes the cost of the guarantee. The critical-point-specific work, bound derivation (EB) and the exception-packing kernels (EP) that follow it to classify and compact the vertices needing exact (eb = 0) treatment, accounts for only about 30% of the compression kernel time; the remaining ∼ 70% is the conventional SZ backbone of Lorenzo prediction (LP) and Huffman coding (HF), itself dominated by entropy coding. The topological guarantee is thus a bounded surcharge on a standard prediction-pluscoding pipeline rather than a pervasive overhead, and the single largest cost is the shared entropy coder, which ANS alone accelerates substantially (§5.5). cuSZp avoids that cost altogether: its fixed-length encoder skips variable-length entropy coding, which is why it is faster and why it compresses so little. 5.4

Comparison with CPU cpSZ

As §5.2 established, the only existing compressor that preserves critical points is the CPU-based cpSZ, so comparing FaCTz’s GPU throughput against a CPU-serial cpSZ would be unfair. To make the comparison fair, we implement an OpenMP-parallel version of cpSZ ourselves. Its offline (twopass) variant parallelizes the per-triangle bound derivation over even and then odd grid rows, which is race-free because each vertex’s bound is a pointwise minimum and hence orderindependent. Its online (single-pass) variant is inherently sequential (each cell depends on its up, left, and upper-left neighbors), so we parallelize it as a wavefront: cells on the same anti-diagonal are mutually independent and run concurrently, with a barrier between diagonals preserving the serial dependency order. Figure 8 compares both FaCTz modes against this parallel cpSZ, run with 128 threads on a separate AMD EPYC 7713 CPU, across five error bounds spanning 10−1 to 10−3 on all three datasets. In throughput (bars, left log axis), both FaCTz modes are roughly two orders of magnitude faster: FaCTz sustains 25–60 GB/s while even the 128-thread cpSZ reaches only ∼ 0.1–0.2 GB/s, a 174–643× speedup mode-formode. In compression ratio (lines, right axis), cpSZ’s two

variants reach 4–15×: its framework stacks the Zstd lossless compressor [9, 48] on top of entropy coding, which raises the ratio but further lowers its throughput. This puts cpSZ above FaCTz-B on every field and above FaCTz-S on Ocean, whereas FaCTz-S stays comparable on DT-10K (13.0 versus 13.7× at 𝜏=0.1) and clearly higher on DT-20K (16.6 versus 9.4×). FaCTz thus turns topology-preserving compression from a pipeline bottleneck (O2) into a negligible cost, and its speculative mode keeps the ratio competitive with the CPU reference while doing so.

5.5

Throughput across Configurations

Figure 10 breaks throughput down across the four FaCTz configurations, and three trends hold on every dataset. First, the ANS coder is faster than Huffman in both stages, and markedly so on decompression: FaCTz-B-ANS decompresses DT-10K at 131 GB/s against 41 GB/s for FaCTz-B-HF. Second, the block-wise mode is generally faster than the speculative one, especially on compression: the per-point speculate– verify–back-off loop performs strictly more work, the price FaCTz-S pays for its higher compression ratio (§5.4). Third, decompression is faster than compression throughout (often by 2–3× with ANS), because decoding merely replays the recorded decisions, with no bound derivation or verification. In absolute terms FaCTz compresses at up to ∼ 60 GB/s and decompresses at up to ∼ 140 GB/s, faster than the interpolation-based cuSZ-i (5–15 GB/s) while additionally preserving every critical point.

5.6

Visual Comparison of Reconstructions

Figure 9 makes the contrast visible on DT-10K (CR ≈ 16) and Ocean (CR ≈ 6). On both fields every reconstruction is visually near-indistinguishable from the original, with finescale texture intact in the zoom insets. The critical points, however, differ sharply: FaCTz-S is entirely green (every critical point preserved), whereas cuSZp and cuZFP scatter P1–P3 violations across the domain, most densely in the turbulent regions where critical points concentrate.

PPoPP ’27, TBD, TBD

Xia et al.

original/preserved critical points

P1

P2

P3

max

(a) original (DT_10K)

(b) FaCTz-S(CR=~16)

(f) FaCTz-S(CR=~6)

(e) original(Ocean)

0

max (c) cuSZp(CR=~16)

(d) cuZFP(CR=~16)

(g) cuSZp(CR=~6)

(h) cuZFP(CR=~6)

Figure 9. Critical points overlaid on reconstructions at matched compression ratio, with LIC visualized as context: DT-10K turbulence (left, CR ≈ 16, first 2500 × 2500 region) and Ocean (right, CR ≈ 6). Within each field: (a, e) original, (b, f) FaCTz-S, (c, g) cuSZp, (d, h) cuZFP. Points are colored by fate—green: preserved; magenta, gray, blue: lost (P1), spurious (P2), and type-changed (P3). FaCTz-S preserves every point (all green); the topology-agnostic baselines scatter P1–P3 violations. Insets zoom the boxed region; background color is vector-field magnitude.

50

Decompression GB/s

GB/s

Compression 0

n K K ea 10 T-20 Oc DTD FaCTz-B-HF FaCTz-B-ANS

100 0

n K K ea 10 T-20 Oc DTD FaCTz-S-HF FaCTz-S-ANS

Figure 10. Per-configuration GPU end-to-end throughput.

6

Related Work

Error-bounded lossy compression. Prediction-based methods such as the SZ compressor family [7, 29, 34, 54] and FPZIP [33] predict each value from decoded neighbors and quantize the residual; transform-based methods (ZFP [31], SPERR [24], TTHRESH [3], MGARD [1]) truncate transform coefficients. Both bound only the magnitude of per-value error and ignore derived topology, the gap FaCTz addresses [8]. GPU compressors. To keep pace with data-generation rates, these pipelines have been ported to GPUs. Representative compressors include cuSZ [44, 45], cuSZp [17, 18], cuSZi [35], SZx [53], cuZFP [31], and LC [10]; the same pipelines have also been carried to wafer-scale engines [41, 42]. Together they reach tens to hundreds of GB/s. FaCTz reuses such a backend (§4) but differs in kind: it is the first GPU compressor to guarantee critical-point preservation, rather than merely enforcing a pointwise error bound. Topology-preserving compression. A separate line preserves derived topology under an error bound. For vector

fields, cpSZ preserves critical points [28, 30], and its variation [49] leverages sign-of-determinant predicates to make the guarantee robust to numerical degeneracy. TspSZ [50] further extends preservation to the full topological skeleton. For scalar fields, methods preserve contour trees [51] and Morse–Smale complexes [26, 27], a general framework augments existing lossy compressors with topological guarantees [13], and a concurrent effort reaches GPU and distributed scale but for scalar-field descriptors rather than vector-field critical points [25]. TFZ carries the idea to secondorder tensor fields [12]. The vector-field methods, however, run on the CPU far below GPU rates (§2.4), and the scalarfield efforts do not address vector-field topology.

7

Conclusion

Error-bounded lossy compression is indispensable for GPUscale scientific simulation, yet a pointwise bound does not protect vector-field topology, and the only compressor that does runs on the CPU far too slowly. We presented FaCTz, the first GPU error-bounded lossy compressor that provably preserves critical points, by decoupling the inherently coupled preservation constraint into independent parallel work in two modes: an analytic block-wise mode for throughput and a speculative per-point mode for ratio. FaCTz preserves every critical point across all datasets and bounds while compressing on the GPU at up to 60 GB/s, two orders of magnitude (up to ∼ 640×) faster than parallel CPU cpSZ, while its speculative mode roughly doubles the block-wise ratio.

FaCTz: Fast Critical-Point and Topology-Aware GPU Compression for Scientific Vector Fields

Acknowledgments Generative AI tools were used to assist with language editing, figure-generation scripts, and LATEX formatting. All technical content, algorithms, data, and claims were authored and verified by the authors.

References [1] Mark Ainsworth, Ozan Tugluk, Ben Whitney, and Scott Klasky. 2019. Multilevel Techniques for Compression and Reduction of Scientific Data—The Multivariate Case. SIAM Journal on Scientific Computing 41, 2 (2019), A1278–A1303. doi:10.1137/18M1166651 [2] Anonymous. 2026. Cluster name withheld for double-blind review. The name of the GPU cluster used for the experiments is omitted because it would identify the authors’ institution; it will be given in the camera-ready version. [3] Rafael Ballester-Ripoll, Peter Lindstrom, and Renato Pajarola. 2020. TTHRESH: Tensor Compression for Multidimensional Visual Data. IEEE Transactions on Visualization and Computer Graphics 26, 9 (2020), 2891–2903. doi:10.1109/TVCG.2019.2904063 [4] Franck Cappello, Sheng Di, Sihuan Li, Xin Liang, Ali Murat Gok, Dingwen Tao, Chun Hong Yoon, Xin-Chuan Wu, Yuri Alexeev, and Frederic T. Chong. 2019. Use Cases of Lossy Compression for FloatingPoint Data in Scientific Data Sets. The International Journal of High Performance Computing Applications 33, 6 (2019), 1201–1220. doi:10.1177/1094342019853336 [5] Franck Cappello, Robert Underwood, Yuri Alexeev, Alison Baker, Ebru Bozdağ, Martin Burtscher, Kyle Chard, Sheng Di, Kyle Gerard Felker, Paul Christopher O’Grady, Hanqi Guo, Yafan Huang, Peng Jiang, Sian Jin, Petter Johansson, Shaomeng Li, Xin Liang, Erik Lindahl, Peter Lindstrom, Zarija Lukić, Magnus Lundborg, Danylo Lykov, Masaru Nagaso, Kento Sato, Amarjit Singh, Seung Woo Son, Shihui Song, William Tang, Dingwen Tao, Jiannan Tian, Kazutomo Yoshii, and Kai Zhao. 2025. What to Support When You’re Compressing: The State of Practice, Gaps and Opportunities for Scientific Data Compression. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis (SC). 1966–1979. doi:10. 1145/3712285.3759856 [6] Jieyang Chen, Qian Gong, Yanliang Li, Xin Liang, Lipeng Wan, Qing Liu, Norbert Podhorszki, and Scott Klasky. 2025. HPDR: Highperformance portable scientific data reduction framework. In 2025 IEEE International Parallel and Distributed Processing Symposium (IPDPS). IEEE, 1104–1116. [7] Sheng Di and Franck Cappello. 2016. Fast Error-Bounded Lossy HPC Data Compression with SZ. In 2016 IEEE International Parallel and Distributed Processing Symposium (IPDPS). IEEE, Chicago, IL, USA, 730–739. doi:10.1109/IPDPS.2016.11 [8] Sheng Di, Jinyang Liu, Kai Zhao, Xin Liang, Robert Underwood, Zhaorui Zhang, Milan Shah, Yafan Huang, Jiajun Huang, Xiaodong Yu, Congrong Ren, Hanqi Guo, Grant Wilkins, Dingwen Tao, Jiannan Tian, Sian Jin, Zizhe Jian, Daoce Wang, Md Hasanur Rahman, Boyuan Zhang, Shihui Song, Jon Calhoun, Guanpeng Li, Kazutomo Yoshii, Khalid Alharthi, and Franck Cappello. 2025. A Survey on ErrorBounded Lossy Compression for Scientific Datasets. Comput. Surveys 57, 11, Article 287 (2025), 38 pages. doi:10.1145/3733104 [9] Facebook, Inc. 2016. Zstandard: Fast Real-Time Compression Algorithm. Software library. https://github.com/facebook/zstd. Accessed 2026. [10] Alex Fallin, Noushin Azami, Sheng Di, Franck Cappello, and Martin Burtscher. 2025. Fast and Effective Lossy Compression on GPUs and CPUs with Guaranteed Error Bounds. In 2025 IEEE International Parallel and Distributed Processing Symposium (IPDPS). IEEE, 874–887. doi:10.1109/IPDPS64566.2025.00083

PPoPP ’27, TBD, TBD

[11] Ian Foster, Mark Ainsworth, Bryce Allen, Julie Bessac, Franck Cappello, Jong Youl Choi, Emil Constantinescu, Philip E. Davis, Sheng Di, Wendy Di, Hanqi Guo, Scott Klasky, Kerstin Kleese van Dam, Tahsin Kurç, Qing Liu, Abid Malik, Kshitij Mehta, Klaus Mueller, Todd Munson, George Ostrouchov, Manish Parashar, Tom Peterka, Line Pouchard, Dingwen Tao, Ozan Tugluk, Stefan Wild, Matthew Wolf, Justin M. Wozniak, Wei Xu, and Shinjae Yoo. 2017. Computing Just What You Need: Online Data Analysis and Reduction at Extreme Scales. In Euro-Par 2017: Parallel Processing (Lecture Notes in Computer Science). Springer, 3–19. doi:10.1007/978-3-319-64203-1_1 [12] Nathaniel Gorski, Xin Liang, Hanqi Guo, and Bei Wang. 2026. TFZ: Topology-Preserving Compression of 2D Symmetric and Asymmetric Second-Order Tensor Fields. IEEE Transactions on Visualization and Computer Graphics 32, 1 (2026), 527–537. doi:10.1109/TVCG.2025. 3634844 [13] Nathaniel Gorski, Xin Liang, Hanqi Guo, Lin Yan, and Bei Wang. 2025. A General Framework for Augmenting Lossy Compressors With Topological Guarantees. IEEE Transactions on Visualization and Computer Graphics 31, 6 (2025), 3693–3705. doi:10.1109/TVCG.2025.3567054 [14] Hanqi Guo, David Lenz, Jiayi Xu, Xin Liang, Wenbin He, Iulian R. Grindeanu, Han-Wei Shen, Tom Peterka, Todd Munson, and Ian Foster. 2021. FTK: A Simplicial Spacetime Meshing Framework for Robust and Scalable Feature Tracking. IEEE Transactions on Visualization and Computer Graphics 27, 8 (2021), 3463–3480. doi:10.1109/TVCG.2021. 3073399 [15] Christian Heine, Heike Leitte, Mario Hlawitschka, Federico Iuricich, Leila De Floriani, Gerik Scheuermann, Hans Hagen, and Christoph Garth. 2016. A survey of topology-based methods in visualization. In Computer Graphics Forum, Vol. 35. Wiley Online Library, 643–667. [16] James L. Helman and Lambertus Hesselink. 1991. Visualizing Vector Field Topology in Fluid Flows. IEEE Computer Graphics and Applications 11, 3 (1991), 36–46. doi:10.1109/38.79452 [17] Yafan Huang, Sheng Di, Guanpeng Li, and Franck Cappello. 2024. cuSZp2: A GPU Lossy Compressor with Extreme Throughput and Optimized Compression Ratio. In SC24: International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE. doi:10.1109/SC41406.2024.00021 [18] Yafan Huang, Sheng Di, Xiaodong Yu, Guanpeng Li, and Franck Cappello. 2023. cuSZp: An Ultra-fast GPU Error-Bounded Lossy Compression Framework with Optimized End-to-End Performance. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis (SC). Association for Computing Machinery, New York, NY, USA, 1–13. doi:10.1145/3581784.3607048 [19] David A. Huffman. 1952. A Method for the Construction of MinimumRedundancy Codes. Proceedings of the IRE 40, 9 (1952), 1098–1101. doi:10.1109/JRPROC.1952.273898 [20] Yukio Kaneda. 2007. DNS of incompressible turbulence in a periodic box with up to 4096ˆ 3 grid points. In APS Division of Fluid Dynamics Meeting Abstracts, Vol. 60. BS–001. [21] Rajkumar Kettimuthu, Zhengchun Liu, David Wheeler, Ian Foster, Katrin Heitmann, and Franck Cappello. 2018. Transferring a Petabyte in a Day. Future Generation Computer Systems 88 (2018), 191–198. doi:10.1016/j.future.2018.05.051 [22] Robert S Laramee, Helwig Hauser, Helmut Doleisch, Benjamin Vrolijk, Frits H Post, and Daniel Weiskopf. 2004. The state of the art in flow visualization: Dense and texture-based techniques. In Computer Graphics Forum, Vol. 23. Wiley Online Library, 203–221. [23] Robert S Laramee, Helwig Hauser, Lingxiao Zhao, and Frits H Post. 2007. Topology-based flow visualization, the state of the art. Topologybased methods in visualization (2007), 1–19. [24] Shaomeng Li, Peter Lindstrom, and John Clyne. 2023. Lossy Scientific Data Compression with SPERR. In 2023 IEEE International Parallel and Distributed Processing Symposium (IPDPS). IEEE. doi:10.1109/ IPDPS54959.2023.00104

PPoPP ’27, TBD, TBD

[25] Yuxiao Li, Mingze Xia, Xin Liang, Bei Wang, and Hanqi Guo. 2026. EXaCTz: Guaranteed Extremum Graph and Contour Tree Preservation for Distributed- and GPU-Parallel Lossy Compression. arXiv preprint arXiv:2604.01397. arXiv:2604.01397. [26] Yuxiao Li, Mingze Xia, Xin Liang, Bei Wang, and Hanqi Guo. 2026. Preserving Discrete Morse–Smale Complexes in Error-Bounded Lossy Compression. IEEE Transactions on Visualization and Computer Graphics (2026). doi:10.1109/TVCG.2026.3684385 [27] Yuxiao Li, Mingze Xia, Xin Liang, Bei Wang, Robert Underwood, Sheng Di, Hemant Sharma, Dishant Beniwal, Franck Cappello, and Hanqi Guo. 2026. pMSz: A Distributed Parallel Algorithm for Correcting Extrema and Morse-Smale Segmentations in Lossy Compression. In 2026 IEEE International Parallel and Distributed Processing Symposium (IPDPS). IEEE. doi:10.1109/IPDPS65963.2026.00025 [28] Xin Liang, Sheng Di, Franck Cappello, Mukund Raj, Chunhui Liu, Kenji Ono, Zizhong Chen, Tom Peterka, and Hanqi Guo. 2023. Toward Feature-Preserving Vector Field Compression. IEEE Transactions on Visualization and Computer Graphics 29, 12 (2023), 5434–5450. doi:10. 1109/TVCG.2022.3214821 [29] Xin Liang, Sheng Di, Dingwen Tao, Sihuan Li, Shaomeng Li, Hanqi Guo, Zizhong Chen, and Franck Cappello. 2018. Error-controlled lossy compression optimized for high compression ratios of scientific datasets. In 2018 IEEE International Conference on Big Data (Big Data). IEEE, 438–447. [30] Xin Liang, Hanqi Guo, Sheng Di, Franck Cappello, Mukund Raj, Chunhui Liu, Kenji Ono, Zizhong Chen, and Tom Peterka. 2020. Toward Feature-Preserving 2D and 3D Vector Field Compression.. In PacificVis. 81–90. [31] Peter Lindstrom. 2014. Fixed-Rate Compressed Floating-Point Arrays. IEEE Transactions on Visualization and Computer Graphics 20, 12 (2014), 2674–2683. doi:10.1109/TVCG.2014.2346458 [32] Peter Lindstrom. 2017. Error distributions of lossy floating-point compressors. Technical Report. Lawrence Livermore National Lab.(LLNL), Livermore, CA (United States). [33] Peter Lindstrom and Martin Isenburg. 2006. Fast and Efficient Compression of Floating-Point Data. IEEE Transactions on Visualization and Computer Graphics 12, 5 (2006), 1245–1250. doi:10.1109/TVCG.2006.143 [34] Jinyang Liu, Sheng Di, Kai Zhao, Xin Liang, Sian Jin, Zizhe Jian, Jiajun Huang, Shixun Wu, Zizhong Chen, and Franck Cappello. 2024. Highperformance effective scientific error-bounded lossy compression with auto-tuned multi-component interpolation. Proceedings of the ACM on Management of Data 2, 1 (2024), 1–27. [35] Jinyang Liu, Jiannan Tian, Shixun Wu, Sheng Di, Boyuan Zhang, Robert Underwood, Yafan Huang, Jiajun Huang, Kai Zhao, Guanpeng Li, Dingwen Tao, Zizhong Chen, and Franck Cappello. 2024. cuSZ-i: High-Ratio Scientific Lossy Compression on GPUs with Optimized Multi-Level Interpolation. In SC24: International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE, Atlanta, GA, USA, 1–15. doi:10.1109/SC41406.2024.00019 [36] Daisuke Matsuoka, Fumiaki Araki, Yumi Inoue, and Hideharu Sasaki. 2016. A new approach to ocean eddy detection, tracking, and event visualization–application to the northwest pacific ocean. Procedia Computer Science 80 (2016), 1601–1611. [37] Duane Merrill and Michael Garland. 2016. Single-Pass Parallel Prefix Scan with Decoupled Look-Back. Technical Report NVR-2016-002. NVIDIA Corporation. NVIDIA Technical Report. [38] NVIDIA Corporation. 2025. nvCOMP: A GPU Compression and Decompression Library, Version 5. Software library, NVIDIA Corporation. https://github.com/NVIDIA/nvcomp. Accessed 2026. [39] Stéphane Popinet. 2013. Basilisk: A Free Software Program for the Solution of Partial Differential Equations on Adaptive Cartesian Meshes. Software project. http://basilisk.fr. Accessed 2026. [40] Seung Woo Son, Zhengzhang Chen, William Hendrix, Ankit Agrawal, Wei-keng Liao, and Alok Choudhary. 2014. Data compression for

Xia et al. the exascale computing era-survey. Supercomputing frontiers and innovations 1, 2 (2014), 76–88. [41] Shihui Song, Yafan Huang, Peng Jiang, Xiaodong Yu, Weijian Zheng, Sheng Di, Qinglei Cao, Yunhe Feng, Zhen Xie, and Franck Cappello. 2024. CereSZ: Enabling and Scaling Error-Bounded Lossy Compression on Cerebras CS-2. In Proceedings of the 33rd International Symposium on High-Performance Parallel and Distributed Computing (HPDC). ACM, 309–321. doi:10.1145/3625549.3658691 [42] Shihui Song, Robert Underwood, Sheng Di, Yafan Huang, Peng Jiang, and Franck Cappello. 2025. A Memory-Efficient and ComputationBalanced Lossy Compressor on Wafer-Scale Engine. In 2025 IEEE International Parallel and Distributed Processing Symposium (IPDPS). IEEE, 1–13. doi:10.1109/IPDPS64566.2025.00084 [43] Holger Theisel, Christian Rössl, and Tino Weinkauf. 2008. Topological representations of vector fields. In Shape analysis and structuring. Springer, 215–240. [44] Jiannan Tian, Sheng Di, Xiaodong Yu, Cody Rivera, Kai Zhao, Sian Jin, Yunhe Feng, Xin Liang, Dingwen Tao, and Franck Cappello. 2021. Optimizing Error-Bounded Lossy Compression for Scientific Data on GPUs. In 2021 IEEE International Conference on Cluster Computing (CLUSTER). IEEE, 283–293. doi:10.1109/Cluster48925.2021.00047 [45] Jiannan Tian, Sheng Di, Kai Zhao, Cody Rivera, Megan Hickman Fulp, Robert Underwood, Sian Jin, Xin Liang, Jon Calhoun, Dingwen Tao, and Franck Cappello. 2020. cuSZ: An Efficient GPU-Based Error-Bounded Lossy Compression Framework for Scientific Data. In Proceedings of the ACM International Conference on Parallel Architectures and Compilation Techniques (PACT). Association for Computing Machinery, New York, NY, USA, 3–15. doi:10.1145/3410463.3414624 [46] Jiannan Tian, Cody Rivera, Sheng Di, Jieyang Chen, Xin Liang, Dingwen Tao, and Franck Cappello. 2021. Revisiting Huffman Coding: Toward Extreme Performance on Modern GPU Architectures. In 2021 IEEE International Parallel and Distributed Processing Symposium (IPDPS). IEEE, 881–891. doi:10.1109/IPDPS49936.2021.00097 [47] Shixun Wu, Jinwen Pan, Jinyang Liu, Jiannan Tian, Ziwei Qiu, Jiajun Huang, Kai Zhao, Xin Liang, Sheng Di, Zizhong Chen, and Franck Cappello. 2025. Boosting Scientific Error-Bounded Lossy Compression through Optimized Synergistic Lossy-Lossless Orchestration. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis (SC) (SC ’25). Association for Computing Machinery, New York, NY, USA, 2024–2037. doi:10.1145/3712285.3759798 [48] Shixun Wu, Jinwen Pan, Jinyang Liu, Jiannan Tian, Ziwei Qiu, Jiajun Huang, Kai Zhao, Xin Liang, Sheng Di, Zizhong Chen, and Franck Cappello. 2025. Boosting Scientific Error-Bounded Lossy Compression through Optimized Synergistic Lossy-Lossless Orchestration. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis (SC). 2024–2037. doi:10.1145/3712285.3759798 [49] Mingze Xia, Sheng Di, Franck Cappello, Pu Jiao, Kai Zhao, Jinyang Liu, Xuan Wu, Xin Liang, and Hanqi Guo. 2024. Preserving Topological Feature with Sign-of-Determinant Predicates in Lossy Compression: A Case Study of Vector Field Critical Points. In 2024 IEEE 40th International Conference on Data Engineering (ICDE). IEEE, Utrecht, Netherlands, 4979–4992. doi:10.1109/ICDE60146.2024.00378 [50] Mingze Xia, Bei Wang, Yuxiao Li, Pu Jiao, Xin Liang, and Hanqi Guo. 2025. TspSZ: An Efficient Parallel Error-Bounded Lossy Compressor for Topological Skeleton Preservation. In 2025 IEEE 41st International Conference on Data Engineering (ICDE). IEEE. doi:10.1109/ICDE65448. 2025.00275 [51] Lin Yan, Xin Liang, Hanqi Guo, and Bei Wang. 2023. TopoSZ: Preserving Topology in Error-Bounded Lossy Compression. IEEE Transactions on Visualization and Computer Graphics (2023). doi:10.1109/TVCG. 2023.3326920

FaCTz: Fast Critical-Point and Topology-Aware GPU Compression for Scientific Vector Fields

[52] PK Yeung, Kiran Ravikumar, Stephen Nichols, and Rohini UmaVaideswaran. 2025. GPU-enabled extreme-scale turbulence simulations: Fourier pseudo-spectral algorithms at the exascale using OpenMP offloading. Computer Physics Communications 306 (2025), 109364. [53] Xiaodong Yu, Sheng Di, Kai Zhao, Jiannan Tian, Dingwen Tao, Xin Liang, and Franck Cappello. 2022. Ultrafast Error-Bounded Lossy Compression for Scientific Datasets. In Proceedings of the 31st International

PPoPP ’27, TBD, TBD

Symposium on High-Performance Parallel and Distributed Computing (HPDC). ACM, 159–171. doi:10.1145/3502181.3531473 [54] Kai Zhao, Sheng Di, Maxim Dmitriev, Thierry-Laurent D. Tonellot, Zizhong Chen, and Franck Cappello. 2021. Optimizing Error-Bounded Lossy Compression for Scientific Data by Dynamic Spline Interpolation. In 2021 IEEE 37th International Conference on Data Engineering (ICDE). IEEE, 1643–1654.

Related documents

• NCCLZ: Compression-Enabled GPU Collectives with Decoupled Quantization and Entropy Coding#1013570
• Compressed-Resident Genomics: Full-Pipeline Device-Resident GPU LZ77 Decode with Position-Invariant Random Access#287099
• Compression and federated learning: an approach to frugal machine learning. (Compression et apprentissage fédéré: une approche pour l&apos;apprentissage machine frugal).#489533
• Taming Bitwise Behavior in GPU Kernels with Tensor Core: Black-Box Reconstruction, Compiler Enforcement, and Static Verification#673469
• FSZ: Breaking the Prediction-Throughput Trade-off in GPU Lossy Compression#381719