What Actually Serializes GPU LZ77 Decode: Three Decoders, Three Mechanisms, and an Encode-Time Lever That Removes the Last One

What Actually Serializes GPU LZ77 Decode Three decoders, three mechanisms, and an encode-time lever that removes the last one Yakiv Shavidze

arXiv:2608.10188v1 [cs.DC] 10 Aug 2026

Independent Researcher ORCID: 0009-0008-3622-3448 https://github.com/yasha1971-coder/aceapex

Abstract—The sequential part of GPU LZ77 decode is not where the field assumes it is. Across three decoder architectures on an H100 we measure that parse, not copy, holds 64–72% of device-resident decode time; that bounding back-reference chain depth—provable, and costing 0.006% in ratio—moves latency by at most 2.8% and, for the file’s own latency spike, provably by nothing at all, since a byte-level comparison of all 15,499 blocks shows the cap alters none of the 181 blocks involved; that selfoverlapping matches are periodic fills rather than dependency chains, which makes them fully parallel and speeds the match layer by 2.75–8.42× bit-perfect; and that the last genuinely sequential element, a four-entry distance history, can be removed by the encoder for 0.540% of ratio, growing the dependencyfree parse run from 4 commands to 706. We also report the floor the format runs into: with a median match of 7 bytes against a 128-byte cache line, bus efficiency is 4.4% and a coalesced write of the same data is 39× faster. A separate section records ten hypotheses these measurements refuted, including one methodological error of our own. Every reproducible claim carries a machine-checkable record: a fresh clone of the tagged release passes 17 of 17 checks reachable without a GPU, none failing. Index Terms—GPU decompression, LZ77, lossless compression, parse, random access, reproducibility

I. I NTRODUCTION Consider the situation directly. You have a 50 GB genome, 80 GB of VRAM, and a request for a 16 KB region. Decompressing everything leaves nowhere to put it. Holding the data compressed and decoding on demand is possible, but then the response time is set by something you do not control. The engineer’s question is simple: what exactly is sequential in a GPU decode, and can it be removed? The field’s answer so far has been “back-reference dependencies.” Gompresso [6] eliminates them at compression time by restricting matches to a per-warp high-water mark, at up to 19% degradation in compression ratio. We measured where the sequential part actually lives, and removed a different one—in the parse—for 0.540%. This paper is a measurement study, and its structure follows what the measurements found rather than what we expected to find. Three decoder architectures are used deliberately, because each exposes a different limiting mechanism, and a claim that survives only one of them is not a claim about the format. a) Three questions this answers: • What does random access into compressed data cost? The cost is blockwise encoding: 6.7% on genome, 24.2% on text—and the match layer returns more than half of it.

TABLE I T HREE DECODER ARCHITECTURES AND WHAT SETS THEIR TIME .

decoder

scheme

time governed by

dense full-pipe

ANS + one match kernel one launch per level, CUDA graph persistent queue, leader per block

parse

wavefront v7-RA seek

work + Nwaves × 4.5 µs token count

Why does my GPU decoder achieve a few percent of bandwidth? The median match is 7 bytes against a 128byte cache line; bus efficiency is 4.4% and the coalesced ceiling is 39× away. • What should be optimized? Parse, at 64–72% of decode time. Not copy, and not chain depth. •

II. S ETUP ACEAPEX stores every back-reference as an absolute position in the decompressed output rather than a relative distance in a sliding window. The encoder performs a global match search and partitions the output into fixed-size blocks; because offsets are absolute, a block decodes as soon as the blocks holding its sources are present. Four streams are stored per block: literals, lengths, absolute offsets, and commands. Three decoders are used throughout, and Table I states what governs time in each. Confusing them is the main way to misread the numbers that follow. All measurements are on one H100 80 GB SXM with an EPYC 4344P host, CUDA 12.x. The canonical corpus is human chromosome 1 (UCSC hg38, 253,935,557 B, 16 KB blocks, 15,499 blocks). Correctness is bit-perfect by FNV or XXH3 against the original bytes; the few numbers without that check are marked where they appear. a) Bench noise: Repeated dense full-pipe runs on chr1 give 69.1 / 73.1 / 69.0 GB/s. We treat 6% as the resolution of this bench and do not claim effects below it. III. T HE PARSE WALL Table II and Figure 1 give the split of device-resident decode across four corpora. Parse holds 63.7–71.5% of the time in every case. This is the paper’s main quantitative contribution and it closes an open item of the series: earlier work in this

