Pith. sign in

REVIEW 3 major objections 7 minor 70 references

Deterministic CPU simulation, not hardware meters, trains code models to cut energy nearly three times more than fine-tuning alone and beat human expert references on most valid outputs.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

T0 review · grok-4.5

2026-07-11 16:59 UTC pith:CDHQAFGF

load-bearing objection Solid empirical recipe: energy-contrastive SFT + simulation-in-the-loop GRPO on a released 3.5M-eval corpus, with a real IPC-trap result and CARET that actually gates correctness. the 3 major comments →

arxiv 2607.04577 v1 pith:CDHQAFGF submitted 2026-07-06 cs.LG cs.SE

Beyond the Need for Speed: Energy-Aware Code Generation via Simulation-Guided Reinforcement Learning

Saurabhsingh Rajput , Tushar Sharma This is my paper
classification cs.LG cs.SE
keywords energy-efficient codelarge language modelsreinforcement learningsimulation-guided trainingsoftware energy consumptioncode generationarchitectural simulationCARET
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

Code models today are trained for functional correctness, so the energy cost of the programs they emit is left as an afterthought. Hardware energy counters are too noisy and too slow to supply the volume of feedback needed for large-scale training. This paper replaces those counters with a deterministic architectural simulator, builds a large energy-labeled corpus of C++ programs, and trains models first by supervised fine-tuning on energy-ranked pairs and then by closed-loop reinforcement learning scored by the simulator. On held-out problems the full pipeline nearly triples the energy reduction of fine-tuning alone, compiles most of its outputs, and beats the energy of human-expert references on more than half of its valid programs. The same analysis shows that common speed proxies such as instructions-per-cycle reverse the true energy ranking on most problems, so a direct energy signal is required.

Core claim

On 143 held-out C++ problems, supervised fine-tuning on energy-contrastive pairs followed by group-relative policy optimization with a simulation-in-the-loop energy or energy-delay reward reaches 12.63% CARET—nearly three times fine-tuning alone—compiles 81.7% of outputs, and beats the human-expert energy reference on 58.4% of valid outputs. Instructions-per-cycle misranks true energy efficiency on 67.8% of problems, so throughput proxies cannot safely substitute for direct energy simulation.

What carries the argument

The simulation-in-the-loop cycle: Sniper/McPAT produces deterministic per-program energy, cycles, and power that score every model rollout during reinforcement learning, together with the CARET metric that multiplies each output’s energy reduction by the fraction of tests it passes and zeros non-compiling code.

Load-bearing premise

Energy rankings from a CPU simulator on short single-threaded competitive-programming C++ programs remain a faithful training target for the energy real deployed code will draw.

What would settle it

On a held-out set of longer multi-threaded or memory-bound production kernels, programs the simulator ranks as lower-energy systematically consume more wall energy than their baselines under careful RAPL or power-meter measurement after identical -O3 compilation.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • Energy, not runtime or instructions-per-cycle, must be the direct training signal if models are to optimize software energy rather than a proxy that often inverts it.
  • Releasing the precomputed Green Tea labels removes the roughly 263,000 CPU-hour barrier to training energy-aware code models.
  • Deployment-facing energy metrics must gate on correctness the way CARET does; reduction rates computed only on valid outputs overstate gains.
  • Closed-loop simulation feedback, not parameter scale alone, is what recovers compilation and deepens optimization on valid programs.
  • A compound energy-delay reward roughly doubles the rate at which models beat human expert energy references relative to single-axis rewards.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • Because the simulator is retargetable by configuration file, the same loop could train models for microarchitectures that do not yet exist before silicon arrives.
  • Memory-bound production servers and mobile/GPU settings, where power varies more than on short compute-bound tasks, may show larger gaps between runtime proxies and true energy and therefore larger benefits from direct simulation.
  • If AI-generated code becomes the bulk of enterprise software, training models to emit lower-energy implementations by default would cut operational electricity without relying on brittle inference-time prompts.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 7 minor

Summary. The paper argues that code LLMs can be trained to optimize program energy, not merely correctness or runtime, by replacing noisy hardware energy measurement with deterministic Sniper/McPAT architectural simulation. From 1,474 PIE C++ problems the authors build Green Tea (3.5M simulations, energy-contrastive pairs), fine-tune with score-conditioned SFT, then run GRPO with a compile–test–simulate reward (energy, runtime, or EDP). They introduce CARET, which multiplies energy reduction by test-pass fraction and zeros non-compiling outputs. On 143 held-out problems the energy-first closed-loop pipeline (Energy-SFT + EDP) reaches 12.63% CARET (2.84× over Energy-SFT alone), 81.7% compile rate, and beats the human reference energy on 58.4% of valid outputs. A corpus analysis shows IPC inverts true energy ranking on 67.8% of problems (the “IPC trap”). Dataset, harness, and models are released.

Significance. Energy of AI-generated code is a timely and under-served objective. The work’s main technical contribution is a reproducible, rank-oriented simulation-in-the-loop training recipe at a scale physical RAPL/power-meter measurement cannot support, plus the Green Tea corpus that amortizes ~263k CPU-hours. CARET is a useful deployment-oriented metric that avoids the binary-correctness gate common in efficiency benchmarks. The within-problem IPC-trap and cycle-vs-power decomposition are concrete, falsifiable findings that justify direct energy simulation over throughput proxies. Strengths include multi-model SFT transfer, five RL init/reward cells in a tight CARET band, paired Wilcoxon tests with Holm–Bonferroni correction, CARET sensitivity conventions, a DeepSeek-Coder-6.7B replication, and a public replication package. If the held-out results hold under the stated scope, the paper is a solid empirical systems/ML contribution for green code generation.

