FZModules: Modular Scientific Compression

• FZModules is a heterogeneous framework for assembling error-bounded, customizable compression pipelines from modular CPU and GPU components.
• It decomposes compression into preprocessing, prediction, quantization, and lossless encoding stages, integrating kernels from cuSZ and FZ-GPU to balance throughput and fidelity.
• Its asynchronous execution using CUDASTF enables stage-level and branch-level concurrency, enhancing throughput for petascale scientific simulations.

Searching arXiv for papers on “FZModules” and related interpretations. FZModules denotes, in the scientific compression literature, a heterogeneous computing framework for assembling error-bounded custom compression pipelines from high-performance modules through a concise extensible interface; it also incorporates an asynchronous task-backed execution library that infers data dependencies, manages memory movement, and exposes branch and stage level concurrency for asynchronous compression pipelines (Ruiter et al., 24 Sep 2025). In this sense, FZModules is a modular reorganization of kernels drawn primarily from cuSZ and FZ-GPU for CPU+GPU construction of customizable scientific lossy-compression workflows. In several unrelated mathematical literatures, the same string is used only as an interpretive shorthand for module-theoretic structures tied to $F$-, $Z$-, or fusion-center constructions. This suggests that the term is strongly context dependent.

1. Scientific compression setting and motivation

FZModules was introduced against the background of scientific simulations and instruments that generate data volumes that overwhelm memory and storage, throttling scalability (Ruiter et al., 24 Sep 2025). The motivating examples include petascale and larger workflows, such as the HACC cosmology code, which can produce petabytes across hundreds of snapshots of one trillion particles. In this environment, error-bounded lossy compression is used to trade controlled reconstruction error for reduced footprint and throughput gains.

The framework is explicitly organized around error-bounded lossy compression. A common pointwise absolute error model is

$|x_i - \hat{x}_i| \le \epsilon,$

while the framework and its source compressors often use range-normalized relative error,

$$|x_i - \hat{x}_i| \le eb \cdot (x_{\max} - x_{\min}).$$

The evaluation also uses Point-Wise Normalized Absolute Error and rate-distortion curves based on PSNR,

$$\text{PSNR} = 10 \log_{10}\left(\frac{(\text{max signal})^2}{\text{MSE}}\right).$$

A central premise is that there is no single best compressor even for one dataset (Ruiter et al., 24 Sep 2025). Optimal design depends on data characteristics, error tolerances and scientific metrics, hardware constraints, and application goals such as maximum throughput, maximum compression ratio, or best reconstruction quality. Fused-kernel GPU compressors supply raw throughput, but they hard-code prediction, quantization, and encoding choices into monolithic kernels; changing one stage usually requires kernel rewrites and may underperform in rate-distortion. FZModules addresses this by exposing the pipeline itself as a configurable object.

2. Pipeline decomposition and module architecture

FZModules adopts an SZ-style decomposition into four main stages: preprocessing, prediction, quantization, and lossless encoding (Ruiter et al., 24 Sep 2025). The architecture is deliberately modular: each stage is implemented by swappable CPU or GPU modules, and complete compressors are formed by chaining modules in order.

Before summarizing the module classes, it is useful to note that the framework keeps the high-performance character of its source systems. The predictor kernels, histogram kernels, and the bit-shuffle and dictionary stages are inherited from cuSZ and FZ-GPU, while the composition logic is elevated to the pipeline level. This preserves high throughput without fixing a single fused design.

Stage	Representative modules	Function
Preprocessing	Range-based relative error handling	Compute $x_{\min}, x_{\max}$, derive normalized error bound
Prediction	Multidimensional Lorenzo predictor; spline interpolator / G-Interp	Reduce redundancy before quantization
Quantization	Standard SZ-style quantizer	Map prediction errors to integer codes and classify outliers
Lossless encoding	Huffman; bit-shuffle + dictionary; optional Zstd	Encode quantization codes and optionally apply secondary compression

