research-article

Open access

Graph IRs for Impure Higher-Order Languages: Making Aggressive Optimizations Affordable with Precise Effect Dependencies

Authors:

Oliver Bračevac,

Supun Abeysinghe,

Tiark RompfAuthors Info & Claims

Proceedings of the ACM on Programming Languages, Volume 7, Issue OOPSLA2

Article No.: 236, Pages 400 - 430

https://doi.org/10.1145/3622813

Published: 16 October 2023 Publication History

Abstract

Graph-based intermediate representations (IRs) are widely used for powerful compiler optimizations, either interprocedurally in pure functional languages, or intraprocedurally in imperative languages. Yet so far, no suitable graph IR exists for aggressive global optimizations in languages with both effects and higher-order functions: aliasing and indirect control transfers make it difficult to maintain sufficiently granular dependency information for optimizations to be effective. To close this long-standing gap, we propose a novel typed graph IR combining a notion of reachability types with an expressive effect system to compute precise and granular effect dependencies at an affordable cost while supporting local reasoning and separate compilation. Our high-level graph IR imposes lexical structure to represent structured control flow and nesting, enabling aggressive and yet inexpensive code motion and other optimizations for impure higher-order programs. We formalize the new graph IR based on a λ-calculus with a reachability type-and-effect system along with a specification of various optimizations. We present performance case studies for tensor loop fusion, CUDA kernel fusion, symbolic execution of LLVM IR, and SQL query compilation in the Scala LMS compiler framework using the new graph IR. We observe significant speedups of up to 21x.

References

[1]

Yuyan Bao, Guannan Wei, Oliver Bračevac, Yuxuan Jiang, Qiyang He, and Tiark Rompf. 2021. Reachability Types: Tracking Aliasing and Separation in Higher-Order Functional Programs. Proc. ACM Program. Lang., 5, OOPSLA (2021), 139:1–139:32.

Digital Library

[2]

Yuyan Bao, Guannan Wei, Oliver Bračevac, and Tiark Rompf. 2023. Modeling Reachability Types with Logical Relations: Semantic Type Soundness, Termination, and Equational Theory. arxiv:2309.05885.

[3]

Gergö Barany and Andreas Krall. 2013. Optimal and Heuristic Global Code Motion for Minimal Spilling. In Compiler Construction - 22nd International Conference, CC 2013, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2013, Rome, Italy, March 16-24, 2013. Proceedings, Ranjit Jhala and Koen De Bosschere (Eds.) (Lecture Notes in Computer Science, Vol. 7791). Springer, 21–40. https://doi.org/10.1007/978-3-642-37051-9_2

Digital Library

[4]

Hendrik Pieter Barendregt, Marko C. J. D. van Eekelen, John R. W. Glauert, Richard Kennaway, Marinus J. Plasmeijer, and M. Ronan Sleep. 1987. Term Graph Rewriting. In PARLE, Parallel Architectures and Languages Europe, Volume II: Parallel Languages, Eindhoven, The Netherlands, June 15-19, 1987, Proceedings, J. W. de Bakker, A. J. Nijman, and Philip C. Treleaven (Eds.) (Lecture Notes in Computer Science, Vol. 259). Springer, 141–158. https://doi.org/10.1007/3-540-17945-3_8

[5]

Nick Benton, Andrew Kennedy, Lennart Beringer, and Martin Hofmann. 2009. Relational semantics for effect-based program transformations: higher-order store. In Proceedings of the 11th International ACM SIGPLAN Conference on Principles and Practice of Declarative Programming, September 7-9, 2009, Coimbra, Portugal, António Porto and Francisco Javier López-Fraguas (Eds.). ACM, 301–312. https://doi.org/10.1145/1599410.1599447

Digital Library

[6]

Nick Benton, Andrew Kennedy, Martin Hofmann, and Lennart Beringer. 2006. Reading, Writing and Relations. In Programming Languages and Systems, 4th Asian Symposium, APLAS 2006, Sydney, Australia, November 8-10, 2006, Proceedings, Naoki Kobayashi (Ed.) (Lecture Notes in Computer Science, Vol. 4279). Springer, 114–130. https://doi.org/10.1007/11924661_7

