This report surveys the major developments in sequential Prolog implementation during the period 1983--1993. In this decade, implementation technology has matured to such a degree that Prolog has left the university and become useful in industry. The survey is divided into four parts. The first part gives an overview of the important technical developments starting with the Warren Abstract Machine (WAM). The second part presents the history and the contributions of the major software and hardware systems. The third part charts the evolution of Prolog performance since Warren's DEC-10 compiler. The fourth part extrapolates current trends regarding the evolution of sequential logic languages, their implementation, and their role in the marketplace.

We define a practical algorithm for distributed rational tree unification and prove its correctness in both the off-line and on-line cases. We derive the distributed algorithm from a centralized one, showing clearly the trade-offs between local and distributed execution. The algorithm is used to realize logic variables in the Mozart Programming System, which implements the Oz language (see

the effects of head unification with the formal parameters ¯ x, given the abstract substitution ff describing the actual parameters, so as to obtain an initial abstract environment A 1 . 2. Let the abstract environment at the program point immediately before the literal q i (¯u i ) be denoted by A i , 1 i n. For i := 1 to n do: A 0 i := analyse call(q i ; A i ); A i+1 := extend abs env (A i ; A 0 i ); 3. Compute and return the abstract environment An+1 projected on the arguments in the head of the clause. A call to a procedure is analyzed by processing each clause for that procedure, in turn, as described above. For each clause, the analysis yields an abstract environment, and these can be "summarized"---for example, using the join operator t on ASub---to yield an abstract environment describing the substitutions that may be obtained when that call returns. In the following sections, we describe how the underlying analysis described above can be extended to detect situations ...

We have added a Java virtual machine (henceforth JVM) bytecode generator to the optimizing Scheme-to-C compiler Bigloo. We named this new compiler BiglooJVM. We have used this new compiler to evaluate how suitable the JVM bytecode is as a target for compiling strict functional languages such as Scheme. In this paper, we focus on the performance issue. We have measured the execution time of many Scheme programs when compiled to C and when compiled to JVM. We found that for each benchmark, at least one of our hardware platforms ran the BiglooJVM version in less than twice the time taken by the Bigloo version. In order to deliver fast programs the generated JVM bytecode must be carefully crafted in order to benefit from the speedup of just-in-time compilers.

Abstract. Erlang is a concurrent functional language, tailored for large-scale distributed and fault-tolerant control software. Its primary implementation is Ericsson’s Erlang/OTP system, which is based on a virtual machine interpreter. HiPE (High-Performance Erlang) adds a native code execution mode to the Erlang/OTP system. This paper describes the x86 version of HiPE, including a detailed account of decisions and principles that guide the design of its compiler and runtime system. We also present a brief performance evaluation which indicates that HiPE/x86 delivers performance improvements on par with the more mature HiPE/SPARC system. 1

The Design and Implementation of a Prototype Exokernel Operating System

This paper discusses a straightforward approach to using untagged and unboxed values in dynamically typed languages. An implementation of our algorithms allows a dynamically typed language to attain performance close to that of highly optimized C code on a variety of benchmarks (including many floating-point intensive computations) and dramatically reduces heap usage. \Delta 1. Introduction

The Embeddable Common Lisp is an implementation of Common Lisp designed for being embeddable within C based applications. ECL uses standard C calling conventions for Lisp compiled functions, which allows C programs to easily call Lisp functions and viceversa. No foreign function interface is required: data can be exchanged between C and Lisp with no need for conversion. ECL is based on a Common Runtime Support (CRS) which provides basic facilities for memory management, dynamic loading and dumping of binary images, support for multiple threads of execution. The CRS is built into a library that can be linked with the code of the application. ECL is modular: main modules are the program development tools (top level, debugger, trace, stepper), the compiler, and CLOS. A native implementation of CLOS is available in ECL: one can configure ECL with or without CLOS. A runtime version of ECL can be built with just the modules which are required by the application. 1 Introduction As applicatio...

We present an implementation of Scheme for microcontroller that is very compact and includes a real-time garbage collector. The compiler, which runs on a normal workstation, produces byte-code from the source program and the bytecode is linked with a runtime module. With this system, we demonstrate that it's clearly possible to run Scheme programs on a microcontroller with 64 KB of memory such as the Motorola 68HC11. Executables that include the whole library can be as little as 22 KB. As a secondary result, the research on memory management for this system brought us to create a space-ecient real-time GC algorithm. 1 Introduction Embedded applications are often implemented by programming microcontrollers in assembly language. Indeed this provides a high degree of control on the microcontroller and fast and compact code for simple applications. However this approach becomes tedious and error prone for more complex applications. For this reason, compilers for higher-level languages su...

This paper presents the compilation of the Scheme programming language to.NET. This platform provides a virtual machine, the Common Language Runtime (CLR), that executes bytecode, the Common Intermediate Language (CIL). Since CIL was designed with language agnosticism in mind, it provides a rich set of language constructs and functionalities. As such, the CLR is the first execution environment that offers type safety, managed memory, tail recursion support and several flavors of pointers to functions. Therefore, the CLR presents an interesting ground for functional language implementations. We discuss how to map Scheme constructs to CIL. We present performance analyses on a large set of real-life and standard Scheme benchmarks. In particular, we compare the speed of these programs when compiled to C, JVM and.NET. We show that in term of speed performance of the Mono implementation of.NET, the best implementing running on both Windows and Linux, still lags behind C and fast JVMs such as the Sun’s implementations.