A partial evaluator, and its use for compiling iterative statements in LISP

Haraldsson, Anders

doi:10.1145/512760.512781

Cited by 14 publications

(9 citation statements)

References 2 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…A large partial evaluator for Lisp as used in practice, with imperative features and property lists, was described in Beckman et al [2]. This work included the use of partial evaluators to translate programs in various languages, as did Haraldsson [22], Emanuelson and Haraldsson [13], and (in the United States) Turchin et al [51]. At the same time, trends to recognize partial evaluation as an important tool appeared among dedicated builders of compiler generators [39,40].…”

Section: Historical Notesmentioning

confidence: 99%

Mix: A self-applicable partial evaluator for experiments in compiler generation

Jones

Sestoft

Søndergaard

1989

Lisp and Symbolic Computation

197

View full text Add to dashboard Cite

Abstract, The program transformation principle called partial evaluation has interesting applications in compilation and compiler generation. Self-applicable partial evaluators may be used for transforming interpreters into corresponding compilers and even for the generation of compiler generators. This is useful because interpreters are significantly easier to write than compilers, but run much slower than compiled code. A major difficulty in writing compilers (and compiler generators) is the thinking in terms of distinct binding times: run time and compile time (and compiler generation time). The paper gives an introduction to partial evaluation and describes a fully automatic though experimental partial evaluator, called mix, able to generate stand-alone compilers as well as a compiler generator. Mix partially evaluates programs written in Mixwell, essentially a first-order subset of statically scoped pure Lisp. For compiler generation purposes it is necessary that the partial evaluator be self-applicable. Even though the potential utility of a self-applicable partial evaluator has been recognized since 1971, a 1984 version of mix appears to be the first successful implementation. The overall structure of mix and the basic ideas behind its way of working are sketched. Finally, some results of using a version of mix are reported.Since the early 1970s it has been k n o w n that in theory, the p r o g r a m transformation principle called partial evaluation can be used for compiling and compiler generation, and even for the a u t o m a t i c generation o f a compiler generator. A partial evaluator able to generate stand-alone compilers and compiler generators had not, however, been successfully implemented before 1984 when the first mix system was brought to work at the University o f Copenhagen.In this paper we discuss partial evaluation and its applications to compiler generation and sketch the partial evaluator we developed, called the mix system. The results we report are sufficiently r e m a r k a b l e to justify further research into using partial evaluation for compiler generation purposes. We also mention other applications. The description here is essentially a snapshot of the mix system and its applications as of early 1987.A partial evaluator m a y be thought of as a " s m a r t interpreter." If an ordinary interpreter is given a p r o g r a m and only part o f this p r o g r a m ' s input data, it will leave * Current address:

show abstract

Section: Historical Notesmentioning

confidence: 99%

Mix: A self-applicable partial evaluator for experiments in compiler generation

Jones

Sestoft

Søndergaard

1989

Lisp and Symbolic Computation

197

View full text Add to dashboard Cite

show abstract

“…The optimizations that have been described always dealt with closure generation but anyo ther optimizations could also be used, for example: invariant removal, common subexpression elimination and expression simplifications [4] [16] [29]. Data and control flowa nalysis could also be computed [17] [18].…”

Section: Discussion Of the Methodsmentioning

confidence: 99%

Using closures for code generation

Feeley¹,

Lapalme²

1987

Computer Languages

View full text Add to dashboard Cite

This paper describes a newapproach to compiling which is based on the extensive use of closures. In this method, a compiled expression is embodied by a closure whose application performs the evaluation of the givenexpression. For each primitive construct contained in the expression to compile, a closure is generated. As a whole, the compiled expression consists of a network of these closures. In a way,' code generation' is replaced by 'closure generation'. This method, combined with an efficient closure implementation, produces compiled code which compares favorably (in execution time) with its interpreted counterpart. It can also be used to implement compilers for embedded languages and as it has been implemented in Scheme, it yields a straightforward metacircular compiler for Scheme.

show abstract

“…Partial evaluation consists of 'hardwiring' the consequences of the fixed arguments/inputs into the program code, thereby specialising the program. Hitherto, all work on partial evaluation has focused on the application of program transformation rules to optimise the specialised program for the application sub-domain of interest [12], [23]. This has the advantage that the resulting specialised program is correct, so long as the original program is correct and all of the transformation steps are correct.…”

Section: Introductionmentioning

confidence: 99%

Specialising Software for Different Downstream Applications Using Genetic Improvement and Code Transplantation

Petke

Harman

Langdon

et al. 2018

IIEEE Trans. Software Eng.

View full text Add to dashboard Cite

Genetic improvement uses automated search to find improved versions of existing software. Genetic improvement has previously been concerned with improving a system with respect to all possible usage scenarios. In this paper, we show how genetic improvement can also be used to achieve specialisation to a specific set of usage scenarios. We use genetic improvement to evolve faster versions of a C++ program, a Boolean satisfiability solver called MiniSAT, specialising it for three applications. Our specialised solvers achieve between 4% and 36% execution time improvement, which is commensurate with efficiency gains achievable using human expert optimisation for the general solver. We also use genetic improvement to evolve faster versions of an image processing tool called ImageMagick, utilising code from GraphicsMagick, another image processing tool which was forked from it. We specialise the format conversion functionality to black & white images and colour images only. Our specialised versions achieve up to 3% execution time improvement.

show abstract

A partial evaluator, and its use for compiling iterative statements in LISP

Abstract: A partial evaluation program for LISP is described, 1.

Cited by 14 publications

References 2 publications

Mix: A self-applicable partial evaluator for experiments in compiler generation

Mix: A self-applicable partial evaluator for experiments in compiler generation

Using closures for code generation

Specialising Software for Different Downstream Applications Using Genetic Improvement and Code Transplantation

Contact Info

Product

Resources

About