The preprocessing stage includes data normalization for relative error and value-range estimation. Prediction includes the multidimensional Lorenzo predictor from cuSZ and the spline-based G-Interp predictor from cuSZ-i. Quantization maps prediction errors to integer codes under the selected error bound and marks unpredictable data as outliers. Lossless encoding then compresses the quantization codes, using either GPU-accelerated histogram construction plus CPU-based Huffman encoding, or the faster bit-shuffle plus dictionary path adapted from FZ-GPU; an optional secondary lossless encoder, currently Zstd, can be applied after the primary encoder.

At the implementation level, modules are written in C++ with CUDA kernels for GPU stages. Predictor kernels operate on multidimensional arrays using block and tile decomposition, histogram kernels compute global code statistics in parallel, and the framework can fuse operations within modules while keeping inter-module composition exposed to the user. The programming model is therefore less rigid than compile-time-only composition, but still constrained by stage interfaces and error-bounded semantics.

3. Heterogeneous execution and asynchronous task flow

An experimental aspect of FZModules is its integration with CUDASTF, a CUDA Sequential Task Flow library for asynchronous task-backed execution (Ruiter et al., 24 Sep 2025). In this mode, tasks are declared with read and write regions and with execution placement on CPU or GPU. CUDASTF then infers data dependencies, builds a directed acyclic graph, moves data between host and device as required, and schedules tasks asynchronously.

The significance of this design lies in the exposure of two forms of concurrency. Stage-level concurrency allows different pipeline stages to overlap when their dependencies permit it. Branch-level concurrency allows independent branches, such as the core quantization-code path and the outlier path, to proceed simultaneously. The paper emphasizes decompression as a particularly clear example: CPU Huffman decoding of quantization codes and GPU scatter of outliers can operate on disjoint subsets of the reconstruction state and therefore run concurrently.

This task-based path is presented as a proof of concept rather than as the highest-throughput deployment mode. The reported throughput is in the tens of GB/s, and the current value of the approach is that it demonstrates how asynchronous heterogeneous compression pipelines can be expressed without manually orchestrating every dependency. A plausible implication is that the framework is intended not merely as a compressor, but as a research substrate for pipeline scheduling, resource placement, and hybrid CPU+GPU exploration.

4. Representative pipelines, datasets, and empirical behavior

The paper evaluates three pipelines built from the framework: FZMod-Default, FZMod-Speed, and FZMod-Quality (Ruiter et al., 24 Sep 2025). These pipelines differ primarily in predictor and primary lossless encoder choice, and thereby explore the throughput versus rate-distortion design space.

Pipeline	Main composition	Primary design target
FZMod-Default	Lorenzo + quantizer + histogram + CPU Huffman	Balanced throughput and compression ratio
FZMod-Speed	Lorenzo + quantizer + bit-shuffle + dictionary	Maximum throughput
FZMod-Quality	G-Interp + quantizer + histogram + CPU Huffman	Better rate-distortion

FZMod-Default uses the GPU Lorenzo predictor and quantizer, GPU-accelerated histogram construction, and a CPU-based Huffman encoder. FZMod-Speed keeps the same predictor and quantizer but replaces Huffman with the FZ-GPU bit-shuffle plus dictionary encoder. FZMod-Quality replaces Lorenzo with G-Interp while retaining Huffman, targeting higher-fidelity prediction and stronger compression ratio.

Evaluation is performed on four representative datasets from SDRBench: CESM-ATM, HACC, HURR, and Nyx. CESM-ATM has 33 fields of size $3600\times 1800\times 26$, totaling about $20.24$ GB; HACC has 6 fields of $280{,}953{,}867$ particles, totaling about $6.74$ GB; HURR has 20 fields of size $Z$0, totaling about $Z$1 GB; Nyx has 6 fields of size $Z$2, totaling about $Z$3 GB. Typical error bounds are $Z$4, $Z$5, and $Z$6, interpreted as range-normalized relative error.

