PivCo-Huffman: SIMD-Optimized Huffman Coding

• The paper introduces PivCo-Huffman, which fuses traditional Huffman coding with wavelet tree bitmaps to enable high-throughput SIMD-friendly encoding and decoding.
• It employs bottom-up merging and tree optimizations that reduce per-symbol operations from 4–7 to 2–3, achieving decoding speeds of 10–40 GB/s on modern CPUs.
• Leveraging branch-free SIMD routines and selective ANS on high-skew nodes, the codec attains compression ratios close to ANS-based methods while maintaining high performance.

Searching arXiv for the specified paper and closely related context. {"query":"(Zukowski, 4 Jun 2026) PivCo-Huffman", "max_results": 5} {"query":"PivCo-Huffman", "max_results": 10} Pivot-Coded Huffman, abbreviated PivCo-Huffman, is an entropy-coding scheme that fuses the classic Huffman tree with the bit-partition layout of wavelet trees, then applies tree and primitive optimizations together with selective ANS on highly skewed nodes. It is presented as a new approach to Huffman coding that enables high-performance SIMD-friendly encoding and decoding operations. In the reported tests, its bottom-up decoder sustains 10–40 GB/s on modern CPUs, roughly 2×–5× faster than canonical-Huffman decoders, while selective ANS integration yields compression ratios approaching those of ANS-based codecs and preserves very high decompression speeds (Zukowski, 4 Jun 2026).

1. Core representation

At the heart of PivCo-Huffman lies the “pivoted” Huffman tree, which is identical in shape to a canonical Huffman tree but stores the bit-stream per node, as in a wavelet tree, rather than code-after-code. The construction begins with an alphabet $S=\{s_1,\ldots,s_\sigma\}$ and frequencies $f(s)$, from which canonical code lengths $\ell(s)$ are computed. A Huffman tree of height $H$ is then built. For each internal node $v$ at depth $d$, the $d^{\text{th}}$ bit of every code whose prefix reaches $v$ is collected into a bitmap $B_v$ of length $n$. Positions where $f(s)$0 are sent to the left child, and positions where $f(s)$1 are sent to the right child (Zukowski, 4 Jun 2026).

This organization changes the computational character of Huffman decoding. Because bitmaps are stored byte-aligned at each node, traversal becomes a sequence of bitmap partition or merge operations rather than pointer-chasing. A plausible implication is that the representation is designed to align the logical structure of a Huffman tree with the data movement patterns favored by wide-SIMD hardware.

The paper also describes tree-level optimization mechanisms layered on top of this representation. These include flat subtrees, non-canonical grouping, and frequent-symbol prefill. The summary states that such tree optimizations reduce operations per symbol from approximately 4–7 down to approximately 2–3, which is presented as one of the main reasons for the observed throughput gains.

2. Encoding and decoding procedures

PivCo-Huffman supports two decoding strategies: top-down decoding, described as natural but write-scattered, and bottom-up decoding, described as preferred and scatter-free. The bottom-up decoder is the high-performance path. It begins by creating, for each leaf $f(s)$2, an output buffer $f(s)$3 of length $f(s)$4, filled with the corresponding leaf symbol. Internal nodes are then processed from depth $f(s)$5 down to $f(s)$6. For each node $f(s)$7, the decoder reads the bitmap $f(s)$8 and either invokes a flat-subtree merge or merges the left and right child buffers using one of three cases: constant/vector, vector/constant, or vector/vector. After the merge, the child buffers are freed and the merged buffer becomes $f(s)$9. The final output is the root buffer (Zukowski, 4 Jun 2026).

