Superoptimizer: a look at the smallest program
ASPLOS II Proceedings of the second international conference on Architectual support for programming languages and operating systems
Explanation-based learning: a survey of programs and perspectives
ACM Computing Surveys (CSUR)
Abstract and concrete categories
Abstract and concrete categories
Sharlit—a tool for building optimizers
PLDI '92 Proceedings of the ACM SIGPLAN 1992 conference on Programming language design and implementation
An approach for exploring code improving transformations
ACM Transactions on Programming Languages and Systems (TOPLAS)
Denali: a goal-directed superoptimizer
PLDI '02 Proceedings of the ACM SIGPLAN 2002 Conference on Programming language design and implementation
Adaptive Optimizing Compilers for the 21st Century
The Journal of Supercomputing
Improving Prolog Performance by Inductive Proof Generalizations
KBCS '89 Proceedings of the International Conference on Knowledge Based Computer Systems
Meta optimization: improving compiler heuristics with machine learning
PLDI '03 Proceedings of the ACM SIGPLAN 2003 conference on Programming language design and implementation
Type error slicing in implicitly typed higher-order languages
Science of Computer Programming - Special issue on 12th European symposium on programming (ESOP 2003)
Automated soundness proofs for dataflow analyses and transformations via local rules
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Predicting Unroll Factors Using Supervised Classification
Proceedings of the international symposium on Code generation and optimization
Automatic generation of peephole superoptimizers
Proceedings of the 12th international conference on Architectural support for programming languages and operating systems
Proceedings of the twenty-seventh ACM SIGMOD-SIGACT-SIGART symposium on Principles of database systems
Equality saturation: a new approach to optimization
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proving optimizations correct using parameterized program equivalence
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
Generalizing logic circuit designs by analyzing proofs of correctness
IJCAI'85 Proceedings of the 9th international joint conference on Artificial intelligence - Volume 1
A quantitative study of reductions in algebraic libraries
Proceedings of the 4th International Workshop on Parallel and Symbolic Computation
Equality-based translation validator for LLVM
CAV'11 Proceedings of the 23rd international conference on Computer aided verification
ITP'11 Proceedings of the Second international conference on Interactive theorem proving
POPL '13 Proceedings of the 40th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Intermediate representations in imperative compilers: A survey
ACM Computing Surveys (CSUR)
Growing solver-aided languages with rosette
Proceedings of the 2013 ACM international symposium on New ideas, new paradigms, and reflections on programming & software
Hi-index | 0.00 |
We present an automated technique for generating compiler optimizations from examples of concrete programs before and after improvements have been made to them. The key technical insight of our technique is that a proof of equivalence between the original and transformed concrete programs informs us which aspects of the programs are important and which can be discarded. Our technique therefore uses these proofs, which can be produced by translation validation or a proof-carrying compiler, as a guide to generalize the original and transformed programs into broadly applicable optimization rules. We present a category-theoretic formalization of our proof generalization technique. This abstraction makes our technique applicable to logics besides our own. In particular, we demonstrate how our technique can also be used to learn query optimizations for relational databases or to aid programmers in debugging type errors. Finally, we show experimentally that our technique enables programmers to train a compiler with application-specific optimizations by providing concrete examples of original programs and the desired transformed programs. We also show how it enables a compiler to learn efficient-to-run optimizations from expensive-to-run super-optimizers.