Rethinking Execution Granularity for Heterogeneous Zero-Knowledge Proof Provers

Abstract

Zero-knowledge proofs (ZKPs) are increasingly used in blockchain systems, privacy-preserving applications, and verifiable cloud computation, but their practical deployment is still constrained by the cost of proof generation. This cost is especially important when proof generation is provided as a cloud-side service, where prover latency directly affects service throughput and resource efficiency. Existing heterogeneous provers mainly follow an operator-centric design, offloading selected GPU-friendly kernels while leaving the overall proving pipeline fragmented across fine-grained execution boundaries. This approach is effective at reducing the cost of major operators, but it also changes the bottleneck structure of modern proving: once dominant kernels are accelerated, end-to-end inefficiency increasingly arises from fragmented cross-stage execution, including host-device transitions, intermediate-state materialization, and CPU-side coordination overhead. In this paper, we argue that the key systems problem is no longer simply which operator to accelerate next, but what the right runtime execution unit should be for heterogeneous ZKP proving. To this end, we propose region-centric execution, a locality-aware runtime abstraction that groups tightly dependent computations into larger execution units based on dependency locality, state continuity, and boundary cost. Building on this abstraction, we design execution mechanisms that preserve deviceresident state, delay unnecessary materialization, coordinate dependent computations within a region, and reduce excessive boundary crossings. We implement our design on top of a Plonky2-based GPU prover and evaluate it on four representative workloads. Region-centric execution improves end-to-end proving performance by $1.36 \times$ on average and up to $1.52 \times$ over an operator-centric baseline, with the gains coming primarily from lower coordination overhead and reduced host-device transfer cost rather than uniformly faster GPU kernels.