Parallel execution of prolog programs: a survey

Since the early days of logic programming, researchers in the field realized the potential for exploitation of parallelism present in the execution of logic programs. Their high-level nature, the presence of nondeterminism, and their referential transparency, among other characteristics, make logic programs interesting candidates for obtaining speedups through parallel execution. At the same time, the fact that the typical applications of logic programming frequently involve irregular computations, make heavy use of dynamic data structures with logical variables, and involve search and speculation, makes the techniques used in the corresponding parallelizing compilers and run-time systems potentially interesting even outside the field. The objective of this article is to provide a comprehensive survey of the issues arising in parallel execution of logic programming languages along with the most relevant approaches explored to date in the field. Focus is mostly given to the challenges emerging from the parallel execution of Prolog programs. The article describes the major techniques used for shared memory implementation of Or-parallelism, And-parallelism, and combinations of the two. We also explore some related issues, such as memory management, compile-time analysis, and execution visualization.

[1]  Johan Montelius,et al.  Exploiting fine-grain parallelism in concurrent constraint languages , 1997, Uppsala theses in computing science.

[2]  Francesca Rossi,et al.  From Eventual to Atomic Locally Atomic CC Programs: A Concurrent Semantics , 1994, ALP.

[3]  Koen De Bosschere,et al.  Blackboard-based Extensions in Prolog , 1996, Softw. Pract. Exp..

[4]  Seif Haridi,et al.  Kernel Andorra Prolog and its Computation Model , 1990, ICLP.

[5]  Ricardo Bianchini,et al.  Evaluating parallel logic programming systems on scalable multiprocessors , 1997, PASCO '97.

[6]  Francesca Rossi,et al.  Strict and Nonstrict Independent And-Parallelism in Logic Programs: Correctness, Efficiency, and Compile-Time Conditions , 1995, J. Log. Program..

[7]  Jeffrey D. Ullman,et al.  Principles of Database and Knowledge-Base Systems, Volume II , 1988, Principles of computer science series.

[8]  Manuel V. Hermenegildo,et al.  Dynamic term size computation in logic programs via program transformation , 1993 .

[9]  Olivier Ridoux,et al.  Dynamic Memory Management for Sequential Logic Programming Languages , 1992, IWMM.

[10]  Khayri A. M. Ali,et al.  OR-Parallel Speedups in a Knowledge Based System: on Muse and Aurora , 1992, FGCS.

[11]  Ricardo Bianchini,et al.  Parallel Logic Programming Systems on Scalable Architectures , 2000, J. Parallel Distributed Comput..

[12]  Enrico Pontelli,et al.  Visualization of And/Or-Parallel Execution of Logic Programs , 1997, ICLP.

[13]  Kim Marriott,et al.  Independence in CLP languages , 2000, TOPL.

[14]  Gopal Gupta Parallel execution of logic programs on shared memory multiprocessors , 1992 .

[15]  Paolo Ciancarini,et al.  Blackboard programming in shared Prolog , 1990 .

[16]  Desh Ranjan,et al.  On the Complexity of Parallel Implementation of Logic Programs , 1997, FSTTCS.

[17]  Jacques Chassin de Kergommeaux,et al.  An Abstract Machine to Implement OR-AND Parallel Prolog Efficiently , 1990, J. Log. Program..

[18]  Rong Yang,et al.  Performance of the Compiler-Based Andorra-I System , 1993, ICLP.

[19]  Kish Shen,et al.  Overview of Daswam: Exploitation of Dependent and-Parallelism , 1996, J. Log. Program..

[20]  Manuel V. Hermenegildo,et al.  Combined Determination of Sharing and Freeness of Program Variables through Abstract Interpretation , 1991, ICLP.

[21]  Manuel V. Hermenegildo,et al.  Optimized Algorithms for Incremental Analysis of Logic Programs , 1996, SAS.

[22]  Jeffrey D. Uuman Principles of database and knowledge- base systems , 1989 .

[23]  Jonas Barklund,et al.  Providing Iteration and concurrency in Logic Programs Through Bounded Quantifications , 1992, FGCS.

[24]  Pascal Van Hentenryck Parallel Constraint Satisfaction in Logic Programming: Preliminary Results of CHIP within PEPSys , 1989, ICLP.

[25]  I. V. Ramakrishnan,et al.  Automata-Driven Indexing of Prolog Clauses , 1995, J. Log. Program..

[26]  Ricardo Bianchini,et al.  The Impact of Cache Coherence Protocols on Parallel Logic Programming Systems , 2000, Computational Logic.

[27]  Laxmikant V. Kalé,et al.  Machine Independent AND and OR Parallel Execution of Logic Programs: Part I-The Binding Environment , 1994, IEEE Trans. Parallel Distributed Syst..

[28]  Manuel V. Hermenegildo,et al.  Determination of Variable Dependence Information through Abstract Interpretation , 1989, NACLP.

[29]  Enrico Pontelli,et al.  Natural Language Multiprocessing: A Case Study , 1998, AAAI/IAAI.

[30]  Manuel Eduardo Correia,et al.  The SBA: Exploiting Orthogonality in AND-OR Parallel Systems , 1997, ILPS.

