Pith. sign in

REVIEW 3 major objections 5 minor 61 references

Pearl: Automatic Code Optimization Using Deep Reinforcement Learning

T0 review · 3 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read A deep reinforcement learning autoscheduler learns to optimize general loop-nest programs and outperforms two established compilers.

desk verdict A credible RL autoscheduler for polyhedral loop nests with a genuinely useful action-space representation, but the 'general loop nests' claim is overbroad because the fixed 56-action space only reaches loop depth 4 and 2-D tiling. read the letter →

arxiv 2506.01880 v1 pith:3EQ7TFNS submitted 2025-06-02 cs.PL

Djamel Rassem Lamouri , Iheb Nassim Aouadj , Smail Kourta , Riyadh Baghdadi This is my paper
classification cs.PL
keywords compilercodeoptimizationreinforcementlearningpolyhedralmodellooptransformationsgraphneuralnetworksautoschedulinggeneralization
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

Pearl is an autoscheduler that uses deep reinforcement learning to choose which loop transformations to apply to a program and where to apply them. The paper's central claim is that an RL agent can learn to optimize general loop-nest programs, not just a fixed set of benchmarks, and that the learned policy transfers to programs unseen during training. If true, this would remove two limitations of earlier RL-based compilers: domain-specificity and the need to retrain for each program. The paper reports a geometric mean speedup of 2.02x over the Tiramisu autoscheduler and 3.36x over Pluto on eight benchmarks, and it presents Pearl as the first RL-based system to support polyhedral optimizations. The key to generality is a compact action space that traverses the program's syntax tree branch by branch, so one fixed set of actions can target any loop nest.

What carries the argument

The machinery that carries the argument is the fixed-size action space built on branch-by-branch AST traversal. The agent's policy network outputs one of 56 actions; each transformation action (interchange I(i,j), reversal R(i), skewing S(i,j), parallelization P(i), tiling T(i,j,x,y), unrolling U(x)) refers to loop levels by their index inside the branch the agent is currently focused on, and a 'Next' action shifts focus to the following branch. Together with a focus tag in the node features that marks the targeted iterator, this lets a single small action space address loop nests of arbitrary shape, trading the astronomically large space of (transformation, branch, iterator) triples for a traversal. The rest of the pipeline—a GATv2-based graph encoder, PPO training, log-speedup rewards, memoization of legality checks and execution times, and actor-critic pre-training—makes this action space learnable within days rather than weeks.

What would settle it

Run Pearl on a Tiramisu program whose branch contains six nested loops; the action space's largest loop index is four, so the deepest loop would be unreachable, and if the resulting schedule cannot improve the program, the generality claim fails.

Watch

Extended reading notes

Core claim

The paper claims that a PPO-trained actor-critic network, fed a graph representation of a Tiramisu program's abstract syntax tree, can output a complete schedule—a sequence of parallelization, unrolling, tiling, skewing, interchange, and reversal actions—that makes the program run faster, and that this capability transfers to programs not seen in training. The enabling representation is an action space of 56 actions that refer to loop levels by fixed indices within the currently targeted branch of the AST, plus a 'Next' action that moves the agent to the next branch; this avoids an action space that would grow with the size of the program. Rewards are the log of the speedup, so the product of intermediate speedups becomes a sum. Training is made practical by caching legality checks and execution times and by pre-training the actor-critic on execution-time prediction. On eight benchmarks, the agent achieves a geometric mean speedup of 3.16x over unoptimized code, 2.02x over Tiramisu, and 3.36x over Pluto.

Load-bearing premise

The fixed set of loop-level indices in the 56-action space assumes that every branch of a loop nest is shallow enough that its loops can be selected by those indices, so the claim of supporting general loop nests is not demonstrated for branches deeper than the largest index.

Editorial extensions

If this is right

  • An RL-based autoscheduler can replace search-based scheduling for general polyhedral programs, reducing the time to find a schedule from minutes of beam search to tens of milliseconds.
  • The branch-by-branch action space design can be reused by other polyhedral compilers that represent programs as loop-nest trees.
  • A single trained policy can be deployed as a drop-in compiler pass that optimizes benchmarks it never saw during training.
  • The memoization and pre-training techniques cut the wall-clock cost of RL training for compilers to about 45 hours, making repeated experiment-driven development feasible.
  • Because every action is checked against polyhedral dependence analysis, the agent's proposed schedules are guaranteed legal by construction.

