An LLVM-Based Optimization Pipeline for SPDZ

TL;DR

This paper presents an LLVM-based optimization pipeline for the SPDZ secure multi-party computation protocol, significantly improving performance and scalability by automating parallelism and communication overlapping while maintaining usability.

Contribution

It introduces a novel LLVM-based framework that automates parallelism and communication optimization for SPDZ, reducing programmer effort and enhancing performance.

Findings

CPU backend achieves up to 5.56x speedup

Strong scaling with thread count demonstrated

GPU backend scales better with larger inputs

Abstract

Actively secure arithmetic MPC is now practical for real applications, but performance and usability are still limited by framework-specific compilation stacks, the need for programmers to explicitly express parallelism, and high communication overhead. We design and implement a proof-of-concept LLVM-based optimization pipeline for the SPDZ protocol that addresses these bottlenecks. Our front end accepts a subset of C with lightweight privacy annotations and lowers it to LLVM IR, allowing us to reuse mature analyses and transformations to automatically batch independent arithmetic operations. Our back end performs data-flow and control-flow analysis on the optimized IR to drive a non-blocking runtime scheduler that overlaps independent operations and aggressively overlaps communication with computation; when enabled, it can map batched operations to GPU kernels. This design preserves a low learning curve by using a mainstream language and hiding optimization and hardware-specific mechanics from programmers. We evaluate the system on controlled microbenchmarks against MP-SPDZ, focusing on online phase performance. Our CPU back end achieves up to 5.56 times speedup under intermediate and heavy algebraic workloads, shows strong scaling with thread count, and our GPU back end scales better as the input size increases. Overall, these results indicate that leveraging LLVM with protocol-aware scheduling is an effective architectural direction for extracting parallelism without sacrificing usability.