Pith. sign in

REVIEW 3 major objections 4 minor 38 references

WarmTuner: Program-Specific Warm Starts for Compiler Autotuning via Offline-to-Online Reinforcement Learning

T0 review · 3 major / 4 minor · reviewed 2026-08-01 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A tuner that starts from a program-specific policy learned offline and keeps adapting online reaches a 1.732x average speedup over GCC -O3.

desk verdict A solid, incremental compiler-autotuning paper whose headline claim overreaches and whose group-size selection leaks test-set information; worth peer review but needs revision. read the letter →

arxiv 2607.25831 v1 pith:RF6K2MNN submitted 2026-07-28 cs.SE

Tianlu Qiao , Mingxuan Zhu , Zeyu Sun , Dan Hao This is my paper · ORCID
classification cs.SE
keywords compilerautotuningflagselectionoffline-to-onlinereinforcementlearningGRPOprogram-conditionedpolicyGCCwarmstartCodeBERT
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper tries to establish that the starting point of compiler autotuning—not just the search—should be learned and adaptable. WarmTuner treats the prior as a trainable policy that predicts each flag's enable probability from source code, pretrains it on historical good configurations, and then updates the same policy online using measured speedups. The authors argue this solves the mismatch problem of existing tuners whose priors are fixed or program-agnostic. If correct, historical tuning data from any strategy can seed a per-program warm start, and online budgets are spent refining rather than rediscovering good regions. The evaluation reports 1.732x average speedup over -O3, best on 14/30 programs, with a significant edge over RIO, SRTuner, and PDCAT and a smaller edge over GroupTuner.

What carries the argument

The central object is a program-conditioned factorized Bernoulli flag policy πθ(x|c_p, x_0). The program embedding c_p comes from averaging CodeBERT chunk embeddings of the source; x_0 is the -O3 flag state, encoded through per-flag state embeddings and an anchor embedding. The policy outputs per-flag enable probabilities qi = σ(zi), pretrained with binary cross-entropy against historical good configurations. Online, GRPO compares K=8 sampled candidates on the same program, computes group-normalized advantages A_i = (r_i - mean)/std, and updates the same policy with a clipped objective plus entropy regularization. This machinery unifies offline knowledge and online feedback in one trainable

What would settle it

Train WarmTuner's offline policy on the same number of random flag configurations that carry no speedup signal (labels shuffled), then run online tuning on the test programs: if the average speedup at 1,250s is indistinguishable from the version pretrained on real historical records, then the offline warm start contributes nothing and the reported gains come from online search alone.

Watch

Extended reading notes

Core claim

On the paper's own terms, WarmTuner demonstrates that compiler flag selection can be framed as an offline-to-online reinforcement learning problem. A factorized Bernoulli policy over 126 GCC flags, conditioned on a CodeBERT source embedding and the -O3 flag state, is first trained with per-flag binary cross-entropy on historical configurations that beat -O3. Then, on each target program, the same policy is refined with GRPO: each round samples eight configurations, measures their speedups, normalizes rewards within the group, and applies a clipped policy update. The paper claims this yields configurations faster than -O3 on all 30 test programs, with speedups from 1.133x to 4.159x and an ave

Load-bearing premise

The whole approach leans on the pretraining data—historical good configurations collected by random iterative optimization—containing enough signal about which flags matter for an unseen program; if that data is uninformative for a target family, the warm start is no better than random and the online budget may not be enough to catch up.

Editorial extensions