[31]  J. W. Lloyd,et al.  Foundations of logic programming; (2nd extended ed.) , 1987 .

[32]  David Y. Y. Yun,et al.  A Scalable Abstract Machine Model to Support Limited-OR (LOR) / Restricted-AND Parallelism (RAP) in Logic Programs , 1988, ICLP/SLP.

[33]  David H. D. Warren,et al.  The SRI Model for Or-Parallel Execution of Prolog: Abstract Design and Implementation Issues , 1987, SLP.

[34]  Enrico Pontelli,et al.  Shared Paged Binding Array: A Universal Datastructure for Parallel Logic Programming , 1995, ICLP.

[35]  Haruyasu Ueda Johan Montelius Dynamic Scheduling in an Implicit Parallel System , 1996 .

[36]  Rui Hu,et al.  Exploiting Parallelism in Tabled Evaluations , 1995, PLILP.

[37]  Ken Satoh,et al.  "Kabu-Wake" Parallel Inference Mechanism and It's Evaluation , 1986, FJCC.

[38]  Peter J. Stuckey,et al.  Incremental analysis of constraint logic programs , 2000, TOPL.

[39]  Maurice Bruynooghe,et al.  Improving abstract interpretations by combining domains , 1993, PEPM '93.

[40]  Manuel V. Hermenegildo,et al.  Some Paradigms for Visualizing Parallel Execution of Logic Programs , 1993, ICLP.

[41]  Enrico Pontelli,et al.  Optimization Schemas for Parallel Implementation of Nondeterministic Languages and Systems , 1997, IPPS.

[42]  Gary Lindstrom,et al.  Or-Parallelism on Applicative Architectures , 1984, International Conference on Logic Programming.

[43]  Manuel V. Hermenegildo,et al.  Using Attributed Variables in the Implementation of Concurrent and Parallel Logic Programming Systems , 1995, ICLP.

[44]  Manuel V. Hermenegildo Some Methodological Issues in the Design of CIAO, a Generic, Parallel Concurrent Constraint Logic Programming System , 1994, PPCP.

[45]  Laxmikant V. Kalé,et al.  Joining AND Parallel Solutions in AND/OR Parallel Systems , 1990, NACLP.

[46]  Enrico Pontelli,et al.  Construction and Optimization of a Parallel Engine for Answer Set Programming , 2001, PADL.

[47]  Gopal Gupta Multiprocessor Execution of Logic Programs , 1994, Springer US.

[48]  Raéd Yousef Sindaha Branch-Level Scheduling in Aurora: The Dharma Scheduler , 1993, ILPS.

[49]  Enrico Pontelli,et al.  Improving the Efficiency of Nondeterministic Independent and-Parallel Systems , 1996, Comput. Lang..

[50]  Akira Aiba,et al.  Parallel Constraint Logic Programming Language GDCC and its Parallel Constraint Solvers , 1992, FGCS.

[51]  Manuel V. Hermenegildo,et al.  Divided We Stand: Parallel Distributed Stack Memory Management , 1993, ICLP-Workshops on Implementation of Logic Programming Systems.

[52]  Amir M. Ben-Amram,et al.  What is a “pointer machine”? , 1995, SIGA.

[53]  Laxmikant V. Kalé,et al.  Compiled Execution of the Reduce-OR Process Model on Multiprocessors , 1989, NACLP.

[54]  Ivan Futó Prolog with Communicating Processes: From T-Prolog to CSR-Prolog , 1993, ICLP.

[55]  Håkan Millroth,et al.  Reform Prolog: The Language and Its Implementation , 1993, ICLP.

[56]  Desh Ranjan,et al.  Data structures for order-sensitive predicates in parallel nondeterministic systems , 2000, Acta Informatica.

[57]  Enrico Pontelli,et al.  On the Duality Between Or-parallelism and And-parallelism in Logic Programming , 1995, Euro-Par.

[58]  Philippe Codognet,et al.  Non-deterministic Stream AND-Parallelism Based on Intelligent Backtracking , 1989, ICLP.

[59]  Manuel V. Hermenegildo,et al.  A simulation study of or- and independent and-parallelism , 1991 .

[60]  Manuel V. Hermenegildo,et al.  An Automatic Translation Scheme from Prolog to the Andorra Kernel Language , 1992, FGCS.

[61]  Jerry L. Potter,et al.  An associative model to minimize matching and backtracking overhead in logic programs with large knowledge bases , 1992 .

[62]  Dennis F. Kibler,et al.  AND Parallelism in Logic Programs , 1983, IJCAI.

[63]  Jacques Chassin de Kergommeaux,et al.  Parallel logic programming systems , 1994, CSUR.

[64]  Ho-fung Leung,et al.  Concurrent Constraint Logic Programming On Massively Parallel SIMD Computers , 1993, ILPS.

[65]  Scheduling Strategies and Speculative Work , 1991, ICLP Workshop on Parallel Execution of Logic Programs.

[66]  Dean Jacobs,et al.  Static Analysis of Logic Programs for Independent And-Parallelism , 1992, J. Log. Program..

[67]  G. G. Stokes "J." , 1890, The New Yale Book of Quotations.

