- 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
A task scheduling algorithm for parallel logic programming systems and its implementation in an AND-parallel Prolog system are described. This algorithm schedules all of the parallel subtasks which are created during the execution of a program, under centralized control, and allows the processors to choose to give their priorities to some tasks so that the solution to a question can be acquired as quickly as possible and so that the parallel system obtains a higher speedup. In this algorithm, co-scheduling is introduced and the load balancing of processors is considered.
Preface: Volume 30, Issue 3
Preface: Volume 30, Issue 3
Using 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 moreParallel Programming Using C++
Foreword by Bjarne Stroustrup Software is generally acknowledged to be the single greatest obstacle preventing mainstream adoption of massively-parallel computing. While sequential applications are routinely ported to platforms ranging from PCs to mainframes, most parallel programs only ever run on one type of machine. One reason for this is that most parallel programming systems have failed to insulate their users from the architectures of the machines on which they have run. Those that have been platform-independent have usually also had poor performance. Many researchers now believe that object-oriented languages may offer a solution. By hiding the architecture-specific constructs required for high performance inside platform-independent abstractions, parallel object-oriented programming systems may be able to combine the speed of massively-parallel computing with the comfort of sequential programming. Parallel Programming Using C++ describes fifteen parallel programming systems based on C++, the most popular object-oriented language of today. These systems cover the whole spectrum of parallel programming paradigms, from data parallelism through dataflow and distributed shared memory to message-passing control parallelism. For the parallel programming community, a common parallel application is discussed in each chapter, as part of the description of the system itself. By comparing the implementations of the polygon overlay problem in each system, the reader can get a better sense of their expressiveness and functionality for a common problem. For the systems community, the chapters contain a discussion of the implementation of the various compilers and runtime systems. In addition to discussing the performance of polygon overlay, several of the contributors also discuss the performance of other, more substantial, applications. For the research community, the contributors discuss the motivations for and philosophy of their systems. As well, many of the chapters include critiques that complete the research arc by pointing out possible future research directions. Finally, for the object-oriented community, there are many examples of how encapsulation, inheritance, and polymorphism can be used to control the complexity of developing, debugging, and tuning parallel software.
Read moreAn object-oriented approach to develop software fault-tolerant mechanisms for parallel programming systems
An object-oriented approach to develop software fault-tolerant mechanisms for parallel programming systems
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 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 moreThe 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
COWL: 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 moreParallel Logic Programming Systems on Scalable Architectures
Parallel Logic Programming Systems on Scalable Architectures
Performance evaluation for parallel mixed-integer linear programming system
We implemented a parallel mixed-integer linear programming system and evaluated performance on a parallel computer with shared memory. Mixed-integer programming systems are implemented by branch-and-bound (B&B) and simplex algorithms in commercial systems. The system can solve problems including both integers and real variables in linear equations. Problems are solved by generating linear programming (LP) relaxation problems in the B&B algorithm and applying them to simplex algorithms. The parallel mixed-integer linear programming system is written in about 4,000 lines of C. In the initial problem solving stage, the system searches a tree using a depth-first strategy to find an incumbent solution as soon as possible. After the system finds an initial solution, it carries out branch cut processing using a breadth-first strategy. If the queue list managing the subproblem executed by simplex algorithm is empty, the incumbent is the optimal solution. We applied parallel programming to the search using a bread...
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 moreAn experiment to measure the usability of parallel programming systems
The growth of commercial and academic interest in parallel and distributed computing during the past 15 years has been accompanied by a corresponding increase in the number of available parallel programming systems (PPS). However, little work has been done to evaluate their usability, or to develop criteria for such evaluations. As a result, the usability of a typical PPS is based on how easily a small set of trivially parallel algorithms can be implemented by its authors. The paper discusses the design and results of an experiment to compare objectively the usability of two PPS. Half of the students in a graduate parallel and distributed computing course solved a problem using the Enterprise PPS while the other half used a PVM-like library of message-passing routines. The objective was to measure usability. The experiment provided valuable feedback as to what features of PPS are useful and the benefits they provide during the development of parallel programs. Although many usability experiments have been conducted for sequential programming languages and environments, they are rare in the parallel programming domain. Such experiments are necessary to help narrow the gap between what parallel programmers want and what current PPSs provide.
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 moreExecution kernel for parallel logic programming
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. >
Read more