A GPU-Supported Lossless Compression Scheme for Rendering Time-Varying Volume Data

Jörg Mensmann, Timo Ropinski, Klaus H. HinrichsVG@Eurographics 2010 · DOI

TL;DR

This paper introduces a hybrid CPU/GPU lossless compression scheme to tackle the challenge of rendering large time-varying volume datasets that exceed GPU memory. By cleverly combining temporal prediction, variable-length coding, and efficient GPU-based decompression, they achieve near-interactive frame rates without sacrificing image quality, making complex simulations more accessible for analysis.

What Problem Does This Paper Address?

Interactive visualization of volumetric data, especially time-varying datasets from simulations (like fluid dynamics or meteorology), is crucial for understanding complex phenomena. However, these datasets are growing rapidly in size, often reaching gigabytes or terabytes. This sheer volume quickly overwhelms the memory capacity of modern GPUs, forcing a reliance on out-of-core streaming techniques. The primary bottleneck in such scenarios is the slow transfer rate between storage, main memory, and GPU memory. While compression can alleviate this, existing lossless compression methods are often too slow for real-time decompression on the GPU, or they introduce visual artifacts that can mislead analysis. This paper aims to bridge this gap by developing a lossless compression scheme that can be efficiently decompressed on the GPU, enabling near-interactive rendering of large time-varying datasets.

Methods

The core of the proposed solution is a hybrid CPU/GPU decompression pipeline. This pipeline is designed to leverage the strengths of both processing units:

  • Temporal Prediction (CPU/GPU): To exploit coherence between consecutive time steps, a prediction model is used. The most basic form is Differential Pulse-Code Modulation (DPCM), where instead of storing the full voxel value, only the difference (error) from the previous time step is stored. This is particularly effective when large regions of the volume don't change, resulting in many zero-error values.
  • Variable-Length Coding (VLC) (GPU): The error values generated by DPCM often exhibit non-uniform distributions. VLC is applied to efficiently encode these values, especially when they are small. Uniform bricks (e.g., all zero errors) are handled efficiently, effectively being omitted.
  • LZO Compression (CPU): For further compression of the data stream, the LZO real-time compression library is used. While LZO is known for its fast decompression, the primary goal here is to reduce the data size for disk storage.
  • Bricking (GPU): The volume is subdivided into 3D bricks. This allows for more efficient compression by treating contiguous blocks of data. The bricks are then reassembled on the GPU for rendering.
  • GPU-Supported Decompression Pipeline: The system uses a multi-threaded approach to overlap disk loading, LZO decompression (on CPU), and data upload to the GPU. Crucially, the final decompression steps (resolving VLC and delta encoding) and brick assembly are performed on the GPU using CUDA kernels. This offloads computationally intensive decompression tasks from the CPU, allowing it to focus on other operations or to prepare subsequent data.

Datasets

The paper evaluates their method on several real-world time-varying volume datasets:

  • Convection: A hydrodynamical simulation of a thermal plume, containing two modalities: temperature (T) and enstrophy (ens). This dataset is characterized by high noise levels and turbulent regions.
  • Combustion: A turbulent combustion simulation with three modalities: chi, vort, and y_oh. This dataset has significant amounts of empty space.
  • Hurricane Isabel: Data from a simulation of atmospheric conditions, specifically the amount of rain at different levels. This is a smaller, sparse dataset with many empty regions.

The paper does not introduce new benchmark datasets but uses these existing ones to demonstrate the effectiveness of their compression scheme.

Key Insights and Ideas

  • GPU as a Decompression Engine: The most significant insight is the realization that GPUs, with their massive parallelism, are not just for rendering but can also be highly effective for decompression tasks, especially when the decompression algorithm is designed to exploit GPU architecture (e.g., coalesced memory access).
  • Hybrid Approach is Key: The paper demonstrates that a purely CPU-based or GPU-based compression/decompression scheme is suboptimal. The hybrid approach, where CPU handles heavy compression (LZO) and GPU handles fast, parallel decompression (VLC, delta decoding, brick assembly), offers the best of both worlds.
  • Temporal Prediction is Crucial for Time-Varying Data: The effectiveness of the scheme hinges on exploiting temporal coherence. DPCM, while simple, lays the groundwork for efficient compression by creating uniform data structures (zero errors) that VLC can exploit.
  • Bricking for Compression, Not Rendering: Subdividing volumes into bricks is presented as a strategy for improving compression efficiency by maintaining spatial coherence within blocks, rather than for rendering itself. The GPU then efficiently reassembles these bricks.
  • Lossless Quality is Achievable: A major win is achieving significant performance gains without any loss of image quality, which is critical for scientific analysis where artifacts can lead to misinterpretations.

Key Results

  • Compression Ratios: The hybrid compression scheme achieved significant compression ratios, varying by dataset. For example, the "hurricane/rain" dataset achieved a compression factor of 25.1, while "convection/T" was around 2.2. The effectiveness of compression is highly dependent on the data's noise level and sparsity.
  • Rendering Speedup: The compression led to substantial rendering speedups. For the "convection/T" dataset, rendering time was reduced from 281 seconds to 108 seconds, a speedup factor of 2.6. The "hurricane/rain" dataset saw a speedup from 35 seconds to 5 seconds, a factor of 7.27.
  • Near-Interactive Performance: The system achieved near-interactive frame rates (up to 6 fps) for large datasets, a significant improvement over uncompressed rendering.
  • GPU Decompression Efficiency: The GPU-based brick assembly was shown to be as efficient as or faster than a CPU implementation, with speedups of up to 1.38 observed when the bottleneck was not disk I/O.
  • On-Device Copy Bottleneck: The transfer of the decompressed volume from global GPU memory to the final 3D texture for rendering was identified as a bottleneck, taking significantly longer than brick assembly.

Limitations and Future Work

  • Floating-Point Data: The current scheme converts floating-point simulation data to 16-bit integers during preprocessing. Direct support for floating-point data would be beneficial for applications where precision is paramount.
  • Disk I/O Bottleneck: While the compression significantly reduces data transfer, for datasets with very high compression ratios (like "hurricane/rain"), the bottleneck can shift from disk throughput to decompression speed. Faster storage (e.g., RAID) is suggested to further improve performance.
  • On-Device Copy Optimization: The time taken for copying data to the 3D texture is a limitation. Future GPU architectures that allow direct writing to 3D textures from kernels are expected to resolve this.
  • Lossy Compression: The authors note that the framework could be extended to incorporate lossy compression techniques for applications where some loss of accuracy is acceptable.
  • Multi-Resolution Techniques: Integration with multi-resolution approaches is mentioned as a potential area for future work.
  • New GPU Architectures: Investigating how new GPU architectures with potentially better support for complex compression algorithms can be leveraged is also suggested.

Summary updated

BibTeX
@inproceedings{mensmann2010gpu,
  author = {Jörg Mensmann and Timo Ropinski and Klaus H. Hinrichs},
  title = {{A GPU-Supported Lossless Compression Scheme for Rendering Time-Varying Volume Data}},
  booktitle = {VG@Eurographics},
  year = {2010},
  doi = {10.2312/vg/vg10/109-116},
}
Figure