Digital Library

[7]

Oliver Bračevac, Guannan Wei, Songlin Jia, Supun Abeysinghe, Yuxuan Jiang, Yuyan Bao, and Tiark Rompf. 2023. Graph IRs for Impure Higher-Order Languages (Technical Report). arxiv:2309.08118.

[8]

Dave Clarke, Johan Östlund, Ilya Sergey, and Tobias Wrigstad. 2013. Ownership Types: A Survey. In Aliasing in Object-Oriented Programming. Types, Analysis and Verification, Dave Clarke, James Noble, and Tobias Wrigstad (Eds.) (Lecture Notes in Computer Science, Vol. 7850). Springer, 15–58. https://doi.org/10.1007/978-3-642-36946-9_3

[9]

Cliff Click. 1995. Global Code Motion / Global Value Numbering. In Proceedings of the ACM SIGPLAN’95 Conference on Programming Language Design and Implementation (PLDI), La Jolla, California, USA, June 18-21, 1995, David W. Wall (Ed.). ACM, 246–257. https://doi.org/10.1145/207110.207154

Digital Library

[10]

Cliff Click and Michael Paleczny. 1995. A Simple Graph-Based Intermediate Representation. In Proceedings ACM SIGPLAN Workshop on Intermediate Representations (IR’95), San Francisco, CA, USA, January 22, 1995, Michael D. Ernst (Ed.). ACM, 35–49. https://doi.org/10.1145/202529.202534

Digital Library

[11]

Ron Cytron, Jeanne Ferrante, Barry K. Rosen, Mark N. Wegman, and F. Kenneth Zadeck. 1991. Efficiently Computing Static Single Assignment Form and the Control Dependence Graph. ACM Trans. Program. Lang. Syst., 13, 4 (1991), 451–490. https://doi.org/10.1145/115372.115320

Digital Library

[12]

Ron Cytron, Andy Lowry, and F. Kenneth Zadeck. 1986. Code Motion of Control Structures in High-Level Languages. In Conference Record of the Thirteenth Annual ACM Symposium on Principles of Programming Languages, St. Petersburg Beach, Florida, USA, January 1986. ACM Press, 70–85. https://doi.org/10.1145/512644.512651

Digital Library

[13]

Olivier Danvy and Ulrik Pagh Schultz. 2000. Lambda-dropping: transforming recursive equations into programs with block structure. Theor. Comput. Sci., 248, 1-2 (2000), 243–287.

Digital Library

[14]

Olivier Danvy and Ulrik Pagh Schultz. 2004. Lambda-Lifting in Quadratic Time. J. Funct. Log. Program., 2004 (2004).

[15]

Olivier Danvy and Ian Zerny. 2013. Three syntactic theories for combinatory graph reduction. ACM Trans. Comput. Log., 14, 4 (2013), 29:1–29:27. https://doi.org/10.1145/2528932

Digital Library

[16]

Stephen Dolan and Alan Mycroft. 2017. Polymorphism, subtyping, and type inference in MLsub. In POPL. ACM, 60–72.

[17]

Gilles Duboscq, Lukas Stadler, Thomas Würthinger, Doug Simon, Christian Wimmer, and Hanspeter Mössenböck. 2013. Graal IR: An extensible declarative intermediate representation. In Proceedings of the Asia-Pacific Programming Languages and Compilers Workshop.

[18]

Jana Dunfield and Neel Krishnaswami. 2022. Bidirectional Typing. ACM Comput. Surv., 54, 5 (2022), 98:1–98:38.

[19]

Conal Elliott, Sigbjørn Finne, and Oege de Moor. 2003. Compiling embedded languages. J. Funct. Program., 13, 3 (2003), 455–481. https://doi.org/10.1017/S0956796802004574

Digital Library

[20]

Grégory M. Essertel, Ruby Y. Tahboub, James M. Decker, Kevin J. Brown, Kunle Olukotun, and Tiark Rompf. 2018. Flare: Optimizing Apache Spark with Native Compilation for Scale-Up Architectures and Medium-Size Data. In OSDI. USENIX Association, 799–815.

Digital Library

[21]

