PerfCoder: Strategy-Guided Code Optimization

• PerfCoder is a family of transformer-based LLMs designed for interpretable, input-specific code performance optimization, generating both strategies and optimized code in a single pass.
• It uses dedicated control tokens to clearly separate optimization strategies from code segments, enabling modular planning and integration with frozen high-capacity code generators.
• Empirical evaluations show that PerfCoder achieves superior speedup and effective optimization rates by leveraging reinforcement learning with runtime feedback.

PerfCoder denotes a family of LLMs, architectures, and training protocols explicitly designed for interpretable, input-specific, and effective program performance optimization via strategy-guided code generation. Developed to address the critical gap between functional code correctness and real-world execution efficiency, PerfCoder systems are fine-tuned on curated optimization trajectories and further aligned by reinforcement learning with measured runtime feedback. In addition to generating high-performance code, PerfCoder models produce human-interpretable optimization plans, enabling both explainability and modular integration in multi-agent planning workflows. On rigorous code optimization tasks, PerfCoder achieves superior speedup and effective optimization rates in both single-step and cooperative two-stage inference paradigms (Yang et al., 16 Dec 2025).

1. Model Foundations and Architecture

PerfCoder builds upon open-source, decoder-only transformer-based LLMs (e.g., CodeLlama-7B, Qwen2.5-Coder-7B), extending their standard language modeling interface through the introduction of dedicated control tokens for strategy and code delineation:

• [SUGG/], [/SUGG]: Demarcate the sequence span corresponding to structured, natural language optimization strategies.
• [OPT/], [/OPT]: Encapsulate the region containing the corresponding performance-optimized code.

The model operates in two modal regimes:

• "Plan + code" mode: Generates both high-level strategies and optimized code in a single pass.
• "Plan-only" mode: Produces only interpretable optimization plans, suitable for planner roles in cooperative frameworks.

Supervised fine-tuning on trajectory-annotated inputs is performed by minimizing the causal language modeling loss:

$$L_{\mathrm{SFT}}(\theta) = -\sum_{t=1}^T \log p_{\theta}\left(y_t \mid y_{<t}, I, x_{\mathrm{slow}}\right),$$

where $I$ is the instruction, $x_{\mathrm{slow}}$ is the unoptimized code, and $y$ is the concatenated strategy and optimized code sequence (Yang et al., 16 Dec 2025).

2. Optimization-Trajectory Dataset and Annotation

Source data is drawn from the PIE dataset (77,967 slow–fast C++ submission pairs). PerfCoder training restricts attention to a high-quality subset ($D_{\mathrm{ref}}$, 30,649 pairs) by:

• Retaining only users' final submissions.
• Replacing outlying slow endpoints with globally fastest known submissions.

Optimization strategies are auto-extracted for each pair $(x_{\mathrm{slow}}, x_{\mathrm{fast}})$ by a 32B instruction-tuned LLM. Each strategy $s_i$ is assigned a canonical category (e.g., “Loop Efficiency Techniques,” “Data Structure Selection”) from $|C|=15$ categories, and annotated with a context-aware explanation. To correct for extreme category imbalance (e.g., 86.7% I/O optimizations, 0.04% multithreading), a balanced subset ($D_b$, 5,000 pairs) is constructed by round-robin sampling (Yang et al., 16 Dec 2025).

The dataset format is:

<Instruction> [SUGG/] – [StrategyName₁]: Explanation₁ – [StrategyName₂]: Explanation₂ [/SUGG] [OPT/] <Optimized code> [/OPT]

3. Reinforcement Learning with Runtime Rewards

After initial supervised training, PerfCoder achieves “plan + code” competence. To ensure generated strategies reliably map to empirical speedup, the planner module is reinforcement fine-tuned using measured runtimes while keeping the optimizer (a code-generation LLM, e.g., Qwen2.5-Inst-32B) frozen.

Given a slow code input, the planner samples $G$ candidate strategy sets. For each, the optimizer synthesizes optimized code, which is then compiled (e.g., g++ -O3) and timed for runtime $T(x)$. The speedup is $A = T(x_{\mathrm{slow}})/T(x_{\text{gen}})$. A quadratic reward function is applied:

• $R = -100$ if $x_{\text{gen}}$ fails to compile;
• $R = -1$ if $A<1$ (regression);
• $R = A^2$ if $A\geq1$ (bonus for large gains).