The encoder is organized top-down. Given $\ell(s)$0, it builds canonical Huffman code lengths and then the tree shape, which may be rebalanced into flat subtrees. It creates an array $\ell(s)$1 of 16-bit codes by replacing each symbol with its code in a scalar pass. It then recursively emits each node bitmap $\ell(s)$2, optionally compresses that bitmap with FSE if the node is marked for ANS encoding, partitions the codes into left and right sub-buffers with SIMD primitives, and recurses on the children. An explicit optimization is used when a child is a leaf: specialized $\ell(s)$3 variants avoid moving data that will never be reprocessed (Zukowski, 4 Jun 2026).

The contrast between the two decoding modes is central to the design. Top-down processing incurs scatter writes, whereas bottom-up merging produces dense streams and eliminates those scattered writes. The paper identifies this change in write pattern as a practical advantage, not merely a representational one.

3. SIMD-oriented primitive operations

The high-cost operations in PivCo-Huffman are implemented with branch-free SIMD kernels. The paper gives ARM NEON examples and states that x86 AVX-512 has analogous instructions. For top-down partition, the kernel loads eight 16-bit indices as bytes, retrieves a 16-byte shuffle mask from a precomputed $\ell(s)$4, applies a table lookup with $\ell(s)$5, and writes both output lanes unconditionally. The associated $\ell(s)$6 and $\ell(s)$7 are 256-entry lookups computed at initialization time, and the text explicitly notes that there are no branches and no bitwise writes inside the hot loop (Zukowski, 4 Jun 2026).

For bottom-up merging, the core primitive $\ell(s)$8 combines two symbol streams of length $\ell(s)$9 via bitmap $H$0. In blocks of eight symbols, it loads left and right symbol vectors, combines them, expands the relevant bitmap byte through $H$1, performs a table lookup, and writes the dense output. The specialized primitive $H$2 unpacks $H$3 bits each from the packed bitmap into codes, performs a $H$4-entry code-to-symbol table lookup, and writes the output densely via $H$5 (Zukowski, 4 Jun 2026).

The reported primitive costs on Apple M4 are 0.02–0.07 ns/symbol, and on Intel c8i 0.03–0.09 ns/symbol. This suggests that the codec’s throughput depends less on traditional branch-heavy tree traversal and more on sustained SIMD table-lookup and memory-bandwidth behavior. The paper also states that byte-aligned bitmaps and block-level decoding map well to modern wide-SIMD and deep out-of-order pipelines.

4. Selective ANS on skewed nodes

Pure Huffman coding is described as being limited to integer-bit code lengths, whereas ANS, specifically tANS/FSE, approaches entropy $H$6 more closely but incurs decoding-state-machine costs. PivCo-Huffman therefore integrates ANS only on bitmaps where it matters. For a bitmap of length $H$7 bits with fraction $H$8 of 1-bits, the node entropy is

$H$9

A node bitmap $v$0 is compressed with tANS/FSE only if three conditions are met: $v$1, for example 256 bits; the skew $v$2, for example 0.625; and

$v$3

for example $v$4 (Zukowski, 4 Jun 2026).

The rationale given is computational amortization. Each FSE symbol decodes one byte of bitmap, corresponding to eight Huffman symbols, so the throughput cost is amortized by a factor of eight. To avoid runtime table building, the implementation uses 50 prebuilt decode tables for skews 50%, 51%, ..., 99% (Zukowski, 4 Jun 2026).

The compression model for the hybrid scheme is summarized as

$v$5

where

$v$6

for each ANS-coded node. The text states that PHA approaches full ANS on skewed data while keeping approximately PH decode speeds. A common misconception would be to treat PivCo-Huffman as a uniformly ANS-based codec; the design described here is instead selective and node-local, with raw storage retained where the criterion is not met.

5. Measured throughput and compression behavior

