Thomas Lindgren

A Simple and Efficient Copying Garbage Collector for Prolog

We show how to implement efficient copying garbage collection for Prolog. We measure the efficiency of the collector compared to a standard mark-sweep algorithm on several programs. We then show how to accomodate generational garbage collection and Prolog primitives that make the implementation more difficult.

The development of the HiPE system: design and experience report

The concurrent functional programming language Erlang has been designed to ease the development of large-scale distributed soft real-time control applications. So far, it has been used quite successfully in industry, both within Ericsson Telecom, where it was designed and developed, and by other companies. This “declarative language success-story” has taken place despite the fact that Erlang implementations are slow compared with implementations of other functional languages. Wanting to improve the performance aspects of publicly available Erlang implementations, which are based on emulators, we embarked on a project called HiPE (High-Performance Erlang) whose aim has been to develop an efficient just-in-time native code compiler for Erlang (called the HiPE system). Since its start in 1996, the system has gone through various (re-)design phases, partly due to implementation choices that did not turn out to be as promising as they appeared on paper, but mainly due to changes in Ericsson’s Erlang system upon which the HiPE system is built. In this article, we describe how the HiPE system was developed, what it currently looks like, and its current performance. We critically examine design decisions that we took, and the main lessons learnt from implementing them. Finally, we also report on our experiences from trying to keep up with the concurrent development of Ericsson’s base Erlang system. As such, this article both documents the HiPE system and can serve as possible guidance to anyone wishing to attempt a similar feat.

Exploiting Recursion-Parallelism in Prolog

We exploit parallelism across recursion levels in a deterministic subset of Prolog. The implementation extends a convential Prolog machine with support for data sharing and process managment. Extensive global dataflow analysis is employed to facilitate parallelization. Promising performance figures, showing high parallel efficiency and low overhead for parallelization, have been obtained on a 24 processor shared-memory multiprocessor.

Polyvariant detection of uninitialized arguments of prolog predicates

Abstract Uninitialized variables are important to high-performance Prolog implementations since they can be bound much more efficiently than standard variables and may reduce the size of environments. In this paper, we propose a straightforward program transformation that detects uninitialized arguments to calls and rewrites the program to make such arguments obvious to the compiler. Our algorithm detects more uninitialized arguments than previously proposed methods, is robust when declarations are lacking and calling modes vary, and never performs worse than the monovariant method previously described in the literature. On a substantial set of benchmarks, our algorithm always performs as well as previous methods, and sometimes considerably better. The transformation adds specialized predicates to the program, on the order of 20% of the original number of predicates.

A Pragmatic Approach to Compilation of Erlang

Erlang is a functional language used in telecommunication products that may contain several hundred thousand lines of source code. In these real-world applications, high runtime performance must be combined with small object-code size and short compilation times. We solve this problem by extending a bytecode implementation of Erlang with a backend compiler that selectively compiles individual functions from their bytecode representation to native code. We discuss how stack-based bytecode is compiled to register code and how the byte-code and native code execution environments are integrated. We compare our compiler to a system that compiles Erlang to machine code via C, and show that our system runs twice as fast, yields smaller object code and requires shorter compilation times.

IGOR: A Tool for Developing Prolog Dataflow Analyzers

IGOR supports concise specification of finite lattices, sets ordered by inclusion, product domains, disjunctive domains and recursive domains. IGOR allows the user to project a domain upon another, and automatically inserts conversions into the generated code as required. IGOR uses types to derive efficient representations of data objects. In the present system, IGOR uses type information to automatically select a set representation based on bit vectors or lists of objects. IGOR allows succinct tabular specifications of builtin operations, which are subsequently expanded into efficient switching code.

Compiler Optimizations in Reform Prolog: Experiments on the KSR-1 Multiprocessor

We describe the compiler analyses of Reform Prolog and evaluate their effectiveness in eliminating suspension and locking on a range of benchmarks. The results of the analysis may also be used to extract non-strict independent and-parallelism.