[68]  Michael Maher Initial Results from the Parallel Implementation of DASWAM , 1996 .

[69]  Manuel V. Hermenegildo,et al.  Extracting Non-Strict Independent And-Parallelism Using Sharing and Freeness Information , 1994, SAS.

[70]  Andrew Taylor,et al.  High Performance Prolog Implementation , 1991 .

[71]  Kim Marriott,et al.  Independence in Dynamically Scheduled Logic Languages , 1996, ALP.

[72]  J. Montelius,et al.  An and/or-parallel implementatin of AKL , 1996 .

[73]  Peter Van Roy,et al.  Can Logic Programming Execute as Fast as Imperative Programming? , 1990 .

[74]  Enrico Pontelli,et al.  Stack splitting A Simple Technique for Implementing Or parallelism and And parallelism on Distributed Machines , 2003 .

[75]  Doug DeGroot Restricted And-Parallelism and Side Effects , 1987, SLP.

[76]  Si-En Chang,et al.  Restricted AND-Parallelism Execution Model with Side-Effects , 1989, NACLP.

[77]  Ken Satoh,et al.  KABU-WAKE: A New Parallel Inference Method and Its Evaluation , 1986, COMPCON.

[78]  Lee Naish Parallelizing NU-Prolog , 1988, ICLP/SLP.

[79]  Manuel V. Hermenegildo,et al.  Program Analysis, Debugging, and Optimization Using the Ciao System Preprocessor , 1999, ICLP.

[80]  Donald A. Smith MultiLog: Data Or-Parallel Logic Programming , 1993, ICLP.

[81]  Manuel V. Hermenegildo,et al.  Efficient Management of Backtracking in AND-Parallelism , 1986, ICLP.

[82]  Kish Shen Exploiting Dependent And-Parallelism in Prolog: The Dynamic Dependent And-Parallel Scheme (DDAS) , 1992, JICSLP.

[83]  Manuel V. Hermenegildo,et al.  The CIAO Multi-Dialect Compiler and System: An Experimentation Workbench for Future (C)LP Systems , 1995, APPIA-GULP-PRODE.

[84]  Robert H. Halstead,et al.  Implementation of multilisp: Lisp on a multiprocessor , 1984, LFP '84.

[85]  Michael J. Wise,et al.  Implementations of distributed Prolog , 1992 .

[86]  Ewing L. Lusk,et al.  Experiments with OR-Parallel Logic Programs , 1987, ICLP.

[87]  Bart Demoen,et al.  Memory compaction for shared memory multiprocessors: design and specification , 1990 .

[88]  Evan Tick,et al.  Parallel logic programming , 1991, Logic programming.

[89]  Yale N. Patt,et al.  Unification Parallelism: How Much Can We Exploit? , 1989, NACLP.

[90]  M. Hermenegildo,et al.  Deriving a fixpoint computation algorithm for top-down abstract interpretation of logic programs , 1990 .

[91]  Lee Naish,et al.  NUA-Prolog: An Extension to the WAM for Parallel Andorra , 1991, ICLP.

[92]  Keith L. Clark,et al.  PARLOG: parallel programming in logic , 1986, ACM Trans. Program. Lang. Syst..

[93]  Saumya K. Debray,et al.  Lower Bound Cost Estimation for Logic Programs , 1997, ILPS.

[94]  William J. Older,et al.  An Incremental Garbage Collector for WAM-Based Prolog , 1992, JICSLP.

[95]  Robert M. Haralick,et al.  Increasing Tree Search Efficiency for Constraint Satisfaction Problems , 1979, Artif. Intell..

[96]  Enrico Pontelli,et al.  Efficient Backtracking in And-Parallel Implementations of Non-deterministic Languages , 1998, ICPP.

[97]  Evan Tick,et al.  The Deevolution of Concurrent Logic Programming Languages , 1995, J. Log. Program..

[98]  Ehud Shapiro,et al.  Concurrent PROLOG: Collected Papers , 1987 .

[99]  Manuel V. Hermenegildo,et al.  A Comparative Study of Methods for Automatic Compile-time Parallelization of Logic Programs , 1994, PASCO.

[100]  Manuel V. Hermenegildo,et al.  Flexible Scheduling for Non-Deterministic, And-parallel Execution of Logic Programs , 1996, Euro-Par, Vol. II.

[101]  Dana S. Scott,et al.  Concurrent constraint programming languages , 1989 .

[102]  Saumya K. Debray,et al.  Global Flow Analysis as a Practical Compilation Tool , 1992, J. Log. Program..

[103]  Maurice Bruynooghe,et al.  A Practical Framework for the Abstract Interpretation of Logic Programs , 1991, J. Log. Program..

[104]  Mats Carlsson,et al.  Interfacing Engines and Schedulers in OR-Parallel Prolog Systems , 1991, PARLE.

[105]  Manuel V. Hermenegildo,et al.  Efficient Term Size Computation for Granularity Control , 1995, ICLP.

[106]  Manuel V. Hermenegildo,et al.  Some methodological issues in the design of CIAO, a generic, parallel concurrent constraint system , 1994 .

[107]  John Wylie Lloyd,et al.  Foundations of Logic Programming , 1987, Symbolic Computation.