Jeanne Ferrante, Karl J. Ottenstein, and Joe D. Warren. 1987. The Program Dependence Graph and Its Use in Optimization. ACM Trans. Program. Lang. Syst., 9, 3 (1987), 319–349. https://doi.org/10.1145/24039.24041

Digital Library

[22]

Jiří Filipovič, Matúš Madzin, Jan Fousek, and Luděk Matyska. 2015. Optimizing CUDA code by kernel fusion: application on BLAS. The Journal of Supercomputing, 3934–3957. https://doi.org/10.1007/s11227-015-1483-z

Digital Library

[23]

Cormac Flanagan, Amr Sabry, Bruce F. Duba, and Matthias Felleisen. 1993. The Essence of Compiling with Continuations. In Proceedings of the ACM SIGPLAN’93 Conference on Programming Language Design and Implementation (PLDI), Albuquerque, New Mexico, USA, June 23-25, 1993, Robert Cartwright (Ed.). ACM, 237–247. https://doi.org/10.1145/155090.155113

Digital Library

[24]

Colin S. Gordon. 2021. Polymorphic Iterable Sequential Effect Systems. ACM Trans. Program. Lang. Syst., 43, 1 (2021), Article 4, April, 79 pages. issn:0164-0925 https://doi.org/10.1145/3450272

Digital Library

[25]

Bastian Hagedorn, Johannes Lenfers, Thomas Koehler, Xueying Qin, Sergei Gorlatch, and Michel Steuwer. 2020. Achieving high-performance the functional way: A functional pearl on expressing high-performance optimizations as rewrite strategies. Proc. ACM Program. Lang., 4, ICFP (2020), 92:1–92:29. https://doi.org/10.1145/3408974

Digital Library

[26]

John Hatcliff and Olivier Danvy. 1994. A Generic Account of Continuation-Passing Styles. In POPL. ACM Press, 458–471.

[27]

Troels Henriksen, Niels G. W. Serup, Martin Elsman, Fritz Henglein, and Cosmin E. Oancea. 2017. Futhark: Purely functional GPU-programming with nested parallelism and in-place array updates. In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2017, Barcelona, Spain, June 18-23, 2017, Albert Cohen and Martin T. Vechev (Eds.). ACM, 556–571. https://doi.org/10.1145/3062341.3062354

Digital Library

[28]

David Van Horn and Harry G. Mairson. 2008. Deciding kCFA is complete for EXPTIME. In Proceeding of the 13th ACM SIGPLAN international conference on Functional programming, ICFP 2008, Victoria, BC, Canada, September 20-28, 2008, James Hook and Peter Thiemann (Eds.). ACM, 275–282. https://doi.org/10.1145/1411204.1411243

Digital Library

[29]

Thomas Johnsson. 1984. Efficient compilation of lazy evaluation. In Proceedings of the 1984 SIGPLAN Symposium on Compiler Construction, Montreal, Canada, June 17-22, 1984, Mary S. Van Deusen and Susan L. Graham (Eds.). ACM, 58–69. https://doi.org/10.1145/502874.502880

Digital Library

[30]

Thomas Johnsson. 1985. Lambda Lifting: Treansforming Programs to Recursive Equations. In FPCA (Lecture Notes in Computer Science, Vol. 201). Springer, 190–203.

[31]

Ralf Jung, Jacques-Henri Jourdan, Robbert Krebbers, and Derek Dreyer. 2021. Safe systems programming in Rust. Commun. ACM, 64, 4 (2021), 144–152.

Digital Library

[32]

Robert Kennedy, Sun Chan, Shin-Ming Liu, Raymond Lo, Peng Tu, and Fred Chow. 1999. Partial Redundancy Elimination in SSA Form. ACM Trans. Program. Lang. Syst., 21, 3 (1999), may, 627–676. issn:0164-0925 https://doi.org/10.1145/319301.319348

Digital Library

[33]

Jens Knoop, Oliver Rüthing, and Bernhard Steffen. 1992. Lazy Code Motion. In Proceedings of the ACM SIGPLAN 1992 Conference on Programming Language Design and Implementation (PLDI ’92). Association for Computing Machinery, New York, NY, USA. 224–234. isbn:0897914759 https://doi.org/10.1145/143095.143136

