PaperlayerView exact revision on arXiv

Source-linked AI summary

BlockMGARD: Accelerating Adaptive Scientific Data Reduction with Region-of-Interest Error Control on GPUs

Yanliang Li, Qian Gong, Qing Liu, Jaemoon Lee, Norbert Podhorszki, Scott Klasky, Xin Liang, Jieyang Chen

arXiv:2609.00205v1cs.DC

TL;DR

Scientific data growth creates storage and I/O pressure, while multilevel transformation compressors provide strong compression but map poorly to GPUs. BlockMGARD addresses this with an on-chip local decomposition, a hybrid local/global hierarchy, and ROI-aware error control. It reports higher throughput than MGARD-X, improved ROI-aware compression ratios, and near-linear scaling across four GPUs.

  • Problem

    Multilevel transformation-based compressors offer strong compression but their memory-intensive, synchronization-heavy decomposition is poorly matched to GPUs and existing approaches lack fine-grained compression-time ROI control.

  • Method

    BlockMGARD combines shared-memory In-cache Block decomposition, global decomposition, automatic hybrid parameter selection, ROI error control, and fused decomposition–quantization.

  • Results

    BlockMGARD achieves up to 4.17× higher compression throughput and 9.13× higher decompression throughput than MGARD-X, with up to 8.63× higher compression ratio than uniform-tolerance baselines under ROI-aware control.

  • Takeaways & Limitations

    The compressor provides adaptive control over throughput, compression ratio, and ROI fidelity while supporting near-ideal scaling across four GPUs.

Abstract

from arXiv · show

The growing scale of scientific data makes lossy compression essential for reducing data volume under controllable error. Transformation-based compressors using multilevel decomposition, such as MGARD, achieve strong compression ratios but map poorly to GPU architectures. We propose BlockMGARD, an adaptive, Region-of-Interest (ROI)-supported GPU lossy compressor, with four contributions: (1) an In-cache Block decomposition leveraging GPU on-chip memory and constant lookup tables to accelerate decomposition; (2) a hybrid hierarchy combining In-cache Block and global decomposition to balance speed and compression ratio; (3) an end-to-end pipeline with fine-grained ROI error control for feature preservation; and (4) an evaluation against state-of-the-art methods on five real-world datasets. Compared to MGARD-X, BlockMGARD achieves up to 4.2x and 9.1x higher compression and decompression throughput, and up to 8.63x higher compression ratio than uniform-tolerance baselines under ROI-aware error control. Across four GPUs, BlockMGARD achieves near-ideal linear scaling and up to 1.58x I/O cost reduction over MGARD-X.

I. INTRODUCTION

Scientific data growth has made storage and movement bottlenecks acute, while transformation-based compressors offer error control but fit GPUs poorly. BlockMGARD redesigns decomposition for GPUs, combines local and global hierarchies, and adds ROI-aware control and an end-to-end pipeline.

  • Multi-terabyte to petabyte-scale scientific datasets increasingly exceed storage and I/O bandwidth growth, making data movement and storage critical bottlenecks.
  • Transformation-based decompression can be computationally inefficient because deep dependencies require substantial coordination and communication.
  • BlockMGARD introduces an In-cache Block hierarchy that uses GPU on-chip memory for localized decomposition and improves performance on small or narrow datasets.
  • A hybrid hierarchy combines high-throughput local decomposition with high-decorrelation global decomposition to trade performance against compression ratio.
  • BlockMGARD provides block-level ROI error control within a complete compression pipeline, preserving critical features while improving compression effectiveness.
  • 4.17× and 9.13× higher compression and decompression throughput, respectively, are reported against MGARD-X across five real-world scientific datasets.

II. BACKGROUND AND RELATED WORKS