The experiments use Quartz H100 and Quartz V100 nodes. The H100 node has 4 NVIDIA H100 SXM GPUs, 2 Intel Xeon 6248 CPUs, and measured GPU–CPU bandwidth of about $Z$7 GB/s; the V100 node has 4 NVIDIA V100 PCIe GPUs, 2 Intel Xeon 8468 CPUs, and measured GPU–CPU bandwidth of about $Z$8 GB/s. Baselines include cuSZp2 and FZ-GPU on the GPU side, and PFPL and SZ3 on the CPU or hybrid side.

The evaluation metric for end-to-end benefit is

$Z$9

where $|x_i - \hat{x}_i| \le \epsilon,$0 is transfer bandwidth, $|x_i - \hat{x}_i| \le \epsilon,$1 is compression ratio, and $|x_i - \hat{x}_i| \le \epsilon,$2 is compression throughput. This metric makes explicit that a fast compressor with weak compression ratio need not dominate a slower compressor with stronger reduction if transfer time is the bottleneck.

Empirically, cuSZp2 usually attains the highest raw throughput, but rate-distortion is stronger for SZ3, PFPL, FZMod-Default, and FZMod-Quality (Ruiter et al., 24 Sep 2025). SZ3 consistently delivers the highest compression ratio; PFPL is often the second-best compression-ratio baseline; FZMod-Speed approaches fused-kernel GPU performance while sacrificing compression ratio and PSNR; and FZMod-Default often achieves higher overall speedup than PFPL and FZMod-Quality in 8 of 12 H100 cases because it balances throughput and compression ratio. The rate-distortion plots place FZMod-Default and FZMod-Quality near the best-quality methods, whereas FZ-GPU, cuSZp2, and FZMod-Speed occupy the throughput-oriented side of the tradeoff.

5. Position relative to other compressors and development trajectory

FZModules is positioned between high-throughput fused GPU compressors and flexible modular CPU frameworks (Ruiter et al., 24 Sep 2025). Relative to SZ3, it inherits the idea of stage-level modularity but targets GPU and heterogeneous execution. Relative to cuSZ, cuSZ-i, and cuSZp2, it re-exposes their kernels as modules rather than as hard-coded pipelines. Relative to FZ-GPU, it retains the bit-shuffle and dictionary strategy but relocates it into a non-fused configurable environment. Relative to PFPL, it behaves more as a framework than as a single algorithm, allowing PFPL-like design choices to be assembled or compared inside the same heterogeneous setting.

The framework therefore makes pipeline design itself a first-class research object. Predictors, quantizers, histogram strategies, primary encoders, and secondary encoders can be varied without rewriting the full compressor. A plausible implication is that FZModules treats scientific compression as a search space over composable operators rather than as a fixed codec.

The paper also states explicit limitations and future directions. The current module set is limited; CUDASTF integration is still experimental; the framework focuses mainly on range-normalized pointwise error bounds; and automatic pipeline selection is not yet implemented (Ruiter et al., 24 Sep 2025). Planned work includes optimizing CUDASTF pipelines, expanding modules and documentation, and building auto-selection mechanisms that choose modules from data characteristics, hardware environment, and desired quality metrics. In this respect, FZModules is both a concrete compression system and a development framework for domain-tailored scientific data reduction.

6. Other research uses of the label