TABLE II F ULL DEVICE - RESIDENT DECODE . PARSE DOMINATES ON EVERY CORPUS . A LL BIT- PERFECT.

corpus dna 200 MB english 200 MB proteins 200 MB chr1 254 MB

TABLE III C OST OF THE DEPTH GUARANTEE . F ULL CHR 1, BASELINE RATIO 3.18065, ALL BIT- PERFECT.

tokens

ANS+parse

copy

parse

GB/s

cap L

589,469 421,940 617,836 5,365,972

1.020 ms 1.440 1.432 2.555

0.581 0.573 0.659 1.021

63.7% 71.5% 68.5% 71.5%

131.0 104.2 100.3 71.0

64 (natural) 32 24 16

max depth

ratio

cost

50 32 24 16

3.18065 3.18078 3.18066 3.18048

0.0000% −0.0041% −0.0003% +0.0053%

Fig. 1. Parse holds 64–72% of device-resident decode on four corpora. Throughput is not proportional to 1/tokens: english has the fewest tokens and a longer parse than dna.

line reported an anchor of roughly 50% measured on a single corpus. The same table refutes a natural model. If throughput were governed by token count alone, english—with the fewest tokens—would have the shortest parse. It has a longer one than dna. IV. D EPTH D OES N OT G OVERN L ATENCY The depth cap works, and it does not do what we expected. We report both halves. A. The bound is real and nearly free A two-pass, forced-literal encoder holds every block’s chain depth at or below a chosen L. The first pass encodes, decodes its own output and derives each token’s depth; matches deeper than L contribute their span to a forced-literal set; the second pass rejects matches covering forced regions. Re-parsing creates new deep chains, so the process iterates until it converges. The container is unchanged—only match selection differs, so any L is read by the same decoder. Table III gives the cost on the full corpus. It is within ±0.006% and negative at L=32. Before capping, 135 / 37 / 16 blocks exceed L=16 / 24 / 32; after capping, none do. B. What the cap does to time On the wavefront decoder, where each level is a kernel launch, depth is visible and small: 51 waves at L=∞ down to 17 at L=16, for −2.63% (5.846 to 5.692 ms, noise 0.003 ms). The marginal cost of a wave is 154 µs/34 = 4.5 µs; repeat baseline readings (5.846–5.852 ms) put it at 4.5–4.7 µs. On the dense full-pipe the effect disappears below bench noise: the ranges at L=50, 32 and 16 overlap. One signal is

Fig. 2. Tightening the cap lowers guaranteed maximum depth at a compression cost within ±0.006%; at L=32 the cost is negative.

stable—copy time at L=16 is 0.965–0.969 ms against 1.022– 1.040 (−6%, non-overlapping), because the cap literalizes deep matches and literals are written coalesced—but parse is 70% of the total, so the effect is submerged. The decisive experiment is on v7-RA seek, at block 7700, with three configurations of equal token mass (spread 295 tokens out of 5.3 million, 0.0055%). Table IV shows that only the configuration which actually reduces cluster depth moves the time; forcing an equal number of leaf tokens, or an equal number outside the cluster, changes nothing. FNV is identical across all four. C. The byte-level refutation The strongest statement needs no GPU at all. Comparing all four streams of every one of the 15,499 blocks, baseline against L=32, exactly 16 blocks differ, and that set coincides exactly with the forced list. The file’s latency spike cluster, blocks 7590–7770, contains none of them: 0 of 181 blocks changed, byte for byte (Figure 4). A cap that alters no byte in a region cannot alter that region’s decode time. This is a negative result carrying its own positive control. D. A reconciling model The three decoders agree under latency ≈ a · waves + b · bytes, with a = 4.5–4.7 µs—the price of an empty wave— and b dominant, ranging 30–181 µs/MB across corpora. For the spike cluster the wave term is identically zero, which is why depth has no purchase there.

TABLE IV E QUAL - TOKEN - MASS CONTROLS AT BLOCK 7700. O NLY REDUCING DEPTH (A) MOVES LATENCY; LEAF (B) AND PLACEBO (C) DO NOT.

config

∆tokens

cluster depth

µs

baseline A (deep forced) B (leaf forced) C (placebo, outside)

