Pith. sign in

REVIEW 3 major objections 6 minor 78 references

Learning how each quantum circuit reacts to individual compiler passes lets QuTuner search the full optimization-pass space and beat prior tuners while cutting online search time.

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:50 UTC pith:G5AB2LXG

load-bearing objection Solid full-pass quantum compiler auto-tuner with a real retrieval corpus and pass embeddings; the 84.85% headline is partly budget asymmetry, but ablations still show the pipeline is useful. the 3 major comments →

arxiv 2607.04586 v1 pith:G5AB2LXG submitted 2026-07-06 quant-ph cs.SE

QuTuner: Feature- and Learning-Guided Optimization Pass Tuning for Quantum Compilers

Ming Zhong , Xiangyu Ren , Jinglei Cheng , Shaohua Li , Zhiding Liang This is my paper
classification quant-ph cs.SE
keywords quantum compilerspass tuningpass embeddingsBayesian optimizationcircuit featuresQiskitPyTKETgraph transformer
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.

Quantum compilers improve fidelity mainly by cutting two-qubit gates, one-qubit gates, and depth, but fixed optimization levels are not best for every circuit and the full pass space is huge. Earlier quantum pass-tuning work searched only a small subset of optimization passes and relied on static circuit structure, which does not show how a circuit actually changes when a pass runs. QuTuner builds a large offline set of Bayesian-optimized full pass sequences, represents each circuit with both static structure features and pass embeddings that record the metric change from applying every pass alone, then trains two models to retrieve and rank candidate sequences for a new circuit before a short Bayesian refinement. On Qiskit it improves the weighted metric reduction by up to about 85 percent over the strongest baseline while reducing online tuning time by roughly three-quarters; on PyTKET it still improves reduction and cuts tuning time by about two-thirds. The paper’s claim is that this feature-and-learning pipeline makes adaptive full-space pass tuning practical across compilers and objectives.

Core claim

QuTuner shows that full optimization-pass spaces can be tuned effectively online by combining static circuit features with optimization-aware pass embeddings—vectors of relative changes in two-qubit gates, one-qubit gates, and depth from applying each pass independently—then retrieving and ranking sequences from a large offline Bayesian-optimized dataset and refining only lightly. That pipeline outperforms Bayesian optimization, genetic search, reinforcement learning, and LLM baselines on circuit-metric reduction while sharply reducing online tuning time on both Qiskit and PyTKET, and can be rebuilt for different compilers or objectives such as estimated fidelity.

What carries the argument

Optimization-aware pass embeddings plus a two-stage retrieve-and-rank model: offline, every pass is profiled alone and concatenated into an embedding; a pruning model predicts that embedding from static features to fetch top-k sequences, a ranker scores them, and lightweight Bayesian optimization refines the best valid seed.

Load-bearing premise

The method assumes that circuits with similar single-pass responses will share useful full pass sequences, so an offline dataset from one circuit collection and backend can seed good online tuning for unseen circuits.

What would settle it

Take a held-out circuit family whose pass embeddings sit near the offline set but whose true best sequences differ sharply, run QuTuner against equal-budget pure Bayesian search and the default high optimization level on the same weighted metric, and check whether the retrieve-and-refine edge disappears.

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

If this is right

  • Full optimization-pass spaces (all 29 Qiskit and all 22 PyTKET optimization passes in the study) become practical to tune online without multi-hundred-iteration pure search per circuit.
  • Pass-response similarity is a stronger retrieval signal for transferring optimized sequences than static circuit features alone.
  • Rebuilding the offline dataset and models once for a new compiler or objective (including estimated fidelity) lets the same online pipeline be reused on future circuits.
  • A minority of circuits still need fallback to the default high optimization level when every retrieved candidate fails validity checks.
  • Sequences learned on a mid-size fake backend transfer to smaller and larger backends with only modest loss on the main metrics.

Where Pith is reading between the lines

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

  • If single-pass embeddings keep predicting useful sequence transfer, compiler packages could ship pretrained retrieval models instead of only fixed optimization levels.
  • Independent pass profiling may miss synergistic multi-pass interactions; profiling small combinations could improve retrieval at higher offline cost.
  • The same offline-dataset, embedding, and light-refine template could apply to other quantum compilation stages once large optimized configuration sets exist.
  • Strong results on mixed algorithm and random circuits still leave open how much distribution shift hurts on narrow real-application families.

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 / 6 minor

Summary. QuTuner is a feature- and learning-guided framework for tuning the full optimization-pass space of quantum compilers. Offline, it runs long Bayesian optimization over all 29 Qiskit V2.2.3 optimization passes on 8,111 QCircuitBench circuits, records best sequences, and builds two complementary circuit representations: static features (scale, SupermarQ structure, interaction graph, DAG) and optimization-aware pass embeddings obtained by independently applying each pass and measuring relative changes in 2Q/1Q counts and depth. A graph-transformer pruning model predicts pass embeddings for retrieval of top-k sequences; a GRU/cross-attention ranker scores them; lightweight BO then refines the best valid seed. Online evaluation on 180 QASMBench/VeriQBench circuits (no exact OpenQASM leakage) reports up to 84.85% better metric reduction than the strongest baseline (short online BO) with 73.59% less tuning time on Qiskit, plus PyTKET and estimated-fidelity adaptations, ablations, and sensitivity studies.

Significance. If the results hold under fairer search-budget controls, the paper is a solid systems contribution to quantum software engineering: it is the first reported full-pass-space tuner for modern Qiskit/PyTKET optimization stages, introduces a practical optimization-aware embedding that correlates better with sequence similarity than static features alone (Fig. 4), and demonstrates transfer across compilers and objectives with multi-baseline, multi-benchmark evidence. Strengths include the large offline dataset, explicit leakage control, feature and pipeline ablations (Table 4, Fig. 9), hyperparameter/dataset-size sensitivity, and backend-size checks. The work is empirical rather than theoretical; its value is a reusable retrieval-plus-refinement recipe and evidence that full-pass tuning is tractable when offline search is amortized.

