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.

Muse (Multi-sequential Prolog engines) is a simple and efficient approach to Orparallel execution of Prolog programs. It is based on having several sequential Prolog engines, each with its local address space, and some shared memory space. It is currently implemented on a 7-processors machine with local/shared memory constructed at SICS, a 16-processors Sequent Symmetry, a 96-processors BBN Butterfly I, and a 45-processors BBN Butterfly II. The sequential SICStus Prolog system has been adapted to Or-parallel implementation. Extra overhead associated with this adaptation is very low in comparison with the other approaches. The speed-up factor is very close to the number of processors in the system for a large class of problems. The goal of this paper is to present the Muse execution model, some of its implementation issues, a variant of Prolog suitable for multiprocessor implementations, and some experimental results obtained from two different multiprocessor systems. Key Words: Or-Par...

PROLOG, the most popular logic programming language, has been developed for single-processor computers. The implementations of sequential Prolog became efficient with the development of the Warren Abstract Machine (WAM) and are still improving. Today many parallel computers are commercially available and the question is how to utilize this opportunity to speed up the execution of Prolog programs. Our approach has been to study and develop efficient techniques for implementing OR-parallel systems for the full Prolog language on UMA and NUMA computers. Based on those techniques a high performance OR-parallel Prolog system has been designed and implemented on six different parallel computers. The system has a number of processes, called workers, consisting of two components: the engine, which does the actual Prolog work, and the scheduler. The schedulers, working together, divide the available work between the engines and support the sequential semantics of Prolog. We have extended th...

We present an extensive, annotated bibliography of the abstract machines designed for each of the main programming paradigms (imperative, object oriented, functional, logic and concurrent). We conclude that whilst a large number of efficient abstract machines have been designed for particular language implementations, relatively little work has been done to design abstract machines in a systematic fashion.

Parallelism and logic programming are two fields that have been successfully combined, as is shown by recent implementations of parallel logic programming systems. There are two main sources of parallelism in logic programming, namely or-parallelism and and-parallelism. Or-parallelism is exploited when several alternative clauses to a goal are executed in parallel. And-parallelism is exploited when we execute two or more goals of the same clause simultaneously. Exploitation of full or-parallelism and and-parallelism is limited by the number of physical processors available in a system. And-parallelism is also limited by the interdependence among goals in a clause. In parallel logic programming systems which exploit both and-parallelism and or-parallelism, a problem that arises is how to distribute processors between the dynamically varying amounts of and-work and or-work that are available. Solutions have been reported for distributing only or-work, or distributing only and-work, but the issue of distributing processors between both kinds of work has not yet been addressed. In this thesis we discuss the problem of distributing and-work and or-work in the context of Andorra-I, a parallel logic programming system that exploits determinate and-parallelism and or-parallelism, and propose scheduling strategies that aim at effi ciently distributing processors between and-work and or-work. We study general criteria that every scheduling strategy should meet to reconfi gure processors without incurring too high overheads in the Andorra-I system. We propose two different strategies to reconfi gure processors between and-work and or-work based on these criteria. One strategy, work-guided, guides its decisions by looking at the amount of current and-work and or-work available in ...

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...

Work which may later be pruned is called speculative work. In this paper we present and evaluate a simple and efficient strategy, used in the Muse OR-parallel Prolog system, for better scheduling of speculative work. The strategy concentrates workers on the leftmost available work in the Prolog tree as long as there exists enough parallelism, thus emulating the sequential Prolog execution as much as possible. This strategy therefore makes it less probable that unnecessary work is executed. A new cut scheme that reduces the amount of speculative work is also presented. The performance results of our strategy are compared with the performance results of similar strategies implemented in the Aurora OR-parallel Prolog system. The comparison shows that our strategy performs quite well. Keywords OR-parallel Prolog; speculative work; scheduling; performance evaluation. 0 1 Introduction Prolog, the most popular logic programming language, has been developed for singleprocessor computers. T...

Parallel Prolog systems consist, at least conceptually, of two components: an engine and a scheduler. This paper addresses the problem of defining a clean interface between these components. Such an interface has been designed for Aurora, a prototype or-parallel implementation of the full Prolog language for shared memory multiprocessors. The practical purpose of the interface is to enable different engine and scheduler implementations to be used interchangeably. The development of the interface has, however, contributed in great extent to the clarification of issues in exploiting or-parallelism in Prolog. We believe that these issues are relevant to a wider circle of research in the area of or-parallel implementations of logic programming. We believe that the concept of an engine-scheduler interface is applicable to a wider range of parallel Prolog implementations. Indeed, the present interface has been used in the Andorra-I system, which supports both and- and or-parallelism. Keywor...

Abstract not found