If this is right

  • If correct, historical records from any tuner—RIO, PDCAT, or others—can be converted into a reusable program-specific policy, so past search effort is not wasted.
  • If correct, programs that differ sharply from the training distribution still get a tailored start, because the same policy is refined on the target program with real measured rewards.
  • If correct, the group-relative GRPO update is a good fit for compiler tuning because it needs no value model and uses cheap within-round comparisons.
  • If correct, the framework transfers beyond GCC flag selection to other optimization interfaces with a defined action space and measurable reward, such as pass ordering or inlining decisions.
  • If correct, the best measured configuration will typically include flags whose semantic role matches the target program's structure, as the jacobi-1d case suggests.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Editorial inference: the gain from offline pretraining probably depends on how well RIO's random search covered the flag combinations that matter for each program family; richer or more targeted historical data could widen or narrow the margin, and the paper only tests one alternative data source.
  • Editorial inference: averaging CodeBERT chunk embeddings may wash out cross-module structure; a representation that preserves call graphs or loop nests could strengthen the program conditioning further.
  • Editorial inference: because the improvement over GroupTuner is not statistically significant (p=0.174 at 5000s), the practical claim is best read as 'competitive and more consistent' rather than strictly dominant over the strongest baseline.
  • Editorial inference: a natural testable extension is to warm-start WarmTuner with records from GroupTuner or SRTuner rather than only RIO/PDCAT, and to measure whether structure-aware history yields even better initial distributions.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. WarmTuner proposes an offline-to-online reinforcement learning framework for GCC flag selection. In the offline stage, a program-conditioned Bernoulli policy over 126 optimization flags is pretrained by per-flag binary cross-entropy on historical good configurations collected by RIO, with programs represented by averaged CodeBERT chunk embeddings. In the online stage, the same policy is refined on the target program using Group Relative Policy Optimization (GRPO), where the reward is the measured speedup over GCC -O3 and candidates are compared within a group of K=8. The paper evaluates WarmTuner on cBench and PolyBench under 1,250/2,500/5,000-second budgets, compares it with RIO, SRTuner, GroupTuner, and PDCAT, and reports a 1.732x average speedup over -O3 at 5,000 seconds, with 14/30 best results, plus ablations of offline pretraining, program representation, optimizer choice, data source, and group size.

Significance. If the results are clean, the paper makes a useful contribution: it directly addresses a real limitation of existing compiler autotuning priors—namely, that they are fixed once online search begins—by making the prior program-conditioned and online-adaptable. The GRPO instantiation is a sensible fit to the group-evaluation structure and avoids a separate value model. The measurement protocol is carefully described, and the availability of a public artifact is a strength. However, the methodological and statistical concerns below must be resolved before the headline claims can be accepted at face value.

major comments (3)
  1. [§IV-B5, footnote 1, Figure 2] The group size K=8 used in RQ1 is selected/validated on the same testing programs used in RQ1. Footnote 1 states that the ablation uses one selection result as initial tuning and testing programs, and §IV-B5 says the variants are compared 'keeping the same testing programs.' As written, this means the Table II results are not independent held-out estimates: test data informed a hyperparameter. Please either state clearly that K=8 was fixed a priori and that Figure 2 is a post hoc confirmation, or re-run with a proper validation split. The issue matters because Figure 2 shows K=16 yields higher average speedups at every budget, so the choice of K materially affects the quantitative comparison, and the p=0.174 against GroupTuner leaves little margin.
  2. [Abstract; §IV-A1] The abstract and Section I claim WarmTuner 'significantly outperforms the compared techniques.' But §IV-A1 reports p=1.74e-1 against GroupTuner, the strongest baseline, i.e., the improvement is not statistically significant. The significant comparisons are only against RIO, SRTuner, and PDCAT. The claim should be qualified in the abstract and conclusion to avoid overstating the result; as written, the central contribution statement is not supported by the reported statistics.
  3. [§III-B, §IV-A1, Table II] Table II reports only point estimates (medians/averages) with no variance, confidence intervals, or per-repeat/per-split distributions, even though the protocol repeats each technique five times and uses three train/test splits. The paired t-test p-values are useful but insufficient to establish that WarmTuner 'performs consistently' when the margin over GroupTuner is small (1.732 vs. 1.669). Please report dispersion measures (e.g., standard deviations or confidence intervals over the five repeats and the three splits), especially for the close GroupTuner comparison.
