We present an extensive, annotated bibliography of the abstract machines designed for each of the main programming paradigms (imperative, object oriented, functional, logic and concurrent). We conclude that whilst a large number of efficient abstract machines have been designed for particular language implementations, relatively little work has been done to design abstract machines in a systematic fashion.

In Part I [5], we proposed an approach to formally describe and compare functional languages implementations. We focused on call-by-value and described well-known compilers for strict languages. Here, we complete our exploration of the design space of implementations by studying call-by-name, call-by-need and graph reduction. We express the whole compilation process as a succession of program transformations in a common framework. At each step, different transformations model fundamental choices or optimizations. We describe and compare the diverse alternatives for the compilation of the call-byname strategy in both environment and graph-based models. The different options for the compilation of b-reduction described in [5] can be applied here as well. Instead, we describe other possibilities specific to graph reduction. Call-by-need is nothing but call-by-name with redex sharing and update. We present how sharing can be expressed in our framework and we describe different...

: We introduce a unified framework to describe, relate, compare and classify functional language implementations. The compilation process is expressed as a succession of program transformations in the common framework. At each step, different transformations model fundamental choices. A benefit of this approach is to structure and decompose the implementation process. The correctness proofs can be tackled independently for each step and amount to proving program transformations in the functional world. This approach also paves the way to formal comparisons by making it possible to estimate the complexity of individual transformations or compositions of them. Our study aims at covering the whole known design space of sequential functional languages implementations. In particular, we consider call-by-value, call-by-name and call-by-need reduction strategies as well as environment and graph-based implementations. We describe for each compilation step the diverse alternatives as program tr...

Krivine presents the machine, which produces weak head normal form results. Sestoft introduces several call-by-need variants of the machine that implement result sharing via pushing update markers on the stack in a way similar to the TIM and the STG machine. When a sequence of consecutive markers appears on the stack, all but the first cause redundant updates. Improvements related to these sequences have dealt with either the consumption of the markers or the removal of the markers once they appear. Here we present an improvement that eliminates the production of marker sequences of length greater than one. This improvement results in the machine, a more space and time e#cient variant of K. We then apply

. In this paper we advocate the use of fold-unfold transformations for mastering the complexity of abstract machines intended for real implementations. The idea is to express the abstract machine as an interpreter in a purely functional language. The initial interpreter should be `obviously correct' (but might be inefficient -- we don't care at this point). Fold-unfold transformations are then used to remove inefficiencies in the interpreter/abstract machine. We illustrate this by deriving (the equivalent of) the E-scheme of the G-machine from (the equivalent of) the composition of C and the EVAL instruction. This is first done on a call-byname (tree reduction) interpreter. To model sharing and the graph manipulation that goes on in a real graph reduction implementation, we use state monads. We do the same transformation of the state monadic interpreter. It is much less straightforward to transform the state monadic interpreter, as we have to lean heavily on the laws of the state monad...

ion avec des environnements partags (As) As ncessite sept nouveaux combinateurs pour exprimer la sauvegarde et la restauration des environnements (dupl e , swap se ), la construction et l'ouverture des fermetures (mkclos, appclos), l'accs aux valeurs (fst, snd), et enfin l'ajout d'une fermeture l'environnement (bind). Ils sont dfinis dans L e par dupl e = l e e. push e e o push e e swap se = l s x. l e e. push s x o push e e mkclos = l s x. l e e. push s (x,e) appclos = l s (x,e). push e e o x fst = l e (e,x). push e e snd = l e (e,x). push s x bind = l e e. l s x. push e (e,x) Rmi Douence & Pascal Fradet La correction de As est exprime par la Proprit 4 (R est une fonction changeant la reprsentation des fermetures de (c, e) en push e e o c). Proprit 4 "E R [[ push e () o As [[ E]] ()]] = b E La transformation As peut tre optimise en ajoutant la rgle : As [[ l s x.E]] r = pop se o As [[ E]] r si x n'est pas libre dans E avec pop se = l e e. l s x. push e e Les variables son...

This thesis describes a compiler for the asynchronous real-time programming language ALDiSP. Though the language has a complex semantics not suited for easy compilation, the compiler has to generate code for target platforms that have stringent space limitations, and for target applications that have to satisfy hard real-time requirements. To accomplish this feat, the compiler is based upon an abstract interpreter that simulates all possible evaluation paths of the program. In a reconstruction phase, the program is then totally re-created from the information gained during this simulation. The abstract interpreter is an extension of the formal semantics of ALDiSP.