We present the clp(FD) system: a Constraint Logic Programming language with finite domain constraints...

The Andorra Kernel Language, AKL, is introduced. We show how AKL provides the programming paradigms of both Prolog and GHC. This is the original goal of the design. It has also been possible to provide capabilities beyond that of Prolog and GHC. There are means to structure search, more powerful than plain backtracking. It is possible to encapsulate searchin concurrent reactive processes. It is also possible to write a multi-way merger with constant delay. In these respects AKL is quite original. 1

Since the early days of logic programming, researchers in the field realized the potential for exploitation of parallelism present in the execution of logic programs. Their high-level nature, the presence of non-determinism, and their referential transparency, among other characteristics, make logic programs interesting candidates for obtaining speedups through parallel execution. At the same time, the fact that the typical applications of logic programming frequently involve irregular computations, make heavy use of dynamic data structures with logical variables, and involve search and speculation, makes the techniques used in the corresponding parallelizing compilers and run-time systems potentially interesting even outside the field. The objective of this paper is to provide a comprehensive survey of the issues arising in parallel execution of logic programming languages along with the most relevant approaches explored to date in the field. Focus is mostly given to the challenges emerging from the parallel execution of Prolog programs. The paper describes the major techniques used for shared memory implementation of Or-parallelism, And-parallelism, and combinations of the two. We also explore some related issues, such as memory

Parallelizing logic programming has attracted much interest in the research community, because of the intrinsic OR- and AND-parallelisms of logic programs. One research stream aims at transparent exploitation of parallelism in existing logic programming languages such as Prolog, whale the family of concurrent logic languages develops language constructs allowing programmers to express the concurrency—that is, the communication and synchronization between parallel processes—within their algorithms. This article concentrates mainly on transparent exploitation of parallelism and surveys the most mature solutions to the problems to be solved in order to obtain efficient implementations. These solutions have been implemented, and the most efficient parallel logic programming systems reach effective speedups over state-of-the-art sequential Prolog implementations. The article also addresses current and prospective research issues in extending the applicability and the efficiency of existing systems, such as models merging the transparent parallehsm and the concurrent logic languages approaches, combination of constraint logic programming with parallelism, and use of highly parallel architectures.

Andorra-I is an experimental parallel Prolog system based on the Basic Andorra model. This model supports both dependent and-parallelism, by executing determinate goals in parallel, and or-parallelism, stemming from the nondeterminate goals. In this paper, we present a new compiler-based version of the Andorra-I system and discuss its performance. We study the system with a wide set of real-life, non-trivial logic programming applications. As Andorra-I provides a powerful programming model, we are able to include Prolog programs, committed-choice programs, and Andorra-style programs. The results show that the system is very effective at exploiting both forms of parallelism, that it compares well with exclusively or-parallel and exclusively and-parallel systems, and that the extra complexity of the model is manageable. Basic performance compares quite well with other compiler-based systems such as SICStus and JAM.

Independent and-parallelism, dependent and-parallelism and or-parallelism are the three main forms of implicit parallelism present in logic programs. In this paper we present a model, IDIOM, which exploits all three forms of parallelism in a single framework. IDIOM is based on a combination of the Basic Andorra Model and the Extended And-Or Tree Model. Our model supports both Prolog as well as the flat concurrent logic languages. We discuss the issues that arise in combining the three forms of parallelism, and our solutions to them. We also present an implementation scheme, based on binding arrays, for implementing IDIOM.

The Agents Kernel Language (AKL) is a general purpose concurrent constraint language. It combines the programming paradigms of searchoriented languages such as Prolog and process-oriented languages such as GHC. The paper is focused on three essential issues in the parallel implementation of AKL for shared-memory multiprocessors: how to maintain multiple binding environments, how to represent the execution state and how to distribute work among workers. A simple scheme is used for maintaining multiple binding environments. A worker will immediately see conditional bindings placed on variables, all workers will have a coherent view of the constraint stores. A locking scheme is used that entails little overhead for operations on local variables. The goals in a guard are represented in a way that allows them to be inserted and removed without any locking. Continuations are used to represent sequences of untried goals. The representation keeps the granularity of work more coarse. Available ...

Much work has been done in the areas of and--parallelism and data parallelism in Logic Programs. Such work has proceeded to a certain extent in an independent fashion. Both types of parallelism offer advantages and disadvantages. Traditional (and--) parallel models offer generality, being able to exploit parallelism in a large class of programs (including that exploited by data parallelism techniques). Data parallelism techniques on the other hand offer increased performance for a restricted class of programs. The thesis of this paper is that these two forms of parallelism are not fundamentally different and that relating them opens the possibility of obtaining the advantages of both within the same system. Some relevant issues are discussed and solutions proposed. The discussion is illustrated through visualizations of actual parallel executions implementing the ideas proposed. Keywords: Parallel Logic Programming, And-Parallelism, Data-Parallelism, Fast Task Startup, Scheduling. 1 I...

A flexible scheduler for distributing and- and or- parallel work in the Andorra-I system is presented. The scheduler allows workers to move freely between teams. Its strategy is based on estimates of and- and or- parallelism available in the execution tree. Preliminary results show that in most cases we can reach or surpass the best performance of Andorra-I running with any fixed team configuration. Since the teams are configured dynamically and automatically, the user does not need to be concerned with choosing an appropriate configuration. Further work is being done to improve the scheduler by using data obtained from compile-time analysis. Keywords: And/Or-parallelism, Multiprocessors, Scheduling. 1 Introduction There are two main sources of parallelism in logic programming, namely or- and andparallelism. Or- parallelism is exploited when several alternative clauses for a goal are executed in parallel. And- parallelism is exploited when we execute two or more goals of the same cla...

The parallel execution of logic programs, in particular written in Prolog, has great potential for efficient high-level parallel programming. Previous efforts have targeted the parallel execution of conjunctions and disjunctions of programs, so-called And-Or parallelism. A recent, promising approach is that of recursion-parallelism, where structurally recursive programs are exploited to yield large amounts of parallelism. In this work, we describe techniques for compiling recursion-parallel Prolog programs. We define a restriction of general recursion-parallelism that is suitable for efficient parallel implementation. The compilation of this language consists of compile-time analysis by abstract interpretation followed by compilation. The analysis is done to ensure that programs satisfy the required properties of efficient implementation and to locate opportunities of optimization. In particular, the analysis distinguishes a hierarchy of data sharing that the compiler attempts to expl...