Digital Library

[34]

Jens Knoop, Oliver Rüthing, and Bernhard Steffen. 1992. Lazy Code Motion. In Proceedings of the ACM SIGPLAN’92 Conference on Programming Language Design and Implementation (PLDI), San Francisco, California, USA, June 17-19, 1992, Stuart I. Feldman and Richard L. Wexelblat (Eds.). ACM, 224–234. https://doi.org/10.1145/143095.143136

Digital Library

[35]

Jens Knoop, Oliver Rüthing, and Bernhard Steffen. 1994. Optimal Code Motion: Theory and Practice. ACM Trans. Program. Lang. Syst., 16, 4 (1994), 1117–1155. https://doi.org/10.1145/183432.183443

Digital Library

[36]

Chris Lattner and Vikram S. Adve. 2004. LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation. In 2nd IEEE / ACM International Symposium on Code Generation and Optimization (CGO 2004), 20-24 March 2004, San Jose, CA, USA. IEEE Computer Society, 75–88. https://doi.org/10.1109/CGO.2004.1281665

[37]

Chris Lattner, Mehdi Amini, Uday Bondhugula, Albert Cohen, Andy Davis, Jacques A. Pienaar, River Riddle, Tatiana Shpeisman, Nicolas Vasilache, and Oleksandr Zinenko. 2021. MLIR: Scaling Compiler Infrastructure for Domain Specific Computation. In CGO. IEEE, 2–14.

Digital Library

[38]

Roland Leiß a, Marcel Köster, and Sebastian Hack. 2015. A graph-based higher-order intermediate representation. In CGO. IEEE Computer Society, 202–212.

[39]

Nicholas D. Matsakis and Felix S. Klock. 2014. The rust language. In Proceedings of the 2014 ACM SIGAda annual conference on High integrity language technology, HILT 2014, Portland, Oregon, USA, October 18-21, 2014, Michael Feldman and S. Tucker Taft (Eds.). ACM, 103–104. https://doi.org/10.1145/2663171.2663188

Digital Library

[40]

Jan Midtgaard. 2012. Control-flow analysis of functional programs. ACM Comput. Surv., 44, 3 (2012), 10:1–10:33.

[41]

Matthew Might. 2007. Environment Analysis of Higher-Order Languages. Ph.D. Dissertation. Georgia Institute of Technology, Atlanta, GA, USA.

Digital Library

[42]

Matthew Might, Yannis Smaragdakis, and David Van Horn. 2010. Resolving and exploiting the k-CFA paradox: illuminating functional vs. object-oriented program analysis. In PLDI. ACM, 305–315.

[43]

Marco T. Morazán and Ulrik Pagh Schultz. 2007. Optimal Lambda Lifting in Quadratic Time. In IFL (Lecture Notes in Computer Science, Vol. 5083). Springer, 37–56.

[44]

Greg Nelson and Derek C. Oppen. 1980. Fast Decision Procedures Based on Congruence Closure. J. ACM, 27, 2 (1980), 356–364. https://doi.org/10.1145/322186.322198

Digital Library

[45]

Thomas Neumann. 2011. Efficiently Compiling Efficient Query Plans for Modern Hardware. Proc. VLDB Endow., 4, 9 (2011), 539–550.

Digital Library

[46]

James Noble, Jan Vitek, and John Potter. 1998. Flexible Alias Protection. In ECOOP’98 - Object-Oriented Programming, 12th European Conference, Brussels, Belgium, July 20-24, 1998, Proceedings, Eric Jul (Ed.) (Lecture Notes in Computer Science, Vol. 1445). Springer, 158–185. https://doi.org/10.1007/BFb0054091

[47]

Martin Odersky and Konstantin Läufer. 1996. Putting Type Annotations to Work. In POPL. ACM Press, 54–67.

[48]

Martin Odersky, Martin Sulzmann, and Martin Wehr. 1999. Type Inference with Constrained Types. Theory Pract. Object Syst., 5, 1 (1999), 35–55.

Digital Library

[49]