major comments (3)
  1. §5.3 and Table 5: The abstract and contributions headline Energy-SFT + EDP at 12.63% CARET, yet Runtime-SFT + EDP reaches 16.41% CARET under the same closed loop, and E-SFT + runtime reaches 14.44%. The text treats the five cells as a “4.22 pp band” and attributes aggregate CARET to the loop rather than reward/init, but still markets a single “energy-first” number. Please either (i) justify why 12.63% is the primary deployment-relevant figure (e.g., correctness/Beat-GT tradeoffs, safety of energy ranking from RQ2) with that comparison made explicit in the abstract, or (ii) report the best closed-loop CARET as primary and demote energy-first to an ablation. As written, the headline understates the best result of the method the paper actually proposes.
  2. §4.2 (Empirical validation of the simulation pipeline): Rank-correctness of Sniper/McPAT is load-bearing for both Green Tea labels and the RL reward. The manuscript reports “avoiding contradiction on 93% of resolvable program pairs and strictly agreeing on 80%” via CodeGreen RAPL, plus <0.1% determinism, but does not state the number of pairs N, how “resolvable” is defined (e.g., RAPL resolution floor, energy-gap threshold), confidence intervals, or whether the spot-check set overlaps training problems. Without N and selection criteria, the 93%/80% figures cannot be assessed. Please report N, selection protocol, and CIs (or a full ranking-agreement table) so readers can judge whether the training signal is adequately validated for the energy gaps used in pair construction (≥10%).
  3. §5.1 / RQ1 and §7–8: The central necessity claim for direct energy simulation rests on within-problem power-driven cases (12.3% of problems with >5% power contribution; 41.2% of cycle-matched pairs with energy gaps). These fractions are measured on short, single-threaded competitive-programming binaries under one Sniper config (EPYC Zen4 @ 1.5 GHz). The implications section (§7) and abstract language (“structurally empowering… inherently energy-efficient code generation models”) extrapolate to production and sustainability impact. The threats section acknowledges the domain limit, but the abstract and implications do not. Please temper abstract/implications claims to the evaluated distribution, or add at least one non-PIE / longer-running / multi-input production-style case study so the transfer claim is evidence-backed rather than promissory.
minor comments (7)
  1. Eq. (2) CARET decomposition: The product is correctly labeled an approximation; still, Figure 7 and §5.3.1 would be clearer if the under/over-estimation factors (1.30× SFT, 1.22× GRPO) appeared in the figure caption, not only in prose.
  2. §4.4 reward constants (ρ_fail=−1.0, ρ_0=−0.8, λ=1.1, ρ_pass=+0.5): Analytical gap reasoning under group normalization is reasonable; a one-sentence note that no sweep was performed (and that results are therefore conditional on these gaps) would help reproducibility claims.
  3. Table 2 / DeepSeek-Coder-6.7B SFT: Compile collapse 95.4%→8.0% is striking; the later GRPO recovery to 5.99% CARET is important—cross-reference that recovery earlier so readers do not dismiss the model family.
  4. Figure 2 (IPC trap) and Figure 3 (power vs runtime): Axis units and the 190 W power floor (Table 1) should be defined in the captions; “190 W floor” appears only in prose.
  5. Listing 1 / score-conditioned prompt: Confirm whether inference always requests score 10/10 (as stated) and whether any ablation of requested score appears in the replication package; §6 mentions score targets as a lever but gives no numbers.
  6. Typos / polish: Title line break “Beyond theNeed for Speed”; abstract “1{,}474” formatting is fine in LaTeX but check PDF spacing; “ghost execution” is defined late—move the definition next to first use in §4.4.
  7. Related work: Afterburner [17] and PIE [58] are correctly positioned; a brief note on how CARET differs from EffiBench/Mercury binary-gated scores (already partly in §2.4) would help metric adoption.

Circularity Check

0 steps flagged

No significant circularity: training signal, held-out evaluation, and CARET/Beat-GT are independent of the claimed gains by construction.

full rationale

The paper’s load-bearing chain is empirical and externally anchored, not definitional. Energy labels and GRPO rewards come from Sniper/McPAT (established third-party simulators), not from quantities defined in terms of the model’s later CARET or Beat-GT. Training uses problem-level 80/10/10 splits so the 143 held-out PIE problems never appear in SFT pairs or RL prompts. CARET weights simulated energy reduction by independent unit-test pass fractions and zeros non-compiling outputs; Beat-GT compares to human-expert PIE references—neither is a tautology of the training objective or a re-label of a fitted parameter. The IPC-trap claim is a corpus statistic (best-energy vs worst-energy IPC per problem), not a prediction forced by a fit. Self-citations (CodeGreen, energy smells, etc.) support infrastructure/context only and do not underwrite uniqueness of the main result. Ablations (five reward/init cells, Runtime-SFT/Afterburner-style baselines, zero-shot/green-prompt) further separate the claimed 12.63% CARET from circular self-reference. No step reduces Eq. X to Eq. Y by construction or renames a fit as a prediction.

