Barton C. Massey

Sequentialization of Parallel Logic Programs with Mode Analysis

The family of concurrent logic programming languages has proved to be a great asset to programmers seeking to quickly construct efficient programs for highly parallel shared-memory machines. If these languages are to be implemented efficiently for other architectures, however, language-specific compile-time analysis techniques must be improved. This work describes a technique and implementation of “sequentialization” (compile-time ordering of body goals) based on automatic “mode analysis” (identification of input and output parameters) for a large subset of concurrent logic programs: feedback-free, fully-moded, flat-guarded programs. We present preliminary performance results from an FGHC-to-C compiler, utilizing these techniques, which produces very fast code.

Concurrent Logic Programs a la Mode

This paper describes and compares two compile-time analysis algorithms for deriving the path modes of a moded concurrent logic program. A path describes a subterm of a procedure argument. Deriving all path modes is a way to perform certain valuable optimizations, such as sequentialization of too-fine concurrent tasks, and scheduling to reduce suspension. We describe our own variation of Ueda and Morita’s original constraint propagation scheme, which includes our novel circular unification algorithm. We also describe an alternative method of finite domain analysis that we developed. The two methods are critiqued and we show the relationship between them.

A common intermediate language and its use in partitioning concurrent declarative programs

The plethora of concurrent declarative language families, each with subtly different semantics, makes the design and implementation of static analyses for these languages a demanding task. However, many of the languages share underlying structure, and if this structure can be exploited, static analysis techniques can be shared across language families. These techniques can thus provide a common kernel for the implementation of quality compilers for this entire language class.The purpose of this paper is to exploit the similarities of non-strict functional and concurrent logic languages in the design of a common intermediate language (CIL). The CIL is introduced incrementally, giving at each step the rationale for its extension. As an application, we present, in CIL form, some state-of-the-art static partitioning algorithms from the literature. This allows us to “uncover” the relative advantages and disadvantages of the analyses, and determine promising directions for improving static partitioning.

Experience with the Super Monaco optimizing compiler

Abstract “Super Monaco” is a shared-memory multiprocessor implementation of a flat concurrent logic programming language. The system evolved from the earlier Monaco project, and retains, by and large, the Monaco intermediate abstract machine. Over the past two years, the compiler and runtime system were modified, incorporating a number of new features improving robustness, flexibility, maintainability, and performance. The optimizing compiler, written in KL1, takes high-level programs and produces intermediate code for the Monaco abstract machine. An “assembler-assembler” converts a host machine description into a KL1 program which translates Monaco intermediate code into target assembly code. There are currently two intermediate code translators: one for SGI MIPS-based hosts, and another for Sequent 80386-based multiprocessors. This paper discusses the compiler design and our experience building it. A cost/benefit analysis of the compiler optimizations is given, with a comparison to similar systems.

Super Monaco: Its Portable and Efficient Parallel Runtime System

“Super Monaco” is the successor to Monaco, a shared-memory multiprocessor implementation of a flat concurrent logic programming language. While the system retains, by-and-large, the older Monaco compiler and intermediate abstract machine, the intermediate code translator and the runtime system have been completely replaced, incorporating a number of new features intended to improve robustness, flexibility, maintainability, and performance. There are currently two native-code backends for 80×86-based and MIPS-based multiprocessors. The runtime system, written in C, improves upon its predecessor with better memory utilization and garbage collection, and includes new features such as an efficient termination scheme and a novel variable binding and hooking mechanism. The result of this organization is a portable system which is robust, extensible, and has performance competitive with C-based systems. This paper describes the design choices made in building the system and the interfaces between the components.

Modes of Comprehension: Mode Analysis of Arrays and Array Comprehensions

A scheme is presented to enable the mode analysis of concurrent logic programs manipulating arrays containing both ground and non-ground elements. To do this we leverage constraint-propagation mode analysis techniques. The key ideas are to restrict multiple assignments only to variables at the leaves of paths, and to extend the language family with array comprehensions. The result is a language not significantly different than generic committed-choice languages, which can be safely mode analyzed, producing useful (not overly conservative) information, even for programs that assign to unbound array elements. An implementation of the analysis is presented.