— −20,837 −20,668 −20,963

4.358 2.615 4.542 4.358

480.4 467.1 480.5 480.5

Fig. 4. Byte-level comparison of all 15,499 blocks. The cap changes 16 blocks, and none of them lie in the latency spike cluster.

Fig. 3. Depth across three decoders: visible and small on wavefront (−2.6%), isolated by placebo control on v7-RA seek (−2.8% for the deep configuration only), and indistinguishable from bench noise on the dense full pipe.

The spike itself is explained by parse, like everything else. A cluster block issues 772 references to 99 distinct cache lines (a 12.7 KB working set, L1-resident) against 473 references to 119 lines in a control block; it is not memory-pathological but instruction-dense, at 767 tokens against a median 357. Its latency ratio, 493 against 386 µs, is smaller than the token ratio because a single-block seek on v7-RA is launch-bound. Solving 386 = F + c · 357 and 493 = F + c · 767 gives a fixed cost F = 293 µs and c = 0.26 µs per token; the fixed part agrees with the 292–387 µs single-tile figures of Section VIII, measured on a different corpus. Only the remainder scales with tokens. Where the depth tail lives at all is a property of the data. A genomic FASTA corpus has a light body with rare very deep blocks (median max-depth 5, maximum 50); a read corpus is uniformly moderate (median 13, maximum 26) and has no extreme to cut (Figures 5 and 6). V. W HAT D OES : P ERIODS , N OT C HAINS A self-overlapping match, where the source range intersects the destination, is treated by every implementation we know as inherently serial. It is not. Writing the fill as out[dst + k] = out[src + k mod dist] places the source entirely outside the written range, so the threads are independent. The period dist is known to the encoder from the start—it is in the format. On chr1 there are 450,984 self-overlapping tokens with dist at P50 = 3, P90 = 5, P99 = 9, maximum 153 (microsatellites). Take the critical path to be the sum over levels of the longest match at that level, since a wave cannot finish before its longest match does: a single level-2 match of length 16,333 at period ≈ 3 accounts for 57% of it (16,333 of 28,587). The patch has two parts and they work only together: the modular semantics, which permits parallelism, and one warp per token, which uses it. Semantics alone on a single thread

Fig. 5. The genome carries a heavy depth tail; reads are bounded. The curves cross near depth 21.

gives −2.4%; with the warp mapping, chr1 falls from 5.846 to 1.291 ms (−77.9%). Table V gives the four corpora; all bit-perfect, and chr1 repeats at 1.291 three times. VI. T HE L AST S EQUENTIAL E LEMENT Decomposing all 10,566,105 commands of chr1 shows what is genuinely sequential: the four-entry distance history behind repeat matches accounts for 5.45% of commands, varint lengths for 0.61%, and the remaining 93.94% is parallelisable by prefix sum. That is demonstrated rather than argued. A pure prefix sum carrying no state reproduced every position of the sequential parse: block 1000 (761 commands) and block 15000 (746) show zero discrepancies in both output and literal positions. Block 5000 shows 30 discrepancies with exactly one varint command; block 0 shows 335 at 2.4% varint. Discrepancies are strictly proportional to varint expansion. Removing the history is an encoder-side decision. With repeat codes suppressed—the distance goes out as a varint, the match itself is preserved, the format is unchanged and the decoder is the same—the chained share falls from 5.46% to 0.02% and the dependency-free run grows from 4 commands to 706 at the median, a factor of 176. The cost is 0.540% of ratio (3.18065 to 3.16347)—equivalently 0.543% growth in compressed size, which is the figure the reproduction record

Fig. 6. Two risk profiles: a narrow body with a long whisker to 50 (genome) against a thick moderate body ending at 26 (reads).

Fig. 7. Self-overlap is a period, not a chain: 2.75–8.42× on the match layer, bit-perfect.

TABLE V M ATCH LAYER WITH PERIOD - AWARE FILL AND ONE WARP PER TOKEN . M ATCH LAYER ONLY— ENTROPY IS OUTSIDE THIS TIMER .

corpus

before (ms)

after

speedup

proteins chr1 silesia enwik9

5.571 5.846 16.018 7.804

0.662 1.291 5.346 2.838

8.42× 4.53× 3.00× 2.75× Fig. 8. The dependency-free run between chained commands grows 176× at the median; 93.94% of commands are already parallelisable by prefix sum.