Axiom & Free-Parameter Ledger

6 free parameters · 6 axioms · 3 invented entities

The central empirical claim rests on standard RL/SFT machinery plus domain choices: a fixed Sniper/McPAT microarchitecture model, analytically set reward gaps, pair-construction thresholds, and the assumption that competitive-programming energy rankings are a useful proxy for energy-aware code generation. No new physical entities are postulated; CARET, Green Tea, and the IPC trap are measurement constructs. Free parameters are mostly training/reward design knobs rather than fits to the headline CARET number.

free parameters (6)
  • Reward constants (ρ_fail, ρ_0, λ, ρ_pass) = −1.0, −0.8, 1.1, +0.5
    Set analytically to −1.0, −0.8, 1.1, +0.5 to structure failure/partial/pass gaps; not swept (Section 4.4). Shape the GRPO gradient and correctness gate.
  • GRPO group size K = 16
    K=16 chosen as budget-driven (vs DeepSeekMath K=64) because each rollout is a full simulation (Section 4.4).
  • Energy-contrastive pair thresholds = ≤6 / ≥7 / 10% floor
    Baseline score ≤6, target ≥7, ≥10% energy reduction floor, and 1–10 decile scoring define the SFT pairs (Section 4.1).
  • LoRA rank and alpha = r=64, α=128
    Rank 64, scaling 128 on attention and FFN projections; not swept for capacity (Section 4.4). Sensitivity check r=32–128 shifts CARET by 0.20 pp.
  • SFT and GRPO learning rates / KL β = 3e-5 / 1e-6 / β=0.04
    AdamW 3e-5 (SFT), 1e-6 (GRPO), β=0.04 from DeepSeekMath defaults rather than tuned on held-out CARET (Section 4.4).
  • Sniper core model (AMD EPYC 9554P @ 1.5 GHz) = Zen4-like 1.5 GHz config
    Fixed simulated microarchitecture for all labels and rewards; absolute frequency claimed rank-invariant under McPAT linearity (Section 4.2).
axioms (6)
  • domain assumption Deterministic interval simulation (Sniper) plus McPAT activity-to-energy mapping preserves within-problem energy rankings sufficiently for training and evaluation.
    Load-bearing for replacing RAPL/hardware meters; supported by cited Sniper accuracy and authors’ 93%/80% hardware ranking check (Sections 2.3, 4.2).
  • domain assumption McPAT energy is linear in activity counts so global calibration does not invert solution orderings.
    Used to argue rank-correctness independent of absolute joule calibration (Sections 2.3, 4.2).
  • domain assumption Competitive-programming C++ solutions (PIE/CodeNet) are a valid testbed for learning energy-relevant source transformations.
    Entire Green Tea corpus and held-out benchmark are drawn from this distribution (Sections 4.1, 8).
  • standard math Energy E = P × t and within-problem power can diverge from cycle count via instruction mix.
    Standard physics used to motivate direct energy over runtime/IPC proxies (RQ1).
  • domain assumption GRPO group-normalized advantages without a learned critic are appropriate when energy spans orders of magnitude across problems.
    Justifies GRPO over PPO (Section 4.4).
  • ad hoc to paper Reward constants need only relative ordering under group normalization, so analytical gaps suffice without hyperparameter search.
    Explicitly stated; not empirically validated by sweep (Sections 4.4, 8).
invented entities (3)
  • CARET (Correctness-Adjusted Reduction in Energy Total) independent evidence
    purpose: Primary deployment metric that weights ERR by test-pass fraction and zeros non-compiling outputs.
    New evaluation construct; defined in Eq. (1) Section 4.5. Independent of training only as a reporting choice; not a physical entity.
  • Green Tea corpus independent evidence
    purpose: 3.5M deterministic energy simulations and 12,455 energy-contrastive pairs over 1,474 C++ problems for training/eval.
    Dataset artifact enabling the method; independent evidence is the released labels and simulation protocol.
  • IPC trap independent evidence
    purpose: Named empirical pattern that the most energy-efficient solution has lower IPC than the least efficient on 67.8% of problems.
    Descriptive finding from Green Tea analysis (RQ1/Figure 2), not a new physical mechanism.

pith-pipeline@v1.1.0-grok45 · 42257 in / 4224 out tokens · 45818 ms · 2026-07-11T16:59:36.760952+00:00 · methodology

0 comments
read the original abstract

Code models strictly prioritize functional correctness, leaving software energy efficiency as an unoptimized byproduct. Training models to generate energy-efficient code requires reproducible feedback at scale, which physical hardware measurement cannot reliably provide due to variance. In this paper, we replace hardware profiling with a deterministic architectural simulation harness to build Green Tea, a corpus of $3.5$ million evaluations across $1{,}474$ C++ problems. We train an energy-aware code model via supervised fine-tuning on energy-contrastive pairs, followed by closed-loop reinforcement learning (GRPO) using simulation-in-the-loop feedback. To rigorously evaluate deployment readiness, we introduce the Correctness-Adjusted Reduction in Energy Total (CARET), a metric that explicitly penalizes code that sacrifices functionality for efficiency. On $143$ held-out problems, our simulation-in-the-loop pipeline achieves $12.63\%$ CARET, nearly tripling the gain of fine-tuning alone, and successfully beats the energy efficiency of human-expert references on $58.4\%$ of its valid outputs. Furthermore, our analysis exposes the IPC trap: standard throughput proxies like Instructions-Per-Cycle (IPC) actively misrank true energy efficiency on $67.8\%$ of problems, proving the absolute necessity of direct energy simulation. By releasing our dataset and infrastructure, we bypass the $263{,}000$ CPU-hours required for reproduction, structurally empowering the community to deploy inherently energy-efficient code generation models.

