Parallel Execution Of Logic Programs Research Articles

Massively parallel execution of logic programs: A static approach

A static model for the parallel execution of logic programs on MIMD distributed memory systems is presented where a refutation is implemented through a process network returned by the compilation of the logic program. The model supports Restricted-AND, OR and stream parallelism and it is integrated with a set of static analyses to optimise the process network. Altogether, the processes interact according to a static data driven model with medium grain operators. Data flowing in the network is tagged to distinguish bindings belonging to the same refutation. A scheduling strategy to integrate low level scheduling and message flow control has been defined. Performance figures are presented.

Parallel execution of logic programs by load sharing

Execution of a logic program can be sped up by load sharing among a group of interconnected processors. Network contention and load imbalance are two potentially limiting factors that must be dealt with carefully. In this paper, we discuss a task scheduling scheme in which processors share the workload by voluntarily following a universal task distribution rule. Communication is reduced by having processors cooperate without frequent exchange of information. However, load balancing is rendered more difficult. We propose solutions to the problem by altering the shape of a search space to remove the so-called structural imbalance, and by following a statistically even task distribution rule. Simulation and experimental data indicate that the method is effective for a number of programs for which existing scheduling methods tend to generate overly fine-grained tasks that lead to heavy traffic in the network. Speed-up factors by the proposed technique are comparable to, or better than, that by a typical system which relies solely on dynamic task migration to balance the workload. The scheme appears to be particularly suitable for implementation on loosely coupled parallel platforms.

Machine independent AND and OR parallel execution of logic programs. II. Compiled execution

For pt.I. see ibid., p. 170-80. In pt.I, we presented a binding environment for the AND and OR parallel execution of logic programs. This environment was instrumental in rendering a compiler for the AND and OR parallel execution of logic programs machine independent. In this paper, we describe a compiler based on the Reduce-OR process model (ROPM) for the parallel execution of Prolog programs, and provide performance of the compiler on five parallel machines: the Encore Multimax, the Sequent Symmetry, the NCUBE 2, the Intel i860 hypercube and a network of Sun workstations. The compiler is part of a machine independent parallel Prolog development system built on top of a run time environment for parallel programming called the Chare kernel, and runs unchanged on these multiprocessors. In keeping with the objectives behind the ROPM, the compiler supports both on and independent AND parallelism in Prolog programs and is suitable for execution on both shared and nonshared memory machines. We discuss the performance of the Prolog compiler in some detail and describe how grain size can be used to deliver performance that is within 10% of the underlying sequential Prolog compiler on one processor, and scale linearly with increasing number of processors on problems exhibiting sufficient parallelism. The loose coupling between parallel and sequential components makes it possible to use the best available sequential compiler as the sequential component of our compiler.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Machine independent AND and OR parallel execution of logic programs. I. The binding environment

We describe a binding environment for the AND and OR parallel execution of logic programs that is suitable for both shared and nonshared memory multiprocessors. The binding environment was designed with a view of rendering a compiler using this binding environment machine independent. The binding environment is similar to closed environments proposed by J. Conery. However, unlike Conery's scheme, it supports OR and independent AND parallelism on both types of machines. The term representation, the algorithms for unification and the join algorithms for parallel AND branches are presented in this paper. We also detail the differences between our scheme and Conery's scheme. A compiler based on this binding environment has been implemented on a platform for machine independent parallel programming called the Chare Kernel.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

And/Or parallel execution of logic programs

This paper proposes a new And/Or parallel execution model (FORDAP) for logic programs which can not only exploit full Or- and independent And-parallelism, but also can exploit dependent And-parallelism with a limited increment of runtime cost. A synchronization mechanism is constructed on a shared variable between its producer and its consumers and a consumer with a large granularity is decomposed further to let its subgoals independent to that producer to execute without delay. A granularity computation algorithm is presented for the control of a goal's decomposition.

Distributed last call optimization for portable parallel logic programming