reports; the control, with the flag off, returns exactly 3.18065. Both are bit-perfect. The comparison with prior work needs care, because the object differs. Gompresso’s dependency elimination removes a match-layer dependency (nested references inside a warp); the element removed here is a parse-layer one—absent from DEFLATE-style formats and present in zstd. The costs are not directly comparable, but both are encode-time decisions with a price in ratio: theirs up to 19%, ours 0.540%. The match-layer dependency itself is what absolute offsets and block independence already remove in this format [1]. VII. T HE M EMORY F LOOR What remains after the sequential part is removed is a bus problem. Copying 61,089,878 logical bytes on chr1 moves 1,392,400,000 bytes of cache-line traffic at 128 B granularity: 4.4% bus efficiency. An independent check writes the same 61 MB coalesced in 0.027 ms (2250.3 GB/s) against our 1.056 ms (58 GB/s)—a gap of 39×. Writes are 82% of the match-layer time, source reads 18%. The cause is granularity: the median match is 7 bytes and 99.4% of tokens are shorter than a warp (Figure 10). This independently rediscovers the work-granularity mechanism reported in Paper 4 of this series [4], from a different direction. Consistent with that paper, sorting tokens by destination within a level changes nothing (1.256 against 1.291 ms, noise): address scatter is not the bottleneck.

VIII. R ANDOM ACCESS AT S CALE On a 50,000,000,000-byte archive of 3,051,758 blocks (22.8 GB of streams, 50 GB of output, 72.8 of 79.2 GB VRAM), decoding one 16 KB tile takes 335.6, 386.6, 360.5 and 292.6 µs at the start, at 16 GB, at 33 GB and at the end— a spread of ±14% around 344 µs with four distinct FNV values and no trend with position. Widening the request scales far better than linearly: one block in 0.339 ms, one thousand blocks (16 MB) in 0.423 ms. We state the boundary: the 50 GB original is not on disk, so there is nothing to compare the FNV values against. This is position-invariance at 50 GB; bit-perfect correctness is shown on the smaller corpora. IX. T HE C LASS Comparing a random-access format against a whole-stream archive measures the constraint, not the mechanism. Table VI therefore places every codec under the same 16,384-byte independent-block constraint, so all are equally seekable. At equal seekability ACEAPEX ranks first on three of five corpora against zstd-19, and ahead of the speed-comparable zstd-3 everywhere, by 4.9% (chr1) to 16.1% (enwik9). The price of addressability is the blockwise constraint itself: wholestream zstd-3 against blockwise zstd-3 differs by 6.68% on chr1 and 24.19% on enwik9—and the match layer returns nearly three quarters of it (3.034 to 3.181 on chr1, recovering 4.85 of the 6.68).

Fig. 9. 4.4% bus efficiency: 1392 MB of traffic for 61 MB of data, and a 39× gap to a coalesced write.

Fig. 11. Position-invariant seek into a 50 GB archive, and a 1000× larger region for 1.25× the time. TABLE VI C OMPRESSION RATIO WITH INDEPENDENT 16 KB BLOCKS FOR ALL CODECS .

corpus chr1 enwik8 enwik9 silesia FASTQ 1 GB

Fig. 10. Depth histogram and match-length CDF for chr1: 60.7% of tokens at depth 0, and a median match of 7 bytes.

X. W HAT W E R EFUTED Every entry below is a measurement, not an opinion. We include our own methodological error. 1) The cap cuts the spike cluster. Zero overlap at L=32; 0 of 181 blocks changed byte for byte. 2) Latency scales with maximum level. Counterexample: english (58 waves, 200 MB) is 6.3× faster than proteins (45 waves, 200 MB). 3) A 4.7 µs-per-wave slope is universal. It ranges 7.8–123.3 across six corpora (16×). The 4.7 figure is the price of an empty wave; the average on chr1 is 114.6. 4) Throughput is proportional to 1/tokens. English has the fewest tokens and a longer parse than dna. 5) A scan parser helps on the current format. The run between chained commands is 4 commands at the median; a 32-thread warp on 4 commands loses to sequential. 6) Sorting tokens by destination will coalesce writes. Mean destination stride at level 2 is 578 B before and 578 B after—already sorted; 1.256 against 1.291 ms is noise. 7) Splitting kernels by match length helps. 1.761 against 1.291 ms, 36% worse: thread idling is not the bottleneck. 8) The spike is a memory-geometry pathology. Line-span 15.1 below the 24.7 of controls; 2.1% overlap bytes against 38.7%; reuse 7.81 against 3.97. The cluster is instruction-dense, not memory-pathological. 9) Raising the minimum match length is a speed lever. At high thresholds the addressability the format exists for