Figures

Figures reproduced from arXiv: 2607.04577 by Saurabhsingh Rajput, Tushar Sharma.

Figure 1
Figure 1. Figure 1: Overview of the three-phase procedure. Phase 1 builds the Green Tea dataset by simulating C++ solutions and pairing a less [PITH_FULL_IMAGE:figures/full_fig_p007_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: IPC vs. energy for the best- and worst-energy solutions per problem. The IPC-trap region highlights problems where the most [PITH_FULL_IMAGE:figures/full_fig_p017_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Power draw vs. runtime, colored by energy. The vertical spread at any fixed runtime demonstrates power variations invisible [PITH_FULL_IMAGE:figures/full_fig_p018_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: SFT (left) and GRPO (right) training progression. Panel (a) illustrates SFT loss reduction. Panels (b) and (c) demonstrate the [PITH_FULL_IMAGE:figures/full_fig_p024_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Empirical Cumulative Distribution Function (CDF) of ERR across training stages (valid outputs only). The right panel categorizes [PITH_FULL_IMAGE:figures/full_fig_p026_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: ERR distribution for Energy-SFT vs. Green Tea (Energy-SFT+GRPO). Green Tea collapses the zero-gain shelf and shifts the [PITH_FULL_IMAGE:figures/full_fig_p026_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: CARET decomposition across Energy-SFT and Green Tea (Energy-SFT+GRPO). CARET is factored into compilation, simulation, [PITH_FULL_IMAGE:figures/full_fig_p027_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: Example 1 (p02766, Category A, algorithmic simplification). SFT simplifies the algorithm, removing array allocations for a 96.7% ERR. The GRPO output achieves an even higher nominal 97.7% ERR by summing digits instead of counting iterations, but is successfully suppressed by the correctness gate for failing tests. problem, the closed-loop GRPO policy produced a compile-valid output that incorrectly summed … view at source ↗
Figure 9
Figure 9. Figure 9: Example 2 (p03325, Category B, memory layout & I/O). SFT removes the array (IPC trap, 11.9% ERR). GRPO stacks fast I/O on top of it, reaching 39.0% ERR and 1.64× speedup [PITH_FULL_IMAGE:figures/full_fig_p031_9.png] view at source ↗
Figure 10
Figure 10. Figure 10: Per-input-class attention shift relative to the base model for Energy-SFT and Runtime-SFT (both EDP-rewarded). Stars [PITH_FULL_IMAGE:figures/full_fig_p033_10.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

70 extracted references · 17 linked inside Pith

  1. [1]

    Aho, Monica S

    Alfred V. Aho, Monica S. Lam, Ravi Sethi, and Jeffrey D. Ullman. 2007.Compilers: Principles, Techniques, and Tools (2nd Edition). Addison-Wesley Longman Publishing Co., Inc

    2007

  2. [2]

    Ayaz Akram and Lina Sawalha. 2016. A Comparison of x86 Computer Architecture Simulators. Poster, SC16 (Int. Conf. for High Performance Computing, Networking, Storage and Analysis). https://sc16.supercomputing.org/sc-archive/tech_poster/poster_files/post233s2-file3.pdf

    2016

  3. [3]

    BW Ang and Na Liu. 2007. Energy decomposition analysis: IEA model versus other methods.Energy policy35, 3 (2007), 1426–1432

    2007

  4. [4]

    Beng Wah Ang. 2004. Decomposition analysis for policymaking in energy:: which is the preferred method?Energy policy32, 9 (2004), 1131–1139

    2004

  5. [5]

    Humza Ashraf, Syed Muhammad Danish, Aris Leivadeas, Yazan Otoum, and Zeeshan Sattar. 2025. Energy-Aware Code Generation with LLMs: Benchmarking Small vs. Large Language Models for Sustainable AI Programming. arXiv:2508.08332 [cs.AI]

    Pith/arXiv arXiv 2025

  6. [6]

    1982.Writing efficient programs

    Jon Louis Bentley. 1982.Writing efficient programs. Prentice-Hall, Inc

    1982

  7. [7]

    Reinhardt, Ali Saidi, Arkaprava Basu, Joel Hestness, Derek R

    Nathan Binkert, Bradford Beckmann, Gabriel Black, Steven K. Reinhardt, Ali Saidi, Arkaprava Basu, Joel Hestness, Derek R. Hower, Tushar Krishna, Somayeh Sardashti, Rathijit Sen, Korey Sewell, Muhammad Shoaib, Nilay Vaish, Mark D. Hill, and David A. Wood. 2011. The gem5 Simulator.ACM SIGARCH Computer Architecture News39, 2 (2011), 1–7

    2011

  8. [8]

    Carlson, Wim Heirman, and Lieven Eeckhout

    Trevor E. Carlson, Wim Heirman, and Lieven Eeckhout. 2011. Sniper: Exploring the Level of Abstraction for Scalable and Accurate Parallel Multi-Core Simulation. InProceedings of 2011 International Conference for High Performance Computing, Networking, Storage and Analysis (SC ’11). ACM/IEEE

    2011

  9. [9]

    Lili Chen, Kevin Lu, Aravind Rajeswaran, Kimin Lee, Aditya Grover, Misha Laskin, Pieter Abbeel, Aravind Srinivas, and Igor Mordatch. 2021. Decision transformer: Reinforcement learning via sequence modeling.Advances in neural information processing systems34 (2021), 15084–15097

    2021

  10. [10]

    Cummings, Matthias Plappert, Fotios Chantzis, Elizabeth Barnes, Ariel Herbert-Voss, William H

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Pondé de Oliveira Pinto, Jared Kaplan, Harrison Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, Nick Ryder, Mikhail Pavlov, Alethea Power, Lukasz Kaiser, Mohammad Bavar...

    Pith/arXiv arXiv 2021

  11. [11]

    Zimin Chen, Sen Fang, and Martin Monperrus. 2024. Supersonic: Learning to Generate Source Code Optimizations in C/C++.IEEE Transactions on Software Engineering50, 11 (Nov. 2024), 2849–2864. doi:10.1109/tse.2024.3423769

    doi:10.1109/tse.2024.3423769 2024

  12. [12]

    Benoit Courty, Victor Schmidt, Goyal-Kamal, MarionCoutarel, Boris Feld, Jérémy Lecourt, LiamConnell, SabAmine, inimaz, supatomic, Mathilde Léval, Luis Blanche, Alexis Cruveiller, ouminasara, Franklin Zhao, Aditya Joshi, Alexis Bogroff, Amine Saboni, Hugues de Lavoreille, Niko Laskaris, Edoardo Abati, Douglas Blank, Ziyao Wang, Armin Catovic, alencon, Mich...

    doi:10.5281/zenodo.11171501 2024

  13. [13]

    Kevin Zheyuan Cui, Mert Demirer, Sonia Jaffe, Leon Musolff, Sida Peng, and Tobias Salz. 2026. The effects of generative AI on high-skilled work: Evidence from three field experiments with software developers.Management Science(2026)

    2026

  14. [14]

    Vlad-Andrei Cursaru, Laura Duits, Joel Milligan, Damla Ural, Berta Rodriguez Sanchez, Vincenzo Stoico, and Ivano Malavolta. 2024. A controlled experiment on the energy efficiency of the source code generated by code llama. InInternational Conference on the Quality of Information and Communications Technology. Springer, 161–176

    2024

  15. [15]

    Shihan Dou, Yan Liu, Haoxiang Jia, Enyu Zhou, Limao Xiong, Junjie Shan, Caishuang Huang, Xiao Wang, Xiaoran Fan, Zhiheng Xi, Yuhao Zhou, Tao Ji, Rui Zheng, Qi Zhang, Tao Gui, and Xuanjing Huang. 2024. StepCoder: Improving Code Generation with Reinforcement Learning from Compiler Feedback. InProceedings of the 62nd Annual Meeting of the Association for Com...

    2024

  16. [16]

    Mingzhe Du, Luu A Tuan, Bin Ji, Qian Liu, and See-Kiong Ng. 2024. Mercury: A code efficiency benchmark for code large language models.Advances in Neural Information Processing Systems37 (2024), 16601–16622

    2024

  17. [17]

    Mingzhe Du, Luu Anh Tuan, Yue Liu, Yuhao Qing, Dong Huang, Xinyi He, Qian Liu, Zejun Ma, and See-kiong Ng. 2025. Afterburner: Reinforcement Learning Facilitates Self-Improving Code Efficiency Optimization. InThirty-ninth Conference on Neural Information Processing Systems

    2025

  18. [18]

    Joe A Garcia. 2019. Exploration of energy consumption using the intel running average power limit interface. In2019 IEEE Space Computing Conference (SCC). IEEE, 1–10

    2019

  19. [19]

    Gartner. 2024. Gartner Says 75% of Enterprise Software Engineers Will Use AI Code Assistants by 2028. Press Release. https://www.gartner.com/en/ newsroom/press-releases/2024-04-11-gartner-says-75-percent-of-enterprise-software-engineers-will-use-ai-code-assistants-by-2028 Accessed: 2026-02-05

    2024

  20. [20]

    Jonas Gehring, Kunhao Zheng, Jade Copet, Vegard Mella, Quentin Carbonneaux, Taco Cohen, and Gabriel Synnaeve. 2025. RLEF: Grounding Code LLMs in Execution Feedback with Reinforcement Learning. arXiv:2410.02089 [cs.AI]

    Pith/arXiv arXiv 2025

  21. [21]

    Aiden Grossman, Ludger Paehler, Konstantinos Parasyris, Tal Ben-Nun, Jacob Hegna, William Moses, Jose M Monsalve Diaz, Mircea Trofin, and Johannes Doerfert. 2024. ComPile: A Large IR Dataset from Production Sources. arXiv:2309.15432 [cs.PL] https://arxiv.org/abs/2309.15432

    Pith/arXiv arXiv 2024

  22. [22]

    Daya Guo, Qihao Zhu, Dejian Yang, Zhenda Xie, Kai Dong, Wentao Zhang, Guanting Chen, Xiao Bi, Y. Wu, Y. K. Li, Fuli Luo, Yingfei Xiong, and Wenfeng Liang. 2024. DeepSeek-Coder: When the Large Language Model Meets Programming – The Rise of Code Intelligence.arXiv preprint arXiv:2401.14196(2024)

    Pith/arXiv arXiv 2024

  23. [23]

    Marcus Hähnel, Björn Döbel, Marcus Völp, and Hermann Härtig. 2012. Measuring Energy Consumption for Short Code Paths Using RAPL. In Proceedings of the GreenMetrics Workshop, in conjunction with ACM SIGMETRICS. Also published in ACM SIGMETRICS Performance Evaluation Review, 40(3):13–17

    2012

  24. [24]

    2011.Computer architecture: a quantitative approach

    John L Hennessy and David A Patterson. 2011.Computer architecture: a quantitative approach. Elsevier

    2011

  25. [25]

    Mark Horowitz. 2014. 1.1 computing’s energy problem (and what we can do about it). In2014 IEEE international solid-state circuits conference digest of technical papers (ISSCC). IEEE, 10–14

    2014

  26. [26]

    Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen

    Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2022. LoRA: Low-Rank Adaptation of Large Language Models. InProceedings of the International Conference on Learning Representations (ICLR)

    2022

  27. [27]

    Dong Huang, Yuhao Qing, Weiyi Shang, Heming Cui, and Jie Zhang. 2024. Effibench: Benchmarking the efficiency of automatically generated code. Advances in Neural Information Processing Systems37 (2024), 11506–11544

    2024

  28. [28]

    Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, Tianyu Liu, Jiajun Zhang, Bowen Yu, Keming Lu, Kai Dang, Yang Fan, Yichang Zhang, An Yang, Rui Men, Fei Huang, Bo Zheng, Yibo Miao, Shanghaoran Quan, Yunlong Feng, Xingzhang Ren, Xuancheng Ren, Jingren Zhou, and Junyang Lin. 2024. Qwen2.5-Coder Technical Report.arXiv preprint arXiv:240...

    Pith/arXiv arXiv 2024

  29. [29]

    2025.Energy and AI

    International Energy Agency. 2025.Energy and AI. Technical Report. International Energy Agency (IEA), Paris. https://www.iea.org/reports/energy- and-ai

    2025

  30. [30]

    Gonzalez, Hao Zhang, and Ion Stoica

    Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph E. Gonzalez, Hao Zhang, and Ion Stoica. 2023. Efficient Memory Management for Large Language Model Serving with PagedAttention. InProceedings of the ACM SIGOPS 29th Symposium on Operating Systems Principles (SOSP). ACM

    2023

  31. [31]

    Alexandre Lacoste, Alexandra Luccioni, Victor Schmidt, and Thomas Dandres. 2019. Quantifying the carbon emissions of machine learning.arXiv preprint arXiv:1910.09700(2019)

    Pith/arXiv arXiv 2019

  32. [32]

    Hung Le, Yue Wang, Akhilesh Deepak Gotmare, Silvio Savarese, and Steven C.H. Hoi. 2022. CodeRL: Mastering Code Generation through Pretrained Models and Deep Reinforcement Learning. InAdvances in Neural Information Processing Systems (NeurIPS), Vol. 35

    2022

  33. [33]

    Charles E Leiserson, Neil C Thompson, Joel S Emer, Bradley C Kuszmaul, Butler W Lampson, Daniel Sanchez, and Tao B Schardl. 2020. There’s plenty of room at the Top: What will drive computer performance after Moore’s law?Science368, 6495 (2020), eaam9744

    2020

  34. [34]

    Strong, Jay B

    Sheng Li, Jung Ho Ahn, Richard D. Strong, Jay B. Brockman, Dean M. Tullsen, and Norman P. Jouppi. 2009. McPAT: An Integrated Power, Area, and Timing Modeling Framework for Multicore and Manycore Architectures. InProceedings of the 42nd Annual IEEE/ACM International Symposium on Manuscript submitted to ACM Beyond theNeed for Speed: Energy-Aware Code Genera...

    2009

  35. [35]

    Mankowitz, Esme Sutherland Robson, Pushmeet Kohli, Nando de Freitas, Koray Kavukcuoglu, and Oriol Vinyals

    Yujia Li, David Choi, Junyoung Chung, Nate Kushman, Julian Schrittwieser, Rémi Leblond, Tom Eccles, James Keeling, Felix Gimeno, Agustin Dal Lago, Thomas Hubert, Peter Choy, Cyprien de Masson d’Autume, Igor Babuschkin, Xinyun Chen, Po-Sen Huang, Johannes Welbl, Sven Gowal, Alexey Cherepanov, James Molloy, Daniel J. Mankowitz, Esme Sutherland Robson, Pushm...

    2022

  36. [36]

    Jiawei Liu, Songrun Xie, Junhao Wang, Yuxiang Wei, Yifeng Ding, and LINGMING ZHANG. 2024. Evaluating Language Models for Efficient Code Generation. InFirst Conference on Language Modeling

    2024

  37. [37]

    Jiate Liu, Yiqin Zhu, Kaiwen Xiao, Qiang Fu, Xiao Han, Wei Yang, and Deheng Ye. 2023. RLTF: Reinforcement Learning from Unit Test Feedback. Transactions on Machine Learning Research (TMLR)(2023). arXiv:2307.04349

    Pith/arXiv arXiv 2023

  38. [38]

    LLVM Project. 2024. LLVM-MCA — LLVM Machine Code Analyzer. https://llvm.org/docs/CommandGuide/llvm-mca.html. Accessed: 2026-02-05

    2024

  39. [39]

    Ilya Loshchilov and Frank Hutter. 2019. Decoupled Weight Decay Regularization. InProceedings of the International Conference on Learning Representations (ICLR)

    2019

  40. [40]

    Michael McCloskey and Neal J Cohen. 1989. Catastrophic interference in connectionist networks: The sequential learning problem. InPsychology of learning and motivation. Vol. 24. Elsevier, 109–165

    1989

  41. [41]

    Mohammadjavad Mehditabar, Saurabhsingh Rajput, and Tushar Sharma. 2026. A Validated Taxonomy on Software Energy Smells. InProceedings of the 42nd IEEE International Conference on Software Maintenance and Evolution (ICSME). arXiv:2604.04809 [cs.SE] https://arxiv.org/abs/2604.04809

    Pith/arXiv arXiv 2026

  42. [42]

    Rui Pereira, Marco Couto, Francisco Ribeiro, Rui Rua, Jácome Cunha, João Paulo Fernandes, and João Saraiva. 2021. Ranking programming languages by energy efficiency.Science of Computer Programming205 (2021), 102609

    2021

  43. [43]

    Ruchir Puri, David S Kung, Geert Janssen, Wei Zhang, Giacomo Domeniconi, Vladimir Zolotov, Julian Dolby, Jie Chen, Mihir Choudhury, Lindsey Decker, et al. 2021. Codenet: A large-scale ai for code dataset for learning a diversity of coding tasks.arXiv preprint arXiv:2105.12655(2021)

    Pith/arXiv arXiv 2021

  44. [44]

    Ruizhong Qiu, Weiliang Zeng, James Ezick, Christopher Lott, and Hanghang Tong. 2025. How efficient is llm-generated code? a rigorous & high-standard benchmark. InInternational Conference on Learning Representations, Vol. 2025. 2233–2261

    2025

  45. [45]

    Saurabhsingh Rajput, Alexander Brandt, Vadim Elisseev, and Tushar Sharma. 2026. FlipFlop: A Static Analysis-based Energy Optimization Framework for GPU Kernels. InProceedings of the IEEE/ACM International Conference on Software Engineering (ICSE). arXiv:2601.13345 [cs.SE] https://arxiv.org/abs/2601.13345

    arXiv 2026

  46. [46]

    Saurabhsingh Rajput and Tushar Sharma. 2026. CodeGreen: Towards Improving Precision and Portability in Software Energy Measurement. In Proceedings of the ACM International Conference on the Foundations of Software Engineering (FSE). arXiv:2603.17924 [cs.SE] https://arxiv.org/abs/ 2603.17924

    arXiv 2026

  47. [47]

    2026.CodeGreen: Towards Improving Precision and Portability in Software Energy Measurement

    Saurabhsingh Rajput and Tushar Sharma. 2026.CodeGreen: Towards Improving Precision and Portability in Software Energy Measurement. doi:10. 5281/zenodo.18371772 Artifact, FSE 2026

    2026

  48. [48]

    Saurabhsingh Rajput and Tushar Sharma. 2026. Energy Flow Graph: Modeling Software Energy Consumption. InProceedings of the ACM International Conference on the Foundations of Software Engineering (FSE). arXiv:2603.17162 [cs.SE] https://arxiv.org/abs/2603.17162

    arXiv 2026

  49. [49]

    Saurabhsingh Rajput, Tim Widmayer, Ziyuan Shang, Maria Kechagia, Federica Sarro, and Tushar Sharma. 2024. Enhancing energy-awareness in deep learning through fine-grained energy measurement.ACM Transactions on Software Engineering and Methodology33, 8 (2024), 1–34

    2024

  50. [50]

    Baptiste Rozière, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaoqing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, Jérémy Rapin, Artyom Kozhevnikov, Ivan Evtimov, Joanna Bitton, Manish Bhatt, Cristian Canton Ferrer, Aaron Grattafiori, Wenhan Xiong, Alexandre Défossez, Jade Copet, Faisal Azhar, Hugo Touvron, Louis Martin, Nico...

    Pith/arXiv arXiv 2023

  51. [51]

    Rui Rua and João Saraiva. 2024. A large-scale empirical study on mobile performance: energy, run-time and memory.Empirical Software Engineering 29, 1 (2024), 31

    2024

  52. [52]

    Daniel Sanchez and Christos Kozyrakis. 2013. ZSim: Fast and Accurate Microarchitectural Simulation of Thousand-Core Systems. InProceedings of the 40th Annual International Symposium on Computer Architecture (ISCA). ACM

    2013

  53. [53]

    John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. 2017. Proximal Policy Optimization Algorithms.arXiv preprint arXiv:1707.06347(2017)

    Pith/arXiv arXiv 2017

  54. [54]

    Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Mingchuan Zhang, Y.K. Li, Y. Wu, and Daya Guo. 2024. DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models.arXiv preprint arXiv:2402.03300(2024)

    Pith/arXiv arXiv 2024

  55. [55]

    Judy Hanwen Shen and Alex Tamkin. 2026. How AI Impacts Skill Formation.arXiv preprint arXiv:2601.20245(2026)

    arXiv 2026

  56. [56]

    Parshin Shojaee, Aneesh Jain, Sindhu Tipirneni, and Chandan K. Reddy. 2023. Execution-based Code Generation using Deep Reinforcement Learning. Transactions on Machine Learning Research (TMLR)(2023). arXiv:2301.13816

    Pith/arXiv arXiv 2023

  57. [57]

    Ilia Shumailov, Zakhar Shumaylov, Yiren Zhao, Nicolas Papernot, Ross Anderson, and Yarin Gal. 2024. AI models collapse when trained on recursively generated data.Nature631, 8022 (2024), 755–759

    2024

  58. [58]

    Alexander Shypula, Aman Madaan, Yimeng Zeng, Uri Alon, Jacob Gardner, Yiming Yang, Tatsunori Hashimoto, Graham Neubig, Parthasarathy Ranganathan, and Amir Yazdanbakhsh. 2024. Learning Performance-Improving Code Edits. InProceedings of the International Conference on Learning Representations (ICLR)

    2024

  59. [59]

    Lola Solovyeva, Sophie Weidmann, and Fernando Castor. 2025. AI-powered, but power-hungry? Energy efficiency of LLM-generated code. In2025 IEEE/ACM Second International Conference on AI Foundation Models and Software Engineering (Forge). IEEE, 49–60. Manuscript submitted to ACM 40 Rajput and Sharma

    2025

  60. [60]

    Tina Vartziotis, Ippolyti Dellatolas, George Dasoulas, Maximilian Schmidt, Florian Schneider, Tim Hoffmann, Sotirios Kotsopoulos, and Michael Keckeisen. 2024. Learn to code sustainably: An empirical study on llm-based green code generation.arXiv preprint arXiv:2403.03344(2024)

    Pith/arXiv arXiv 2024

  61. [61]

    Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need.Advances in neural information processing systems30 (2017)

    2017

  62. [62]

    Roberto Verdecchia, June Sallou, and Luís Cruz. 2023. A Systematic Review of Green AI.WIREs Data Mining and Knowledge Discovery13, 4 (2023)

    2023

  63. [63]

    Siddhant Waghjale, Vishruth Veerendranath, Zhiruo Wang, and Daniel Fried. 2024. ECCO: Can we improve model-generated code efficiency without sacrificing functional correctness?. InProceedings of the 2024 Conference on Empirical Methods in Natural Language Processing. 15362–15376

    2024

  64. [64]

    Max Weber, Christian Kaltenecker, Florian Sattler, Sven Apel, and Norbert Siegmund. 2023. Twins or false friends? A study on energy consumption and performance of configurable software. In2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). IEEE, 2098–2110

    2023

  65. [65]

    Yuxiang Wei, Olivier Duchenne, Jade Copet, Quentin Carbonneaux, Lingming Zhang, Daniel Fried, Gabriel Synnaeve, Rishabh Singh, and Sida I. Wang. 2025. SWE-RL: Advancing LLM Reasoning via Reinforcement Learning on Open Software Evolution. arXiv:2502.18449 [cs.AI]

    Pith/arXiv arXiv 2025

  66. [66]

    Ohlsson, Björn Regnell, and Anders Wesslén

    Claes Wohlin, Per Runeson, Martin Höst, Magnus C. Ohlsson, Björn Regnell, and Anders Wesslén. 2012.Experimentation in Software Engineering. Springer, Berlin, Heidelberg

    2012

  67. [67]

    Yongliang Wu, Yizhou Zhou, Ziheng Zhou, Yingzhe Peng, Xinyu Ye, Xinting Hu, Wenbo Zhu, Lu Qi, Ming-Hsuan Yang, and Xu Yang. 2026. On the Generalization of SFT: A Reinforcement Learning Perspective with Reward Rectification. InProceedings of the International Conference on Learning Representations (ICLR). arXiv:2508.05629 [cs.LG]

    arXiv 2026

  68. [68]

    Yuexiang Zhai, Shengbang Tong, Xiao Li, Mu Cai, Qing Qu, Yong Jae Lee, and Yi Ma. 2023. Investigating the catastrophic forgetting in multimodal large language models.arXiv preprint arXiv:2309.10313(2023)

    Pith/arXiv arXiv 2023

  69. [69]

    Tianjun Zhang, Fangchen Liu, Justin Wong, Pieter Abbeel, and Joseph E Gonzalez. 2023. The wisdom of hindsight makes language models better instruction followers. InInternational Conference on Machine Learning. PMLR, 41414–41428

    2023

  70. [70]

    Speed Zhu, Jianwei Cai, Guang Chen, Lulu Wu, Saiyong Yang, and Wiggin Zhou. 2025. DRIVE: Data Curation Best Practices for Reinforcement Learning with Verifiable Reward in Competitive Code Generation. arXiv:2511.06307 [cs.LG] Manuscript submitted to ACM

    arXiv 2025