Scientific lossy compressors balance error control, compression efficiency, and GPU parallelism. MGARD provides multilevel, error-controlled decorrelation, but its dependencies and global hierarchy constrain parallelism and GPU fit.

  • Lossless compressors usually achieve less than 2× compression on scientific floating-point data, whereas error-bounded lossy methods often reach 10:1 to 100:1 or more.
  • GPU-accelerated methods improve throughput, but transformation-based approaches retain dependency-limited parallelism while prediction-based methods may sacrifice compression efficiency on spatially correlated data.
  • MGARD: MGARD uses nested-grid multilevel decomposition rooted in finite element theory, with levels defined across the entire structured-grid domain.
  • MGARD: MGARD recursively interpolates coarse values, subtracts them from fine data, and applies mass-matrix corrections to produce recoverable multilevel coefficients.
  • MGARD: Level-dependent quantization tolerances yield provable L∞ and other-norm reconstruction bounds, including bounds for derived quantities of interest.
  • MGARD-X provides portable GPU/CPU kernels, and BlockMGARD reuses its global decomposition; both hierarchies assume structured grids.

C. Region-of-Interest Based Compression

Scientific ROIs require higher fidelity for numerically important regions, but prior GPU approaches mainly support selective decompression rather than non-uniform precision during compression. Block-wise decomposition enables compression-time ROI control.

  • A scientific ROI is a subset whose value justifies higher fidelity than the surrounding data, often identified by steep gradients or coherent structures.
  • Perceptual ROI methods from image compression do not satisfy scientific requirements for strict reconstruction error bounds.
  • Prior scientific methods explored automatically detected detailed regions, vertex-wise adaptive bounds, and topology-based error constraints.
  • STZ and VGC support spatially selective decompression, but both use a uniform compression-time error bound and vary access rather than precision.
  • Block-wise independent processing makes it possible to vary precision during compression for ROI-aware error control.
  • Existing multilevel decomposition is poorly matched to GPUs because repeated global-memory access, synchronization, and dimensionality constrain efficient parallelism.

IV. METHOD

BlockMGARD redesigns the transform and quantization stages around a hybrid hierarchy of local In-cache Block and global levels, with shared-memory execution and compile-time indexing.

  • IV. METHOD: BlockMGARD combines L local In-cache Block levels with M global levels, allowing throughput–compression-ratio trade-offs and block-granularity ROI error control.
  • IV. METHOD: The pipeline follows transform–quantize–lossless encode, while decomposition and quantization are fused to eliminate their intervening global-memory round trip.
  • A. In-cache Block Decomposition: 8×8×8 blocks co-optimize shared-memory capacity and thread parallelism, using intermediate arrays that coexist within the on-chip working set.
  • A. In-cache Block Decomposition: Compile-time constexpr tables store index mappings, mass-matrix entries, and interpolation weights for fixed block dimensions.
  • A. In-cache Block Decomposition: Direct table lookups replace runtime division and modulo operations, reducing per-thread instructions and eliminating index-dependent branching.
  • A. In-cache Block Decomposition: The entire 9.3 KB working set remains in shared memory, with global memory used only for initial loading and final storage.
  • A. In-cache Block Decomposition: Fixed block dimensions give warp threads identical execution paths without boundary-handling conditionals.
  • A. In-cache Block Decomposition: Linear thread indexing provides conflict-free shared-memory access for single- and double-precision data.

B. Hybrid Hierarchy Architecture

The hybrid hierarchy combines fast local In-cache Block decomposition with global MGARD decomposition, allowing users to tune performance, compression quality, and hierarchy depth. Its parameter-selection strategy uses throughput modeling and a time budget to choose configurations.

  • B. Hybrid Hierarchy Architecture: The first L levels use In-cache Block local decomposition, followed by M levels of MGARD global decomposition.The total hierarchy depth is L + M.
  • B. Hybrid Hierarchy Architecture: Larger L values prioritize speed by reducing global memory operations, while smaller L values favor compression quality and fewer artifacts.Global decomposition preserves global features better but increases runtime.
  • B. Hybrid Hierarchy Architecture: The parameter M controls the final coarseness of the hierarchical representation and affects the achievable compression ratio.
  • B. Hybrid Hierarchy Architecture: Throughput modeling separates latency-bound scaling from throughput-bound saturation and identifies knee points at approximately 8,012 FP32 blocks and 5,073 FP64 blocks.The model uses per-block slope and measured peak throughput to locate where marginal gains become negligible.
  • B. Hybrid Hierarchy Architecture: Automatic parameter selection enumerates valid (L, M) pairs, filters them under a time budget, and selects the configuration maximizing M while minimizing L in ties.Predictions combine the In-cache Block throughput model for local levels with separate fitted models for global decomposition and other pipeline stages.