lz4

zstd-3

brotli-9

zstd-19

ACEAPEX

rank

1.786 1.595 1.750 1.907 2.324

3.034 2.334 2.567 2.675 3.629

3.287 2.564 2.824 2.882 3.910

3.475 2.488 2.736 2.936 4.029

3.181 2.638 2.981 3.005 3.965

3 1 1 1 2

is lost, and the relative spike grows, from 2.2× to 20× (Figure 13). 10) Our own error, corrected in the same session. We compared a blockwise format against whole-stream zstd. Constraints must be equalised before measuring; Table VI is the corrected form. XI. R ELATED W ORK Gompresso [6] is the closest prior system and is a single work, not two: it offers two variants (Huffman-coded and bytecoded) and two strategies for back-reference dependencies— multi-round resolution during decode, and dependency elimination at compression time. The latter does not insert checkpoints; it forbids nested references that would create intrawarp dependencies by searching only below a per-warp highwater mark. Its reported price is up to 19% degradation in compression ratio for that strategy, summarised in their conclusion as no more than 10% overall, for a 2–3× decode gain on a Tesla K40. That dependency is not the one we remove. Their elimination targets the match layer; absolute offsets and block independence already remove the match-layer dependency in this format [1]. What Section VI removes is a parselayer dependency—a four-entry distance history, absent from DEFLATE-style formats and present in zstd. The two costs, 19% and 0.540%, are therefore not directly comparable, though both are encode-time decisions paid for in ratio. CODAG [5] raises decode parallelism by mapping compressed chunks to warps at runtime rather than varying compression granularity, and reports GPU decode as computebound—consistent with the parse share we measure here.

Bench noise is 6% on the dense full pipe. We do not claim effects below it. Depth is not claimed to be irrelevant—on the wavefront decoder it is measurable and equals −2.6%. • The 50 GB seek is not bit-perfect; the original is not on disk. Position-invariance is measured, correctness shown on smaller corpora. • Removing the distance history is not verified on GPU. The chain is removed and measured on CPU; the resulting decode speedup is an estimate and is not claimed as a result. • The minimum-match probe is not bit-perfect—tokens were dropped without substituting literals. It illustrates a mechanism only. • Wavefront numbers are match-layer only, with entropy outside the timer. They are never decode throughput. • The class matrix covers five corpora. The Pizza & Chili sets were measured on the GPU bench but are not in the ratio matrix. •

Fig. 12. Under an equal 16 KB independent-block constraint, ACEAPEX ranks first on three of five corpora against zstd-19.

R EPRODUCIBILITY

Fig. 13. Raising the minimum match length trades the match layer for entropy coding, with an optimum on genome and none on text.

Paper 4 of this series [4] identified work granularity as the governor of decode throughput; the bus measurement in Section VII arrives at the same mechanism from the traffic side. Bounding the height of an LZ parse is studied in theory. Height-bounded LZ [7] bounds worst-case access time through the height of the referencing forest, giving O(h) predecessor queries, and shows that finding the smallest parsing under a height bound is NP- and APX-hard. Our result is complementary and, on this hardware, deflationary: we provide a practical encoder that reaches a valid parsing under the bound bit-perfectly on a full corpus, and then measure that on a GPU the height h costs almost nothing—at most 2.8%, and provably zero where the file’s own latency spike lives. LZ-End [8] addresses extraction time from compressed text and work on balanced straight-line programs [9] addresses asymptotic derivation depth; both are algorithmic statements, while ours concerns the physical realization of a boundeddepth absolute-offset parse as a CUDA and VRAM execution layer. XII. L IMITATIONS •

One GPU. H100 80 GB SXM. Behaviour on other generations is untested; the 4.5–4.7 µs wave cost is a property of the CUDA graph on this hardware.