minor comments (4)
  1. [Table II] Several entries lack spacing between consecutive numbers (e.g., '1.3361.392', '1.4581.494', '1.3831.416'). Please fix the formatting and consider splitting the table for readability.
  2. [§IV-B5, Figure 2] The text says K=16 gives 'comparable performance at 1,250 seconds and only slightly higher speedups under larger budgets,' but the plotted values appear to show K=16 exceeding K=8 by roughly 0.06 at every budget. Please reconcile the description with the figure.
  3. [§III-A, Table I] The dataset description says cBench has 20 programs and Table II lists 20 cBench IDs, but Table I appears to label only C1–C20 while the text says 'P1–P30 denote the 30 PolyBench programs.' Clarify how the 30 testing programs in Table II were selected from the 50 total programs and how per-program averages across appearances are computed.
  4. [§IV-A1] The paper states that offline pretraining costs about 9.18 minutes per split and calls this negligible, but it does not include this cost in the comparison budgets. If the claim is that WarmTuner is practical under the stated budgets, please state explicitly whether the offline cost is excluded from the 1,250/2,500/5,000-second budgets.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular derivation: WarmTuner's speedups are measured, not fitted; the only notable caveat is test-set-informed K selection, which is an evaluation-validity issue rather than a circularity reduction.

full rationale

WarmTuner's derivation chain is self-contained. Offline pretraining (Section II-A, Eq. 3) trains the policy on historical good configurations collected by RIO; online tuning (Section II-B, Eqs. 5-9) uses measured speedups over -O3 as rewards. The final Table II speedups are measured compile-run outcomes, not outputs of the model that are then recycled as evidence, so no prediction reduces to its input by construction. Same-group citations ([8], [9], [16]) are used as related work and baselines, not as load-bearing theorems; they are independently published and compared on measured results. The one caveat worth flagging is not circularity: Section IV-B5 selects GRPO group size K=8 using testing programs ('we use one selection result as initial tuning and testing programs', footnote 1; Fig. 2 uses 'the same testing programs'), so the reported averages may be somewhat optimistic. This is a test-set-selection / hyperparameter-tuning concern, not a by-construction equivalence: K is a model configuration choice, and the speedup numbers are independently measured. The paper also honestly reports p=1.74e-1 vs GroupTuner. Overall, no circular step is present.

Assumptions & free parameters 6 free parameters · 6 assumptions · 0 invented entities

The contribution is empirical and rests on ML modeling assumptions rather than parameter-free theory. No new physical or conceptual entities are introduced; the policy is a neural network model. The most important implicit dependencies are the RIO-generated pretraining labels, the CodeBERT embedding, and the independent-Bernoulli action model.

free parameters (6)
  • GRPO group size K = 8
    Default group size chosen after ablation comparing K=4, 8, and 16 on evaluation programs; larger groups give slightly higher speedups at higher cost.
  • entropy coefficient beta = 0.02
    Hand-set in the online loss (Equation 9); no sensitivity analysis is reported.
  • clipping threshold epsilon = 0.2
    Standard PPO-style clipping threshold, chosen without reported tuning study.
  • offline learning rate / batch size / epochs = 5e-4 / 64 / 300
    Supervised pretraining hyperparameters; no sensitivity analysis reported.
  • online learning rate = 1e-4
    Hand-set learning rate for GRPO updates.
  • historical label filter = speedup > 1
    Only RIO configurations with speedup greater than 1 are used as supervised labels; this threshold determines the pretraining dataset.
assumptions (6)
  • domain assumption CodeBERT source-code embeddings capture optimization-relevant program structure.
    Used in Section II-A to construct program embeddings; if invalid, the program-conditioned warm start is uninformative.
  • domain assumption Averaging 512-token chunk embeddings preserves whole-program optimization information.
    Equation 1 averages CodeBERT [CLS] embeddings across chunks; this discards cross-chunk and order information.
  • domain assumption A factorized Bernoulli policy over 126 flags is an adequate action model.
    Equation 4 samples each flag independently; flag interactions are not represented in the policy, only implicitly in measured rewards.
  • domain assumption RIO search records with speedup > 1 are valid supervision for flag probabilities.
    Offline labels come from random iterative optimization; the paper assumes these survivors contain enough signal for unseen programs.
  • standard math GRPO/PPO clipped objective with group-relative advantages improves the policy under compile-run feedback.
    The online update relies on standard policy-gradient machinery; correctness of the estimator is assumed.
  • domain assumption Runtime measurements are stable enough to compare candidates across nearby time windows.
    The protocol measures candidates and -O3 in adjacent windows, but individual candidate rewards are not repeated, so noise is not quantified.

