Johan Bevemyr

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.

Prolog with Arrays and Bounded Quantifications

It is proposed to add bounded quantifications to Prolog. The main reason is one of natural expression, many algorithms are expressed more elegantly in a declarative way using bounded quantifications than using existing means, i.e., recursion. In particular this is true for numerical algorithms, an area where Prolog has been virtually unsuccessful so far. Moreover, bounded quantification has been found to be at least as efficient as recursion, when applicable. We outline an implementation of bounded quantification through an extension of Warrens abstract Prolog machine and give performance figures relative to recursion. Finally, we have shown elsewhere that bounded quantification has a high potential for parallel implementation. One can often run the same program on a sequential computer and on several kinds of parallel computers.

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.

Parallel bounded quantification—preliminary results

We have extended D. H. D. Warrens abstract machine for sequential Prolog with parallel instructions that implement bounded quantifications, an extension to Prolog proposed by Barklund and Bevemyr. These instructions are intended for parallel computers supporting the data parallel programming model. Luther, an emulator for the sequential abstract machine implemented in the C programming language, has been extended with these instructions, implemented in the data parallel C* programming language.We have coded three example programs that use bounded quantifications, and run them in the emulator on a Connection Machine model 200, a SIMD parallel computer. We compare the run times on this parallel computer with the run times obtained with a sequential implementation of bounded quantifications on a SUN-4M sequential computer.The best result is that one parallel bounded quantification program runs 30 times faster on the Connection Machine than an ordinary recursive program implementing the same algorithm running on the sequential computer. It is conceivable that one can obtain far higher speed-ups when running on larger data parallel computers using bounded quantifications.

Executing Bounded Quantifications on Shared Memory Multiprocessors

We present a schema for executing bounded quantifications on shared memory multiprocessors, using the WAM-based abstract machine designed for recursion parallel execution developed by Bevemyr, Lindgren and Millroth. Preliminary results indicate almost linear speed-up on 24 processors for some quantified expressions. The parallelization overhead is low, in the order of 10–15%.

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.

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.