Outside scientific compression, the string “FZModules” appears in several mathematical and physical contexts as an interpretive label rather than as a single standardized formal term. In the setting of pointed fusion categories, it refers to modules over $|x_i - \hat{x}_i| \le \epsilon,$3, equivalently representations of the twisted quantum double $|x_i - \hat{x}_i| \le \epsilon,$4, whose simple objects are labeled by $|x_i - \hat{x}_i| \le \epsilon,$5 and whose braiding, twist, and fusion are encoded by the modular data $|x_i - \hat{x}_i| \le \epsilon,$6 and $|x_i - \hat{x}_i| \le \epsilon,$7 of the Drinfeld center (Gruen et al., 2018). In vertex-algebra theory, it denotes the combined formal-group and Zhu change-of-variables viewpoint on vertex $|x_i - \hat{x}_i| \le \epsilon,$8-algebras and $|x_i - \hat{x}_i| \le \epsilon,$9-coordinated modules, especially through the correspondence between $$|x_i - \hat{x}_i| \le eb \cdot (x_{\max} - x_{\min}).$$0-modules and $$|x_i - \hat{x}_i| \le eb \cdot (x_{\max} - x_{\min}).$$1-coordinated modules for the Zhu-transformed vertex algebra with $$|x_i - \hat{x}_i| \le eb \cdot (x_{\max} - x_{\min}).$$2 (Li, 2010).

In number-theoretic contexts, the same label is used for module-like structures of modular relations among double zeta values, where period polynomials and modular forms generate spaces of relations in the formal double zeta space (Tasaka, 2023), and for a spectral organization of Fibonacci zeta functions via dihedral $$|x_i - \hat{x}_i| \le eb \cdot (x_{\max} - x_{\min}).$$3 Maass forms (Assaf et al., 3 Feb 2025). In noncommutative gauge theory, it is used for fuzzy modules, namely finite projective modules over matrix algebras equipped with derivation-based connections, module parallel transports, and separating gauge-invariant observables (Schenkel, 2012).

Several further module-theoretic constructions are adjacent but terminologically distinct. In symmetric-group representation theory, the established term is Foulkes modules, where homomorphisms from Specht modules are described by set families and minimal constituents are classified combinatorially (Paget et al., 2010). In arithmetic and algebraic combinatorics, one finds face modules for realizable $$|x_i - \hat{x}_i| \le eb \cdot (x_{\max} - x_{\min}).$$4-matroids with Hilbert series given by a specialization of the Grothendieck–Tutte polynomial (Martino, 2017). In commutative algebra and $$|x_i - \hat{x}_i| \le eb \cdot (x_{\max} - x_{\min}).$$5-module theory, nearby structures include $$|x_i - \hat{x}_i| \le eb \cdot (x_{\max} - x_{\min}).$$6-modules (Zhang, 2022), modules of finite $$|x_i - \hat{x}_i| \le eb \cdot (x_{\max} - x_{\min}).$$7-type and $$|x_i - \hat{x}_i| \le eb \cdot (x_{\max} - x_{\min}).$$8-abundant modules (Dao et al., 2016), and $$|x_i - \hat{x}_i| \le eb \cdot (x_{\max} - x_{\min}).$$9-zips with $$\text{PSNR} = 10 \log_{10}\left(\frac{(\text{max signal})^2}{\text{MSE}}\right).$$0-structure, where exact tensor functors $$\text{PSNR} = 10 \log_{10}\left(\frac{(\text{max signal})^2}{\text{MSE}}\right).$$1 are equivalent to quotient stacks of the form $$\text{PSNR} = 10 \log_{10}\left(\frac{(\text{max signal})^2}{\text{MSE}}\right).$$2 (Pink et al., 2012).

Taken together, these usages suggest that “FZModules” is not a settled cross-disciplinary technical term. In current arXiv usage, its most explicit formalization is the heterogeneous scientific-compression framework of 2025, while in the mathematical literature it functions mainly as a contextual shorthand for module categories or module-like structures tied to $$\text{PSNR} = 10 \log_{10}\left(\frac{(\text{max signal})^2}{\text{MSE}}\right).$$3-, $$\text{PSNR} = 10 \log_{10}\left(\frac{(\text{max signal})^2}{\text{MSE}}\right).$$4-, Frobenius-, or center-based constructions (Ruiter et al., 24 Sep 2025).