We describe an efficient technique for incorporating Baker's incremental garbage collection algorithm into the STG-machine on stock hardware. This algorithm eliminates the stop/go execution associated with bulk copying collection algorithms, allowing the system to place an upper bound on the time taken to perform a store operation. The implementation exploits the fact that objects are always accessed by jumping to code rather than being explicitly dereferenced. The technique works by modifying the entry code-pointer when an object is in the transient state of being evacuated but not scavenged. An attempt to enter it from the mutator causes the object to "self-scavenge" transparently before resetting its entry code pointer. We describe an implementation of the scheme in v4.01 of the Glasgow Haskell Compiler and report performance results obtained by executing benchmark programs from the nofib suite. These experiments show an average slowdown of less than 6% when compared to stop-a...

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 presents the Brisk Machine #54#, a machine for executing functional languages, designed to be simple and #exible to support a number of run-time execution models for the Brisk compiler. Design considerations have been made to support dynamic loading, deterministic concurrency #23,51#, distribution, debugging tools and logic programming #76#. To achieve this, the compiler's intermediate language, the Brisk Kernel Language BKL is simpler than the STG language #100#, as evaluation, extension and optimisation issues are relegated to special built-in functions. Moreover, function calls are saturated, as any function has an known arity and in every call to it, is applied to the rightnumber of arguments, which makes the machine dynamic and supports dynamic loading.

Interpretation is an implicit part of today’s programming; it has great power but is overused and has significant costs. For example, interpreters are typically significantly hard to understand and hard to reason about. The methodology of “Totally Functional Programming” (TFP) is a reasoned attempt to redress the problem of interpretation. It incorporates an awareness of the undesirability of interpretation with observations that definitions and a certain style of programming appear to offer alternatives to it. Application of TFP is expected to lead to a number of significant outcomes, theoretical as well as practical. Primary among these are novel programming languages to lessen or eliminate the use of interpretation in programming, leading to better-quality software. However, TFP contains a number of lacunae in its current formulation, which hinder development of these outcomes. Among others, formal semantics and type-systems for TFP languages are yet to be discovered, the means to reduce interpretation in programs is to be determined, and a detailed explication is needed of interpretation, definition, and the differences between the two. Most important of all however is the need to develop a complete understanding of the nature of interpretation. In this work, suitable type-systems for TFP languages are identified, and guidance given regarding the construction of appropriate formal semantics. Techniques, based around the ‘fold’ operator, are identified and developed for modifying programs so as to reduce the amount of interpretation they contain. Interpretation as a means of language-extension is also investigated. v Finally, the nature of interpretation is considered. Numerous hypotheses relating to it considered in detail. Combining the results of those analyses with discoveries from elsewhere in this work leads to the proposal that interpretation is not, in fact, symbol-based computation, but is in fact something more fundamental: computation that varies with input. We discuss in detail various implications of this characterisation, including its practical application. An often more-useful property, ‘inherent interpretiveness’, is also motivated and discussed in depth. Overall, our inquiries act to give conceptual and theoretical foundations for practical TFP.

The leading implementations of graph reduction all target conventional processors designed for low-level imperative execution. In this paper, we present a processor specially designed to perform graph-reduction. Our processor – the Reduceron – is implemented using off-the-shelf reconfigurable hardware. We highlight the lowlevel parallelism present in sequential graph reduction, and show how parallel memories and dynamic analyses are used in the Reduceron to achieve an average reduction rate of 0.55 function applications per clock-cycle. Categories and Subject Descriptors C.1.3 [Processor Architectures]: Other Architecture Styles—High-level language architectures;

This paper introduces an alternative representation for λ-terms which has the notable property that the search for the leftmost outermost redex is restricted to two steps. This is important in the implementation of a lazy functional programming language, as this search consumes time and space. The representation introduced is similar to that resulting from the implementation technique of reversing pointers in the left spine of a term while traversing it, except that here the pointers in the left spine are reversed before reduction. This paper completely develops this new representation, including rigourous proofs of the correctness as a representation for -terms and a number of properties, such as the restriction on the search for the next redex. It is shown that the representation can be used with graphs, hence it can be used as the basis for an implementation of a lazy functional language. An implementation is introduced and its performance is compared with a conventional implementati...