major comments (3)
  1. Abstract / Sec. 5.2 / Fig. 6 / Table 2: The headline 84.85% relative improvement over BO is measured against a deliberately short online BO (10 initial + 50 iterations, early stop 20), while QuTuner reuses 500-iteration offline BO sequences (Sec. 4.1.5) plus a further 10+20 lightweight BO budget (Sec. 4.2). The paper correctly notes that long BO is too expensive for online evaluation, but the effectiveness claim then mixes method quality with amortized offline search. Please add a matched-budget control (e.g., online BO with total evaluations comparable to QuTuner’s online budget, and/or BO warm-started from O3 with the same wall-clock or iteration budget as QuTuner’s online stage) and report absolute reductions for both. Ablation Fig. 9 (w/o BO still strong) supports retrieval value but does not equalize total search effort; without this, the relative-gain claim overstates the contribut
  2. Sec. 3.2.4–3.2.5, Fig. 4, Sec. 4.1.5: The load-bearing assumption is that independent single-pass metric deltas form a retrieval basis that predicts multi-pass sequence utility for unseen families despite pass interactions. Fig. 4 shows higher edit similarity of BO sequences when pass-embedding similarity is high, but edit similarity of offline sequences is not the same as transfer utility on held-out benchmarks. Please quantify retrieval quality on the 180 evaluation circuits (e.g., rank of the best transferable sequence among top-k, correlation between predicted embedding similarity and realized S(c) of retrieved sequences, and failure modes when all top-k are invalid—already 11.67% fallback). If similarity–utility is weak for some families, the two-stage models mainly seed short BO; that should be stated as a limitation with evidence.
  3. Sec. 5.1 baselines (RL, GPT, QWen) and Fig. 7: Many RL/LLM cases sit at 0% because generated sequences fail to compile, with failures scored as 0% reduction. That inflates QuTuner’s relative advantage if validity is not enforced for those baselines the way hardware-validity checks are for BO/QuTuner (Sec. 4.1.5). Please report compile-success rates, repair/retry policies, and metric reductions conditioned on successful compilation, or constrain LLM/RL outputs to the same validity filter used for QuTuner candidates. Otherwise the multi-baseline comparison is not apples-to-apples on the primary effectiveness axis.
minor comments (6)
  1. Eq. (1) / Sec. 3.2.1: The 80/10/10 weights on Δ2Q/Δ1Q/ΔDepth are reasonable but free parameters; a short sensitivity table (e.g., 60/20/20 or equal weights) would show whether ranking of methods is stable.
  2. Fig. 6 vs. abstract: Clarify whether “84.85%” is relative improvement of relative reductions (e.g., (r_Q − r_BO)/r_BO) or another aggregation; state the exact formula once near Fig. 6.
  3. Sec. 4.1.5: Report wall-clock and CPU-core hours more prominently in the main text when claiming online time savings, so offline amortization is transparent to readers.
  4. Sec. 5.3 / Fig. 8: Backend transfer is only shown for QuTuner; a short BO comparison on FakeBrooklynV2/FakeFez would strengthen the scalability claim.
  5. Typos/clarity: “QuTunerfirst”, “QuTunertrains”, missing spaces after tool names in several places; standardize “O3” vs “-O3” axis labels in figures.
  6. Related work: briefly contrast sequence encoding (repetition up to 3, priority sort) with classical phase-ordering encodings so the search-space definition is easier to reproduce.

Circularity Check

0 steps flagged

Empirical retrieval-plus-refinement systems paper; no derivation reduces by construction to its inputs.

full rationale

QuTuner is an engineering/systems paper, not a first-principles derivation. The claimed gains are measured reductions of 2Q/1Q/depth (or estimated fidelity) relative to external compiler defaults (Qiskit O3, PyTKET O2) on held-out OpenQASM benchmarks with an explicit no-exact-code-leakage check against the offline corpus. Pass embeddings are independently measured single-pass metric deltas, not labels of the final BO sequences; the pruning model predicts those embeddings from static features, and the ranker ranks retrieved sequences by relative effectiveness—standard supervised retrieval, not a tautology. Offline BO (500 iterations) builds a retrieval corpus; online evaluation uses short BO (20 iterations) seeded by retrieval, compared to short online BO/GA/RL/LLM baselines. That is a budget asymmetry that may inflate relative gains, but it is an experimental-design concern, not circularity: the paper does not redefine the evaluation metric as the offline fit, nor does it import a uniqueness theorem or ansatz via self-citation to force the result. Ablations and multi-compiler/objective re-runs further treat the pipeline as falsifiable. Score 1 only for the minor, non-load-bearing self-referential structure that models are trained on the same offline BO corpus they later retrieve from—normal for retrieval-augmented tuning and not equivalent to claiming a prediction by construction.

Axiom & Free-Parameter Ledger

5 free parameters · 5 axioms · 3 invented entities

Load-bearing content is empirical and engineering-heavy: weighted circuit metrics, single-pass profiling as a proxy for sequence behavior, retrieval from offline BO optima, and model/hyperparameter choices. No new physical entities; free parameters are objective weights and search/model knobs that shape reported gains.

free parameters (5)
  • Objective weights (α,β,γ) on Δ2Q, Δ1Q, ΔDepth
    Hand-set to 80%/10%/10% (Eq. 1) because 2Q gates dominate cost; this choice defines the primary evaluation metric and BO target.
  • Top-k retrieval size
    Default k=10 for candidate sequences; sensitivity shows mild dependence but selection is design choice, not derived.
  • Online lightweight BO budget
    10 initial samples, 20 iterations, early stop 5 (vs offline 500/50); balances time vs quality and directly affects reported speedups.
  • Pass repetition cap in sequence encoding
    Each pass allowed up to three times in BO search space; expands combinatorial space by design.
  • Model architecture hyperparameters
    Graph-transformer depth, embedding dims (192/256/87), learning rates, epochs, batch size chosen for training; affect retrieval/ranking quality.
axioms (5)
  • domain assumption All 29 Qiskit V2.2.3 optimization-stage passes preserve circuit semantics and are safe to include in the search space.
    Sec. 4.1.1 relies on documentation not marking them semantics-changing; correctness of tuned sequences depends on this.
  • ad hoc to paper Independent single-pass metric deltas (pass embeddings) are sufficiently informative proxies for multi-pass sequence utility despite pass interactions.
    Sec. 2.2 and 3.2.4 explicitly trade off combination profiling cost; Fig. 4 is supporting evidence, not a proof of sufficiency.
  • domain assumption Hardware-agnostic reductions in 2Q/1Q/depth (or EF on a fake backend) are appropriate primary objectives for optimization-stage tuning.
    Sec. 3.2.1; layout/routing fixed at O3 defaults so measured gains are attributed to optimization passes under that coupling.
  • domain assumption QCircuitBench circuits plus BO optima form a representative retrieval corpus for QASMBench/VeriQBench-style workloads under the same backend class.
    Dataset construction Sec. 4.1.5 and evaluation leakage check; generalization claim rests on this coverage.
  • standard math Standard ML training assumptions (MSE for embedding regression; k-way cross-entropy ranking) yield useful online retrieval without formal generalization guarantees.
    Sec. 4.1.6; ordinary supervised learning setup.