Reading between the lines

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

  • If the generality claim holds for branches deeper than the fixed action indices cover, the same branch-by-branch design could extend to sparse or irregular loop nests by refining what counts as a branch.
  • The training programs are generated with the same methodology as the Tiramisu autoscheduler's random programs, so the reported generalization is measured against that distribution; a different training distribution might shift the benchmark speedups.
  • The 2.02x geometric mean over Tiramisu is an average over eight benchmarks with a wide spread (0.27 to 6.1), suggesting the agent's advantage is concentrated in tiling and parallelization patterns that a larger benchmark set would pin down.
  • The HalideRL comparison is limited because HalideRL trains per benchmark and crashed on three of them; a full head-to-head would require HalideRL converged on every benchmark.
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 / 5 minor

Summary. The paper presents Pearl, a PPO-based reinforcement-learning autoscheduler integrated with the Tiramisu polyhedral compiler. Programs are represented as abstract syntax trees whose nodes are encoded as fixed-size feature vectors and processed by a two-layer GATv2 graph neural network; a policy head selects among 56 discrete actions corresponding to loop transformations (interchange, reversal, skewing, parallelization, tiling, unrolling) plus a Next action that moves the focus from one AST branch to the next. Training uses 2,500 randomly generated Tiramisu programs, execution-time and legality-check memoization, and actor-critic pretraining on an execution-time prediction task. On a suite of eight benchmarks, Pearl reports a geometric mean speedup of 3.16x over unoptimized code, 2.02x over the Tiramisu autoscheduler, and 3.36x over Pluto, with an average scheduling time of 33.36 ms. The paper claims that Pearl is the first RL-based system to support general loop nests, to generalize to programs unseen during training, and to support polyhedral optimizations.

Significance. If its claims hold, Pearl is a useful empirical contribution: it demonstrates a complete RL pipeline in a realistic polyhedral compiler, introduces a branch-by-branch traversal mechanism that avoids a combinatorially large action set, and contributes two practical training accelerations (memoization and actor-critic pretraining) with ablations. The code and dataset are released, and the GNN and PPO hyperparameters are reported in detail. The reported speedups on the standard benchmark set are competitive. However, the central generality claim is broader than the implemented action space supports, and the comparative evaluation lacks sufficient protocol detail to fully substantiate the headline speedup ratios.

major comments (3)
  1. [Section 4.2.1 and Figure 5] The implemented action space is a fixed vocabulary of 56 actions with absolute loop-level indices: interchange I(0,1) through I(3,4), reversal R(0) through R(4), skewing S(0,1) through S(2,3), parallelization P(0) and P(1), 2-D tiling T(0,1,...) through T(3,4,...), and unrolling of the innermost loop. The Next action changes the focused branch but does not re-parameterize these indices, so any loop at depth 5 or deeper in a branch is unreachable by the policy, and no action can express 3-D tiling. This contradicts the paper's statements that Pearl supports 'general loop nests' and 'general programs composed of loop nests manipulating tensors.' The claim should either be narrowed to nests of depth at most 5 with 2-D tiling, or the action parameterization must be made relative to branch depth (or extended dynamically) and evaluated on deeper nests and 3-D stencils.
  2. [Section 6.3 and Table 3] The paper states that Pearl's schedule was executed 30 times and the minimum taken, but it does not state whether the Tiramisu Autoscheduler, Pluto, and HalideRL schedules were evaluated under the same protocol, on the same machine, and with the same number of repetitions. No error bars, standard deviations, or run-to-run statistics are reported. Because the headline claims are geometric mean speedups over only eight benchmarks, the comparison is not yet reproducible; please specify the exact evaluation protocol for every system and report variance statistics.
  3. [Section 4.6 and Section 6.3] The generalization claim rests on training on 2,500 randomly generated programs and evaluating on eight benchmarks, but the paper never documents the relationship between the training distribution and the benchmark suite. The reader cannot verify that the eight benchmarks are truly unseen (for example, that they are not generated by the same random generator with similar structure), and the benchmark set is small. Please explicitly confirm disjointness, describe the training-program distribution (including loop depths and branch counts), and consider adding more benchmarks or a distribution-distance analysis.