Group Relative Policy Optimization (GRPO) with within-group normalization is used to update planner parameters. This aligns PerfCoder’s strategy outputs to maximize actual performance gains (Yang et al., 16 Dec 2025).

4. Interpretable Optimization Strategy Generation

By induction over the strategy + code dataset, PerfCoder learns to emit structured lists of optimization plans in the following canonical template:

[SUGG/] – [Loop Efficiency Techniques]: Unroll the inner loop by a constant factor to reduce branch overhead. – [Memory Usage and Allocation]: Replace memset with implicit zero initialization via vector constructor. [/SUGG] [OPT/] <Transformed code> [/OPT]

In “plan-only” mode, the output terminates at [/SUGG]. These plans are both actionable—enabling direct audit by engineers—and modular, as they can be provided as mid-level guidance to more powerful code generators in planner-optimizer workflows. Strategy annotation improves both average speedup and effective optimization rate, indicating the necessity of interpretable supervision (Yang et al., 16 Dec 2025).

5. Experimental Evaluation and Comparative Performance

PerfCoder is validated against baselines (GPT-4, GPT-5, CodeLlama, Qwen2.5, Effi-Learner) on the PIE benchmark. Three core metrics are reported:

• Speedup: Ratio $T(\mathrm{slow})/T(\mathrm{opt})$ over 20 tests (invalid code counts as 1).
• Effective Optimization Rate: Percentage of samples both correct and with at least 1.1× speedup.
• Code Accuracy: Percentage passing all functional tests.

Key findings include:

Model	Size	Steps	Speedup	EffOpt	Accuracy
GPT-5	–	1-step	1.96×	53.3%	93.7%
PerfCoder-QC (7B)	7B	1-step	2.50×	33.1%	43.5%
Qwen2.5-Coder + PerfCoder (2-step)	7B+32B	2-step	2.26×	44.9%	61.7%
PerfCoder-QC (1.5B)+GPT-5 (GRPO)	1.5B+GPT-5	2-step+RL	4.82×	79.9%	97.9%

PerfCoder-QC (7B) achieves higher speedup than GPT-5 (1.96× vs 2.50×) despite being much smaller. Using PerfCoder strategies to guide larger LLMs (e.g., Qwen2.5-Inst-32B) in a two-stage paradigm yields additive gains. RL-aligned PerfCoder as a planner with frozen GPT-5 as optimizer achieves the highest speedup recorded (Yang et al., 16 Dec 2025).

6. Planner–Optimizer Cooperative Workflow

PerfCoder enables a planner–optimizer workflow in which the “planner” (PerfCoder, in plan-only mode) emits an interpretable set of strategies, which are then provided as explicit guidance to an “optimizer” LLM that generates the corresponding transformed code:

1. Input: $x_{\mathrm{slow}}$, instruction $I$.
2. Planner generates $S=\{s_i\}$ with [SUGG/], terminates at [/SUGG].
3. Combined prompt $$P=I+x_{\mathrm{slow}}+\text{[SUGG/]}S\text{[/SUGG]}$$ is sent to the optimizer with “[OPT/]”.
4. Optimizer decodes $x_{\mathrm{opt}}$.
5. Final output is $x_{\mathrm{opt}}$.

This dual-inference approach leverages the strengths of both interpretable planning and high-capacity code generation. It is especially effective in reinforcement learning loops for aligning planning behavior with actual runtime gains (Yang et al., 16 Dec 2025).

7. Key Insights, Limitations, and Future Directions

PerfCoder demonstrates that strategy-aware, interpretable supervision and explicit runtime feedback are crucial for large-scale code performance optimization. Simple scaling or code–code pair fine-tuning without structured annotations produces markedly inferior results. Modular, interpretable planning enables both auditability and composability in LLM-based development environments.

Limitations include reliance on a 32B open-source model for strategy extraction, focus on C++ competitive-programming kernels, and evaluation restricted to wall-clock time. Prospective directions comprise extending to multi-language domains, real-world multi-module codebases, and integrating hardware-/energy-aware reward signals (Yang et al., 16 Dec 2025).

A plausible implication is that widespread adoption of the planner–optimizer and interpretable-strategy paradigm could recalibrate the balance between code generation correctness and performance, further narrowing the gap between LLM-optimized and human-optimized software systems.