Canonical corpus: chr1, UCSC hg38, md5 9465e0f0df6e2c6eb39729c39cee5465, 253,935,557 B, block size 16,384. Second corpus for the depth distributions: ERR194147 (NA12878, Illumina Platinum; ENA path ERR194/ERR194147), md5 9af9ffaa..., slice of exactly 3052 × 16384 = 50,003,968 B—the first ≈50 MB, not 1 GB. A separate 50,000,000,000 B slice of the same accession is the archive of Section VIII. Golden corpora: enwik8, enwik9, silesia.tar, Pizza & Chili dna/english/proteins at 200 MB. Artifacts are archived at DOI 10.5281/zenodo.21874972 (release tag paper5-v1, commit 22de9dc); the concept DOI 10.5281/zenodo.20440964 always resolves to the latest version. The repository contains the run-parallel wavefront kernel wf_par.cu, its semantics-only control wf_run.cu, the encoder with the FORCED_BIN, NO_REP and MIN_MATCH paths used here, and reproduce_paper5.sh. MIT licensed. A PPENDIX : R EPRODUCIBILITY C ONTRACT Every figure in this paper carries a level rather than a caveat in prose. R is reproducible: a command, an expected value and a tolerance, with code, script and corpus fixed by accession and digest. M is measured but not bit-perfect, with the reason the judge cannot be applied stated explicitly. E is an estimate computed from measured quantities, with its formula and inputs given. R. Parse share 63.7–71.5% on four corpora; depth on all three decoders; the byte-level hash test over 15,499 blocks; run parallelism 2.75–8.42×; the no-repeat cost of 0.540%; fullpipe chr1 at 71.0 GB/s; the class matrix of five corpora against five codecs; the ratio(L) curve; the 6% bench noise.

M. The 50 GB seek—the original is not on disk, so the FNV values have nothing to compare against. The minimum-match probe—tokens were dropped without substituting literals. E. The 2.7× figure for a scan parser: parse 2.555 ms scaled by the 93.94% parallelisable share gives roughly 0.15 ms, which has not been verified on a GPU. reproduce_paper5.sh writes one JSON record per claim—identifier, level, expected value, tolerance, measured value, verdict, command—so that checking the paper against a run is mechanical rather than visual. A fresh clone of the tagged release, on an EPYC 4344P host without a GPU, reproduces every R claim reachable there: 17 pass, 0 fail, 6 skipped (three GPU claims need a CUDA device; three are the declared M and E entries). The recorded run ships as results.json. R EFERENCES [1] Y. Shavidze, “Parallel LZ77 decoding via encode-time absolute offset resolution,” arXiv:2606.04268, 2026. [2] Y. Shavidze, “Compressed-resident genomics,” arXiv:2606.18900, 2026. [3] Y. Shavidze, “Unified position-invariant random access through two compression layers,” arXiv:2606.24531, 2026. [4] Y. Shavidze, “What governs decode throughput in absolute-offset GPU LZ77?” arXiv:2607.18541, 2026. [5] Park et al., “CODAG: characterizing and optimizing decompression algorithms for GPUs,” arXiv:2307.03760, 2023. [6] E. Sitaridi, R. Mueller, T. Kaldewey, G. Lohman, and K. A. Ross, “Massively-parallel lossless data decompression,” in Proc. 45th Int. Conf. on Parallel Processing (ICPP), 2016. arXiv:1606.00519. [7] H. Bannai, M. Funakoshi, D. Hendrian, M. Matsuda, and S. J. Puglisi, “Height-bounded Lempel-Ziv encodings,” in Proc. 32nd Annual European Symposium on Algorithms (ESA), LIPIcs vol. 308, pp. 18:1–18:18, 2024. doi:10.4230/LIPIcs.ESA.2024.18, arXiv:2403.08209. [8] S. Kreft and G. Navarro, “LZ77-like compression with fast random access,” Proc. DCC, 2010, pp. 239–248. [9] M. Ganardi, A. Jeż, and M. Lohrey, “Balancing straight-line programs,” J. ACM, 2021.

Related documents

• ACEAPEX: Parallel LZ77 Decoding via Encode-Time Absolute Offset Resolution#259434
• Penn Library's Ms. Codex 760 - [Ethica Nicomachea]. (Video Orientation)#207050
• What Irregularity Costs: CUDA C++, Rust, and Triton on a Hash-Blocked GPU Workload#441766
• 5GDescrambler: Locating, Descrambling, and Decoding 5G Scheduling Information (long version)#667929
• RTP Payload Format for Scalable Video Coding#220700