minor comments (5)
  1. [Figure 3] The caption and the figure contain the typo 'Revesral tag'; it should read 'Reversal tag.'
  2. [Section 5.2] The text attributes the initial random exploration to 'the use the epsilon greedy algorithm,' but PPO uses an entropy bonus rather than epsilon-greedy action selection; please describe the exploration mechanism accurately and fix the grammar.
  3. [Section 6.3 and Table 3] For HalideRL, three benchmarks crashed and are reported as '/', but the geometric mean of 0.23 is presented without explaining how missing entries are handled; please specify whether the geomean is computed over the available benchmarks only.
  4. [Section 6.7] There are two presentation typos: 'cost optimizations' should be 'code optimizations' and 'in33.36 milliseconds' should be 'in 33.36 milliseconds.'
  5. [Section 4.2] The text describes 'loop tiling' generically, but the action space only supports 2-D tiling; please state this limitation explicitly where the transformations are introduced.

Circularity Check

0 steps flagged · score 0.0 of 10

No load-bearing circularity: speedups are measured against external baselines; the only self-citation tie is data provenance, not a derivation step.

full rationale

Pearl makes no closed-form derivation whose conclusion is equivalent to its premises. The central claims are that a fixed 56-action policy over six loop transformations plus Next can optimize loop nests and generalize to unseen programs, and that the resulting schedules outperform Tiramisu, Pluto, and HalideRL on measured benchmarks. The speedup numbers are obtained by executing optimized code and taking the minimum of 30 runs (Section 6.3), so the reported results are measured against an external baseline, namely unoptimized execution time, rather than being algebraically forced by the reward definition. The policy is trained on 2,500 randomly generated programs and evaluated on a different benchmark suite; no benchmark speedup is used as a fitted label and then reported as a prediction. The only self-citation tie is that the training-program generation methodology and the benchmark suite are taken from Baghdadi et al. [8], which overlaps with the present authors; this affects data provenance and potential distribution overlap, but it does not make any reported speedup true by construction because the baselines, Tiramisu autoscheduler, Pluto, and HalideRL, are external systems evaluated on the same machines. The fixed action-index vocabulary in Section 4.2.1 is a coverage and generality limitation for deep nests or 3-D tiling, but that is a correctness risk, not a circularity: the paper never defines 'general loop nests' in terms of its own action space in a way that would make the claim true by definition. No circular derivation or fitted-input-renamed-as-prediction step was found.

Assumptions & free parameters 4 free parameters · 3 assumptions · 0 invented entities

No mathematical derivation is involved; the ledger captures hand-chosen architecture choices and domain assumptions on which the empirical claims rest.

free parameters (4)
  • GNN hidden size = 128
    Architecture choice selected via experiments in Section 6.4; not fitted to benchmark speedups.
  • Number of actions = 56
    Hand-fixed action space; central to the claim of covering loop transformations, but may not cover all loop nest depths.
  • Tile size range = 2 to 256 (powers of 2)
    Action parameter range chosen by design in Section 4.2.
  • Reward log base = 4
    Design choice in Section 4.5 to stabilize training; not fitted to data.
assumptions (3)
  • domain assumption Tiramisu's polyhedral legality check guarantees correctness of transformations.
    Section 4.5: 'We use classical polyhedral dependence analysis and legality checking to guarantee the correctness of transformations.' If legality check were unsound, speedups would not imply correct code.
  • domain assumption Execution time measured on the cluster (min of 30 runs) is a stable, valid reward signal.
    Section 6.3: 'we execute the schedule obtained by the RL agent 30 times before taking the minimum to reduce the effect of noise.'
  • domain assumption Randomly generated programs from Baghdadi et al. [8] form a suitable training distribution for generalizing to real benchmarks.
    Section 4.6 says training uses 2,500 randomly generated programs using the methodology of [8]; the paper does not measure distribution shift to the eight benchmark kernels.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Pearl: Automatic Code Optimization Using Deep Reinforcement Learning." pith.science (2026). https://pith.science/paper/3EQ7TFNS

@misc{pith2026250601880,
  author       = {Pith},
  title        = {Pith review of: Pearl: Automatic Code Optimization Using Deep Reinforcement Learning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/3EQ7TFNS}},
  note         = {Machine review of arXiv:2506.01880}
}
read the original abstract

