Academia.eduAcademia.edu

Outline

Title
Abstract
Introduction
Access to Data
Results
References
All Topics
Computer Science

Parallel Execution of Independent Subgoals

Profile image of Christian PerceboisChristian Percebois

1988, IFAC Proceedings Volumes

Abstract

COALA (Actor-Oriented Computer for Logic and its Applications) is a multiprocessor architecture project. The aim of the project is to exploit pa r allelism inherent in logic programs automatically, i.e. without any programmer intervention. First , the paper summarizes the work presented earlier : the definition of a parallel interpreting model. Extensions are then presented which allow the model to take into account the execution of independent subgoals. The last part of the paper comments dynamic measureQents obtained from the different versions of the model .

Related papers

Simulation results of a multiprocessor PROLOG architecture based on a distributed and/or graph
Irene Durand

Lecture Notes in Computer Science, 1987

This paper summarizes the principal results of the simulation of the COALA (Calculateur Orient6 Acteurs pour ia Logique et ses Applications) machine : an Actor-Oriented Computer for Logic and its Applications.

View PDFchevron_right
An abstract interpretation scheme for identifying inherent parallelism in logic programs
Leon Sterling

New Generation Computing, 1990

We describe a new scheme for the abstract interpretation of logic programs. The scheme was developed to identify and integrate different forms of inherent parallelism in logic programs at compile time. The scheme has four components: generalization, abstract unification, summarization and concretization, algorithms for which are discussed. The abstract domain for interpretation consists of type expressions which are used as program modes. The generated mode information has been applied to identify different classes of procedures exhibiting different forms of inherent parallelism. The mode information has also been applied for detection of guards and producer-consumer relationship. The advantages and limitations of our resulting scheme are discussed. An Abstract Interpretation .Scheme for Identifying Inherent Parallelism in Logic Programs 275 suspended processes. We use mode information, expressed in terms of type expressions, to identify producer-consumer relationship and provide synchronization at compile time. We also use modes to identify guards. Development of transformation schemes: We use different source-tosource transformation scheme for simulation of OR-parallelism to stream parallelism and AND-parallelism under the framework of committedchoice AND-parallelism 1~ extended to generate multiple solutions. 2' 3~ This transformation integrates OR-parallelism, AND-parallelism, and stream parallelism. Logic Program Abstract Interpretation with abstract domain as polymorphic type expression Logic program with modes expressed as polymorphic type expressions Procedure Classification based on integration of type expression, modes, disjointness, and determinacy Logic program with procedure classification based upon inherent parallelism Transformation scheme to transform logic program to extended committed-choice AND-parallelism Transformed committed-choice logic program A.K. Bansal and L. S. Sterling

View PDFchevron_right
Annotation Algorithms for Unrestricted Independent And-Parallelism in Logic Programs
Amadeo Casas

Logic-Based Program Synthesis and …, 2008

We present two new algorithms which perform source-to-source transformations aimed at exploiting goal-level, restricted independent and-parallelism. They rely on annotating the code with execution primitives which are simpler and more flexible than the well-known &/2 parallel execution operator. This makes it possible to generate better parallel expressions by exposing more potential parallelism among the literals of a clause than is possible with &/2. The algorithms we present differ on whether the order of the solutions obtained is preserved or not and on the use of determinism information. Finally, we compare the performance obtained by our approach with that of previous annotation algorithms and show that we can obtain relevant improvements.

View PDFchevron_right
Distributed execution of actor programs
G. Agha

Languages and Compilers for Parallel Computing

A number of programming language models, including actors, provide inherent concurrency. We are developing high-level language constructs using actors and studying their implementation on multiprocessor architectures. This report describes our experience with programming in actors by means of a specic example of scientic computation. We also discuss work in progress on language annotations and compilation technology for ecient program execution on multiprocessors. 1 Introduction Concurrent language models, such as concurrent logic programming, functional programming and actors, provide inherent concurrency in the evaluation of expressions. However, unlike other models, actors allow state to be directly expressed and manipulated. Our experience suggests that this enables us to write programs which not only avoid unnecessary sequencing of actions but which are also easily understandable. We discuss the structure of actor languages and issues related to their implementation on distributed memory architectures.

View PDFchevron_right
Path for AND-parallel execution of logic programs
Suhyun lee

Information Processing Letters, 1994

An efficient backward execution method for AND-parallelism in logic programs is proposed. It is devised through a close examination of some relation over literals, which can be represented by paths in the data dependency graphs. The scheme is more efficient than other works in the sense that it performs less unfruitful resetting (and consequently, canceling) operations. Its rationale is also intuitively clear and natural. Furthermore, the relevant analyses needed for the proposal are largely achieved at compile time, which alludes to actual efficiency.

View PDFchevron_right
On Composing Concurrent Logic Processes
Leon Sterling

Proc. 12th Int'l Conf. on Logic Programming, ICLP