invented entities (3)
  • Optimization-aware pass embedding no independent evidence
    purpose: Vector of per-pass relative changes in 2Q, 1Q, and depth used as optimization-behavior features for similarity and model targets.
    Core representational contribution of the paper; independent_evidence is internal (Fig. 4 correlation), not an external physical observable.
  • QuTuner two-stage prune+rank models (graph-transformer pruning model + GRU/cross-attention ranker) no independent evidence
    purpose: Predict pass embeddings and rank retrieved sequences for unseen circuits before lightweight BO.
    Architectural assembly of known components for this task; value is empirical performance, not a new scientific object.
  • QCircuitBench-derived full-pass optimization dataset (8,111 BO sequences) no independent evidence
    purpose: Offline retrieval corpus of optimized pass sequences with features and embeddings.
    Artifact constructed for this work; not independently published as a community benchmark in the paper.

pith-pipeline@v1.1.0-grok45 · 27794 in / 3978 out tokens · 34682 ms · 2026-07-11T16:50:12.925505+00:00 · methodology

0 comments
read the original abstract

Quantum compilers play a key role in transforming quantum circuits into lower-cost implementations with improved execution fidelity. This process is commonly guided by circuit-level metrics, such as gate counts and circuit depth. Although compiler pass tuning has been widely studied in classical compilation, directly transferring these techniques to quantum compilers is challenging, because quantum programs are expressed as circuits and exhibit optimization behaviors that are shaped by quantum-specific structures. Prior quantum compiler tuning approaches have begun to use circuit features to guide pass selection, but they remain limited in two aspects: they search only a small portion of the optimization-pass space, and they mainly rely on static features that do not explicitly reflect how a circuit reacts to compiler optimizations. We present QuTuner, a feature-guided quantum compiler pass tuning framework that generalizes across compilers and tuning objectives. QuTuner first builds a large optimization dataset. It then characterizes each circuit from two complementary views: static circuit features that describe circuit structure, and optimization-aware pass embeddings that summarize the circuit's responses to individual optimization passes. Using these representations, QuTuner trains two offline models to retrieve and rank candidate pass sequences for unseen circuits, followed by lightweight refinement. We evaluate QuTuner on Qiskit and PyTKET using two benchmark suites. On Qiskit, QuTuner improves the evaluation-metric reduction by up to 84.85% over the strongest baseline while reducing tuning time by 73.59%. On PyTKET, it improves metric reduction by up to 18.68% with a 64.49% reduction in tuning time. These results show that QuTuner provides an effective approach to adaptive pass tuning for quantum compilers.

Figures

Figures reproduced from arXiv: 2607.04586 by Jinglei Cheng, Ming Zhong, Shaohua Li, Xiangyu Ren, Zhiding Liang.