Compilers are crucial in optimizing programs and accelerating their execution. However, optimizing programs automatically using compilers is not trivial. Recent work has attempted to use reinforcement learning (RL) to solve this problem. It has limitations though. Current methods either do not support the optimization of general loop nests or can only be used to optimize loop nests seen during training. In this paper, we propose Pearl, a novel framework that uses deep reinforcement learning to automate compiler code optimization. It uses an RL agent to select the sequence of code optimizations a compiler should apply to make the input code run faster. This agent can optimize general loop nests and can generalize to programs unseen during training. To enable the optimization of general loop nests, we propose a novel representation of the action space that allows the RL agent to select on which part of the loop nest a given code optimization should be applied. Training RL agents for loop nest optimization is slow and data-intensive. We accelerate this process by caching results and pre-training the agent. Integrated with the Tiramisu compiler, our approach streamlines optimization and outperforms existing methods. To the best of our knowledge, Pearl is the first RL-based system to support general programs composed of loop nests manipulating tensors while still being able to generalize to programs unseen during training. It is also the first to support the class of polyhedral optimizations, a class of advanced loop nest optimizations. We evaluate Pearl on a set of benchmarks, and demonstrate competitive performance improvements over state-of-the-art compilers. Notably, Pearl achieves a geometric mean speedup of 2.02x compared to Tiramisu and 3.36x compared to Pluto.

Figures

Figures reproduced from arXiv: 2506.01880 by the authors.