[108]  José M. Troya,et al.  An OR Parallel Prolog Model for Distributed Memory Systems , 1993, PLILP.

[109]  Ricardo J. Lopes The BEAM: Towards a first EAM Implementation , 1997 .

[110]  Rong Yang,et al.  The Andorra-I Engine: A Parallel Implementation of the Basic Andorra Model , 1991, ICLP.

[111]  Manuel V. Hermenegildo,et al.  Implementing Distributed Concurrent Constraint Execution in the CIAO System , 1996, APPIA-GULP-PRODE.

[112]  Francesca Rossi,et al.  Partial Order and Contextual Net Semantics for Atomic and Locally Atomic CC Programs , 1998, Sci. Comput. Program..

[113]  Dennis F. Kibler,et al.  Parallel interpretation of logic programs , 1981, FPCA '81.

[114]  Saumya K. Debray,et al.  Task granularity analysis in logic programs , 1990, PLDI '90.

[115]  David H. D. Warren,et al.  Scheduling Speculative Work in Or-Parallel Prolog Systems , 1993, ICLP.

[116]  Péter Szeredi Performance Analysis of the Aurora Or-Parallel Prolog System , 1989, NACLP.

[117]  Patrick Cousot,et al.  Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints , 1977, POPL.

[118]  Annika Wærn,et al.  Transparent And-Parallelism in the Presence of Shared Free Variables , 1988, ICLP/SLP.

[119]  Yves Deville,et al.  A Distributed Arc-Consistency Algorithm , 1995, Sci. Comput. Program..

[120]  Ian Foster,et al.  Strand: New Concepts in Parallel Programming , 1990 .

[121]  Michael J. Wise Prolog multiprocessors , 1986 .

[122]  Roland Karlsson,et al.  A High Performance OR-parallel Prolog System , 1992 .

[123]  Serge Le Huitouze A New Data Structure for Implementing Extensions to Prolog , 1990, PLILP.

[124]  Manuel V. Hermenegildo,et al.  Memory Performance of AND-parallel Prolog on Shared-Memory Architectures , 1988, ICPP.

[125]  Johan Bevemyr A Generational Parallel Copying Garbage Collector for Shared Memory Prolog , 1995 .

[126]  Yow-Jian Lin,et al.  A parallel implementation of logic programs , 1988 .

[127]  Enrico Pontelli,et al.  Data parallel logic programming in &ACE , 1995, SPDP.

[128]  Fosca Giannotti,et al.  A Technique for Recursive Invariance Detection and Selective Program Specification , 1991, PLILP.

[129]  Reem Bahgat,et al.  Pandora: Non-deterministic Parallel Logic Programming , 1989, ICLP.

[130]  Karen Villaverde,et al.  Incremental stack-splitting mechanisms for efficient parallel implementation of search-based AI systems , 2001, International Conference on Parallel Processing, 2001..

[131]  Vítor Santos Costa,et al.  Distance: A New Metric for Controlling Granularity for Parallel Execution , 1999, J. Funct. Log. Program..

[132]  Abraham Silberschatz,et al.  A framework for the parallel processing of Datalog queries , 1990, SIGMOD '90.

[133]  Manuel V. Hermenegildo,et al.  Effectivness of abstract interpretation in automatic parallelization: a case study in logic programming , 1999, TOPL.

[134]  Saumya K. Debray,et al.  Non-Failure Analysis for Logic Programs , 1997, ICLP.

[135]  Saumya K. Debray,et al.  Functional computations in logic programs , 1989, TOPL.

[136]  M. V. Hermenegildo,et al.  Designing a high performance parallel logic programming system , 1987, CARN.

[137]  Paul Tarau,et al.  Towards Inference and Computation Mobility: The Jinni Experiment , 1998, JELIA.

[138]  Luís Moniz Pereira,et al.  Delta Prolog: A Distributed Backtracking Extension with Events , 1986, ICLP.

[139]  David H. D. Warren,et al.  Flexible scheduling of or-parallelism is Aurora: the Bristol scheduler , 1991 .

[140]  Rong Yang,et al.  The Andorra-I Preprocessor: Supporting Full Prolog on the Basic Andorra Model , 1991, ICLP.

[141]  Hassan Aït-Kaci An introduction to LIFE: Programming with Logic, Inheritance, Functions, and Equations , 1993, ILPS.

[142]  Manuel V. Hermenegildo,et al.  Global Analysis of Standard Prolog Programs , 1996, ESOP.

[143]  Inês de Castro Dutra Strategies for Scheduling And- and Or-Parallel Work in Parallel Logic Programming Systems , 1994, ILPS.

[144]  Leon Sterling,et al.  The Art of Prolog , 1987, IEEE Expert.

[145]  Manuel V. Hermenegildo,et al.  Automatic Exploitation of Non-Determinate Independent And-Parallelism in the Basic Andorra Model , 1993, LOPSTR.

[146]  Rong Yang,et al.  Parallel Constraint Solving in Andorra-I , 1992, FGCS.

[147]  Saumya K. Debray,et al.  A Simple Program Transformation for Parallelism , 1994, ILPS.

