- Front Matter
- 10.1016/s1571-0661(05)80113-6
Preface: Volume 30, Issue 3
- Jan 01, 2000
- Electronic Notes in Theoretical Computer Science
- Ines Dutra + 5 more +5
Preface: Volume 30, Issue 3
An execution kernel model for implementing various parallel logic programming systems is presented. The execution kernel is based on the notion of communicating sequential logic programs. The parallel logic programming language called the kernel language (KL), designed on the basis of the kernel model, is also presented. A complete KL program is viewed as a collection of cooperating logic programming tasks. Communication and synchronization is handled by message passing. Goals can be activated in parallel. >
Preface: Volume 30, Issue 3
Preface: Volume 30, Issue 3
The parallel logic programming system in the FGCS project and its future directions
The parallel logic programming system in the FGCS project and its future directions
Parallel Logic Programming Systems on Scalable Architectures
Parallel Logic Programming Systems on Scalable Architectures
Optimising parallel logic programming systems for scalable machines
Parallel logic programming (PLP) systems have obtained good performance on traditional bus-based shared-memory architectures. However, the scalable multiprocessors being developed today pose new challenges. Our experience with a sophisticated PLP system, Andorra-I, demonstrates that indeed performance suffers greatly on modern architectures. In order to improve performance, we perform a detailed analysis of the cache behaviour of all Andorra-I data structures via executiondriven simulation of a DASH-like multiprocessor. Based on this analysis we optimise the Andorra-I code using 5 different techniques. Our results show that the techniques provide significant performance improvements, leading to the conclusion that PLP systems can and should perform well on modern scalable multiprocessors.
Read moreUsing Compile-Time Granularity Information to Support Dynamic Work Distribution in Parallel Logic Programming Systems
A very important component of a parallel system that generates irregular computational patterns is its work distribution strategy Scheduling strategies for these kinds of systems must be smart enough in order to dynamically balance workload while not incurring a very high overhead. Logic programs running on parallel logic programming systems are examples of irregular parallel computations. The two main forms of parallelism exploited by parallel logic programming systems are: and parallelism, that arises when several literals in the body of a clause can execute in parallel, and or-parallelism, that arises when several alternative clauses in the data base program can be selected in parallel. In this work we show that scheduling strategies for distributing and work and or-work in parallel logic programming systems must combine information obtained at compile-time with runtime information whenever possible, in order to obtain better performance. The information obtained at compile-time has two advantages over current implemented systems that use only runtime information: (1) the user does not need to adjust parameters in arder to estimate sizes of and-work and or-work for the programs; (2) the schedulers can use more accuratc estimates of sizes of and-work and or-work to make belter decisions at runtime. We did our experiments with Andorra-I, a parallel logic programming system that exploits both determinare and-parallelism and or-parallelism. In order to obtain compile-time granularity information we used the ORCA tool. Our benchmark set ranges from programs containing and parallelism only, or-parallelism only and a combination of both and-, and or-parallelism. Our results show that, when well designed, scheduling strategies can actually benefit from compile-time granularity information.
Read moreAn experiment for truly parallel logic programming
A truly parallel logic programming system is proposed. The system is based on the commercially available parallel logic programming language STRAND, which has been extended in order to overcome the inherent limitations of such systems, like AND-type of parallelism, lack of backtracking, limited unification, etc. The system has been tested using an example from the area of natural language processing.
Read moreThe Influence of Architectural Parameters on the Performance of Parallel Logic Programming Systems
In this work we investigate how different machine settings for a hardware Distributed Shared Memory (DSM) architecture affect the performance of parallel logic programming (PLP) systems. We use execution-driven simulation of a DASH-like multiprocessor to study the impact of the cache block size, the cache size, the network bandwidth, the write buffer size, and the coherence protocol on the performance of Andorra-I, a PLP system capable of exploiting implicit parallelism in Prolog programs. Among several other observations, we find that PLP systems favour small cache blocks regardless of the coherence protocol, while they favour large cache sizes only in the case of invalidate-based coherence. We conclude that the cache block size, the cache size, the network bandwidth, and the coherence protocol have a significant impact on the performance, while the size of the write buffer is somewhat irrelevant.
Read moreSome methodological issues in the design of CIAO, a generic, parallel concurrent constraint logic programming system
We informally discuss several issues related to the parallel execution of logic programming systems and concurrent logic programming systems, and their generalization to constraint programming. We propose a new view of these systems, based on a particular definition of parallelism. We argue that, under this view, a large number of the actual systems and models can be explained through the application, at different levels of granularity, of only a few basic principles: determinism, non-failure, independence (also referred to as stability), granularity, etc. Also, and based on the convergence of concepts that this view brings, we sketch a model for the implementation of several parallel constraint logic programming source languages and models based on a common, generic abstract machine and an intermediate kernel language.
Read moreParallel logic programming systems
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, while 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 parallelism and the concurrent logic languages approaches, combination of constraint logic programming with parallelism, and use of highly parallel architectures.
Read moreA Planning System for Aircraft Production with parallel constraint logic programming
PSAP (Planning System for Aircraft Production) is an aircraft production planning decision support system, whose aim is to schedule the aircraft production over the next years (more than five years) at Dassault factories. Each possible solution respecting the order calendar involves a production cost. PSAP must provide a low cost near optimal solution, as well as one which is robust with respect to manufacturing constraints. It needs to be computationaly efficient in order to allow a flexible interactive use. PSAP has been designed with the knowledge representation and control allowed by a parallel constraint and logic programming system; it has been implemented in ECL'PSe and in ElipSys. This paper presents the results of experiments on several benchmarks allowed to extract positive results about the parallelism uses.Key wordsaircraft productionparallel CLPoptimizationproduction cost
Read moreDistributing AND-work and OR-work in parallel logic programming systems
In parallel logic programming systems that exploit both AND-parallelism and OR-parallelism, the problem arises of 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 paper, 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. We describe dynamic scheduling strategies that aim at efficiently distributing processors between AND-work and OR-work, and compare their performance with the performance produced by a static scheduling strategy, for a wide range of benchmarks.
Read moreParallel logic programming on distributed shared memory system
We present an implementation of a parallel logic programming system on a distributed shared memory (DSM) system. Firstly, we give a brief introduction to Andorra-I parallel logic programming system implemented on multiprocessors. Secondly, we outline the concurrent programming environment provided by a distributed shared memory system TreadMarks. Thirdly, we discuss the implementation issues of Andorra-I system based on TreadMarks, such as, shared memory consistency, synchronization, mutual exclusion, shared memory allocation. Finally, we discuss the implementation results and further research issues for building a practically useful logic-based reasoning system on distributed shared memory systems.
Read moreCOWL: Copy-On-Write for logic programs
In order for parallel logic programming systems to become popular, they should serve the broadest range of applications. To achieve this goal, designers of parallel logic programming systems would like to exploit maximum parallelism for existing and novel applications, ideally by supporting both and-parallelism and or-parallelism. Unfortunately, the combination of both forms of parallelism is a hard problem, and available proposals cannot match the efficiency of, say, or-parallel only systems. We propose a novel approach to And/Or Parallelism in logic programs. Our initial observation is that stack copying, the most popular technique in or-parallel systems, does not work well with And/Or systems because memory management is much more complex. Copying is also a significant problem in operating systems where the copy-on-write (COW) has been developed to address the problem. We demonstrate that this technique can also be applied to And/Or systems, and present both shared memory and distributed shared memory designs.
Read moreReduction of code space in parallel logic programming systems
This paper presents the problem of the explosion of code space in methods for exploiting independent AND-parallelism in parallel logic programming systems, and proposes a scheme to solve it. The scheme can largely reduce the code space with minimal loss of parallelism. Some key algorithms in the scheme are presented in this paper. Finally, we give the experimental results and the preliminary performance analysis on the scheme.
Read morePerformance Analysis of a Strategy to Distribute And-work and Or-work in Parallel Logic Programming Systems
This paper studies the performance of Andorra-I, a parallel logic programming system that exploits and-parallelism and or-parallelism with a novel strategy to distribute and-work and or-work among processors. The strategy, work-guided guides it’s decisions by looking at the amount of current and-work and or-work avaliable in an application during execution. The scheduler decision strategy moves workers from one parallel task to another according to the tasks sizes. Results show that the work-guided strategy works quite well and produces better results than the ones produced with a version of Andorra-I that does not a flow dynamic migration of workers during execution. We believe that this strategy can be applied to other parallel logic programming systems that aim to exploit both and-and or-parallelism in a single framework.
Read more