C. Region-of-Interest Error Control

BlockMGARD assigns spatially varying tolerances at block granularity and conservatively propagates the strictest tolerance through the hierarchy to preserve ROI error bounds.

  • Tolerance assignment: ROI extraction discretizes user-defined regions to block resolution, assigning strict tolerance τ2 to critical features and progressively looser tolerances elsewhere.The pressure-field example uses value ranges to distinguish strict ROI, normal ROI, and background regions.
  • Tolerance assignment: BlockMGARD assigns strict, normal, and background tolerances to blocks, with τ2 < τ1 < τ0.Users can derive tolerance maps programmatically or specify regions explicitly; partially overlapping blocks receive the stricter tolerance.
  • Tolerance propagation: At coarser levels, blocks may combine contributions from fine-level regions with different tolerances because 5 × 5 × 5 outputs are assembled into 8 × 8 × 8 blocks.This spatial reorganization creates tolerance mixing across decomposition boundaries.
  • Tolerance propagation: Each coarse block inherits the minimum tolerance among contributing fine-level blocks, ensuring reconstructed values satisfy the strictest L∞ bound.The rule is applied recursively through all local levels, so strict ROI tolerances expand into an influence region at coarser levels.
  • Trade-off: Conservative propagation can allocate unnecessary bits to blocks outside the original strict ROI, with overhead increasing with local decomposition depth L.For moderate L, the influence region remains localized because ROI regions are typically spatially concentrated.

D. Pipeline Stage Fusion

BlockMGARD fuses quantization into the In-cache Block decomposition kernel to avoid writing and rereading detail coefficients through global memory.

  • Unfused pipeline: The unfused pipeline writes full-precision coefficients to global memory before a separate quantization kernel reads and quantizes them.This creates a full-precision global-memory round trip for detail coefficients used only during quantization.
  • Fused pipeline: The fused kernel quantizes detail coefficients while they remain in shared memory and writes quantized symbols directly to global memory.The 125 threads producing the 5 × 5 × 5 coarse output still write full precision for subsequent levels, while 387 threads process detail coefficients.

A. Experimental Setup

The evaluation compares BlockMGARD with GPU compressors across five scientific datasets using controlled error bounds and kernel-level performance measurements.

  • Platform and baselines: The experiments use four NVIDIA H100 GPUs and compare BlockMGARD against MGARD-X, cuZFP, and VGC.The platform includes 80 GB HBM3 per H100 and CUDA Toolkit 12.4.
  • Error control: Evaluation uses L∞-norm relative error bounds of 1e−2, 1e−4, and 1e−6, with reconstructed values constrained below the specified tolerance.Conversions are applied for VGC, while fixed rates are measured for cuZFP to match target error bounds.
  • Datasets: The study covers NYX, Hurricane ISABEL, SCALE-LETKF, Miranda, and S3D, averaging results across four variables per dataset.These are real-world HPC simulation datasets from the Scientific Data Reduction Benchmarks suite.
  • Measurement scope: The single-level comparison measures kernel execution time only, excluding host-device data transfer overhead.Four variables per dataset are evaluated and averaged for the controlled throughput comparison.
  • Performance: In-cache Block reaches 233–381 GB/s decomposition throughput versus 44–120 GB/s for global decomposition, yielding a 3.16×–5.26× speedup.For recomposition, it reaches 204–327 GB/s versus 47–117 GB/s, with a 2.79×–4.40× speedup.

C. Hybrid Hierarchy Decomposition