[148]  Evan Tick,et al.  Memory performance of Prolog architectures , 1987, The Kluwer international series in engineering and computer science.

[149]  Inês de Castro Dutra,et al.  Distributing AND-work and OR-work in parallel logic programming systems , 1996, Proceedings of HICSS-29: 29th Hawaii International Conference on System Sciences.

[150]  Rong Yang,et al.  IDIOM: Integrating Dependent And-, Independent And-, and Or-parallelism , 1991, ISLP.

[151]  Paul Tarau,et al.  Blackboard‐based extensions in Prolog , 1996, Softw. Pract. Exp..

[152]  Manuel V. Hermenegildo,et al.  The DCG, UDG, and MEL Methods for Automatic Compile-time Parallelization of Logic Programs for Independent And-parallelism , 1990, ICLP.

[153]  Bart Demoen,et al.  A Parallel Implementation for AKL , 1993, PLILP.

[154]  Doug DeGroot,et al.  Restricted AND-Parallelism , 1984, FGCS.

[155]  Ewing Lusk,et al.  Studying parallel program behavior with upshot , 1991 .

[156]  Enrico Pontelli,et al.  Extended dynamic dependent and-parallelism in ACE , 1997, PASCO '97.

[157]  Enrico Pontelli,et al.  Concurrent Web-Programming in CLP(WEB) , 2000, HICSS.

[158]  Hans Tebra Optimistic And-Parallelism in Prolog , 1987, PARLE.

[159]  Patrick Cousot,et al.  Abstract Interpretation and Application to Logic Programs , 1992, J. Log. Program..

[160]  Enrico Pontelli,et al.  ACE: And/Or-parallel Copying-based Execution of Logic Programs , 1994, ICLP.

[161]  Gopal Gupta,et al.  And-Or Parallelism on Shared-Memory Multiprocessors , 1993, J. Log. Program..

[162]  Manuel V. Hermenegildo,et al.  Abstract Multiple Specialization and Its Application to Program Parallelization , 1999, J. Log. Program..

[163]  Takashi Chikayama,et al.  Paragraph: A Graphical Tuning Tool for Multiprocessor Systems , 1992, FGCS.

[164]  Joachim Schimpf,et al.  ECLiPSe: A Platform for Constraint Logic Programming , 1997 .

[165]  Saumya K. Debray,et al.  A Methodology for Granularity-Based Control of Parallelism in Logic Programs , 1996, J. Symb. Comput..

[166]  Raéd Yousef Sindaha The Dharma scheduler-definitive scheduling in Aurora on multiprocessors architecture , 1992, [1992] Proceedings of the Fourth IEEE Symposium on Parallel and Distributed Processing.

[167]  Gopal Gupta,et al.  Cuts and Side-Effects in And-Or Parallel Prolog , 1996, J. Log. Program..

[168]  Donald A. Smith,et al.  Multilog and Data or-Parallelism , 1996, J. Log. Program..

[169]  Evelina Lamma,et al.  Improving Distributed Unification through Type Analysis , 1997, Euro-Par.

[170]  Akikazu Takeuchi Parallel logic programming , 1992, Wiley series in parallel computing.

[171]  Manuel V. Hermenegildo,et al.  The ciao prolog system , 2002 .

[172]  Håkan Millroth Reforming Compilation of Logic Programs , 1991, ISLP.

[173]  Doug DeGroot A Technique for Compiling Execution Graph Expressions for Restricted And-Parallelism in Logic Programs , 1988, J. Parallel Distributed Comput..

[174]  Maurice Bruynooghe,et al.  A framework for the abstract interpretation of logic programs , 1987 .

[175]  George H. Pollard Parallel execution of Horn clause programs , 1982 .

[176]  R. Costa,et al.  YAP user''s manual , 1989 .

[177]  Hassan Aït-Kaci,et al.  Warren's Abstract Machine: A Tutorial Reconstruction , 1991 .

[178]  Péter Szeredi,et al.  Applications of the Aurora Parallel Prolog System to Computational Molecular Biology , 1993, ILPS.

[179]  Laxmikant V. Kalé,et al.  A Memory Organization Independent Binding Environment for AND and OR Parallel Execution of Logic Programs , 1988, ICLP/SLP.

[180]  Simon Kasif,et al.  PRISM - A Parallel Inference System for Problem Solving , 1983, Logic Programming Workshop.

[181]  Manuel V. Hermenegildo,et al.  Using Attributed Variables in the Implementation of Parallel and Concurrent Logic Programming Systems , 1994, Workshop on Design and Impl. of Parallel Logic Programming Systems.

[182]  Nikos Drakos Unrestricted And-Parallel Execution of Logic Programs with Dependency Directed Backtracking , 1989, IJCAI.

[183]  Dean Jacobs,et al.  Accurate and Efficient Approximation of Variable Aliasing in Logic Programs , 1989, NACLP.

[184]  Ricardo Rocha,et al.  Novel Models for Or-Parallel Logic Programs: A Performance Analysis , 2000, Euro-Par.

[185]  Peter Kacsuk Execution models of Prolog for parallel computers , 1990 .