Martin Odersky, Christoph Zenger, and Matthias Zenger. 2001. Colored local type inference. In POPL. ACM, 41–53.

[50]

Michael Paleczny, Christopher Vick, and Cliff Click. 2001. The Java HotSpot^ tm Server Compiler. In Proceedings of the Java Virtual Machine Research and Technology Symposium. 1, 1–12.

[51]

Lionel Parreaux. 2020. The simple essence of algebraic subtyping: principal type inference with subtyping made easy (functional pearl). Proc. ACM Program. Lang., 4, ICFP (2020), 124:1–124:28.

Digital Library

[52]

Simon L. Peyton-Jones. 1987. The Implementation of Functional Programming Languages. Prentice-Hall.

[53]

Simon L. Peyton-Jones and Jon Salkild. 1989. The Spineless Tagless G-Machine. In Proceedings of the fourth international conference on Functional programming languages and computer architecture, FPCA 1989, London, UK, September 11-13, 1989, Joseph E. Stoy (Ed.). ACM, 184–201. https://doi.org/10.1145/99370.99385

Digital Library

[54]

Benjamin C. Pierce and David N. Turner. 2000. Local Type Inference. ACM Trans. Program. Lang. Syst., 22, 1 (2000), 1–44.

Digital Library

[55]

John C. Reynolds. 2002. Separation Logic: A Logic for Shared Mutable Data Structures. In 17th IEEE Symposium on Logic in Computer Science (LICS 2002), 22-25 July 2002, Copenhagen, Denmark, Proceedings. IEEE Computer Society, 55–74. https://doi.org/10.1109/LICS.2002.1029817

[56]

Jared Roesch, Steven Lyubomirsky, Logan Weber, Josh Pollock, Marisa Kirisame, Tianqi Chen, and Zachary Tatlock. 2018. Relay: a new IR for machine learning frameworks. In Proceedings of the 2nd ACM SIGPLAN International Workshop on Machine Learning and Programming Languages, MAPL 2018, Justin Gottschlich and Alvin Cheung (Eds.). ACM, 58–68. https://doi.org/10.1145/3211346.3211348

Digital Library

[57]

Tiark Rompf. 2012. Lightweight modular staging and embedded compilers: Abstraction without regret for high-level high-performance programming. Ph.D. Dissertation. EPFL.

[58]

Tiark Rompf. 2016. The Essence of Multi-stage Evaluation in LMS. In A List of Successes That Can Change the World - Essays Dedicated to Philip Wadler on the Occasion of His 60th Birthday, Sam Lindley, Conor McBride, Philip W. Trinder, and Donald Sannella (Eds.) (Lecture Notes in Computer Science, Vol. 9600). Springer, 318–335. https://doi.org/10.1007/978-3-319-30936-1_17

[59]

Tiark Rompf and Nada Amin. 2015. Functional pearl: a SQL to C compiler in 500 lines of code. In ICFP. ACM, 2–9.

[60]

Tiark Rompf and Martin Odersky. 2010. Lightweight modular staging: a pragmatic approach to runtime code generation and compiled DSLs. In Generative Programming And Component Engineering, Proceedings of the Ninth International Conference on Generative Programming and Component Engineering, GPCE 2010, Eindhoven, The Netherlands, October 10-13, 2010, Eelco Visser and Jaakko Järvi (Eds.). ACM, 127–136. https://doi.org/10.1145/1868294.1868314

Digital Library

[61]

Tiark Rompf, Arvind K. Sujeeth, Nada Amin, Kevin J. Brown, Vojin Jovanovic, HyoukJoong Lee, Manohar Jonnalagedda, Kunle Olukotun, and Martin Odersky. 2013. Optimizing data structures in high-level programs: new directions for extensible compilers based on staging. In The 40th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL ’13, Rome, Italy - January 23 - 25, 2013, Roberto Giacobazzi and Radhia Cousot (Eds.). ACM, 497–510. https://doi.org/10.1145/2429069.2429128

Digital Library

[62]

