Evan Tick

The deevolution of concurrent logic programming languages

Abstract This article surveys the field of implementation of concurrent logic programming languages. I briefly review language semantics and programming paradigms, before summarizing the results of the past decade in compiler and runtime system implementation. A theme throughout the research presented is the deevolution of concurrent logic programming languages due to the limitations of what systems designers and compiler writers can efficiently implement, as well as the growing perception among programmers that reduced expressivity is sufficient.

Greedy partitioned algorithms for the shortest-path problem

A partitioned, priority-queue algorithm for solving the single-source best-path problem is defined and evaluated. Finding single-source paths for sparse graphs is notable because of its definitelack of parallelism-no known algorithms are scalable. Qualitatively, we discuss the close relationships between our algorithm and previous work by Quinn, Chikayama, and others. Performance measurements of variations of the algorithm, implemented both in concurrent and imperative programming languages on a shared-memory multiprocessor, are presented. This quantitative analysis of the algorithms provides insights into the tradeoffs between complexity and overhead in graph-searching executed in high-level parallel languages with automatic task scheduling.

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.

A compile-time granularity analysis algorithm and its performance evaluation

A major implementation problem with implicitly parallel languages, is that small grain size can lead to execution overheads and reduced performance. We present a new granularity-analysis scheme that produces estimators, at compile time, of the relative execution weight of each procedure invocation. These estimators can be cheaply evaluated at runtime to approximate the relative task granularities, enabling intelligent scheduling decisions. Our method seeks to balance tradeoffs between analysis complexity, estimator accuracy, and runtime overhead of evaluating the estimator. To this end, rather than analyze data size or dependencies, we introduceiteration parameters to handle recursive procedures. This simplification facilitates solving the recurrence equations that describe the granularity estimators, and reduces the runtime overhead of evaluating these estimators. The algorithm is described in the context of concurrent logic programming languages, although the concepts are applicable to functional languages in general. We show, for a benchmark suite, that the method accurately estimates cost. Multiprocessor simulation results quantify the advantage of dynamically scheduling tasks with the granularity information.

Sequentializing Parallel Programs

A compile-time technique is presented for determining if a set of procedures within a parallel program can be executed sequentially without causing deadlock. The analysis and methods are described for committed-choice parallel logic programming languages; however, the concepts are general enough for any concurrent languages with fine-grain communicating processes. We derive methods for ensuring that sequential evaluation of a program module cannot result in producer-consumer suspension within the module itself, thereby resulting in deadlock. The advantages of sequentializing fine-grain languages include the use of all “traditional” compiler optimizations, such as global register allocation, and continuation-stacking procedure invocation.

Monaco: A High-Performance Flat Concurrent Logic Programming System

This paper describes Monaco, a high-performance implementation of flat committed-choice languages such as Flat Guarded Horn Clauses. The compiler produces native code for linking to a runtime system on shared-memory multiprocessors. A reduced abstract-machine instruction set facilitates decision-graph code generation and traditional optimizations based on dataflow analysis. An inexpensive system-call interface is provided to lower the overhead of memory allocation and procedure invocation. Unification has been optimized to streamline the common cases. We report initial performance measurements of our current instantiation of the system, for the Sequent Symmetry, for a suite of benchmarks.

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 Compile-Time Memory-Reuse Scheme for Concurrent Logic Programs

As large amounts of garbage are generated in concurrent logic programs, it becomes necessary to salvage used memory frequently and efficiently, with a garbage collector. Another approach is to detect when a data structure becomes garbage and reuse it. In concurrent languages it is particularly difficult to determine when a data structure is garbage and suitable for destructive update. Dynamic schemes, such as reference counting, incur space and time overheads that can be unacceptable. In contrast, static-analysis techniques identify data objects whose storage may be reused. Information from static analysis can be used by the compiler in generating appropriate instructions for reuse, incurring little or no runtime overhead. In this paper we present a new static-analysis technique for reuse detection. We present empirical performance measurements comparing the new scheme against binary reference counting (MRB). It is shown that, a simple static analysis can achieve most of the benefits of MRB and improve the execution time.

Memory-and buffer-referencing characteristics of WAM-based Prolog

Abstract Several local data buffers are proposed and measurements are presented for variations of the Warren–abstract–machine (WAM) architecture for PROLOG. First, literature in this area is reviewed. Choice-point buffers, stack buffers, split-stack buffers, multiple register sets, copyback caches, and “smart” caches are then examined. Evaluation parameters such as stack reference depth and reset depth are defined, and measurements are presented motivating the local-memory designs. A memory-trace-driven simulator was used to collect miss- and traffic-ratio statistics for the local memories. Statistics collected from four benchmark programs indicate that small (

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.