A difficult but challenging problem is the efficient exploitation of AND and OR parallelism in logic programs without making any assumptions about the underlying target machine(s). In earlier papers, we described the design of a binding environment for AND and OR parallel execution of logic programs on shared and nonshared memory machines and the performance of a compiler (called ROLOG) using this binding environment on a range of MIMD parallel machines. In this paper, we present an important optimization for portable parallel logic programming, namely distributed last-call optimization , an analog of the tail recursion optimization for sequential Prolog. This scheme has been implemented in the ROLOG compiler, which ports unchanged on several shared memory and nonshared memory machines. We describe the effect of this optimization on several OR, AND/OR and AND parallel benchmark programs.

DIALOG — A dataflow model for parallel execution of logic programs

The paper presents a dataflow execution model, DIALOG, for logic programs which operates on an intermediate virtual machine. The virtual machine is granulated at clause argument level to exploit argument parallelism through unification. The model utilises a new variable binding scheme that eliminates dereference operations for accessing variables, and therefore supports OR-parallelism in the highly distributed dataflow environment. The model has been implemented in Occam. A conventional dataflow architecture in support of the model has been simulated as a testbed for the evaluation. The simulation indicates some encouraging results and suggests future improvements.

A distributed fair polling scheme applied to OR-parallel logic programming

A task scheduling algorithm for parallel execution of logic programs on NUMA multiprocessors is proposed. The algorithm endorces a so-calledfair polling policy. We show analytically that the proposed algorithm has a good isoefficiency function. Results from simulation on switch based NUMA architecture multiprocessors, the BBN Butterfly GP1000 and TC2000, corroborate the analysis. The proposed algorithm exhibits performance characteristics very similar to that of its counterpart that uses a shared memory. It achieves reasonable speed-up on benchmarks, using a nonconstant time task migration protocol. In addition, fair polling algorithms (with or without a shared memory) are shown to beconsistently superior than several other known polling schemes that do not maintain fairness, for a variety of benchmark programs.

The reduce-or process model for parallel execution of logic programs

A method for parallel execution of logic programs is presented. It uses REDUCE-OR trees instead of AND-OR or SLD trees. The REDUCE-OR trees represent logic-program computations in a manner suitable for parallel interpretation. The REDUCE-OR process model is derived from the tree representation by providing a process interpretation of tree development, and devising efficient bookkeeping mechanisms and algorithms. The process model is complete—it produces any particular solution eventually—and extracts full OR parallelism. This is in contrast to most other schemes that extract AND parallelism. It does this by solving the problem of interaction between AND and OR parallelism effectively. An important optimization that effectively controls the apparent overhead in the process model is given. Techniques that trade parallelism for reducing overhead are also described.

Towards a parallel inference machine: the APIM project

This paper gives an overview of the APIM (Aristotle Parallel Inference Machine) research project, which aims to the design of a new multiprocessor architecture for the parallel execution of logic programs. The APIM system is designed to support both OR-parallelism and independent AND-parallelism in an all solutions approach. It has been developed by adapting the RPM, a sequential high performance inference machine, developed in our Lab.

Introduction of dosim predicate to Prolog

This paper proposes a predicate nameddosim which provides a new function for parallel execution of logic programs. The parallelism achieved by this predicate is a simultaneous mapping operation such as bagof and setof predicates. However, the degree of parallelism can be easily decided by arranging the arguments of the dosim goal. The parallel processing system with dosim was realized on a tight-coupled multiprocessor machine. To control the degree of parallelism and reduce the amount of memory required for execution, we introduce the grouping method for the goals executed in parallel and some variations of the dosim predicate. The effectiveness of the proposed method is demonstrated by the results of the execution of several applications.

The OR-forest-based parallel execution model of logic programs