The reported decoding throughput figures are block decode rates. On Apple M4, the bottom-up decoder reaches 38.2 GB/s on proba80, 17.5 GB/s on english, 12.6 GB/s on html_wiki, 15.0 GB/s on prose_pride, 16.2 GB/s on json_api, 27.9 GB/s on dna_fasta, 14.6 GB/s on chinese_text, and 13.8 GB/s on calgary_pic. On AWS c8i, the corresponding figures are 21.6, 38.2, 22.2, 37.9, 37.8, 35.3, 32.1, and 37.9 GB/s. The same section reports ratios versus Huff0 of 4.4× / 8.8× for proba80, 2.5× / 7.5× for english, 1.9× / 6.0× for html_wiki, 2.3× / 6.5× for prose_pride, 2.3× / 7.1× for json_api, 4.0× / 5.2× for dna_fasta, 2.1× / 5.9× for chinese_text, and 3.0× / 9.0× for calgary_pic (Zukowski, 4 Jun 2026).

Encoding throughput is lower, and the summary separates end-to-end performance from prebuilt-tree performance. End-to-end throughput is reported as 4.1 GB/s for proba80, 2.3 for english, 1.8 for html_wiki, and 2.1 for prose_pride; prebuilt-tree throughput is 8.7, 5.2, 4.5, and 5.0 GB/s, respectively. The reference Huff0 values listed are 4.5, 2.6, 2.0, and 2.3 (Zukowski, 4 Jun 2026).

Compression-ratio behavior distinguishes pure PH from PH+ANS and compares both with Huff0 and Oodle FSE. For proba80, PH is 1.250, PH+ANS 1.050, Huff0 1.250, and Oodle FSE 1.000. For english, the values are 4.247, 4.243, 4.247, and 4.240. For html_wiki, they are 5.634, 5.624, 5.634, and 5.620. For prose_pride, they are 4.605, 4.604, 4.605, and 4.600. For json_api, they are 5.240, 5.235, 5.240, and 5.230. For dna_fasta, they are 2.265, 2.095, 2.265, and 2.080. For chinese_text, they are 5.978, 5.970, 5.978, and 5.950. For calgary_pic, they are 1.690, 1.180, 1.690, and 1.130. The paper summarizes this by stating that PH+ANS closes about 90% of the gap to pure FSE on skewed data such as calgary_pic and dna_fasta while keeping decode bandwidth above 20 GB/s (Zukowski, 4 Jun 2026).

6. Trade-offs, interpretation, and relation to existing codecs

The practical trade-offs are stated explicitly. PivCo-Huffman works on multi-kilobyte blocks, for example 8 KB, and overhead grows on tiny inputs. Its per-node bitmaps require memory approximately equal to total input size plus tree metadata, described as about +1–2% overhead. Efficient implementations depend on NEON, AVX2, AVX-512, or equivalent SIMD support, while scalar fallback is slower. The implementation is also more complex because tree reshaping, bottom-up merging, and FSE selection all add code size (Zukowski, 4 Jun 2026).

The summary gives five reasons for the codec’s performance relative to existing implementations. First, by pivoting codes into per-node bitmaps in a wavelet-tree layout, it turns unpredictable bit-by-bit traversal into data-parallel SIMD partition and merge. Second, tree optimizations such as flat subtrees, non-canonical grouping, and frequent-symbol prefill reduce the operation count per symbol. Third, bottom-up merging replaces scattered writes with dense vector outputs, allowing fuller use of memory bandwidth. Fourth, selective per-node ANS on high-skew bitmaps recovers most of ANS’s compression gains at one-eighth its cost. Fifth, block-level decoding and byte-aligned bitmaps map well to current CPU microarchitectures (Zukowski, 4 Jun 2026).

These claims also delimit the method’s scope. PivCo-Huffman is not presented as a universal replacement for every entropy coder or every workload. Its advantages are strongest when block-level processing, SIMD execution, and skew-aware selective ANS can be exploited together. Conversely, the stated block overhead, memory overhead, and implementation complexity indicate that the design is a throughput-oriented reformulation of Huffman coding rather than a minimal-complexity codec. The paper’s overarching interpretation is that it rethinks Huffman through wavelet trees and SIMD data parallelism, while applying ANS only where the local bitmap statistics justify it.