[186]  Bogumil Hausman Pruning and Scheduling Speculative Work in Or-Parallel Prolog , 1989, PARLE.

[187]  Laxmikant V. Kalé,et al.  The Reduce-Or Process Model for Parallel Execution of Logic Programs , 1991, J. Log. Program..

[188]  Rong Yang,et al.  Andorra I: a parallel Prolog system that transparently exploits both And-and or-parallelism , 1991, PPOPP '91.

[189]  Laura Ricci,et al.  Pipeline optimizations in and-parallelism by abstract interpretation , 1990 .

[190]  David Page ILP: Just Do It , 2000, ILP.

[191]  Saumya K. Debray,et al.  Estimating the Computational Cost of Logic Programs , 1994, SAS.

[192]  Paul Tarau,et al.  Inference and Computation Mobility with Jinni , 1999, The Logic Programming Paradigm.

[193]  Doug DeGroot A Technique for Compiling Execution Graph Expressions for Restricted and Parallelism in Logic Programs , 1987, ICS.

[194]  André Véron,et al.  Virtual memory support for OR-parallel logic programming systems , 1991 .

[195]  Karsten Schmidt,et al.  How to calculate symmetries of Petri nets , 2000 .

[196]  Manuel V. Hermenegildo,et al.  Relating Goal-Scheduling, Precedence, and Memory Management in AND-Parallel Execution of Logic Programs , 1987, ICLP.

[197]  Lourdes Araujo,et al.  Parallel Execution Models for Constraint Programming over Finite Domains , 1999, PPDP.

[198]  Dennis J. Volper,et al.  Geometric retrieval in parallel , 1988 .

[199]  Peter Van Roy,et al.  1983-1993: The Wonder Years of Sequential Prolog Implementation , 1994, J. Log. Program..

[200]  Lourdes Araujo,et al.  A Parallel Prolog System for Distributed Memory , 1997, J. Log. Program..

[201]  Peter Van Roy,et al.  High-performance logic programming with the Aquarius Prolog compiler , 1992, Computer.

[202]  Kish Shen Improving the Execution of Dependent And-Parallel Prolog DDAS , 1994, PARLE.

[203]  Kenneth R. Traub,et al.  Compilation as partitioning: a new approach to compiling non-strict functional languages , 1989, FPCA.

[204]  Manuel V. Hermenegildo,et al.  Effectiveness of combined sharing and freeness analysis using abstract interpretation , 1992 .

[205]  Inês de Castro Dutra,et al.  Distributing and- and or-work in the Andorra-I parallel logic programming system , 1995 .

[206]  Ehud Shapiro,et al.  The family of concurrent logic programming languages , 1989, CSUR.

[207]  Mats Carlsson Design and implementation of an or-parallel Prolog engine , 1990, RIT / KTH / TRITA-CS.

[208]  Mats Carlsson,et al.  Guest Editors' Introduction: High-Performance Implementations of Logic Programming Systems , 1996, J. Log. Program..

[209]  Gert Smolka Constraints in OZ , 1996, CSUR.

[210]  Ho-fung Leung,et al.  Performance of a Data-Parallel Concurrent Constraint Programming System , 1995, ASIAN.

[211]  Peter Borgwardt Parallel Prolog Using Stack Segements on Shared-Memory Multiprocessors , 1984, SLP.

[212]  David Maier,et al.  Computing with logic , 1988 .

[213]  Vipin Kumar,et al.  AND-Parallel Execution of Logic Programs on a Shared-Memory Multiprocessor , 1988, J. Log. Program..

[214]  Manuel V. Hermenegildo,et al.  IDRA (IDeal Resource Allocation): Computing Ideal Speedups in Parallel Logic Programming , 1996, Euro-Par, Vol. II.

[215]  Manuel Eduardo Correia,et al.  DAOS - Scalable And-Or Parallelism , 1999, Euro-Par.

[216]  Manuel V. Hermenegildo,et al.  Automatic Compile-Time Parallelization of Logic Programs for Restricted, Goal Level, Independent and Parallelism , 1999, J. Log. Program..

[217]  Enrico Pontelli,et al.  Stack-splitting: Or-/And-parallelism on Distributed Memory Machines , 1999, ICLP.

[218]  Pascal Van Hentenryck,et al.  Design, Implementation, and Evaluation of the Constraint Language cc(FD) , 1994, Constraint Programming.

[219]  Rong Yang P-Prolog - A Parallel Logic Programming Language , 1988, World Scientific Series in Computer Science.

[220]  Kim Marriott,et al.  Analyzing logic programs with dynamic scheduling , 1994, POPL '94.

[221]  Seif Haridi,et al.  An evaluation of Penny: a system for fine grain implicit parallelism , 1997, PASCO '97.

[222]  Manuel V. Hermenegildo,et al.  Relating Data-Parallelism and (and-) Parallelism in Logic Programs , 1995, Comput. Lang..

[223]  Andrzej Ciepielewski,et al.  Performance Evaluation of a Storage Model for OR--Parallel Execution of Logic Programs , 1986, SLP.

[224]  Manuel V. Hermenegildo,et al.  An Abstract Machine for Restricted AND-Parallel Execution of Logic Programs , 1986, ICLP.

[225]  Kazunori Ueda,et al.  Guarded Horn Clauses , 1986, LP.

[226]  J. Lloyd Foundations of Logic Programming , 1984, Symbolic Computation.

[227]  Desh Ranjan,et al.  The Temporal Precedence Problem , 2000, Algorithmica.

[228]  Gilberto Filé,et al.  Yet Another Intelligent Backtracking Method , 1988, ICLP/SLP.

[229]  Saumya K. Debray,et al.  Cost analysis of logic programs , 1993, TOPL.

[230]  Mats Carlsson On the Efficiency of Optimising Shallow Backtracking in Compiled Prolog , 1989, ICLP.

[231]  Victor W. Marek,et al.  Computing stable models in parallel , 2001, Answer Set Programming.

[232]  David A. Bader,et al.  SIMPLE: A Methodology for Programming High Performance Algorithms on Clusters of Symmetric Multiprocessors (SMPs) , 1998, J. Parallel Distributed Comput..

[233]  Jack Belzer,et al.  Encyclopedia of Computer Science and Technology , 2020 .

[234]  Nuno A. Fonseca,et al.  VisAll: A Universal Tool to Visualise Parallel Execution of Logic Programs , 1998, IJCSLP.

[235]  Kish Shen Studies of and/or parallelism in Prolog , 1992 .

[236]  Saumya K. Debray,et al.  Transformationbased implementation and optimization of programs exploiting the basic Andorra model. , 1995 .

[237]  Seif Haridi,et al.  A Formal Model for Or-Parallel Execution of Logic Programs , 1983, IFIP Congress.

[238]  Péter Szeredi,et al.  Scheduling Or-parallelism in Aurora: The Manchester Scheduler , 1989, International Conference on Logic Programming.

[239]  Steven David Prestwich,et al.  Visualizing Parallel Logic Program Execution for Performance Tuning , 1996, JICSLP.

[240]  Inẽs de Castro Dutra,et al.  Strategies for scheduling and- and or- work in parallel logic programming systems , 1994, ICLP 1994.

[241]  Dharma P. Agrawal,et al.  A Randomized Parallel Backtracking Algorithm , 1988, IEEE Trans. Computers.

[242]  Paul Watson,et al.  Or-Parallel Prolog on a Distributed Memory Architecture , 2000, J. Log. Program..

[243]  Mike Reeve,et al.  Why and How in the ElipSys OR-parallel CLP System , 1993, PARLE.

[244]  Kim Marriott,et al.  Independence in Constraint Logic Programs , 1993, ILPS.

[245]  Ricardo Rocha,et al.  YapOr: an Or-Parallel Prolog System Based on Environment Copying , 1999, EPIA.

[246]  Vanusa Menditi Calegario,et al.  Performance Evaluation of Or-Parallel Logic Programming Systems on Distributed Shared-Memory Architectures , 1999, Euro-Par.

[247]  Enrico Pontelli,et al.  Implementation Mechanisms for Dependent And-Parallelism , 1997, ICLP.

[248]  Andrzej Ciepielewski,et al.  Cut and Side-Effects in Or-Parallel Prolog , 1988, FGCS.

[249]  Robert A. Kowalski,et al.  Logic for problem solving , 1982, The computer science library : Artificial intelligence series.

[250]  Philip T. Cox,et al.  Finding Backtrack Points for Intelligent Backtracking , 1984, Implementations of Prolog.

[251]  Michael J. Maher,et al.  The Semantics of Constraint Logic Programs , 1998, J. Log. Program..

[252]  Christian Schulte,et al.  Parallel Search Made Simple , 2000 .

[253]  Doug DeGroot,et al.  AND-Parallelism of Logic Programs Based on a Static Data Dependency Analysis , 1985, COMPCON.

[254]  Seif Haridi,et al.  Data Diffusion Machine - A Scalable Shared Virtual Memory Multiprocessor , 1988, FGCS.

[255]  Philippe Robert,et al.  The Parallel ECRC Prolog System PEPSys: An Overview and Evaluation Results , 1988, FGCS.

[256]  Ricardo Bianchini,et al.  The Influence of Architectural Parameters on the Performance of Parallel Logic Programming Systems , 1999, PADL.

[257]  Andy King,et al.  Lower-bound Time-complexity Analysis of Logic Programs , 1997, ILPS.

[258]  Ewing L. Lusk,et al.  A Graphical Tool for Observing the Behavior of Parallel Logic Programs , 1987, SLP.

[259]  Philippe Robert,et al.  The PEPSys Model: Combining Backtracking, AND- and OR-Parallelism , 1987, SLP.

[260]  Seif Haridi,et al.  OR-Parallel Prolog Made Efficient on Shared Memory Multiprocessors , 1987, SLP.

[261]  William McCune,et al.  Parallel Logic Programming for Numeric Applications , 1986, ICLP.

[262]  Gopal Gupta,et al.  Analysis of Or-parallel execution models , 1993, TOPL.

[263]  Bart Demoen,et al.  A la recherche de la me´moire perdu: Memory compaction for shared memory multiprocessors , 1990 .

[264]  Inês de Castro Dutra,et al.  A Flexible Scheduler for the Andorra-I System , 1991, ICLP Workshop on Parallel Execution of Logic Programs.

[265]  Barbara M. Chapman,et al.  Supercompilers for parallel and vector computers , 1990, ACM Press frontier series.

[266]  Abraham Silberschatz,et al.  Distributed processing of logic programs , 1988, SIGMOD '88.

[267]  Lu Xu,et al.  Distributed Garbage Collection for the Parallel Inference Engine PIE64 , 1989, NACLP.

[268]  HaridiSeif,et al.  Garbarge collection for Prolog based on WAM , 1988 .

[269]  Pascal Van Hentenryck ACE: And/Or-parallel Copying-based Execution of Logic Programs , 1994 .

[270]  Laurent Perron Search Procedures and Parallelism in Constraint Programming , 1999, CP.

[271]  Laxmikant Vasudeo Kale Parallel architectures for problem solving (prolog, logic-programming, interconnection, network) , 1985 .

[272]  Håkan Millroth,et al.  Compiler Optimizations in Reform Prolog: Experiments on the KSR-1 Multiprocessor , 1995, Euro-Par.

[273]  David Page,et al.  ILP: Just Do It , 2000, Computational Logic.

[274]  Takashi Chikayama,et al.  A Portable and Efficient Implementation of KL1 , 1994, PLILP.

[275]  Gopal Gupta,et al.  And-or parallelism in full prolog , 1991 .

[276]  Ian T. Foster,et al.  A Sequential Implementation of Parlog , 1986, ICLP.

[277]  Akira Hattori,et al.  Generation Type Garbage Collection for Parallel Logic Languages , 1990, NACLP.

[278]  Manuel V. Hermenegildo,et al.  An abstract machine based execution model for computer architecture design and efficient implementation of logic programs in parallel , 1986 .

[279]  Maurice Bruynooghe,et al.  Towards a Real-Time Garbage Collector for Prolog , 1985, SLP.

[280]  Gopal Gupta,et al.  High performance logic programming , 2000 .

[281]  Péter Szeredi Using Dynamic Predicates in an Or--Parallel Prolog System , 1991, ISLP.

[282]  Joachim Schimpf,et al.  Parallel CLP on Heterogeneous Networks , 1994, ICLP.

[283]  Enrico Pontelli,et al.  &ACE: a high-performance parallel Prolog system , 1995, IPPS.

[284]  Fumio Mizoguchi,et al.  Concurrent Execution of Optimal Hypothesis Search for Inverse Entailment , 2000, ILP.

[285]  Manuel V. Hermenegildo,et al.  Concurrency in Prolog Using Threads and a Shared Database , 1999, ICLP.

[286]  Mi Lu A Parallel Unification , 1990 .

[287]  Shyam Mudambi Performances of Aurora on NUMA Machines , 1991, ICLP.

[288]  Manuel V. Hermenegildo,et al.  Towards Independent And-Parallelism in CLP , 1996, PLILP.

[289]  Mats Carlsson,et al.  SICStus Prolog User''s Manual , 1993 .

[290]  Manuel V. Hermenegildo Parallelizing irregular and pointer-based computations automatically: Perspectives from logic and constraint programming , 2000, Parallel Comput..

[291]  Enrico Pontelli,et al.  Automatic Compile-time Parallelization of Prolog Programs for Dependent And-Parallelism , 1997, ICLP.

[292]  Khayri A. M. Ali OR-Parallel Execution of Prolog on BC-Machine , 1988, ICLP/SLP.

[293]  Kish Shen Initial Results of the Parallel Implementation of DASWAM , 1996, JICSLP.

[294]  Ricardo Rocha,et al.  Or-Parallelism within Tabling , 1999, PADL.

[295]  John S. Conery Parallel Execution of Logic Programs , 1987 .

[296]  Manuel V. Hermenegildo,et al.  Compile-Time Derivation of Variable Dependency Using Abstract Interpretation , 1992, J. Log. Program..

[297]  David H. D. Warren,et al.  Or-Parallel Execution Models of Prolog , 1987, TAPSOFT, Vol.2.

[298]  Allan Gottlieb,et al.  Highly parallel computing , 1989, Benjamin/Cummings Series in computer science and engineering.

[299]  I. V. Ramakrishnan,et al.  Automata-driven indexing of Prolog clauses , 1989, POPL '90.

[300]  Jean-Marie Jacquet,et al.  Multi-Prolog: Definition, Operational Semantics and Implementation , 1993, International Conference on Logic Programming.

[301]  Jim A. Crammond A comparative study of unification algorithms for OR-parallel execution of logic languages , 1985, IEEE Transactions on Computers.

[302]  Timothy J. Hickey,et al.  Global Compilation of Prolog , 1989, J. Log. Program..

[303]  B. Ramkumar,et al.  Machine Independent AND and OR Parallel Execution of Logic Programs: Part II-Compiled Execution , 1994, IEEE Trans. Parallel Distributed Syst..

[304]  Vítor Santos Costa COWL: Copy-On-Write for logic programs , 1999, Proceedings 13th International Parallel Processing Symposium and 10th Symposium on Parallel and Distributed Processing. IPPS/SPDP 1999.