This paper discusses two methodological approaches for combining concur-rent programs written in a modular way. The rst one is based on the composition of traces. It is intuitive and simple but evidences the need for a more abstract approach. The second one meets this need. It ...

View PDFchevron_right
And-parallel execution of logic programs on a shared-memory multiprocessor
Yow-jian Lin

The Journal of Logic Programming, 1991

This paper presents the implementation and performance results of an ANn-parallel execution model of logic programs on a shared-memory multiprocessor. The execution model is meant for logic programs with "don't-know nondeterrninism", and handles binding conflicts by dynamically detecting dependencies among literals. The model also incorporates intelligent backtracking at the clause level. Our implementation of this model is based upon the Warren Abstract Machine (WAM); hence it retains most of the efficiency of the WAM for sequential segments of logic programs. Performance results on Sequent Balance 21000 show that on suitable programs, our parallel implementation can achieve linear speedup on dozens of processors. We also present an analysis of different overheads encountered in the implementation of the execution model.

View PDFchevron_right
An abstract model for parallel execution of prolog
Pedro Patinho

2017

Logic programming has been used in a broad range of fields, from artifficial intelligence applications to general purpose applications, with great success. Through its declarative semantics, by making use of logical conjunctions and disjunctions, logic programming languages present two types of implicit parallelism: and-parallelism and or-parallelism. This thesis focuses mainly in Prolog as a logic programming language, bringing out an abstract model for parallel execution of Prolog programs, leveraging the Extended Andorra Model (EAM) proposed by David H.D. Warren, which exploits the implicit parallelism in the programming language. A meta-compiler implementation for an intermediate language for the proposed model is also presented. This work also presents a survey on the state of the art relating to implemented Prolog compilers, either sequential or parallel, along with a walk-through of the current parallel programming frameworks. The main used model for Prolog compiler implement...

View PDFchevron_right
Massively parallel execution of logic programs: A static approach
Fabrizio Baiardi

Journal of Systems Architecture, 1997

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.

View PDFchevron_right
Parallel programming with logic languages: A survey
Paolo Ciancarini

Computer Languages, 1992

View PDFchevron_right

References (16)

  1. G. Berger Sabbatel. Mesures Com- portementales sur l'Interpretation de PROLOG. Actes du 5~me Seminai- re sur la Programmation en Logique, Tegastel, France, 21-23 mai 1986, pp. 293-307.
  2. J.S. Conery, D.F. Kibler. AND-Para- lelism and Nondeterminism in Logic Programs. New Generation Computing. Vol. 3 (1985), pp. 43-70.
  3. D. DeGroot. Restricted AND-Paral- lelism. Proc. of the International Conference of Fifth Generation Com- puter Systems 1984, Tokyo, Japan, November 1984, pp.47l-478.
  4. I. Durand. Un Mod~le d'Interpreta- tion Repartie pour une Architecture Multiprocesseur PROLOG. Doctorat de l'Universite Paul Sabatier, Tou- louse, France, Octobre 1986.
  5. I. Futo. System Simulation of Co- operative Problem Solving on a PROLOG basis.Implementations of PROLOG, ed. J. Campbell, Ellis Hortwood Ltd., England 1984, pp. 613-622.
  6. I. Futo, C. Percebois, I. Durand, C. Simon, B. Bonhoure. Simulation Study of a Multiprocessor PROLOG Architecture.First Italian Confe- rence on Logic Programming, Genova, Italy, March 1986 (invited paper).
  7. C. Hewitt, H. Lieberman. Design IAsues in Parallel Architectures for Artificial Intelligence. Proc. Compcon Spring 84, February 1984, pp. 418-423.
  8. N.Ito, H. Shimizu, M. Kishi, E. Kuno, R. Rokusawa. Data-Flow based Execution Mechanism of Parallel and Concurrent PROLOG. New Genera- tion Computing, Vol.3 (1985), pp. 15-4l.
  9. S. Kasif, M. Kohli, J. Minker. PRISM -A Parallel Inference Sys- tem for Problem Solving. Proc. of the 1983 Logic Programming Workshop, Algarve, Portugal, June 1983, pp. 123-152.
  10. S. Kasif, J. Minker. The Intelli- gent Channel : A Scheme for AND/OR Parallelism in Logic Programs. TR-1414, Department of Computer Science, University of Maryland, College Park, 1984.
  11. R.M. Keller, G. Lindstrom, S.Patil A Loosely Coupled Applicative Multi-Processing System. AFIPS Press, 1979, pp. 613-622.
  12. R. Kowalski. Logic for Problem Solving. The Computer Science Library, Elsevier, 1979.
  13. R. Onai, M. Aso, H. Shimizu, K. Kaneda, M. Matsumoto. Architecture of a Reduction-Based Parallel Inference Machine: PIM-R. New Generation Computing, Vol. 3 (1985) pp. 197-228.
  14. C. Percebois, I. Futo, I. Durand, C. Simon, B. Bonhoure. An Actor- Oriented Multiprocessor Architec- ture for Prolog : COALA.First Italian Conference on Logic Program- ming. Genova, Italy, March 1986 (invited paper).
  15. C. Percebois, I. Futo, I. Durand, C. Simon, B. Bonhoure. Simulation Results of a Multiprocessor PROLOG Architecture based on a Distribu- ted AND/OR Graph. International Joint Conference on Theory and Pratice of Software Development TAPSOFT'87, Pisa, Ital y , March 1987, pp.126-139.
  16. S. Taylor, A. Lowry, C.Q. Maguire Jr., S.J. Stolfo. Logic Program- ming using Parallel Associative Operations. Proc. of the 1984 International S ymposium on Logic Programming, Atlantic City, USA, February 1984, pp. 58-68." H. Westphal, P. Robert, J. Chassin, J.C. Syre. The PEPS y s Model: Combining Backtracking, AND-and OR-parallelism. Proc. 1987 Sympo- sium on Logic Programming, Au- gust 31-September 4 1987, San Francisco, pp. 436-448. . .

