Extended Dynamic Dependent And-Parallelism in ACE

1986

A backtracking algorithm for AND-Parallelism and its implementation at the Abstract Machine level are presented: first, a class of AND-Parallelism models based on goal independence is defined, and a generalized version of Restricted AND-Parallelism (RAP) introduced as characteristic of this class. A simple and efficient backtracking algorithm for RAP is then discussed. An implementation scheme is presented for this algorithm which offers minimum overhead, while retaining the performance and storage economy of sequent ial implementations and taking advantage of goal independence to avoid unnecessary backtracking ("restricted intelligent backtracking"). Finally, the implementation of backtracking in sequential and AND-Parallcl systems is explained through a number of examples.

ACM Transactions on Programming Languages and Systems, 1993

We discuss fundamental limitations of or-parallel execution models of nondeterministic programming languages. Or-parallelism corresponds to executing the di erent nondeterministic computational paths in parallel. A natural way to represent the state of (parallel) execution of a nondeterministic program is by means of an or-parallel tree. We identify three important criteria that underlie the design of or-parallel implementations based upon the or-parallel tree: constant-time access to variables, constant-time task creation, and constant-time task switching, where the term`constant-time' means that the time for these operations is independent of the number of nodes in the or-parallel tree, as well as the size of each node. We prove that all three criteria cannot be simultaneously satis ed by any or-parallel execution model based on a nite number of processors but unbounded memory. We discuss in detail the application of our result to the class of logic programming languages, and show how our result can serve as a useful way to categorize the various or-parallel methods proposed in this eld. We also discuss the suitability of di erent or-parallel implementation strategies for di erent parallel architectures. y This paper generalizes and expands the results in our paper, \Criteria for Or-Parallel Execution Models of Logic Programs," in

2008

Most efficient implementations of parallel logic programming rely on complex low-level machinery which is arguably difficult to implement and modify. We explore an alternative approach aimed at taming that complexity by raising core parts of the implementation to the source language level for the particular case of and-parallelism. We handle a significant portion of the parallel implementation at the Prolog level with the help of a comparatively small number of concurrency-related primitives which take care of lower-level tasks such as locking, thread management, stack set management, etc. The approach does not eliminate altogether modifications to the abstract machine, but it does greatly simplify them and it also facilitates experimenting with different alternatives. We show how this approach allows implementing both restricted and unrestricted (i.e., non fork-join) parallelism. Preliminary experiments show that the performance sacrificed is reasonable, although granularity control is required in some cases. Also, we observe that the availability of unrestricted parallelism contributes to better observed speedups.

New Generation Computing, 1996

The Agents Kernel Language (AKL) is a general purpose concurrent constraint language. It combines the programming paradigms of search-oriented languages such as Prolog and process-oriented languages such as GHC.

1989

Thus the extended and-or tree has two new nodes: a 'sequential' node (for RAP's sequential goals), and a 'cross-product' node (for the cross-product of solutions from and-or-parallel goals). The other main features of our approach are: (i) each processor's binding-array is accompanied by a base-array, for constant access-t ime to variables in the presence of andparallelism; (ii) coarse-grain parallelism is supported by our processor scheduling poli.q, to minimize the cost of binding-array updates during task-switching; (iii) essentially, two new classes of WAM instructions are introduced: the 'check' instructions of RAP-WA:VI, and 'allocate' instructions for the different types of nodes. (iv) Several optimizations are proposed to minimize the cost of task switrhing. This extended \\"AM is currently being implemented on a Balance Sequent 8000.

Proceedings of the ACM SIGPLAN 1989 Conference on Programming language design and implementation - PLDI '89, 1989

… on Implementation of …, 2007

The Journal of Logic Programming, 1993

This paper presents an extended and-or tree and an extended WAM (Warren Abstract Machine) for e ciently supporting both and-parallel and or-parallel execution of logic programs on shared-memory multiprocessors. Our approach for exploiting both andand or-parallelism is based on the binding-arrays method for or-parallelism and the RAP (Restricted And-Parallelism) method for and-parallelism, two successful methods for implementing or-parallelism and and-parallelism respectively. Our combined and-or model avoids redundant computations when goals exhibit both and-and or-parallelism, by representing the crossproduct of the solutions from the and-or parallel goals rather than re-computing them. We extend the classical and-or tree with two new nodes: a`sequential' node (for RAP's sequential goals), and a`crossproduct' node (for the crossproduct of solutions from and-or-parallel goals). The paper also presents an extension of the WAM, called AO-WAM, which is used to compile logic programs for and-or parallel execution based on the extended and-or tree. The AO-WAM incorporates a number of novel features: (i) inclusion of a base array with each processor's binding-array for constant-time access to variables in the presence of and-parallelism; (ii) inclusion of new stack frames and instructions to express solution sharing, (iii) novel optimizations which minimize the cost of binding-array updates in the presence of and-parallelism. y This is an expanded version of the paper, \Compiled And-Or Parallel Execution on Shared Memory

Computer Languages, 1996

We present the design and implementation of the and-parallel component of ACE. ACE is a computational model for the full Prolog language that simultaneously exploits both or-parallelism and independent and-parallelism. A high performance implementation of the ACE model has been realized and its performance reported in this paper. We discuss how some of the standard problems which appear when implementing and-parallel systems are solved in ACE. We then propose a number of optimizations aimed at reducing the overheads and the increased memory consumption which occur in such systems when using previously proposed solutions. Finally, we present results from an implementation of ACE which includes the optimizations proposed. The results show that ACE exploits and-parallelism with high e ciency and high speedups. Furthermore, they also show that the proposed optimizations, which are applicable to many other and-parallel systems, signi cantly decrease memory consumption and increase speedups and absolute performance both in forwards execution and during backtracking.

Parallel Processing Letters, 2010

The challenge of programming many-core architectures efficiently and effectively requires models and methods to co-design chip architectures and their software tool chain, using an approach that is both vertical and general. In this paper, we present compilation schemes for a general model of concurrency captured in a parallel language designed for system-level programming and as a target for higher level compilers. We also expose the challenges of integrating these transformation rules into a sequential-oriented compiler. Moreover, we discuss resource mapping inherent to those challenges. Our aim has been to reuse as much of the existing sequential compiler technology as possible in order to harness decades of prior research in compiling sequential languages.