Tiark Rompf, Arvind K. Sujeeth, HyoukJoong Lee, Kevin J. Brown, Hassan Chafi, Martin Odersky, and Kunle Olukotun. 2011. Building-Blocks for Performance Oriented DSLs. In Proceedings IFIP Working Conference on Domain-Specific Languages, DSL 2011, Bordeaux, France, 6-8th September 2011, Olivier Danvy and Chung-chieh Shan (Eds.) (EPTCS, Vol. 66). 93–117. https://doi.org/10.4204/EPTCS.66.5

[63]

Amir Shaikhha, Andrew W. Fitzgibbon, Dimitrios Vytiniotis, and Simon Peyton Jones. 2019. Efficient differentiable programming in a functional array-processing language. Proc. ACM Program. Lang., 3, ICFP (2019), 97:1–97:30. https://doi.org/10.1145/3341701

Digital Library

[64]

Olin Shivers. 1988. Control-Flow Analysis in Scheme. In Proceedings of the ACM SIGPLAN’88 Conference on Programming Language Design and Implementation (PLDI), Atlanta, Georgia, USA, June 22-24, 1988, Richard L. Wexelblat (Ed.). ACM, 164–174. https://doi.org/10.1145/53990.54007

Digital Library

[65]

Olin Shivers. 1991. Control-Flow Analysis of Higher-Order Languages or Taming Lambda. Ph.D. Dissertation. Carnegie Mellon University, PA, USA.

[66]

Olin Shivers. 2004. Higher-Order Control-Flow Analysis in Retrospect: Lessons Learned, Lessons Abandoned. In Best of PLDI. ACM, 257–269.

[67]

Lukas Stadler, Thomas Würthinger, and Hanspeter Mössenböck. 2014. Partial Escape Analysis and Scalar Replacement for Java. In 12th Annual IEEE/ACM International Symposium on Code Generation and Optimization, CGO 2014, Orlando, FL, USA, February 15-19, 2014, David R. Kaeli and Tipp Moseley (Eds.). ACM, 165.

[68]

Michel Steuwer, Toomas Remmelg, and Christophe Dubach. 2017. Lift: A functional data-parallel IR for high-performance GPU code generation. In Proceedings of the 2017 International Symposium on Code Generation and Optimization, CGO 2017, Austin, TX, USA, February 4-8, 2017, Vijay Janapa Reddi, Aaron Smith, and Lingjia Tang (Eds.). ACM, 74–85.

Digital Library

[69]

Arvind K. Sujeeth, Kevin J. Brown, HyoukJoong Lee, Tiark Rompf, Hassan Chafi, Martin Odersky, and Kunle Olukotun. 2014. Delite: A Compiler Architecture for Performance-Oriented Embedded Domain-Specific Languages. ACM Trans. Embed. Comput. Syst., 13, 4s (2014), 134:1–134:25. https://doi.org/10.1145/2584665

Digital Library

[70]

Ruby Y. Tahboub, Grégory M. Essertel, and Tiark Rompf. 2018. How to Architect a Query Compiler, Revisited. In SIGMOD Conference. ACM, 307–322.

Digital Library

[71]

Ross Tate, Michael Stepp, Zachary Tatlock, and Sorin Lerner. 2009. Equality saturation: A new approach to optimization. In Proceedings of the 36th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2009, Savannah, GA, USA, January 21-23, 2009, Zhong Shao and Benjamin C. Pierce (Eds.). ACM, 264–276. https://doi.org/10.1145/1480881.1480915

Digital Library

[72]

Amin Timany, Robbert Krebbers, Derek Dreyer, and Lars Birkedal. 2022. A Logical Approach to Type Soundness. https://iris-project.org/pdfs/2022-submitted-logical-type-soundness.pdf

[73]

Ben L. Titzer. 2015. Digging into the TurboFan JIT. http://web.archive.org/web/20220414155345/https://v8.dev/blog/turbofan-jit

[74]

TPC. 1999. TPC Benchmark H. http://web.archive.org/web/20220407033028/https://www.tpc.org/tpch/

[75]

D. A. Turner. 1979. A new implementation technique for applicative languages. Software: Practice and Experience, 9, 1 (1979), 31–49. https://doi.org/10.1002/spe.4380090105

[76]