Related papers

A model for combined and-or parallel execution of logic programs
Bharat Jayaraman

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.

View PDFchevron_right
Automatic Unrestricted Independent And-Parallelism in Logic Programs
Amadeo Casas

2007

We present new algorithms which perform automatic parallelization via source-to-source transformations. The objective is to exploit goal-level, unrestricted independent andparallelism. The proposed algorithms use as targets new parallel execution primitives which are simpler and more flexible than the well-known &/2 parallel operator, which makes it possible to generate better parallel expressions by exposing more potential parallelism among the literals of a clause than is possible with &/2. The main differences between the algorithms stem from whether the order of the solutions obtained is preserved or not, and on the use of determinacy information. We briefly describe the environment where the algorithms have been implemented and the runtime platform in which the parallelized programs are executed. We also report on an evaluation of an implementation of our approach. We compare the performance obtained to that of previous annotation algorithms and show that relevant improvements can be obtained.

View PDFchevron_right
Effectivness of abstract interpretation in automatic parallelization: a case study in logic programming
Maria Garcia de la Banda

ACM Transactions on Programming Languages and Systems, 1999

We report on a detailed study of the application and e ectiveness of program analysis based on abstract interpretation to automatic program parallelization. We study the case of parallelizing logic programs using the notion of strict independence. We rst propose and prove correct a methodology for the application in the parallelization task of the information inferred by abstract interpretation, using a parametric domain. The methodology is generic in the sense of allowing the use of di erent analysis domains. A number of well-known approximation domains are then studied and the transformation into the parametric domain de ned. The transformation directly illustrates the relevance and applicability of each abstract domain for the application. Both local and global analyzers are then built using these domains and embedded in a complete parallelizing compiler. Then, the performance of the domains in this context is assessed through a number of experiments. A comparatively wide range of aspects is studied, from the resources needed by the analyzers in terms of time and memory to the actual bene ts obtained from the information inferred. Such bene ts are evaluated both in terms of the characteristics of the parallelized code and of the actual speedups obtained from it. The results show that data ow analysis plays an important role in achieving e cient parallelizations, and that the cost of such analysis can be reasonable even for quite sophisticated abstract domains. Furthermore, the results also o er signi cant insight into the characteristics of the domains, the demands of the application, and the trade-o s involved.

View PDFchevron_right
Exploiting implicit parallelism of logic languages with the SAM
Giancarlo Succi

1992

Abstract Many researchers have been trying to use the implicit parallelism of logic languages parallelizing the execu-tion of independent clauses. However this approach has the disadvantage of requiring a heavy overhead for processes scheduling and synchronizing, for data migration and for collecting the results. In this p~ per a different approach is proposed, the data paralfei one. The focus is on large collections of data and the core idea is to parallelize the execution ofelement-wise operations.

View PDFchevron_right
ACE: And/or-parallel copying-based execution of logic programs
Gopal Gupta

Lecture Notes in Computer Science, 1991

In this paper we present a novel execution model for parallel implementation of logic programs which is capable of exploiting both independent and-parallelism and or-parallelism in an e cient way. This model extends the stack copying approach, which has been successfully applied in the Muse system to implement or-parallelism, by integrating it with proven techniques used to support independent and-parallelism. We show how all solutions to non-deterministic andparallel goals are found without repetitions. This is done through recomputation as in Prolog (and in various and-parallel systems, like &-Prolog and DDAS), i.e., solutions of and-parallel goals are not shared. We propose a scheme for the e cient management of the address space in a way that is compatible with the apparently incompatible requirements of both and-and or-parallelism. We also show how the full Prolog language, with all its extra-logical features, can be supported in our and-or parallel system so that its sequential semantics is preserved. The resulting system retains the advantages of both purely or-parallel systems as well as purely and-parallel systems. The stack copying scheme together with our proposed memory management scheme can also be used to implement models that combine dependent and-parallelism and or-parallelism, such as Andorra and Prometheus.

View PDFchevron_right

Related topics

  • Computer Science
    • 580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved