On the Performance of Cloud-based ARM SVE for Zero-Knowledge Proving Systems

Dumitrel Loghin, Shuang Liang, S. Liu, Xiong Liu, Pingcheng Ruan, Zhigang Ye

This paper, authored by researchers at OKX Group, explores a critical question for the future of decentralized finance: Can the cost-efficiency of ARM-based cloud servers be leveraged to speed up the computationally grueling process of generating Zero-Knowledge Proofs (ZKPs)?

TL;DR

While ARM-based cloud instances are significantly cheaper than their x86-64 counterparts, current hardware (like AWS Graviton4 and GCP Axion) is 1.4x to 1.6x slower at generating ZKPs. The bottleneck isn't the ARM instruction set—which is actually more flexible for cryptography—but rather the smaller vector widths (128-bit vs. 512-bit) and lower clock speeds of current ARM deployments.

What Problem Does This Paper Address?

Zero-Knowledge Proofs are the "gold standard" for scaling blockchains like Ethereum via ZK-rollups (e.g., Polygon zkEVM). However, proving a batch of transactions is incredibly resource-intensive, often requiring massive x86-64 server clusters with hundreds of CPU cores.

ARM-based servers (using Neoverse architectures) are roughly 20% cheaper in the cloud, but most ZKP software is heavily optimized for x86-64's AVX512 (Advanced Vector Extensions). The researchers wanted to know if ARM’s SVE (Scalable Vector Extension) could close the performance gap, potentially allowing for much cheaper blockchain infrastructure.

Methods

The authors implemented and benchmarked the core cryptographic primitives used in the Polygon zkProver:

  • Goldilocks Field Operations: Arithmetic over the specific prime field ($P = 2^{64} - 2^{32} + 1$) used in modern ZKPs.
  • Poseidon Hash: A "sponge-based" hash function optimized for ZK circuits.
  • Merkle Tree Building: Constructing a tree with over 4 million leaves, a common "hotspot" that accounts for ~30% of ZKP execution time.

They compared hand-written SVE/SVE2 assembly against highly optimized AVX2/AVX512 implementations across several cloud providers, including AWS (Graviton3/4), GCP (Axion), and Alibaba Cloud (Yitian 710). They also performed a "what-if" analysis using the QEMU emulator to project how ARM would perform if it had larger vector registers.

Datasets

The study did not use traditional machine learning datasets. Instead, it used a standardized benchmark:

  • Merkle Tree Construction: Building a tree with $2^{22}$ (4,194,304) leaves.
  • Input Data: Chunks of eight 64-bit Goldilocks field elements per leaf.

Key Insights and Ideas

  • ISA Superiority: Interestingly, the ARM SVE/SVE2 Instruction Set Architecture (ISA) is actually better suited for cryptography than x86-64. SVE supports unsigned 64-bit integers natively, whereas AVX is primarily designed for signed integers. This allows ARM to perform field additions and subtractions with fewer instructions.
  • The SVE2 "Multiplier" Effect: SVE2 introduces the svmulh instruction, which returns the high half of a 128-bit product. This reduces the instruction count for 64-bit multiplication from 18 instructions (in standard SVE) to just 2.
  • Compiler Bottlenecks: The researchers found that GCC 13 produced inefficient SVE code, often inserting unnecessary "move" instructions (movprfx). Hand-written assembly or the newer GCC 14 was required to reach peak performance.
  • Hardware vs. Architecture: The performance lag is a physical implementation issue, not a design flaw. Current ARM cloud chips use 128-bit vector registers, while high-end Intel/AMD chips use 512-bit registers. This means x86 can process four times as much data per vector instruction.

Key Results

  • Performance Gap: AWS Graviton4 is 1.6x slower and GCP Axion is 1.4x slower than the latest AMD EPYC and Intel Xeon servers when building Merkle trees.
  • Frequency Matters: x86-64 instances typically run at ~3.7 GHz, while ARM instances are often underclocked to 2.8–3.1 GHz in cloud environments.
  • The "What-If" Projection: If ARM hardware designers increased the SVE vector width to 512 bits and matched x86 clock speeds, the researchers estimate ARM would be 29% faster than EPYC while maintaining its price advantage.

Limitations and Future Work

The primary limitation is the current state of cloud hardware. While the SVE architecture allows for vectors up to 2048 bits, cloud providers have opted for conservative 128-bit implementations to save on power and die area.

The authors suggest two main paths forward:

  1. Hardware Evolution: ARM designers should implement 512-bit SVE units to compete directly with AVX512 in high-performance computing (HPC) and ZKP workloads.
  2. Cloud Optimization: Cloud providers should consider "unlocking" higher clock frequencies for ARM instances to better utilize their architectural efficiency.

For now, x86-64 remains the king of the ZKP hill, but the architectural groundwork for an ARM takeover has already been laid.

Summary updated

Abstract

Zero-knowledge proofs (ZKP) are becoming a gold standard in scaling blockchains and bringing Web3 to life. At the same time, ZKP for transactions running on the Ethereum Virtual Machine require powerful servers with hundreds of CPU cores. The current zkProver implementation from Polygon is optimized for x86-64 CPUs by vectorizing key operations, such as Merkle tree building with Poseidon hashes over the Goldilocks field, with Advanced Vector Extensions (AVX and AVX512). With these optimizations, a ZKP for a batch of transactions is generated in less than two minutes. With the advent of cloud servers with ARM which are at least 10% cheaper than x86-64 servers and the implementation of ARM Scalable Vector Extension (SVE), we wonder if ARM servers can take over their x86-64 counterparts. Unfortunately, our analysis shows that current ARM CPUs are not a match for their x86-64 competitors. Graviton4 from Amazon Web Services (AWS) and Axion from Google Cloud Platform (GCP) are 1.6X and 1.4X slower compared to the latest AMD EPYC and Intel Xeon servers from AWS with AVX and AVX512, respectively, when building a Merkle tree with over four million leaves. This low performance is due to (1) smaller vector size in these ARM CPUs (128 bits versus 512 bits in AVX512) and (2) lower clock frequency. On the other hand, ARM SVE/SVE2 Instruction Set Architecture (ISA) is at least as powerful as AVX/AVX512 but more flexible. Moreover, we estimate that increasing the vector size to 512 bits will enable higher performance in ARM CPUs compared to their x86-64 counterparts while maintaining their price advantage.
BibTeX
@misc{loghin2025performance,
  author = {Dumitrel Loghin and Shuang Liang and S. Liu and Xiong Liu and Pingcheng Ruan and Zhigang Ye},
  title = {{On the Performance of Cloud-based ARM SVE for Zero-Knowledge Proving Systems}},
  year = {2025},
  eprint = {2506.09505},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2506.09505},
}
Figure