Agentic Code Optimization via Compiler-LLM Cooperation

TL;DR

This paper introduces a multi-agent system that combines traditional compiler optimizations with LLM-based code generation to improve program performance while maintaining correctness, achieving up to 1.25x speedups.

Contribution

It presents a novel cooperative framework integrating compiler passes and LLMs at multiple abstraction levels for optimized code generation.

Findings

Outperforms existing compiler optimizations and LLM baselines.

Achieves up to 1.25x speedup in program execution.

Demonstrates effective distribution of computational resources across abstraction levels.

Abstract

Generating performant executables from high level languages is critical to software performance across a wide range of domains. Modern compilers perform this task by passing code through a series of well-studied optimizations at progressively lower levels of abstraction, but may miss optimization opportunities that require high-level reasoning about a program's purpose. Recent work has proposed using LLMs to fill this gap. While LLMs can achieve large speedups on some programs, they frequently generate code that is incorrect. In this work, we propose a method to balance the correctness of conventional compiler optimizations with the ``creativity'' of LLM-based code generation: compiler-LLM cooperation. Our approach integrates existing compiler optimization passes with LLM-based code generation at multiple levels of abstraction, retaining the best features of both types of code optimization. We realize our approach with a multi-agent system that includes (1) LLM-based optimization agents for each level of abstraction, (2) individual compiler constituents as tools, (3) an LLM-based test generation agent that probes the correctness and performance of generated code, and (4) a guiding LLM that orchestrates the other components. The strategy enables LLM-based optimization of input programs at multiple levels of abstraction and introduces a method for distributing computational budget between levels. Our extensive evaluation shows that compiler-LLM cooperation outperforms both existing compiler optimizations and level-specific LLM-based baselines, producing speedups up to 1.25x.