A new framework for parallel execution of logic programs is presented in this paper, including the OR-forest description and the abstract process model. The OR-forest description cannot only retain the merits of the OR-tree description in achieving high independence of computation units and high degree of OR-parallelisms, but also overcome two drawbacks of the OR-tree description: the lack of the ability for describing AND-parallel execution and the redundancies in describing OR-parallel execution. In our abstract process model, AND-parallelisms are realized by processes simultaneously searching multiple trees, and OR-parallelisms are realized by processes simultaneously searching multiple branches of the trees. Software simulations have shown that the OR-forest-based execution system, incorporated with an automatic partition algorithm, can exploit AND-OR-parallelisms in both deterministic and nondeterministic programs.

A wide instruction word architecture for parallel execution of logic programs coded in BSL

This paper begins by describing BSL, a new logic programming language fundamentally different from Prolog. BSL is a nondeterministic Algol-class language whose programs have a natural translation to first order logic; executing a BSL program without free variables amounts to proving the corresponding first order sentence. A new approach is proposed for parallel execution of logic programs coded in BSL, that relies on advanced compilation techniques for extracting fine grain parallelism from sequential code. We describe a new “Very Long Instruction Word” (VLIW) architecture for parallel execution of BSL programs. The architecture, now being designed at the IBM Thomas J. Watson Research Center, avoids the synchronization and communication delays (normally associated with parallel execution of logic programs on multiprocessors), by determining data dependences between operations at compile time, and by coupling the processing elements very tightly, via a single central shared register file. A simulator for the architecture has been implemented and some simulation results are reported in the paper, which are encouraging.

Some results on the complexity of exploiting data dependency in parallel logic programs

We consider several problems related to maintaining and analyzing dataflow dependencies in and-parallel execution of logic programs. Several problems related to optimal selection of literals for parallel execution are established to be intractable (NP-complete). Most importantly, we establish intractability even when the arity of the predicates in the logic program is restricted to a small constant. This situation represents PROLOG programs used in practice. We subsequently address the complexity of maintaining data- dependency changes that occur during program execution as variables in the literals become instantiated. For this problem we propose a simple and efficient data structure to maintain the dataflow dependencies among literals during the execution of the program. These dependencies may then be used by an intelligent control to minimize backtracking.

Review of Parallel execution of logic programs by John Conery. Kluwer Academic Publishers 1987.

Review of Parallel execution of logic programs by John Conery. Kluwer Academic Publishers 1987.

Book review: Parallel Execution of Logic Programs by John S. Conery (Kluwer Academic Publiishers 1987)

This book covers a range of applications of logic to AI, from resolution to reflection. Some of the chapters cover current "hot" topics such as nonmonotonic reasoning and epistemic logic for which textbook summaries have not been available. Each chapter ends with a brief bibliographic essay covering work through 1987. For those who haven't kept up with the literature in each of the half-dozen current research areas covered, this book will serve as an admirable vade mecum. It is well-designed as a text for a theoretical course in artificial intelligence as well, provided one finds the logical point of view congenial.

Book review: The Logical Foundations of Artificial Intelligence. by Michael R. Genesereth and Nils Nilsson (Morgan Kaufmann 1987)

This book is an updated version of the author's Ph.D. dissertation[1]. In this book, the author presents an abstract model for parallel execution of logic programs and attempts to define a framework for implementing parallel interpreters. The author describes the research in three layers of abstraction: theory, operation, and implementation. At the theory level, the author discusses syntax, semantics, and control strategies for logic programming and Prolog. For the operation level, the author presents his AND/OR Process Model and an updated survey of related work. For the implementation level, he describes implementation techniques for interpreters based on the specification of the abstract model. The book is divided into seven chapters as follows:

New Books

Parallel Execution of Logic Programs is about the AND/OR Process Model, an abstract model for parallel execution of logic programs. This new book defines a framework for implementing parallel interpreters. The research presented here provides an intermediate level of abstraction between hardware and semantics, a set of requirements for a parallel interpreter running on a multiprocessor architecture.