Building program optimizers with rewriting strategies

Abstract

We describe a language for defining term rewriting strategies, and its application to the production of program optimizers. Valid transformations on program terms can be described by a set of rewrite rules; rewriting strategies are used to describe when and how the various rules should be applied in order to obtain the desired optimization effects. Separating rules from strategies in this fashion makes it easier to reason about the behaviof of the optimizer as a whole, compared to traditional monolithic optimizer implementations. We illustrate the expressiveness of our language by using it to describe a simple optimizer for an ML-like intermediate representation.The basic strategy language uses operators such as sequential composition, choice, and recursion to build transformers from a set of labeled unconditional rewrite rules. We also define an extended language in which the sideconditions and contextual rules that arise in realistic optimizer specifications can themselves be expressed as strategydriven rewrites. We show that the features of the basic and extended languages can be expressed by breaking down the rewrite rules into their primitive building blocks, namely matching and building terms in variable binding environments. This gives us a low-level core language which has a clear semantics, can be implemented straightforwardly and can itself be optimized. The current implementation generates C code from a strategy specification.

Programming errors in traversal programs over structured data

“…Mentions of simple "laws" for strategies as well as strategy properties can be found scattered over the strategic programming literature [22,6,24,21,9,3]. The present paper provides the first substantial attempt of a systematic discussion of programming errors and their relationship to strategy properties.…”

“…We assume basic strategy combinators as they were pioneered by the Stratego language [22]: "id " -the always succeeding strategy returning the input term as is; "fail " -the always failing strategy; "sequ ss ′ " -sequential composition of s and s ′ ;" choice ss ′ " -try s first, and try s ′ second, if s failed; "all s" -apply s to all immediate subterms of a given term, and fail if there is any subterm for which s fails; "one s" -apply s to the leftmost immediate subterm of a given term such that the application does not fail, and fail if there is no such immediate subterm. The combinators all and one, when used recursively, enable the key capability of strategic programming: traversal arbitrarily deeply into terms.…”

“…Let us define some recursive strategy combinators that model traversal schemes as they appear in the literature [22,8,19]. The following folklore schemes are actually written in Haskell syntax, subject to an embedding of the aforementioned strategy combinators into Haskell.…”

“…However, there are scenarios that call for polymorphic, problem-specific constituents of traversals; cf. [22,13,14] for some concrete samples. Hence, the original (generic) schemes must be retained.…”

“…Over the last 10 years, this problem domain has triggered advances in term rewriting and general-purpose programming with rewriting-like capabilities [22,23,13,24,21] so that traversals (perhaps even highly reusable traversal strategies) are programmable.…”