Eelco Visser, Zine-El-Abidine Benaissa, and Andrew P. Tolmach. 1998. Building Program Optimizers with Rewriting Strategies. In Proceedings of the third ACM SIGPLAN International Conference on Functional Programming (ICFP ’98), Baltimore, Maryland, USA, September 27-29, 1998, Matthias Felleisen, Paul Hudak, and Christian Queinnec (Eds.). ACM, 13–26. https://doi.org/10.1145/289423.289425

Digital Library

[77]

Christopher Peter Wadsworth. 1971. Semantics and Pragmatics of the Lambda-Calculus. Ph.D. Dissertation. University of Oxford.

[78]

Fei Wang, Guoyang Chen, Weifeng Zhang, and Tiark Rompf. 2019. Parallel Training via Computation Graph Transformation. In 2019 IEEE International Conference on Big Data (Big Data). 3430–3439. https://doi.org/10.1109/BigData47090.2019.9006180

[79]

Fei Wang, James M. Decker, Xilun Wu, Grégory M. Essertel, and Tiark Rompf. 2018. Backpropagation with Callbacks: Foundations for Efficient and Expressive Differentiable Programming. In Advances in Neural Information Processing Systems 31: Annual Conference on Neural Information Processing Systems 2018, NeurIPS 2018, December 3-8, 2018, Montréal, Canada, Samy Bengio, Hanna M. Wallach, Hugo Larochelle, Kristen Grauman, Nicolò Cesa-Bianchi, and Roman Garnett (Eds.). 10201–10212.

[80]

Fei Wang, Daniel Zheng, James M. Decker, Xilun Wu, Grégory M. Essertel, and Tiark Rompf. 2019. Demystifying differentiable programming: shift/reset the penultimate backpropagator. Proc. ACM Program. Lang., 3, ICFP (2019), 96:1–96:31. https://doi.org/10.1145/3341700

Digital Library

[81]

Stephen Weeks. 2006. Whole-program compilation in MLton. In Proceedings of the ACM Workshop on ML, 2006, Portland, Oregon, USA, September 16, 2006, Andrew Kennedy and François Pottier (Eds.). ACM, 1. https://doi.org/10.1145/1159876.1159877

Digital Library

[82]

Guannan Wei, Oliver Bračevac, Shangyin Tan, and Tiark Rompf. 2020. Compiling symbolic execution with staging and algebraic effects. Proc. ACM Program. Lang., 4, OOPSLA (2020), 164:1–164:33. https://doi.org/10.1145/3428232

Digital Library

[83]

Guannan Wei, Oliver Bračevac, Songlin Jia, Yuyan Bao, and Tiark Rompf. 2023. Polymorphic Reachability Types: Tracking Freshness, Aliasing, and Separation in Higher-Order Generic Programs. arxiv:2307.13844.

[84]

Guannan Wei, Songlin Jia, Ruiqi Gao, Haotian Deng, Shangyin Tan, Oliver Bračevac, and Tiark Rompf. 2023. Compiling Parallel Symbolic Execution with Continuations. In ICSE. IEEE, 1316–1328.

[85]

Guannan Wei, Shangyin Tan, Oliver Bračevac, and Tiark Rompf. 2021. LLSC: a parallel symbolic execution compiler for LLVM IR. In ESEC/SIGSOFT FSE. ACM, 1495–1499.

[86]

Max Willsey, Chandrakana Nandi, Yisu Remy Wang, Oliver Flatt, Zachary Tatlock, and Pavel Panchekha. 2021. egg: Fast and extensible equality saturation. Proc. ACM Program. Lang., 5, POPL (2021), 1–29. https://doi.org/10.1145/3434304

Digital Library

[87]

Thomas Würthinger, Christian Wimmer, Andreas Wöß, Lukas Stadler, Gilles Duboscq, Christian Humer, Gregor Richards, Doug Simon, and Mario Wolczko. 2013. One VM to rule them all. In ACM Symposium on New Ideas in Programming and Reflections on Software, Onward! 2013, part of SPLASH ’13, Indianapolis, IN, USA, October 26-31, 2013, Antony L. Hosking, Patrick Th. Eugster, and Robert Hirschfeld (Eds.). ACM, 187–204. https://doi.org/10.1145/2509578.2509581

