Souper: A Synthesizing Superoptimizer (1711.04422v2)

Abstract: If we can automatically derive compiler optimizations, we might be able to sidestep some of the substantial engineering challenges involved in creating and maintaining a high-quality compiler. We developed Souper, a synthesizing superoptimizer, to see how far these ideas might be pushed in the context of LLVM. Along the way, we discovered that Souper's intermediate representation was sufficiently similar to the one in Microsoft Visual C++ that we applied Souper to that compiler as well. Shipping, or about-to-ship, versions of both compilers contain optimizations suggested by Souper but implemented by hand. Alternately, when Souper is used as a fully automated optimization pass it compiles a Clang compiler binary that is about 3 MB (4.4%) smaller than the one compiled by LLVM.

Overview of "A Synthesizing Superoptimizer"

The paper "A Synthesizing Superoptimizer" presents the development and evaluation of Souper, an innovative superoptimizer designed to derive novel middle-end compiler optimizations automatically. Souper operates within the domain-specific intermediate representation (IR) environment of LLVM, a widely-used compiler framework.

Motivation and Context

Compiler optimizations, typically found in the middle-end, are imperative yet arduous to implement correctly due to the evolving landscape of hardware platforms and the rise of high-level programming languages. Souper emerges as a tool capable of harnessing the advancements in SAT and SMT solvers, which efficiently derive equivalence proofs necessary for validating optimizations. The motivation is to reduce the engineering burden in compiler development by automating the discovery of optimal code sequences through program synthesis techniques.

Technical Contributions

Souper introduces an overview-driven approach to discover optimizations at the LLVM IR level. Key contributions include:

1. Synthesis Algorithm: Extending the algorithm by Gulwani et al., Souper synthesizes optimizations through a counterexample-guided inductive synthesis (CEGIS) process. It generates LLVM IR optimizations by providing a cost-efficient solution to equivalence-checking quantified formulas.
2. Intermediate Representation: Souper's IR, a control-flow-free and functional subset of LLVM, captures optimizable instruction sequences in directed acyclic graphs. The IR is designed to work closely with LLVM's bitvector operations, maintaining polymorphism regarding instruction bitwidths.
3. Path Conditions and Block Conditions: The optimizer captures control-flow-derived facts through constructs like path conditions and block conditions to assist in synthesizing optimizations that converge pre-extracted dataflow paths.
4. Practical Integration: The tool was integrated into both LLVM and Microsoft Visual C++ compilers. Souper can function offline, generating suggestions for compiler developers, or operate online as an active compiler phase, making direct optimizations.
5. Validation and Soundness: The optimizer includes a validation mechanism through equivalence checking and employs SMT solvers to ensure soundness, with facilities to cross-verify with tools like Alive.

Numerical Results and Impact

Souper demonstrates tangible impacts, such as reducing the size of binaries. For example, an LLVM-compiled Clang binary was reduced by 4.4% in size when Souper-generated optimizations were employed, though a minor 2% slowdown was observed. This emphasizes the potential for size optimization, albeit with some runtime trade-offs.

Practical and Theoretical Implications

• Practical Implications: The implementation of optimizations derived from Souper has enhanced the efficiency of both LLVM and Microsoft compilers. The ability to replace variables with constants plays a crucial role in optimizing dead code elimination and constant propagation. The paper reports that 40 new optimizations were hand-implemented in the Visual C++ compiler based on suggestions from Souper, leading to significant code size reductions for Windows builds.
• Theoretical Implications: This research showcases the potential of using solver-based synthesis in automating compiler optimizations. It offers a framework that could be extended to other domains, potentially simplifying extensions for verified compilers like CompCert by integrating automated proof systems.

Future Directions

The authors suggest several avenues for future research, such as automating the generalization of optimizations to create parameterized optimization patterns and integrating backend-specific code sequences. They also propose extending Souper's IR to support other verified platforms, bridging the gap between research and practical deployment.

In conclusion, Souper represents a significant step forward in compilation technology by demonstrating the feasible integration of synthesis-driven techniques in compilers, thereby reducing manual efforts in optimization development and providing a robust platform for further advancements in automated compiler technology.