how reviews work

0 comments
Cite this review

Pith. "Pith review of WarmTuner: Program-Specific Warm Starts for Compiler Autotuning via Offline-to-Online Reinforcement Learning." pith.science (2026). https://pith.science/paper/RF6K2MNN

@misc{pith2026260725831,
  author       = {Pith},
  title        = {Pith review of: WarmTuner: Program-Specific Warm Starts for Compiler Autotuning via Offline-to-Online Reinforcement Learning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/RF6K2MNN}},
  note         = {Machine review of arXiv:2607.25831}
}
read the original abstract

Compilers are fundamental software tools that translate high-level programs into machine code. Modern compilers expose hundreds of optimizations, each turned on or off through an optimization flag, to improve the performance of the generated code. However, the number of possible flag combinations grows exponentially, making it difficult to find a flag configuration well suited to a given target program. Existing compiler auto-tuning techniques reduce tuning cost by pruning the search space, injecting search biases, or predicting configuration performance. Although some exploit program features, the knowledge they extract from historical data is frozen once search begins; runtime feedback then guides only the search itself, never the prior. As a result, when this prior mismatches the target program, these methods waste much of the limited online budget before the search reaches good configurations. We propose WarmTuner, an offline-to-online reinforcement learning framework that instead turns historical records into a program-conditioned policy that predicts each flag's setting over the full flag space and remains adaptable on the target program. Offline, WarmTuner learns this program-conditioned policy over the full flag space from historical good configurations. Online, it refines the same policy on the target program using real compile-run feedback, so that the policy is driven by measured speedups rather than limited to the historical data. We instantiate the online update with Group Relative Policy Optimization (GRPO), which compares candidates in the same round and avoids a separate value model. We evaluate WarmTuner on GCC 15.2.0 with cBench and PolyBench. The results show that WarmTuner achieves an average speedup of 1.732x over GCC -O3 and obtains the best result on 14/30 programs, significantly outperforming the compared techniques.

Figures

Figures reproduced from arXiv: 2607.25831 by the authors.