Digital Library

[88]

Ian Zerny. 2013. On graph rewriting, reduction, and evaluation in the presence of cycles. High. Order Symb. Comput., 26, 1-4 (2013), 63–84. https://doi.org/10.1007/s10990-014-9103-9

Digital Library

Cited By

Abeysinghe SXhebraj ARompf T(2024)Flan: An Expressive and Efficient Datalog Compiler for Program AnalysisProceedings of the ACM on Programming Languages10.1145/36329288:POPL(2577-2609)Online publication date: 5-Jan-2024
https://dl.acm.org/doi/10.1145/3632928
Wei GBračevac OJia SBao YRompf T(2024)Polymorphic Reachability Types: Tracking Freshness, Aliasing, and Separation in Higher-Order Generic ProgramsProceedings of the ACM on Programming Languages10.1145/36328568:POPL(393-424)Online publication date: 5-Jan-2024
https://dl.acm.org/doi/10.1145/3632856
Čugurović MVujošević Janičić MJovanović VWürthinger T(2024)GraalSP: Polyglot, efficient, and robust machine learning-based static profilerJournal of Systems and Software10.1016/j.jss.2024.112058213(112058)Online publication date: Jul-2024
https://doi.org/10.1016/j.jss.2024.112058

Index Terms

Graph IRs for Impure Higher-Order Languages: Making Aggressive Optimizations Affordable with Precise Effect Dependencies
1. Software and its engineering
  1. Software notations and tools

Recommendations

Definitional Interpreters for Higher-Order Programming Languages

Higher-order programming languages (i.e., languages in which procedures or labels can occur as values) are usually defined by interpreters that are themselves written in a programming language based on the lambda calculus (i.e., an applicative language ...
A simple separate compilation mechanism for block-structured languages

A very simple and efficient technique for the introduction of separate compilation facilities into compilers for block-structured languages is presented. Using this technique, programs may be compiled in parts while the compile-time checking advantages ...
Definitional interpreters for higher-order programming languages
ACM '72: Proceedings of the ACM annual conference - Volume 2

Higher-order programming languages (i.e., languages in which procedures or labels can occur as values) are usually defined by interpreters which are themselves written in a programming language based on the lambda calculus (i.e., an applicative language ...

Comments

Information & Contributors

Information

Published In

cover image Proceedings of the ACM on Programming Languages

Proceedings of the ACM on Programming Languages Volume 7, Issue OOPSLA2

October 2023

2250 pages

EISSN:2475-1421

DOI:10.1145/3554312

Editor:
Michael Hicks
Amazon, USA

Issue’s Table of Contents

Copyright © 2023 Owner/Author.

This work is licensed under a Creative Commons Attribution 4.0 International License.

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 16 October 2023

Published in PACMPL Volume 7, Issue OOPSLA2

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article

Funding Sources

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

3
Total Citations
View Citations
426
Total Downloads

Downloads (Last 12 months)426
Downloads (Last 6 weeks)56

Reflects downloads up to 10 Aug 2024

Other Metrics

View Author Metrics

Citations

Cited By

Abeysinghe SXhebraj ARompf T(2024)Flan: An Expressive and Efficient Datalog Compiler for Program AnalysisProceedings of the ACM on Programming Languages10.1145/36329288:POPL(2577-2609)Online publication date: 5-Jan-2024
https://dl.acm.org/doi/10.1145/3632928
Wei GBračevac OJia SBao YRompf T(2024)Polymorphic Reachability Types: Tracking Freshness, Aliasing, and Separation in Higher-Order Generic ProgramsProceedings of the ACM on Programming Languages10.1145/36328568:POPL(393-424)Online publication date: 5-Jan-2024
https://dl.acm.org/doi/10.1145/3632856
Čugurović MVujošević Janičić MJovanović VWürthinger T(2024)GraalSP: Polyglot, efficient, and robust machine learning-based static profilerJournal of Systems and Software10.1016/j.jss.2024.112058213(112058)Online publication date: Jul-2024
https://doi.org/10.1016/j.jss.2024.112058

View Options

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Get Access

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Article

Media

Figures

Other

Tables

View Issue’s Table of Contents