Figure 1
Figure 1. Figure 1: Challenges of quantum compiler pass tuning. (a) Quantum circuits have specific features distinct from clas￾sical programs, such as gate counts and circuit depth. (b) Existing studies do not cover the full optimization pass tun￾ing space. hardware-supported bases, optimization applies analysis and transformation passes to reduce circuit cost, and schedul￾ing assigns execution times to operations under hardw… view at source ↗
Figure 2
Figure 2. Figure 2: The overall workflow of QuTuner. In the figure, → denotes the flow of circuit features, → denotes pass em￾beddings, and → denotes optimized pass sequences. cannot directly capture how a circuit responds to different optimization passes. To address this limitation, we are motivated to directly measure how a quantum circuit responds to different passes, leading to a pass profiling mechanism. Specifically, we… view at source ↗
Figure 3
Figure 3. Figure 3: Feature representations of an example quantum circuit, QAOA MaxCut-n2, in OpenQASM. OpenQASM is a unified representation for quantum circuits [11]. 3.2 Offline Stage 3.2.1 Tuning Objective. Existing quantum compiler tun￾ing works consider various metrics including the 2Q gate counts [36, 40], 1Q gate counts [36], circuit depth [36, 53, 54], and estimated fidelity [20, 53, 54]. In this work, we adopt a weig… view at source ↗
Figure 4
Figure 4. Figure 4: Static feature-based and pass embedding-based measurements of BO optimized pass sequence similarity (measured by edit similarity, higher is better). positional value indicates the relative order of the gate in the circuit DAG. For the edge structure, we use an edge list of gate-index pairs to represent gate dependencies. These four types of static circuit features jointly capture various circuit characteri… view at source ↗
Figure 5
Figure 5. Figure 5: Two-stage selection model design of QuTuner, including the pruning model (a) and the ranker model (b). of each node in the DAG features into node embeddings, and then feeds the node embeddings together with the DAG edge list into graph transformer layers. The graph transformer produces DAG representations, which are then aggregated by mean pooling and projected into a global DAG-level representation. This … view at source ↗
Figure 6
Figure 6. Figure 6: Comparison of tuning effectiveness between QuTuner and baselines in Qiskit V2.2.3. GA BO RL GPT QWen QTuner R e d u ctio n O v er -O 3 Benchmarks Y X 2Q Gates 1Q Gates Depth 2Q Gates 1Q Gates Depth 2Q Gates 1Q Gates Depth 2Q Gates 1Q Gates Depth 2Q Gates 1Q Gates Depth Small Medium Large Combinational Variational QASMBench VeriQBench 0% 100% -10% QuTuner [PITH_FULL_IMAGE:figures/full_fig_p009_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Per-case optimization distribution of QuTuner and baselines. A slight x-axis jitter improves visibility of overlapping points. Many RL, GPT, and QWen cases concentrate at 0% reduction because of failed compilations, as described in Sec. 5.1 [PITH_FULL_IMAGE:figures/full_fig_p009_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: Scalability analysis across different quantum back￾ends. can identify valid pass sequences for most cases, while the fallback mechanism remains necessary for robustness. 5.3 Scalability Analysis of QuTuner (RQ.2) As introduced in Sec. 4.1.5, our optimization dataset is con￾structed on the 127-qubit FakeWashingtonV2 backend and used for pass retrieval in QuTuner. To evaluate scalability, we further test QuT… view at source ↗
Figure 10
Figure 10. Figure 10: Hyperparameter analysis of QuTuner. 10% 30% 50% 70% Dataset Size (Random Sampling Ratio) 20% 40% 60% 80% 100% R e d uc. O v er -O 3 Y 1Q Gates 2Q Gates X Circuit Depth [PITH_FULL_IMAGE:figures/full_fig_p010_10.png] view at source ↗
Figure 11
Figure 11. Figure 11: Dataset size sampling analysis of QuTuner. 5.5.1 Hyperparameter. The sensitivity evaluation results of the three key hyperparameters are shown in [PITH_FULL_IMAGE:figures/full_fig_p010_11.png] view at source ↗
Figure 12
Figure 12. Figure 12: Comparison between QuTuner and BO in PyTKET V2.13.0 over its highest optimization level O2. 2Q 1Q Depth Est. Fid. 2Q 1Q Depth Est. Fid. 2Q 1Q Depth Est. Fid. 2Q 1Q Depth Est. Fid. 2Q 1Q Depth Est. Fid. 2Q 1Q Depth Est. Fid. Small Medium Large Variational Combinational QASMBench VeriQBench Average R e d uctio n O v er -O 3 Benchmarks 52.2% Estimated Fidelity Circuit-Level Metrics (Eq.(1)) 30.9% 28.4% 19.4%… view at source ↗
Figure 13
Figure 13. Figure 13: Comparison of estimated fidelity (EF) and circuit￾level metrics (Eq. (1)) as tuning objectives. level O2 as the reduction baseline. We still use IBM FakeWash￾ingtonV2 as the target backend for both dataset construction and evaluation, accessed through the IBMQBackend interface in pytket-qiskit v0.77.0. We continue to use QCircuitBench to construct the PyTKET￾specific optimization dataset, and apply the lo… 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

78 extracted references · 13 canonical work pages

  1. [1]

    Eigen AI. 2026. High-Performance AI for Enterprises.https://www. eigenai.com/

    2026

  2. [2]

    Ashouri, Andrea Bignoli, Gianluca Palermo, Cristina Silvano, Sameer Kulkarni, and John Cavazos

    Amir H. Ashouri, Andrea Bignoli, Gianluca Palermo, Cristina Silvano, Sameer Kulkarni, and John Cavazos. 2017. MiCOMP: Mitigating the Compiler Phase-Ordering Problem Using Optimization Sub-Sequences and Machine Learning.ACM Trans. Archit. Code Optim.14, 3, Article 29 (Sept. 2017), 28 pages. doi:10.1145/3124452

    doi:10.1145/3124452 2017

  3. [3]

    Abdul Basit, Minghao Shao, Muhammad Haider Asif, Nouhaila Innan, Muhammad Kashif, Alberto Marchisio, and Muhammad Shafique. 2025. PennyCoder: Efficient Domain-Specific LLMs for PennyLane-Based Quantum Code Generation. In2025 IEEE International Conference on Quantum Computing and Engineering (QCE). IEEE, Albuquerque, New Mexico, USA, 229–234. doi:10.1109/q...

    doi:10.1109/qce65121.2025.10324 2025

  4. [4]

    Charlie Campbell, Hao (Mark) Chen, Wayne Luk, and Hongxiang Fan

  5. [5]

    InProceedings of the 62nd Annual ACM/IEEE Design Automation Conference (DAC ’25)

    Enhancing LLM-Based Quantum Code Generation with Multi- Agent Optimization and Quantum Error Correction. InProceedings of the 62nd Annual ACM/IEEE Design Automation Conference (DAC ’25). IEEE Press, San Francisco, California, United States, Article 414, 7 pages. doi:10.1109/DAC63849.2025.11133316

    doi:10.1109/dac63849.2025.11133316 2025

  6. [6]

    Olson, Matthias De- groote, Peter D

    Yudong Cao, Jonathan Romero, Jonathan P. Olson, Matthias De- groote, Peter D. Johnson, Mária Kieferová, Ian D. Kivlichan, Tim Menke, Borja Peropadre, Nicolas P. D. Sawaya, Sukin Sim, Libor Veis, and Alán Aspuru-Guzik. 2019. Quantum Chemistry in the Age of Quantum Computing.Chemical Reviews119, 19 (2019), 10856– 10915. arXiv:https://doi.org/10.1021/acs.che...

    doi:10.1021/acs.chemrev.8b00803 2019

  7. [7]

    Junjie Chen, Ningxin Xu, Peiqi Chen, and Hongyu Zhang. 2021. Effi- cient Compiler Autotuning via Bayesian Optimization. InProceedings of the 43rd International Conference on Software Engineering(Madrid, Spain)(ICSE ’21). IEEE Press, 1198–1209. doi:10.1109/ICSE43902.2021. 00110

    doi:10.1109/icse43902.2021 2021

  8. [8]

    Kean Chen, Wang Fang, Ji Guan, Xin Hong, Mingyu Huang, Junyi Liu, Qisheng Wang, and Mingsheng Ying. 2022. VeriQBench: A Benchmark for Multiple Types of Quantum Circuits. arXiv:2206.10880 [quant-ph] https://arxiv.org/abs/2206.10880

    Pith/arXiv arXiv 2022

  9. [9]

    Yihan Chen, Huanhuan Chen, Yuan Yao, Ping Yu, Feng Xu, and Xi- aoxing Ma. 2025. Exploiting Booster Pass Chain for Compiler Phase Ordering. InProceedings of the 16th International Conference on In- ternetware (Internetware ’25). Association for Computing Machinery, New York, NY, USA, 175–185. doi:10.1145/3755881.3755899

    doi:10.1145/3755881.3755899 2025

  10. [10]

    Coons, Behnam Robatmili, Matthew E

    Katherine E. Coons, Behnam Robatmili, Matthew E. Taylor, Bertrand A. Maher, Doug Burger, and Kathryn S. McKinley. 2008. Feature selection and policy optimization for distributed instruction placement using reinforcement learning. InProceedings of the 17th International Con- ference on Parallel Architectures and Compilation Techniques(Toronto, Ontario, Can...

    work page doi:10.1145/1454115.1454122 2008

  11. [11]

    Cooper, Philip J

    Keith D. Cooper, Philip J. Schielke, and Devika Subramanian. 1999. Optimizing for Reduced Code Space Using Genetic Algorithms. In Proceedings of the ACM SIGPLAN 1999 Workshop on Languages, Com- pilers, and Tools for Embedded Systems(Atlanta, Georgia, USA)(LCTES ’99). Association for Computing Machinery, New York, NY, USA, 1–9. doi:10.1145/314403.314414

    work page doi:10.1145/314403.314414 1999

  12. [12]

    Cross, Lev S

    Andrew W. Cross, Lev S. Bishop, John A. Smolin, and Jay M. Gambetta

  13. [13]

    arXiv:1707.03429 [quant- ph]https://arxiv.org/abs/1707.03429

    Open Quantum Assembly Language. arXiv:1707.03429 [quant- ph]https://arxiv.org/abs/1707.03429

    Pith/arXiv arXiv

  14. [14]

    Chris Cummins, Volker Seeker, Dejan Grubisic, Baptiste Roziere, Jonas Gehring, Gabriel Synnaeve, and Hugh Leather. 2025. LLM Compiler: Foundation Language Models for Compiler Optimiza- tion. InProceedings of the 34th ACM SIGPLAN International Confer- ence on Compiler Construction(Las Vegas, NV, USA)(CC ’25). As- sociation for Computing Machinery, New York...

    doi:10.1145/3708493.3712691 2025

  15. [15]

    Chris Cummins, Bram Wasti, Jiadong Guo, Brandon Cui, Jason Ansel, Sahir Gomez, Somya Jain, Jia Liu, Olivier Teytaud, Benoit Steiner, Yuan- dong Tian, and Hugh Leather. 2022. CompilerGym: robust, performant compiler optimization environments for AI research. InProceedings of the 20th IEEE/ACM International Symposium on Code Generation and Optimization(Virt...

    doi:10.1109/cgo53902.2022.9741258 2022

  16. [16]

    Siddharth Dangwal, Gokul Subramanian Ravi, Lennart Maximilian Seifert, Poulami Das, James Sud, and Frederic T. Chong. 2025. Clif- ford Assisted Optimal Pass Selection for Quantum Transpilation. arXiv:2306.15020 [quant-ph]https://arxiv.org/abs/2306.15020

    Pith/arXiv arXiv 2025

  17. [17]

    Egger, Claudio Gambella, Jakub Marecek, Scott McFaddin, Martin Mevissen, Rudy Raymond, Andrea Simonetto, Stefan Woerner, and Elena Yndurain

    Daniel J. Egger, Claudio Gambella, Jakub Marecek, Scott McFaddin, Martin Mevissen, Rudy Raymond, Andrea Simonetto, Stefan Woerner, and Elena Yndurain. 2020. Quantum Computing for Finance: State- of-the-Art and Future Prospects.IEEE Transactions on Quantum Engi- neering1 (2020), 1–24. doi:10.1109/TQE.2020.3030314

    work page doi:10.1109/tqe.2020.3030314 2020

  18. [18]

    Unai Garciarena and Roberto Santana. 2016. Evolutionary Optimiza- tion of Compiler Flag Selection by Learning and Exploiting Flags Interactions. InProceedings of the 2016 on Genetic and Evolutionary Computation Conference Companion(Denver, Colorado, USA)(GECCO ’16 Companion). Association for Computing Machinery, New York, NY, USA, 1159–1166. doi:10.1145/2...

    work page doi:10.1145/2908961.2931696 2016

  19. [19]

    Xiaoyu Guo, Minggu Wang, and Jianjun Zhao. 2025. QuanBench: Benchmarking Quantum Code Generation with Large Language Mod- els. In2025 40th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE Press, Seoul, South Korea

    2025

  20. [20]

    Ruobing Han and Hyesoon Kim. 2024. Exponentially Expanding the Phase-Ordering Search Space via Dormant Information. InPro- ceedings of the 33rd ACM SIGPLAN International Conference on Com- piler Construction(Edinburgh, United Kingdom)(CC 2024). Asso- ciation for Computing Machinery, New York, NY, USA, 250–261. doi:10.1145/3640537.3641582

    doi:10.1145/3640537.3641582 2024

  21. [21]

    Harrow, Avinatan Hassidim, and Seth Lloyd

    Aram W. Harrow, Avinatan Hassidim, and Seth Lloyd. 2009. Quantum Algorithm for Linear Systems of Equations.Phys. Rev. Lett.103 (Oct 2009), 150502. Issue 15. doi:10.1103/PhysRevLett.103.150502 QuTuner: Feature- and Learning-Guided Optimization Pass Tuning for Quantum Compilers

    doi:10.1103/physrevlett.103.150502 2009

  22. [22]

    Mohammad Abrarul Hasanat, Ludmir Jason, Patel Tirthak, and Ro- han Basu Roy. 2026. TuniQ: Autotuning Compilation Passes for Quan- tum Workloads at Scale for Effectiveness and Efficiency. InProceedings of the 39th ACM International Conference on Supercomputing(Belfast, Northern Ireland)(ICS ’26). Association for Computing Machinery, New York, NY, USA

    2026

  23. [23]

    Kenneth Hoste and Lieven Eeckhout. 2008. Cole: compiler optimiza- tion level exploration. InProceedings of the 6th Annual IEEE/ACM In- ternational Symposium on Code Generation and Optimization(Boston, MA, USA)(CGO ’08). Association for Computing Machinery, New York, NY, USA, 165–174. doi:10.1145/1356058.1356080

    work page doi:10.1145/1356058.1356080 2008

  24. [24]

    Bishop, John Lapeyre, Ali Javadi-Abhari, and Eddy Z

    Fei Hua, Yuwei Jin, Yanhao Chen, Suhas Vittal, Kevin Krsulich, Lev S. Bishop, John Lapeyre, Ali Javadi-Abhari, and Eddy Z. Zhang. 2023. CaQR: A Compiler-Assisted Approach for Qubit Reuse through Dy- namic Circuit. InProceedings of the 28th ACM International Confer- ence on Architectural Support for Programming Languages and Op- erating Systems, Volume 3(V...

    doi:10.1145/3582016.3582030 2023

  25. [25]

    Qijing Huang, Ameer Haj-Ali, William Moses, John Xiang, Ion Stoica, Krste Asanovic, and John Wawrzynek. 2019. AutoPhase: Compiler Phase-Ordering for HLS with Deep Reinforcement Learning. In2019 IEEE 27th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). 308–308. doi:10.1109/FCCM. 2019.00049

    work page doi:10.1109/fccm 2019

  26. [26]

    IBM. 2026. Fake Provider.https://quantum.cloud.ibm.com/docs/en/ api/qiskit-ibm-runtime/fake-provider

    2026

  27. [27]

    IBM. 2026. FakeWashingtonV2 Backend.https://quantum.cloud. ibm.com/docs/en/api/qiskit-ibm-runtime/fake-provider-fake- washington-v2

    2026

  28. [28]

    IBM. 2026. Introduction to Qiskit and IBM Quantum.https://quantum. cloud.ibm.com/docs/en/guides

    2026

  29. [29]

    IBM. 2026. Optimization Passes in Qiskit Transpiler.https://quantum. cloud.ibm.com/docs/en/api/qiskit/2.2/transpiler_passes

    2026

  30. [30]

    IBM. 2026. RemoveBarriers Pass.https://quantum.cloud.ibm.com/ docs/en/api/qiskit/2.2/qiskit.transpiler.passes.RemoveBarriers

    2026

  31. [31]

    Sameer Kulkarni and John Cavazos. 2012. Mitigating the compiler optimization phase-ordering problem using machine learning. InPro- ceedings of the ACM International Conference on Object Oriented Pro- gramming Systems Languages and Applications(Tucson, Arizona, USA) (OOPSLA ’12). Association for Computing Machinery, New York, NY, USA, 147–162. doi:10.1145/...

    doi:10.1145/2384616.2384628 2012

  32. [32]

    Antonis Kyprianidis, A J Rasmusson, and Philip Richerme. 2024. Interaction graph engineering in trapped-ion quantum simulators with global drives.New Journal of Physics26, 2 (feb 2024), 023033. doi:10.1088/1367-2630/ad264d

    work page doi:10.1088/1367-2630/ad264d 2024

  33. [33]

    Ang Li, Samuel Stein, Sriram Krishnamoorthy, and James Ang. 2023. QASMBench: A Low-Level Quantum Benchmark Suite for NISQ Eval- uation and Simulation.ACM Transactions on Quantum Computing4, 2, Article 10 (Feb. 2023), 26 pages. doi:10.1145/3550488

    doi:10.1145/3550488 2023

  34. [34]

    Gushu Li, Yufei Ding, and Yuan Xie. 2019. Tackling the Qubit Map- ping Problem for NISQ-Era Quantum Devices. InProceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems(Providence, RI, USA) (ASPLOS ’19). ACM, NY, USA, 1001–1014

    2019

  35. [35]

    Lingda Li, Thomas Flynn, and Adolfy Hoisie. 2024. Learning Gener- alizable Program and Architecture Representations for Performance Modeling. InProceedings of the International Conference for High Per- formance Computing, Networking, Storage, and Analysis(Atlanta, GA, USA)(SC ’24). IEEE Press, Article 66, 15 pages. doi:10.1109/SC41406. 2024.00072

    work page doi:10.1109/sc41406 2024

  36. [36]

    Zhiding Liang, Zhixin Song, Jinglei Cheng, Hang Ren, Tianyi Hao, Rui Yang, Yiyu Shi, and Tongyang Li. 2024. Combining Parameterized Pulses and Contextual Subspace for More Practical VQE. InProceedings of the 61st ACM/IEEE Design Automation Conference. 1–6

    2024

  37. [37]

    Wan-Hsuan Lin, Daniel Bochen Tan, and Jason Cong. 2025. Reuse- Aware Compilation for Zoned Quantum Architectures Based on Neu- tral Atoms. In2025 IEEE International Symposium on High Performance Computer Architecture (HPCA). 127–142. doi:10.1109/HPCA61900.2025. 00021

    doi:10.1109/hpca61900.2025 2025

  38. [38]

    Yi Liu, Yuqiong Jin, and Jinchen Xu. 2025. A Portable Auto-Tuning Framework for Quantum Compilation Optimization Based on D3QN. InProceedings of the 2025 6th International Conference on Computer Information and Big Data Applications (CIBDA ’25). Association for Computing Machinery, New York, NY, USA, 1422–1428. doi:10.1145/ 3746709.3746950

    arXiv 2025

  39. [39]

    Peixun Long and Jianjun Zhao. 2024. Testing Multi-Subroutine Quan- tum Programs: From Unit Testing to Integration Testing.ACM Trans. Softw. Eng. Methodol.33, 6, Article 147 (June 2024), 61 pages. doi:10.1145/3656339

    doi:10.1145/3656339 2024

  40. [40]

    Ning Ma and Heng Li. 2025. Understanding and Estimating the Exe- cution Time of Quantum Circuits.ACM Trans. Softw. Eng. Methodol. (Nov. 2025). doi:10.1145/3778031Just Accepted

    work page doi:10.1145/3778031just 2025

  41. [41]

    Meta. 2026. Faiss Documentation.https://faiss.ai/index.html

    2026

  42. [42]

    Daniel Mills, Ifan Williams, Jacob Swain, Gabriel Matos, Enrico Ri- naldi, and Alexander Koziell-Pipe. 2026. Reinforcement Learning for Adaptive Composition of Quantum Circuit Optimisation Passes. arXiv:2601.21629 [quant-ph]https://arxiv.org/abs/2601.21629

    arXiv 2026

  43. [43]

    Le, Benoit Steiner, Rasmus Larsen, Yuefeng Zhou, Naveen Kumar, Mohammad Norouzi, Samy Bengio, and Jeff Dean

    Azalia Mirhoseini, Hieu Pham, Quoc V. Le, Benoit Steiner, Rasmus Larsen, Yuefeng Zhou, Naveen Kumar, Mohammad Norouzi, Samy Bengio, and Jeff Dean. 2017. Device placement optimization with rein- forcement learning. InProceedings of the 34th International Conference on Machine Learning - Volume 70(Sydney, NSW, Australia)(ICML’17). JMLR.org, 2430–2439

    2017

  44. [44]

    Juan Manuel Murillo, Jose Garcia-Alonso, Enrique Moguel, Johanna Barzen, Frank Leymann, Shaukat Ali, Tao Yue, Paolo Arcaini, Ricardo Pérez-Castillo, Ignacio García-Rodríguez de Guzmán, Mario Piattini, Antonio Ruiz-Cortés, Antonio Brogi, Jianjun Zhao, Andriy Miranskyy, and Manuel Wimmer. 2025. Quantum Software Engineering: Roadmap and Challenges Ahead.ACM ...

    doi:10.1145/3712002 2025

  45. [45]

    Paul Nation, Abdullah Ash Saki, Sebastian Brandhofer, Luciano Bello, Shelly Garion, Matthew Treinish, and Ali Javadi-Abhari. 2025. Bench- marking the performance of quantum computing software for quan- tum circuit creation, manipulation and compilation.Nature Computa- tional Science5 (04 2025), 427–435. doi:10.1038/s43588-025-00792-y

    work page doi:10.1038/s43588-025-00792-y 2025

  46. [46]

    Siyuan Niu, Adrien Suau, Gabriel Staffelbach, and Aida Todri-Sanial

  47. [47]

    doi:10.1109/TQE.2020.3026544

    A Hardware-Aware Heuristic for the Qubit Mapping Problem in the NISQ Era.IEEE Transactions on Quantum Engineering1 (2020), 1–14. doi:10.1109/TQE.2020.3026544

    doi:10.1109/tqe.2020.3026544 2020

  48. [48]

    OpenAI. 2026. GPT-OSS-120B.https://huggingface.co/openai/gpt- oss-120b

    2026

  49. [49]

    Haolin Pan, Lianghong Huang, Jinyuan Dong, Mingjie Xing, and Yanjun Wu. 2026. ECCO: Evidence-Driven Causal Reasoning for Compiler Optimization. arXiv:2602.00087 [cs.LG]https://arxiv.org/ abs/2602.00087

    arXiv 2026

  50. [50]

    Haolin Pan, Hongyu Lin, Haoran Luo, Yang Liu, Kaichun Yao, Libo Zhang, Mingjie Xing, and Yanjun Wu. 2025. Compiler-R1: Towards Agentic Compiler Auto-tuning with Reinforcement Learning. InThe Thirty-ninth Annual Conference on Neural Information Processing Sys- tems.https://openreview.net/forum?id=tY8ctrD4W2

    2025

  51. [51]

    Haolin Pan, Yuanyu Wei, Mingjie Xing, Yanjun Wu, and Chen Zhao

  52. [52]

    InProceedings of the 23rd ACM/IEEE International Symposium on Code Generation and Optimization(Las Vegas, NV, USA) (CGO ’25)

    Towards Efficient Compiler Auto-tuning: Leveraging Synergis- tic Search Spaces. InProceedings of the 23rd ACM/IEEE International Symposium on Code Generation and Optimization(Las Vegas, NV, USA) (CGO ’25). Association for Computing Machinery, New York, NY, USA, 614–627. doi:10.1145/3696443.3708961 Ming Zhong, Xiangyu Ren, Jinglei Cheng, Shaohua Li, and Zh...

    work page doi:10.1145/3696443.3708961

  53. [53]

    Sunghyun Park, Salar Latifi, Yongjun Park, Armand Behroozi, Byung- soo Jeon, and Scott Mahlke. 2022. SRTuner: effective compiler opti- mization customization by exposing synergistic relations. InProceed- ings of the 20th IEEE/ACM International Symposium on Code Generation and Optimization(Virtual Event, Republic of Korea)(CGO ’22). IEEE Press, 118–130. do...

    doi:10.1109/cgo53902.2022.9741263 2022

  54. [54]

    Love, Alán Aspuru-Guzik, and Jeremy L

    Alberto Peruzzo, Jarrod McClean, Peter Shadbolt, Man-Hong Yung, Xiao-Qi Zhou, Peter J. Love, Alán Aspuru-Guzik, and Jeremy L. O’Brien. 2014. A Variational Eigenvalue Solver on a Photonic Quantum Processor.Nature Communications5, 1 (7 2014), 7 pages. doi:10.1038/ncomms5213

    doi:10.1038/ncomms5213 2014

  55. [55]

    Lei Qiu, Zi Yang, Fang Lyu, Ming Zhong, Huimin Cui, and Xiaobing Feng. 2026. Beyond Pass-by-Pass Optimization: Intent-Driven IR Optimization with Large Language Models. arXiv:2602.18511 [cs.PL] https://arxiv.org/abs/2602.18511

    arXiv 2026

  56. [56]

    Quantinuum. 2026. PyTKET API documentation.https://docs. quantinuum.com/tket/api-docs/index.html

    2026

  57. [57]

    Nils Quetschlich, Lukas Burgholzer, and Robert Wille. 2025. Compiler Optimization for Quantum Computing Using Reinforcement Learn- ing. InProceedings of the 60th Annual ACM/IEEE Design Automation Conference(San Francisco, California, United States)(DAC ’23). IEEE Press, 1–6. doi:10.1109/DAC56929.2023.10248002

    doi:10.1109/dac56929.2023.10248002 2025

  58. [58]

    Nils Quetschlich, Lukas Burgholzer, and Robert Wille. 2025. MQT Predictor: Automatic Device Selection with Device-Specific Circuit Compilation for Quantum Computing.ACM Transactions on Quantum Computing6, 1, Article 10 (Jan. 2025), 26 pages. doi:10.1145/3673241

    doi:10.1145/3673241 2025

  59. [59]

    QWen. 2026. Qwen3-Coder: Agentic Coding in the World.https: //qwenlm.github.io/blog/qwen3-coder/

    2026

  60. [60]

    Alexey Svyatkovskiy, Shao Kun Deng, Shengyu Fu, and Neel Sun- daresan. 2020. IntelliCode Compose: Code Generation Using Trans- former. InProceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering(Virtual Event, USA)(ESEC/FSE 2020). Asso- ciation for Computing Machinery, Ne...

    doi:10.1145/3368089.3417058 2020

  61. [61]

    Siwei Tan, Liqiang Lu, Debin Xiang, Tianyao Chu, Congliang Lang, Jintao Chen, Xing Hu, and Jianwei Yin. 2025. HornBro: Homotopy-Like Method for Automated Quantum Program Repair.Proc. ACM Softw. Eng.2, FSE, Article FSE034 (June 2025), 23 pages. doi:10.1145/3715751

    doi:10.1145/3715751 2025

  62. [62]

    Cross, Frederic T

    Runzhou Tao, Yunong Shi, Jianan Yao, Xupeng Li, Ali Javadi-Abhari, Andrew W. Cross, Frederic T. Chong, and Ronghui Gu. 2022. Gi- allar: push-button verification for the qiskit Quantum compiler. In Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation(San Diego, CA, USA)(PLDI 2022). Association for C...

    doi:10.1145/3519939.3523431 2022

  63. [63]

    Smith, Joshua Viszlai, Xin-Chuan Wu, Nikos Hardavel- las, Margaret R

    Teague Tomesh, Pranav Gokhale, Victory Omole, Gokul Subramanian Ravi, Kaitlin N. Smith, Joshua Viszlai, Xin-Chuan Wu, Nikos Hardavel- las, Margaret R. Martonosi, and Frederic T. Chong. 2022. SupermarQ: A Scalable Quantum Benchmark Suite. In2022 IEEE International Sym- posium on High-Performance Computer Architecture (HPCA). 587–603. doi:10.1109/HPCA53966....

    doi:10.1109/hpca53966.2022.00050 2022

  64. [64]

    Lukas Trümper, Tal Ben-Nun, Philipp Schaad, Alexandru Calotoiu, and Torsten Hoefler. 2023. Performance Embeddings: A Similarity- Based Transfer Tuning Approach to Performance Optimization. InPro- ceedings of the 37th ACM International Conference on Supercomputing (Orlando, FL, USA)(ICS ’23). Association for Computing Machinery, New York, NY, USA, 50–62. d...

    doi:10.1145/3577193.3593714 2023

  65. [65]

    Sanjay Vishwakarma, Francis Harkins, Siddharth Golecha, Vishal Sharathchandra Bajpe, Nicolas Dupuis, Luca Buratti, David Kremer, Ismael Faro, Ruchir Puri, and Juan Cruz-Benito

  66. [66]

    arXiv:2406.14712 [quant-ph] https://arxiv.org/abs/2406.14712

    Qiskit HumanEval: An Evaluation Benchmark For Quan- tum Code Generative Models. arXiv:2406.14712 [quant-ph] https://arxiv.org/abs/2406.14712

    Pith/arXiv arXiv

  67. [67]

    Pan, Frederic T

    Hanrui Wang, Zhiding Liang, Jiaqi Gu, Zirui Li, Yongshan Ding, Wei- wen Jiang, Yiyu Shi, David Z. Pan, Frederic T. Chong, and Song Han

  68. [68]

    InPro- ceedings of the 41st IEEE/ACM International Conference on Computer- Aided Design(San Diego, California)(ICCAD ’22)

    TorchQuantum Case Study for Robust Quantum Circuits. InPro- ceedings of the 41st IEEE/ACM International Conference on Computer- Aided Design(San Diego, California)(ICCAD ’22). Association for Computing Machinery, New York, NY, USA, Article 136, 9 pages. doi:10.1145/3508352.3561118

    doi:10.1145/3508352.3561118

  69. [69]

    Jiyuan Wang, Qian Zhang, Guoqing Harry Xu, and Miryung Kim

  70. [70]

    In 2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE)

    QDiff: Differential Testing of Quantum Software Stacks. In 2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE Press, Melbourne, Australia, 692–704. doi:10. 1109/ASE51524.2021.9678792

    arXiv 2021

  71. [71]

    Xinyi Wang, Shaukat Ali, Tao Yue, and Paolo Arcaini. 2024. Quantum Approximate Optimization Algorithm for Test Case Optimization. IEEE Transactions on Software Engineering50, 12 (2024), 3249–3264. doi:10.1109/TSE.2024.3479421

    work page doi:10.1109/tse.2024.3479421 2024

  72. [72]

    Shangzhou Xia, Jianjun Zhao, Fuyuan Zhang, and Xiaoyu Guo. 2025. Quantum Concolic Testing.Proc. ACM Softw. Eng.2, ISSTA, Article ISSTA051 (June 2025), 21 pages. doi:10.1145/3728926

    doi:10.1145/3728926 2025

  73. [73]

    Amanda Xu, Abtin Molavi, Swamit Tannu, and Aws Albarghouthi

  74. [74]

    InProceedings of the 30th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 1(Rotterdam, Netherlands)(ASPLOS ’25)

    Optimizing Quantum Circuits, Fast and Slow. InProceedings of the 30th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 1(Rotterdam, Netherlands)(ASPLOS ’25). Association for Computing Machinery, New York, NY, USA, 777–793. doi:10.1145/3669940.3707240

    doi:10.1145/3669940.3707240

  75. [75]

    Rui Yang, Ziruo Wang, Yuntian Gu, Yitao Liang, and Tongyang Li. 2025. QCircuitBench: A Large-Scale Dataset for Benchmarking Quantum Algorithm Design. InThe Thirty-ninth Annual Conference on Neural Information Processing Systems Datasets and Benchmarks Track.https: //openreview.net/forum?id=NkiLldW2bi

    2025

  76. [76]

    Jiayu Zhao, Chunwei Xia, and Zheng Wang. 2025. Leveraging Com- pilation Statistics for Compiler Phase Ordering. In2025 IEEE Interna- tional Parallel and Distributed Processing Symposium (IPDPS). 533–545. doi:10.1109/IPDPS64566.2025.00054

    doi:10.1109/ipdps64566.2025.00054 2025

  77. [77]

    Mingxuan Zhu, Dan Hao, and Junjie Chen. 2024. Compiler Autotuning through Multiple-phase Learning.ACM Trans. Softw. Eng. Methodol. 33, 4, Article 100 (April 2024), 38 pages. doi:10.1145/3640330

    doi:10.1145/3640330 2024

  78. [78]

    Mingxuan Zhu, Zeyu Sun, and Dan Hao. 2025. PDCAT: Preference- Driven Compiler Auto-tuning.Proc. ACM Softw. Eng.2, FSE, Article FSE039 (June 2025), 21 pages. doi:10.1145/3715756

    work page doi:10.1145/3715756 2025