Figure 1
Figure 1. Overview of WarmTuner. are applied after the first two linear layers. The output is reshaped into an n × 16 matrix, so that each optimization flag is associated with one 16-dimensional prediction vector. Finally, the logit zi of each flag is computed as the dot product between its 16-dimensional prediction vector and a trainable -O3 anchor embedding. The enable probability of flag i ∈ {1, . . . , n} is then computed… view at source ↗
Figure 2
Figure 2. Impact of GRPO group size on average speedup. [PITH_FULL_IMAGE:figures/full_fig_p010_2.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

38 extracted references · 1 canonical work pages

  1. [1]

    A survey on compiler autotuning using machine learning,

    A. H. Ashouri, W. Killian, J. Cavazos, G. Palermo, and C. Silvano, “A survey on compiler autotuning using machine learning,”ACM Computing Surveys, vol. 51, no. 5, pp. 1–42, 2018

    2018

  2. [2]

    Using machine learning to focus iterative optimization,

    F. Agakov, E. Bonilla, J. Cavazos, B. Franke, G. Fursin, M. F. P. O’Boyle, J. Thomson, M. Toussaint, and C. K. I. Williams, “Using machine learning to focus iterative optimization,” inProceedings of the International Symposium on Code Generation and Optimization. IEEE, 2006, pp. 295–305

    2006

  3. [3]

    Finding effective compilation sequences,

    L. Almagor, K. D. Cooper, A. Grosul, T. J. Harvey, S. W. Reeves, D. Subramanian, L. Torczon, and T. Waterman, “Finding effective compilation sequences,”ACM SIGPLAN Notices, vol. 39, no. 7, pp. 231–239, 2004

    2004

  4. [4]

    Efficient compiler autotuning via bayesian optimization,

    J. Chen, N. Xu, P. Chen, and H. Zhang, “Efficient compiler autotuning via bayesian optimization,” inProceedings of the 43rd IEEE/ACM International Conference on Software Engineering. IEEE, 2021, pp. 1198–1209

    2021

  5. [5]

    Evolutionary optimization of com- piler flag selection by learning and exploiting flags interactions,

    U. Garciarena and R. Santana, “Evolutionary optimization of com- piler flag selection by learning and exploiting flags interactions,” in Proceedings of the Genetic and Evolutionary Computation Conference Companion, 2016, pp. 1159–1166

    2016

  6. [6]

    Kisuki, P

    T. Kisuki, P. Knijnenburg, M. O’Boyle, and H. Wijshoff,Iterative compilation in program optimization. Universiteit Leiden, 2002

    2002

  7. [7]

    Feature mining for machine learning based compilation optimization,

    F. Li, F. Tang, and Y . Shen, “Feature mining for machine learning based compilation optimization,” in2014 Eighth International Conference on Innovative Mobile and Internet Services in Ubiquitous Computing. IEEE, 2014, pp. 207–214

    2014

  8. [8]

    Compiler auto-tuning via critical flag selection,

    M. Zhu and D. Hao, “Compiler auto-tuning via critical flag selection,” inProceedings of the 38th IEEE/ACM International Conference on Automated Software Engineering. IEEE, 2023, pp. 1000–1011

    2023

Show all 38 references
  1. [9]

    Compiler autotuning through multiple- phase learning,

    M. Zhu, D. Hao, and J. Chen, “Compiler autotuning through multiple- phase learning,”ACM Transactions on Software Engineering and Methodology, vol. 33, no. 4, pp. 1–38, 2024

    2024

  2. [10]

    COLE: Compiler optimization level ex- ploration,

    K. Hoste and L. Eeckhout, “COLE: Compiler optimization level ex- ploration,” inProceedings of the 6th Annual IEEE/ACM International Symposium on Code Generation and Optimization, 2008, pp. 165–174

    2008

  3. [11]

    Automatic selection of GCC optimization options using a gene weighted genetic algorithm,

    S.-C. Lin, C.-K. Chang, and N.-W. Lin, “Automatic selection of GCC optimization options using a gene weighted genetic algorithm,” in Proceedings of the 13th Asia-Pacific Computer Systems Architecture Conference. IEEE, 2008, pp. 1–8

    2008

  4. [12]

    Deconstructing iterative optimization,

    Y . Chen, S. Fang, Y . Huang, L. Eeckhout, G. Fursin, O. Temam, and C. Wu, “Deconstructing iterative optimization,”ACM Transactions on Architecture and Code Optimization, vol. 9, no. 3, pp. 1–30, 2012

    2012

  5. [13]

    Automatic configuration of GCC using irace,

    L. P ´erez C ´aceres, F. Pagnozzi, A. Franzin, and T. St ¨utzle, “Automatic configuration of GCC using irace,” inInternational Conference on Artificial Evolution. Springer, 2017, pp. 202–216

    2017

  6. [14]

    OpenTuner: An extensible frame- work for program autotuning,

    J. Ansel, S. Kamil, K. Veeramachaneni, J. Ragan-Kelley, J. Bosboom, U.-M. O’Reilly, and S. Amarasinghe, “OpenTuner: An extensible frame- work for program autotuning,” inProceedings of the 23rd International Conference on Parallel Architectures and Compilation, 2014, pp. 303– 316

    2014

  7. [15]

    COBAYN: Compiler autotuning framework using bayesian networks,

    A. H. Ashouri, G. Mariani, G. Palermo, E. Park, J. Cavazos, and C. Silvano, “COBAYN: Compiler autotuning framework using bayesian networks,”ACM Transactions on Architecture and Code Optimization, vol. 13, no. 2, pp. 1–25, 2016

    2016

  8. [16]

    PDCAT: Preference-driven compiler auto- tuning,

    M. Zhu, Z. Sun, and D. Hao, “PDCAT: Preference-driven compiler auto- tuning,”Proceedings of the ACM on Software Engineering, vol. 2, no. FSE, pp. 847–867, 2025

    2025

  9. [17]

    SRTuner: Effective compiler optimization customization by exposing synergistic relations,

    S. Park, S. Latifi, Y . Park, A. Behroozi, B. Jeon, and S. Mahlke, “SRTuner: Effective compiler optimization customization by exposing synergistic relations,” inProceedings of the IEEE/ACM International Symposium on Code Generation and Optimization. IEEE, 2022, pp. 118–130

    2022

  10. [18]

    GroupTuner: Efficient group-aware compiler auto-tuning,

    B. Gao, M. Yao, Z. Wang, D. Liu, D. Li, X. Chen, and Y . Guo, “GroupTuner: Efficient group-aware compiler auto-tuning,” inProceed- ings of the 26th ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, and Tools for Embedded Systems, 2025, pp. 122– 133

    2025

  11. [19]

    DeepSeekMath: Pushing the limits of mathematical reasoning in open language models,

    Z. Shao, P. Wang, Q. Zhu, R. Xu, J. Song, X. Bi, H. Zhang, M. Zhang, Y . K. Li, Y . Wuet al., “DeepSeekMath: Pushing the limits of mathematical reasoning in open language models,”arXiv preprint arXiv:2402.03300, 2024

    2024 arXiv

  12. [20]

    “cBench,” https://ctuning.org/wiki/index.php/CTools:CBench, 2024, ac- cessed: 2026-06-07

    2024

  13. [21]

    PolyBench,

    “PolyBench,” https://sourceforge.net/p/polybench/wiki/Home/, 2024, ac- cessed: 2026-06-07

    2024

  14. [22]

    Artifact Package for An Offline-to-Online Reinforcement Learning Framework for Compiler Autotuning,

    Anonymous Authors, “Artifact Package for An Offline-to-Online Reinforcement Learning Framework for Compiler Autotuning,” 2026. [Online]. Available: https://doi.org/10.5281/zenodo.21091417

    2026 doi

  15. [23]

    CodeBERT: A pre-trained model for programming and natural languages,

    Z. Feng, D. Guo, D. Tang, N. Duan, X. Feng, M. Gong, L. Shou, B. Qin, T. Liu, D. Jianget al., “CodeBERT: A pre-trained model for programming and natural languages,” inFindings of the Association for Computational Linguistics: EMNLP 2020, 2020, pp. 1536–1547

    2020

  16. [24]

    Prox- imal policy optimization algorithms,

    J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov, “Prox- imal policy optimization algorithms,”arXiv preprint arXiv:1707.06347, 2017

    2017 arXiv

  17. [25]

    PyTorch: An imperative style, high-performance deep learning library,

    A. Paszke, S. Gross, F. Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antigaet al., “PyTorch: An imperative style, high-performance deep learning library,”Advances in Neural Information Processing Systems, vol. 32, 2019

    2019

  18. [26]

    Transformers: State- of-the-art natural language processing,

    T. Wolf, L. Debut, V . Sanh, J. Chaumond, C. Delangue, A. Moi, P. Cistac, T. Rault, R. Louf, M. Funtowiczet al., “Transformers: State- of-the-art natural language processing,” inProceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demo...

    2020

  19. [27]

    Available: https://gcc.gnu.org/onlinedocs/gcc- 15.2.0/gcc/Optimize-Options.html

    GNU Compiler Collection (GCC),Using the GNU Compiler Collec- tion (GCC): Options That Control Optimization, Free Software Foun- dation, 2025, [Online]. Available: https://gcc.gnu.org/onlinedocs/gcc- 15.2.0/gcc/Optimize-Options.html. Accessed: Jun. 23, 2026

    2025

  20. [28]

    Simple statistical gradient-following algorithms for connectionist reinforcement learning,

    R. J. Williams, “Simple statistical gradient-following algorithms for connectionist reinforcement learning,”Machine learning, vol. 8, no. 3, pp. 229–256, 1992

    1992

  21. [29]

    Micomp: Mitigating the compiler phase-ordering problem using optimization sub-sequences and machine learning,

    A. H. Ashouri, A. Bignoli, G. Palermo, C. Silvano, S. Kulkarni, and J. Cavazos, “Micomp: Mitigating the compiler phase-ordering problem using optimization sub-sequences and machine learning,”ACM Trans- actions on Architecture and Code Optimization (TACO), vol. 14, no. 3, pp. 1...

    2017

  22. [30]

    AutoPhase: Compiler phase-ordering for HLS with deep reinforcement learning,

    Q. Huang, A. Haj-Ali, W. Moses, J. Xiang, I. Stoica, K. Asanovic, and J. Wawrzynek, “AutoPhase: Compiler phase-ordering for HLS with deep reinforcement learning,” inProceedings of the 27th Annual International Symposium on Field-Programmable Custom Computing Machines. IEEE, 20...

    2019

  23. [31]

    Mitigating the compiler optimization phase-ordering problem using machine learning,

    S. Kulkarni and J. Cavazos, “Mitigating the compiler optimization phase-ordering problem using machine learning,” inProceedings of the ACM international conference on Object oriented programming systems languages and applications, 2012, pp. 147–162

    2012

  24. [32]

    MILEPOST GCC: Machine learning enabled self-tuning compiler,

    G. Fursin, Y . Kashnikov, A. W. Memon, Z. Chamski, O. Temam, M. Namolaru, E. Yom-Tov, B. Mendelson, A. Zaks, E. Courtoiset al., “MILEPOST GCC: Machine learning enabled self-tuning compiler,” International Journal of Parallel Programming, vol. 39, no. 3, pp. 296– 327, 2011

    2011

  25. [33]

    CompilerGym: Robust, performant compiler optimization environments for AI research,

    C. Cummins, B. Wasti, J. Guo, B. Cui, J. Ansel, S. Gomez, S. Jain, J. Liu, O. Teytaud, B. Steineret al., “CompilerGym: Robust, performant compiler optimization environments for AI research,” inProceedings of the IEEE/ACM International Symposium on Code Generation and Optimizat...

    2022

  26. [34]

    MLGO: A machine learning guided compiler optimizations frame- work,

    M. Trofin, Y . Qian, E. Brevdo, Z. Lin, K. Choromanski, and D. Li, “MLGO: A machine learning guided compiler optimizations frame- work,”arXiv preprint arXiv:2101.04808, 2021

    2021 arXiv

  27. [35]

    Large language models for compiler optimization,

    C. Cummins, V . Seeker, D. Grubisic, M. Elhoushi, Y . Liang, B. Roziere, J. Gehring, F. Gloeckle, K. Hazelwood, G. Synnaeveet al., “Large language models for compiler optimization,”arXiv preprint arXiv:2309.07062, 2023

    2023 arXiv

  28. [36]

    LLM Compiler: Foundation language models for compiler optimization,

    C. Cummins, V . Seeker, D. Grubisic, B. Roziere, J. Gehring, G. Syn- naeve, and H. Leather, “LLM Compiler: Foundation language models for compiler optimization,” inProceedings of the 34th ACM SIGPLAN International Conference on Compiler Construction, 2025, pp. 141–153

    2025

  29. [37]

    DeCOS: Data-efficient reinforcement learning for compiler optimization selection ignited by LLM,

    T. Cui, P.-C. Yew, S. McCamant, and A. Zhai, “DeCOS: Data-efficient reinforcement learning for compiler optimization selection ignited by LLM,” inProceedings of the 39th ACM International Conference on Supercomputing, 2025, pp. 943–958

    2025

  30. [38]

    LLM- VeriOpt: Verification-guided reinforcement learning for LLM-based compiler optimization,

    X. Fang, J. Kang, R. Rocha, S. Ainsworth, and L. Mukhanov, “LLM- VeriOpt: Verification-guided reinforcement learning for LLM-based compiler optimization,” inProceedings of the IEEE/ACM International Symposium on Code Generation and Optimization. IEEE, 2026, pp. 740–755

    2026

Pith tools

Reviewed August 1, 2026 · model on record in the stance chip above.