A High-Level Implementation of Non-deterministic, Unrestricted, Independent And-Parallelism

Abstract

Abstract. The growing popularity of multicore architectures has renewed interest in language-based approaches to the exploitation of parallelism. Logic programming has proved an interesting framework to this end, and there are parallel implementations which have achieved significant speedups, but at the cost of a quite sophisticated low-level machinery. This machinery has been found challenging to code and, specially, to maintain and expand. In this paper, we follow a different approach which adopts a higher level view by raising some of the core components of the implementation to the level of the source language. We briefly present an implementation model for independent and-parallelism which fully supports non-determinism through backtracking and provides flexible solutions for some of the main problems found in previous andparallel implementations. Our proposal is able to optimize the execution for the case of deterministic programs and to exploit unrestricted andparallelism, which allows exposing more parallelism among clause literals than fork-join-based proposals. We present performance results for an implementation, including data for benchmarks where and-parallelism is exploited in non-deterministic programs.

An overview of Ciao and its design philosophy

“…These extensions have also introduced imperative control structures and nested syntactic scopes. Concurrency, Parallelism, and Distributed Execution: other packages bring in different capabilities for expressing concurrency (including a concurrent, shared version of the internal fact database which can be used for synchronization (Carro and Hermenegildo 1999)), distribution, and parallel execution (Cabeza and Hermenegildo 1995;Casas et al 2008). A notion of "active objects" also allows compiling objects so that they are ultimately mapped to a standalone process, which can then be transparently accessed by the rest of an application.…”

“…level which are used as support for independent and-parallel execution (Casas et al 2008). Task stealing is used to achieve independence between the number of O.S.…”

A Segment-Swapping Approach for Executing Trapped Computations

“…Unfortunately, this solution creates a difference between logical and physical views of the stacks, and adds the complexity of having to manage parallel accesses to the private stacks of each of the agents. More recently, a further solution to the problem was presented in [14], which is based on moving the execution of the trapped goals to the top of the stack before the agent starts to compute a new answer of the parallel goal. This solution simplifies the implementation, reducing the need for low-level machinery in comparison to previous approaches.…”

“…Such implementation is based on a previous high-level implementation of IAP [14], whose functionality has been augmented with the support to manage trapped goals and garbage slots.…”

“…In order to avoid complexity, recent approaches to independent and-parallelism focus more on simplicity than on ultimate performance, abstracting core components of the implementation out to the source level. In [14], a high-level implementation of goal-level IAP was proposed that showed reasonable speedups despite the overhead added by the high level nature of the implementation. Other recent proposals [15], with a different focus from traditional approaches, concentrate on providing machinery to take advantage of underlying thread-based OS building blocks.…”