Figure 1
Figure 1. The construction of the Abstract Syntax Tree from a loop nest in a Tiramisu function. The nodes in the tree with [PITH_FULL_IMAGE:figures/full_fig_p009_1.png] view at source ↗
Figure 2
Figure 2. The process of building ℎ 𝑓 𝐺 where ⊕ produces two vectors, the first vector by summing node features 𝐻 (𝑘) and the second vector by applying element-wise maximization. These two vectors are concatenated to form ℎ (𝑘) 𝐺 , representing aggregated graph features after 𝑘 message passing steps. The ∥ symbol represents the final concatenation of vectors ℎ (𝑘) 𝐺 to construct ℎ 𝑓 𝐺 . 4 Method Description 4.1 States Represe… view at source ↗
Figure 3
Figure 3. The construction of nodes features. 4.1.1 Node Feature Representation. There are two types of nodes in the AST: iterators and computations. To make the difference between the two types, we use a vector of the same size to represent both types with different tags and padding. Using the same example as above, we will depict the details of each node representation in [PITH_FULL_IMAGE:figures/full_fig_p010_3.png] view at source ↗
Figures from the paper (8 more)
Figure 4
Figure 4. Figure 4: The graph at the left has 2 nodes colored in orange that represent the initial targeted branch. After applying [PITH_FULL_IMAGE:figures/full_fig_p012_4.png]
Figure 5
Figure 5. Figure 5: The action space 4.2.1 Detailed Actions Space. The agent’s action space consists of 56 actions, each one represents a loop transformation with its parameters [PITH_FULL_IMAGE:figures/full_fig_p012_5.png]
Figure 6
Figure 6. Figure 6: The architecture of our actor-critic agent. The backbone of this model processes the graph input and produces [PITH_FULL_IMAGE:figures/full_fig_p013_6.png]
Figure 7
Figure 7. Figure 7: The performance of three agents using different GNN layers, the y-axis represents the average [PITH_FULL_IMAGE:figures/full_fig_p019_7.png]
Figure 8
Figure 8. Figure 8: Reward Averages Across Different Experiments over Training Steps Manus [PITH_FULL_IMAGE:figures/full_fig_p019_8.png]
Figure 9
Figure 9. Figure 9: Reward Averages of our Agents With and Without Execution Time and Legality Check Memoization [PITH_FULL_IMAGE:figures/full_fig_p021_9.png]
Figure 10
Figure 10. Figure 10: Number of hits during the training of the RL agent. [PITH_FULL_IMAGE:figures/full_fig_p022_10.png]
Figure 11
Figure 11. Figure 11: Reward Averages of our Agents With and Without Actor-Critic Pre-training [PITH_FULL_IMAGE:figures/full_fig_p023_11.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

61 extracted references · 39 canonical work pages

  1. [1]

    Andrew Adams, Karima Ma, Luke Anderson, Riyadh Baghdadi, Tzu-Mao Li, Michaël Gharbi, Benoit Steiner, Steven Johnson, Kayvon Fatahalian, Frédo Durand, and Jonathan Ragan-Kelley. 2019. Learning to Optimize Halide with Tree Search and Random Programs. ACM Trans. Graph. 38, 4, Article 121 (jul 2019), 12 pages. https://doi.org/10.1145/3306346.3322967

    arXiv 2019

  2. [2]

    Byung Hoon Ahn, Prannoy Pilligundla, Amir Yazdanbakhsh, and Hadi Esmaeilzadeh. 2020. Chameleon: Adaptive Code Optimiza- tion for Expedited Deep Neural Network Compilation. arXiv:2001.08743

    arXiv 2020

  3. [3]

    Mohamed Riyadh Baghdadi. 2015. Improving tiling, reducing compilation time, and extending the scope of polyhedral compilation . Ph. D. Dissertation. Paris 6

    work page 2015

  4. [4]

    Riyadh Baghdadi, Albert Cohen, Cedric Bastoul, Louis-Noel Pouchet, and Lawrence Rauchwerger. 2011. The Potential of Synergistic Static, Dynamic and Speculative Loop Nest Optimizations for Automatic Parallelization. arXiv:1111.6756 [cs.DC]

    work page Pith review arXiv 2011

  5. [5]

    Riyadh Baghdadi, Albert Cohen, Tobias Grosser, Sven Verdoolaege, Javed Absar, Sven Van Haastregt, Alexey Kravets, Anton Lokhmotov, and Alastair Donaldson. 2015. PENCIL Language Specification. Ph. D. Dissertation. INRIA

    work page 2015

  6. [6]

    Riyadh Baghdadi, Albert Cohen, Serge Guelton, Sven Verdoolaege, Jun Inoue, Tobias Grosser, Georgia Kouveli, Alexey Kravets, Anton Lokhmotov, Cedric Nugteren, et al. 2013. PENCIL: Towards a platform-neutral compute intermediate language for DSLs. arXiv preprint arXiv:1302.5586 (2013). Manuscript submitted to ACM Pearl: Automatic Code Optimization Using Dee...

    work page Pith review arXiv 2013

  7. [7]

    Riyadh Baghdadi, Abdelkader Nadir Debbagh, Kamel Abdous, Fatima Zohra Benhamida, Alex Renda, Jonathan Elliott Frankle, Michael Carbin, and Saman Amarasinghe. 2020. TIRAMISU: A Polyhedral Compiler for Dense and Sparse Deep Learning. arXiv:2005.04091 [cs.DC]

    work page Pith review arXiv 2020

  8. [8]

    Riyadh Baghdadi, Massinissa Merouani, Mohamed-Hicham Leghettas, Kamel Abdous, Taha Arbaoui, Karima Benatchba, et al

    work page

Show all 61 references
  1. [9]

    Riyadh Baghdadi, Jessica Ray, Malek Ben Romdhane, Emanuele Del Sozzo, Abdurrahman Akkas, Yunming Zhang, Patricia Suriana, Shoaib Kamil, and Saman Amarasinghe. 2019. Tiramisu: A polyhedral compiler for expressing fast and portable code. In 2019 IEEE/ACM International Symposium ...

    2019

  2. [10]

    Riyadh Baghdadi, Jessica Ray, Malek Ben Romdhane, Emanuele Del Sozzo, Patricia Suriana, Shoaib Kamil, and Saman P Ama- rasinghe. 2018. Tiramisu: A code optimization framework for high performance systems. arXiv preprint arXiv:1804.10694 (2018)

    2018 arXiv

  3. [11]

    Uday Bondhugula, Albert Hartono, J Ramanujam, and P Sadayappan. 2008. Pluto: A practical and fully automatic polyhedral program optimization system. In Proceedings of the ACM SIGPLAN 2008 Conference on Programming Language Design and Implementation (PLDI 08), Tucson, AZ (June ...

    2008

  4. [12]

    Uday Bondhugula, Albert Hartono, Jagannathan Ramanujam, and Ponnuswamy Sadayappan. 2008. A practical automatic polyhedral parallelizer and locality optimizer. In Proceedings of the 29th ACM SIGPLAN Conference on Programming Language Design and Implementation. 101–113

    2008

  5. [13]

    Ramanujam, and P

    Uday Bondhugula, Albert Hartono, J. Ramanujam, and P. Sadayappan. 2008. A practical automatic polyhedral parallelizer and locality optimizer. In PLDI. 101–113

    2008

  6. [14]

    Alexander Brauckmann, Andrés Goens, and Jeronimo Castrillon. 2021. A reinforcement learning environment for polyhedral optimizations. arXiv preprint arXiv:2104.13732 (2021)

    2021 arXiv

  7. [15]

    Shaked Brody, Uri Alon, and Eran Yahav. 2022. How Attentive are Graph Attention Networks? arXiv:2105.14491 [cs.LG]

    2022 arXiv

  8. [16]

    Tianqi Chen, Thierry Moreau, Ziheng Jiang, Lianmin Zheng, Eddie Yan, Meghan Cowan, Haichen Shen, Leyuan Wang, Yuwei Hu, Luis Ceze, et al. 2018. TVM: An automated end-to-end optimizing compiler for deep learning. arXiv preprint arXiv:1802.04799 (2018)

    2018 arXiv

  9. [17]

    Tianqi Chen, Lianmin Zheng, Eddie Yan, Ziheng Jiang, Thierry Moreau, Luis Ceze, Carlos Guestrin, and Arvind Krishnamurthy

  10. [18]

    Chris Cummins, Bram Wasti, Jiadong Guo, Brandon Cui, Jason Ansel, Sahir Gomez, Somya Jain, Jia Liu, Olivier Teytaud, Benoit Steiner, et al. 2022. Compilergym: Robust, performant compiler optimization environments for ai research. In 2022 IEEE/ACM International Symposium on Cod...

    2022

  11. [19]

    Alain Darte and Guillaume Huard. 2005. New Complexity Results on Array Contraction and Related Problems. J. VLSI Signal Process. Syst. 40, 1 (May 2005), 35–55. https://doi.org/10.1007/s11265-005-4937-3

    2005 doi

  12. [20]

    Feautrier

    P. Feautrier. 1988. Array expansion. In Proceedings of the 2nd international conference on Supercomputing . ACM, St. Malo, France, 429–441. https://doi.org/10.1145/55364.55406

    1988

  13. [21]

    2011.Polyhedron Model

    Paul Feautrier and Christian Lengauer. 2011.Polyhedron Model. Springer US, Boston, MA, 1581–1592. https://doi.org/10.1007/978- 0-387-09766-4_502

    2011 doi

  14. [22]

    Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. 2017. Neural message passing for quantum chemistry. In International conference on machine learning . PMLR, 1263–1272

    2017

  15. [23]

    Sadayappan, and Sven Verdoolaege

    Tobias Grosser, Albert Cohen, Justin Holewinski, P. Sadayappan, and Sven Verdoolaege. 2014. Hybrid Hexagonal/Classical Tiling for GPUs. In Proceedings of Annual IEEE/ACM International Symposium on Code Generation and Optimization (Orlando, FL, USA) (CGO ’14). ACM, New York, NY...

    2014

  16. [24]

    Tobias Grosser, Armin Groslinger, and Christian Lengauer. 2012. Polly - Performing Polyhedral Optimizations on a Low- Level Intermediate Representation. Parallel Processing Letters 22, 4 (2012). http://dblp.uni-trier.de/db/journals/ppl/ppl22.html# Manuscript submitted to ACM 2...

    2012

  17. [25]

    Ameer Haj-Ali, Hasan Genc, Qijing Huang, William Moses, John Wawrzynek, Krste Asanović, and Ion Stoica. 2020. Protuner: tuning programs with monte carlo tree search. arXiv preprint arXiv:2005.13685 (2020)

    2020 arXiv

  18. [26]

    Yacine Hakimi, Riyadh Baghdadi, and Yacine Challal. 2023. A hybrid machine learning model for code optimization. International Journal of Parallel Programming 51, 6 (2023), 309–331

    2023

  19. [27]

    Will Hamilton, Zhitao Ying, and Jure Leskovec. 2017. Inductive representation learning on large graphs. Advances in neural information processing systems 30 (2017)

    2017

  20. [28]

    Guoliang He, Sean Parker, and Eiko Yoneki. 2023. X-RLflow: Graph Reinforcement Learning for Neural Network Subgraphs Transformation. arXiv:2304.14698 [cs.LG] https://arxiv.org/abs/2304.14698

    2023 arXiv

  21. [29]

    Qijing Huang, Ameer Haj-Ali, William Moses, John Xiang, Ion Stoica, Krste Asanovic, and John Wawrzynek. 2020. Autophase: Juggling hls phase orderings in random forests with deep reinforcement learning. arXiv preprint arXiv:2003.00671 (2020)

    2020 arXiv

  22. [30]

    Wang Huanting, Tang Zhanyong, Zhang Cheng, Zhao Jiaqi, Cummins Chris, Leather Hugh, and Wang Zheng. 2022. Automating Reinforcement Learning Architecture Design for Code Optimization. In Proceedings of the 31st ACM SIGPLAN International Conference on Compiler Construction (Seou...

    2022

  23. [31]

    Irigoin and R

    F. Irigoin and R. Triolet. 1988. Supernode Partitioning. In (POPL’88). San Diego, CA, 319–328

    1988

  24. [32]

    Thomas N Kipf and Max Welling. 2016. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907 (2016)

    2016 arXiv

  25. [33]

    Günter Klambauer, Thomas Unterthiner, Andreas Mayr, and Sepp Hochreiter. 2017. Self-normalizing neural networks. Advances in neural information processing systems 30 (2017)

    2017

  26. [34]

    Vincent Lefebvre and Paul Feautrier. 1998. Automatic storage management for parallel programs. Parallel Comput. 24 (1998), 649–671. https://doi.org/10.1016/S0167-8191(98)00029-5

    1998 doi

  27. [35]

    Chunting Liu and Riyadh Baghdadi. 2025. Data-Efficient Performance Modeling via Pre-training. In Proceedings of the 34th ACM SIGPLAN International Conference on Compiler Construction . 48–59

    2025

  28. [36]

    Yizhi Liu, Yao Wang, Ruofei Yu, Mu Li, Vin Sharma, and Yida Wang. 2019. Optimizing{CNN} model inference on{CPUs}. In 2019 USENIX Annual Technical Conference (USENIX ATC 19) . 1025–1040

    2019

  29. [37]

    Moshe Looks, Marcello Herreshoff, DeLesley Hutchins, and Peter Norvig. 2017. Deep Learning with Dynamic Computation Graphs. arXiv:1702.02181

    2017 arXiv

  30. [38]

    Massinissa Merouani, Khaled Afif Boudaoud, Iheb Nassim Aouadj, Nassim Tchoulak, Islem Kara Bernou, Hamza Benyamina, Fatima Benbouzid-Si Tayeb, Karima Benatchba, Hugh Leather, and Riyadh Baghdadi. 2024. LOOPer: A Learned Automatic Code Optimizer For Polyhedral Compilers. arXiv ...

    2024

  31. [39]

    2020.A deep learning based cost model for automatic code optimization in tiramisu

    Massinissa Merouani, Mohamed-Hicham Leghettas, Riyadh Baghdadi, Taha Arbaoui, and Karima Benatchba. 2020.A deep learning based cost model for automatic code optimization in tiramisu . Ph. D. Dissertation. PhD thesis, 10 2020

    2020

  32. [40]

    Lina Mezdour, Khadidja Kadem, Massinissa Merouani, Amina Selma Haichour, Saman Amarasinghe, and Riyadh Baghdadi. 2023. A deep learning model for loop interchange. In Proceedings of the 32nd ACM SIGPLAN International Conference on Compiler Construction. 50–60

    2023

  33. [41]

    Ravi Teja Mullapudi, Andrew Adams, Dillon Sharlet, Jonathan Ragan-Kelley, and Kayvon Fatahalian. 2016. Automatically Scheduling Halide Image Processing Pipelines. ACM Trans. Graph. 35, 4, Article 83 (jul 2016), 11 pages. https://doi.org/10.1145/ 2897824.2925952

    2016

  34. [42]

    Aditya Paliwal, Felix Gimeno, Vinod Nair, Yujia Li, Miles Lubin, Pushmeet Kohli, and Oriol Vinyals. 2020. Reinforced Genetic Algorithm Learning for Optimizing Computation Graphs. arXiv:1905.02494

    2020 arXiv

  35. [43]

    Marcelo Pecenin, André Murbach Maidl, and Daniel Weingaertner. 2019. Optimization of halide image processing schedules with reinforcement learning. In Anais do XX Simpósio em Sistemas Computacionais de Alto Desempenho . SBC, 37–48. Manuscript submitted to ACM Pearl: Automatic ...

    2019

  36. [44]

    Louis-Noël Pouchet et al. 2012. Polybench: The polyhedral benchmark suite. URL: http://www. cs. ucla. edu/pouchet/software/poly- bench 437 (2012), 1–1

    2012

  37. [45]

    Ramanujam, P

    Louis-Noël Pouchet, Uday Bondhugula, Cédric Bastoul, Albert Cohen, J. Ramanujam, P. Sadayappan, and Nicolas Vasilache

  38. [46]

    Quilleré and S

    F. Quilleré and S. Rajopadhye. 2000. Optimizing Memory Usage in the Polyhedral Model. ACM Trans. on Programming Languages and Systems 22, 5 (Sept. 2000), 773–815

    2000

  39. [47]

    Jonathan Ragan-Kelley, Connelly Barnes, Andrew Adams, Sylvain Paris, Frédo Durand, and Saman Amarasinghe. 2013. Halide: A Language and Compiler for Optimizing Parallelism, Locality, and Recomputation in Image Processing Pipelines. SIGPLAN Not. 48, 6 (jun 2013), 519–530. https:...

    2013

  40. [48]

    John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. 2017. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347 (2017)

    2017 arXiv

  41. [49]

    Sutton and A.G

    R.S. Sutton and A.G. Barto. 2018. Reinforcement Learning, second edition: An Introduction . MIT Press. https://books.google.dz/ books?id=sWV0DwAAQBAJ

    2018

  42. [50]

    William Thies, Frédéric Vivien, Jeffrey Sheldon, and Saman Amarasinghe. 2001. A unified framework for schedule and storage optimization. In Proc. of the 2001 PLDI Conf

    2001

  43. [51]

    Konrad Trifunovic, Albert Cohen, David Edelsohn, Feng Li, Tobias Grosser, Harsha Jagasia, Razya Ladelsky, Sebastian Pop, Jan Sjodin, and Ramakrishna Upadrasta. 2010. GRAPHITE Two Years After: First Lessons Learned From Real-World Polyhedral Compilation

    2010

  44. [52]

    Nicolas Vasilache, Cedric Bastoul, Albert Cohen, and Sylvain Girbal. 2006. Violated Dependence Analysis. In Proceedings of the 20th Annual International Conference on Supercomputing (Cairns, Queensland, Australia) (ICS ’06). Association for Computing Machinery, New York, NY, U...

    2006

  45. [54]

    Nicolas Vasilache, Oleksandr Zinenko, Theodoros Theodoridis, Priya Goyal, Zachary DeVito, William S Moses, Sven Verdoolaege, Andrew Adams, and Albert Cohen. 2018. Tensor comprehensions: Framework-agnostic high-performance machine learning abstractions. arXiv preprint arXiv:180...

    2018 arXiv

  46. [55]

    Sven Verdoolaege, Juan Carlos Juega, Albert Cohen, José Ignacio Gómez, Christian Tenllado, and Francky Catthoor. 2013. Polyhedral parallel code generation for CUDA. ACM Trans. Archit. Code Optim. 9, 4, Article 54 (jan 2013), 23 pages. https: //doi.org/10.1145/2400682.2400713

    2013

  47. [56]

    Michael E Wolf and Monica S Lam. 1991. A loop transformation theory and an algorithm to maximize parallelism. IEEE transactions on parallel and distributed systems 2, 4 (1991), 452–471

    1991

  48. [57]

    Lianmin Zheng, Chengfan Jia, Minmin Sun, Zhao Wu, Cody Hao Yu, Ameer Haj-Ali, Yida Wang, Jun Yang, Danyang Zhuo, Koushik Sen, et al. 2020. Ansor: Generating{High-Performance} tensor programs for deep learning. In 14th USENIX symposium on operating systems design and implementa...

    2020

  49. [58]

    Gonzalez, and Ion Stoica

    Lianmin Zheng, Chengfan Jia, Minmin Sun, Zhao Wu, Cody Hao Yu, Ameer Haj-Ali, Yida Wang, Jun Yang, Danyang Zhuo, Koushik Sen, Joseph E. Gonzalez, and Ion Stoica. 2023. Ansor: Generating High-Performance Tensor Programs for Deep Learning. arXiv:2006.06762

    2023 arXiv

  50. [59]

    Zhen Zheng, Pengzhan Zhao, Guoping Long, Feiwen Zhu, Kai Zhu, Wenyi Zhao, Lansong Diao, Jun Yang, and Wei Lin. 2021. FusionStitching: Boosting Memory Intensive Computations for Deep Learning Workloads. arXiv:2009.10924 Manuscript submitted to ACM

    2021 arXiv

  51. [2011]

    In 38th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages (POPL’11)

    Loop Transformations: Convexity, Pruning and Optimization. In 38th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages (POPL’11). ACM Press, Austin, TX, 549–562

  52. [2019]

    arXiv:1805.08166

    Learning to Optimize Tensor Programs. arXiv:1805.08166

    arXiv

  53. [2021]

    Proceedings of Machine Learning and Systems 3 (2021), 181–193

    A deep learning based cost model for automatic code optimization. Proceedings of Machine Learning and Systems 3 (2021), 181–193

    2021

Pith tools

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