[Paper Review] Accelerating Lossless Data Compression with GPUs

R. L. Cloud, Matthew Leon Curry+3 more|arXiv (Cornell University)|Jun 21, 2011

Algorithms and Data Compression4 references14 citations

TL;DR

This paper proposes a GPU-accelerated variant of Huffman compression that enables block-wise, independent compression and decompression by modifying code packing and block boundary handling. Using CUDA on an NVIDIA GTX 285, the GPU encoder achieves over 4 GB/sec throughput (excluding memory transfer), outperforming both sequential and OpenMP CPU implementations, demonstrating that GPUs can effectively accelerate lossless compression despite algorithmic branching and data-parallel challenges.

ABSTRACT

Huffman compression is a statistical, lossless, data compression algorithm that compresses data by assigning variable length codes to symbols, with the more frequently appearing symbols given shorter codes than the less. This work is a modification of the Huffman algorithm which permits uncompressed data to be decomposed into indepen- dently compressible and decompressible blocks, allowing for concurrent compression and decompression on multiple processors. We create implementations of this modified algorithm on a current NVIDIA GPU using the CUDA API as well as on a current Intel chip and the performance results are compared, showing favorable GPU performance for nearly all tests. Lastly, we discuss the necessity for high performance data compression in today's supercomputing ecosystem.

Motivation & Objective

• Address the growing need for high-performance lossless data compression in supercomputing environments with bandwidth and storage constraints.
• Overcome the inherent sequential nature of traditional Huffman compression by enabling independent block processing for parallel execution.
• Evaluate the feasibility and performance of GPU acceleration for Huffman encoding and decoding using CUDA on modern GPUs.
• Compare GPU performance against sequential and multi-core CPU implementations to assess real-world acceleration potential.
• Demonstrate that GPU acceleration can be effective even for algorithms with complex branching, provided memory access and kernel design are optimized.

Proposed method

• Modify the Huffman algorithm to allow independent compression of fixed-size data blocks by storing block length as a 4-byte integer at the start of each block.
• Pack encoded blocks to 4-byte boundaries to avoid bit-alignment issues across block boundaries during decompression.
• Implement a GPU-based encoder and decoder using the CUDA API on an NVIDIA GTX 285 with 240 cores.
• Use a binary tree traversal mechanism for decoding, with bit-level operations for encoding, both adapted for coalesced memory access.
• Apply asynchronous memory transfers to overlap data movement with computation, reducing I/O bottlenecks in online or streaming workloads.
• Compare performance against a sequential CPU implementation and an OpenMP-parallelized CPU version to isolate GPU acceleration benefits.

Experimental results

Research questions

• RQ1 Can a modified Huffman compression algorithm be made amenable to block-level parallelization on GPUs without sacrificing compression efficiency?
• RQ2 To what extent can GPU architectures accelerate Huffman encoding and decoding compared to modern multi-core CPUs?
• RQ3 How do branching patterns and memory access patterns affect GPU performance in lossless compression workloads with variable-length codes?
• RQ4 What is the impact of memory transfer overhead on end-to-end compression throughput in GPU-accelerated systems?
• RQ5 Can GPU acceleration provide practical performance gains for lossless compression in real-world scientific computing workloads?

Key findings

• The GPU-based Huffman encoder achieved a raw throughput of over 4 GB/sec on the NVIDIA GTX 285, excluding memory transfer times.
• Despite the GPU having 60× more cores than the CPU, the speedup over the OpenMP CPU encoder was moderate due to divergent branching in the kernel.
• The GPU decoder achieved higher acceleration than the encoder, as it involved fewer branching operations and better memory coalescing.
• The CPU decoder showed super-linear speedup with increasing thread counts (up to 8 threads), aided by Intel’s Hyper-Threading and memory request hiding.
• Asynchronous memory transfers can help mitigate I/O bottlenecks in online or streaming compression scenarios.
• While the GPU encoder outperformed CPU alternatives, the overall system throughput remains limited by data transfer overhead, making standalone use impractical for current hardware.