The hybrid hierarchy replaces selected global decomposition levels with In-cache Block levels, exposing a speed–compression-ratio trade-off in end-to-end evaluation.

  • Hybrid performance: Under a fixed three-level depth, changing from L=1/M=2 to L=2/M=1 reduces execution time across datasets, achieving a 1.72×–2.96× speedup.The full global baseline is slowest because it repeatedly performs full-dataset global-memory operations.
  • Compression trade-off: Hybrid configurations retaining global levels preserve 0.64×–1.78× of full-global compression ratio across NYX, Hurricane, SCALE-LETKF, and Miranda.Configurations without global levels suffer severe compression-ratio degradation.
  • End-to-end comparison: Against MGARD-X, BlockMGARD achieves 1.52×–3.49× compression-throughput speedup and 1.40×–8.23× decompression-throughput speedup.The gain is attributed to each In-cache Block touching global memory only twice.
  • Compression trade-off: Block partitioning lowers compression ratio in several cases, especially SCALE and S3D, because it disrupts spatial locality used by global decomposition.The penalty depends on dataset and tolerance; increasing M relative to L can trade throughput for improved compression ratio.
  • Fused pipeline: BlockMGARD-Fused reaches 2.04×–4.17× compression-throughput and 1.69×–9.13× decompression-throughput speedups over MGARD-X without compression-ratio loss.Kernel fusion adds further throughput improvements over the unfused BlockMGARD configuration.

E. ROI-aware Compression

BlockMGARD uses ROI-aware error control to preserve fidelity in scientifically critical regions while relaxing tolerances elsewhere, improving compression efficiency and visual quality at comparable output sizes.

  • Higher Compression Ratio at Matched Visual Quality: 5.17× compression ratio versus 3.41× for cuZFP and 1.67× for VGC at matched REL 1e−6 visual fidelity.BlockMGARD preserves spatial features within the ROI while intentionally allowing lower fidelity in relaxed-tolerance background regions.
  • Higher Compression Ratio at Matched Visual Quality: BlockMGARD faithfully reconstructs high-gradient meteorological features in the ROI under tight REL 1e−6 tolerance.The ROI is a 150 × 150 subregion containing active pressure-gradient structures in the PRES field.
  • Superior Visual Fidelity at Matched Compression Ratio: At a target compression ratio of approximately 50×, BlockMGARD provides superior visual fidelity within scientifically sensitive regions.The comparison uses global/ROI PSNR on the 120th 384 × 384 Miranda density slice.
  • Higher Compression Ratio with ROI-Aware Error Control: At REL 1e−4, BlockMGARD improves compression ratio across all five datasets while guaranteeing the same ROI accuracy as globally uniform baselines.The method applies tight tolerance inside the ROI and relaxed tolerance in less critical background regions.
  • Higher Compression Ratio with ROI-Aware Error Control: 34.78× and 42.75× compression ratios on Miranda and S3D are 8.63× and 1.84× higher than MGARD-X, respectively.BlockMGARD also improves over the strongest baseline by 2.89× on NYX, 2.28× on Hurricane, and 1.16× on SCALE-LETKF.

F. Parallel I/O and Scalability

BlockMGARD reduces end-to-end scientific I/O cost through high compression ratios and scales efficiently across multiple GPUs, while extreme precision can make some datasets effectively incompressible.

  • Parallel I/O: Lossless compression increases total I/O time by 1.19–1.48× over the uncompressed baseline because scientific floating-point data compresses only marginally.The measured wall time includes compression, writing, decompression, and reading.
  • Parallel I/O: BlockMGARD maintains more consistent I/O acceleration than VGC as tolerances tighten, whereas VGC averages 3.68× at 1e−4 and 2.21× at 1e−6.VGC’s speedup declines as compression ratio diminishes and decompression overhead grows; cuZFP provides more modest acceleration.
  • Parallel I/O: BlockMGARD delivers 3.4×–14.8× I/O speedup at 1e−2 and 2.0×–8.6× at 1e−4 across datasets.Effective write bandwidth improves by up to 25.2× on NYX.
  • Parallel I/O: At 1e−6, BlockMGARD’s total I/O time approaches the uncompressed baseline for Hurricane ISABEL and SCALE-LETKF.The reported times are 0.97× and 0.94×, respectively, because these datasets become incompressible at extreme precision.
  • Scalability: BlockMGARD achieves near-linear multi-GPU throughput scaling, reaching 461.9 GB/s compression and 391.9 GB/s decompression on S3D across four H100 GPUs.Each GPU independently processes the same dataset without inter-GPU communication.
Loading 2609.00205v1…