Hash Performance (SHA2, SHA3, SHAKE) - Benchmark
Many security and proof-system pipelines spend a large share of time in hashing: integrity checks, commitments, KDFs, and similar steps. When throughput matters, moving that work off the CPU can change the overall cost profile.
This post reports throughput for SHA2, SHA3, and SHAKE on one server CPU versus one professional GPU, using cuPQC-Hash from the cuPQC SDK, with the same message size and parallel batching setup on both platforms.
Benchmark Configuration
We measured throughput using cuPQC SDK v0.4.1 on an AMD EPYC 9124 (16-core server processor) as the CPU baseline against an NVIDIA RTX PRO 6000 (Blackwell generation) using cuPQC-Hash. Each hash processes an 8 KB message; the workload uses parallel cores on the CPU and the GPU’s parallel execution model so many independent hash outputs are computed at once, which is how peak GB/s throughput is achieved. The figure below summarizes CPU vs GPU throughput and speedup for each algorithm.
Benchmark Analysis
SHA-2
The SHA2-256 algorithm achieves 672 GB/s throughput on the RTX PRO 6000, representing a 14× speedup over the CPU baseline. SHA2-512 shows even more dramatic improvement at 46× faster, reaching 646 GB/s.
SHA-3 and SHAKE
The SHA-3 family demonstrates the most impressive acceleration results in our benchmark. SHA3-256 achieves a 101× speedup at 710 GB/s, while SHAKE128 reaches the highest absolute hash rate at 891 GB/s with 99× acceleration. SHAKE256 leads in relative performance with 103× speedup, processing 723 GB/s.
These exceptional gains stem from SHA-3's sponge construction, which exposes substantial parallelism that GPU architectures can exploit effectively. The Keccak permutation at SHA-3's core maps naturally to GPU compute units.
In cuPQC-Hash, these primitives are implemented as batched CUDA kernels with shared memory and per-family layout choices so the GPU can stay in a throughput-oriented regime rather than serializing work.
Performance impact on cryptographic workloads
When hashing is a dominant part of the workload, higher SHA2/SHA3/SHAKE throughput can shorten wall-clock time for the surrounding pipeline. That pattern shows up in different designs depending on where time goes: for example hash-based signatures, Merkle-tree commitments and updates, and some zero-knowledge / proof-system stacks that evaluate many hashes in parallel can be sensitive to raw hash throughput.
Taken together, the figure and the sections above highlight where GPU acceleration is strongest: SHA3 and SHAKE see the largest relative gains, while SHA2-256 still improves meaningfully on the GPU even though the CPU baseline is already high.
Get started
cuPQC-Hash exposes GPU-accelerated SHA2, SHA3, SHAKE, and Posiedon 2 with a consistent API. For the full API (hash primitives), see the cuPQC-Hash API reference. On this hub, the SHA-2 Hash Function tutorial walks through an example application.
