Parallel Logic Programming: A Sequel

Multi-core and highly connected architectures have become ubiquitous, and this has brought renewed interest in language-based approaches to the exploitation of parallelism. Since its inception, logic programming has been recognized as a programming paradigm with great potential for automated exploitation of parallelism. The comprehensive survey of the first twenty years of research in parallel logic programming, published in 2001, has served since as a fundamental reference to researchers and developers. The contents are quite valid today, but at the same time the field has continued evolving at a fast pace in the years that have followed. Many of these achievements and ongoing research have been driven by the rapid pace of technological innovation, that has led to advances such as very large clusters, the wide diffusion of multi-core processors, the game-changing role of general-purpose graphic processing units, and the ubiquitous adoption of cloud computing. This has been paralleled by significant advances within logic programming, such as tabling, more powerful static analysis and verification, the rapid growth of Answer Set Programming, and in general, more mature implementations and systems. This survey provides a review of the research in parallel logic programming covering the period since 2001, thus providing a natural continuation of the previous survey. In order to keep the survey self-contained, it restricts its attention to parallelization of the major logic programming languages (Prolog, Datalog, Answer Set Programming) and with an emphasis on automated parallelization and preservation of the sequential observable semantics of such languages. The goal of the survey is to serve not only as a reference for researchers and developers of logic programming systems but also as engaging reading for anyone interested in logic and as a useful source for researchers in parallel systems outside logic programming.

[1]  V. S. Costa,et al.  Fifty Years of Prolog and Beyond , 2022, Theory Pract. Log. Program..

[2]  John P. Gallagher,et al.  Analysis and Transformation of Constrained Horn Clauses for Program Verification , 2021, Theory Pract. Log. Program..

[3]  Andrea Formisano,et al.  Scalable Energy Games Solvers on GPUs , 2021, IEEE Transactions on Parallel and Distributed Systems.

[4]  John P. Gallagher,et al.  From Big-Step to Small-Step Semantics and Back with Interpreter Specialisation , 2020, VPT/HCVS@ETAPS.

[5]  Paraschos Koutris,et al.  Topology-aware Parallel Data Processing: Models, Algorithms and Systems at Scale , 2020, CIDR.

[6]  Manuel V. Hermenegildo,et al.  Incremental Analysis of Logic Programs with Assertions and Open Predicates , 2019, LOPSTR.

[7]  Agostino Dovier,et al.  GPU-based parallelism for ASP-solving , 2019, DECLARE.

[8]  Pavle Subotic,et al.  Fast Parallel Equivalence Relations in a Datalog Compiler , 2019, 2019 28th International Conference on Parallel Architectures and Compilation Techniques (PACT).

[9]  John P. Gallagher,et al.  Towards a General Framework for Static Cost Analysis of Parallel Logic Programs , 2019, ArXiv.

[10]  Carlo Zaniolo,et al.  A Case for Stale Synchronous Distributed Model for Declarative Recursive Computation , 2019, Theory and Practice of Logic Programming.

[11]  Martin Gebser,et al.  The Seventh Answer Set Programming Competition: Design and Results , 2019, Theory and Practice of Logic Programming.

[12]  Bernhard Scholz,et al.  A specialized B-tree for concurrent datalog evaluation , 2019, PPoPP.

[13]  Jignesh M. Patel,et al.  Scaling-Up In-Memory Datalog Processing: Observations and Techniques , 2018, Proc. VLDB Endow..

[14]  Agostino Dovier,et al.  Towards Distributed Computation of Answer Sets , 2019, CILC.

[15]  Alice Tarzariol,et al.  Evolution of Algorithm Portfolio for Solving Strategies , 2019, CILC.

[16]  Chiaki Sakama,et al.  Computing Logic Programming Semantics in Linear Algebra , 2018, MIWAI.

[17]  Manuel V. Hermenegildo,et al.  Static Performance Guarantees for Programs with Runtime Checks , 2018, PPDP.

[18]  Miroslaw Truszczynski,et al.  An introduction to the stable and well-founded semantics of logic programs , 2018, Declarative Logic Programming.

[19]  Manuel V. Hermenegildo,et al.  Multivariant Assertion-based Guidance in Abstract Interpretation , 2018, LOPSTR.

[20]  Antonius Weinzierl,et al.  The DLVHEX System , 2018, KI - Künstliche Intelligenz.

[21]  Steffen Zeuch,et al.  Query Execution on Modern CPUs , 2018 .

[22]  Carlo Zaniolo,et al.  Scaling-up reasoning and advanced analytics on BigData , 2018, Theory and Practice of Logic Programming.

[23]  Martin Gebser,et al.  Evaluation Techniques and Systems for Answer Set Programming: a Survey , 2018, IJCAI.

[24]  Andrea Omicini,et al.  Logic Programming as a Service , 2018, Theory Pract. Log. Program..

[25]  Ciaran McCreesh,et al.  A review of literature on parallel constraint solving , 2018, Theory and Practice of Logic Programming.

[26]  Manuel V. Hermenegildo,et al.  Interval-based resource usage verification by translation into Horn clauses and an application to energy consumption , 2018, Theory and Practice of Logic Programming.

[27]  Jianzhong Li,et al.  Data management on new processors: A survey , 2018, Parallel Comput..

[28]  Manuel V. Hermenegildo,et al.  Some trade-offs in reducing the overhead of assertion run-time checks via static analysis , 2018, Sci. Comput. Program..

[29]  Agostino Dovier,et al.  Parallel Answer Set Programming , 2018, Handbook of Parallel Constraint Reasoning.

[30]  Manuel V. Hermenegildo,et al.  Static Performance Guarantees for Programs with Runtime Checks , 2018, PPDP.

[31]  Agostino Dovier,et al.  MASP-Reduce: A Proposal for Distributed Computation of Stable Models , 2018, ICLP.

[32]  Nataliia Stulova Improving Run-time Checking in Dynamic Programming Languages , 2018 .

[33]  Manuel V. Hermenegildo,et al.  Towards Incremental and Modular Context-Sensitive Analysis , 2018, ICLP.

[34]  Andrea Formisano,et al.  Accelerating Energy Games Solvers on Modern Architectures , 2017, IA3@SC.

[35]  Antonius Weinzierl,et al.  Techniques for Efficient Lazy-Grounding ASP Solving , 2017, DECLARE.

[36]  Carlo Zaniolo,et al.  Fixpoint semantics and optimization of recursive Datalog programs with aggregates* , 2017, Theory and Practice of Logic Programming.

[37]  Yi-Cheng Tu,et al.  Fast Equi-Join Algorithms on GPUs: Design and Implementation , 2017, SSDBM.

[38]  Ricardo Rocha,et al.  On scaling dynamic programming problems with a multithreaded tabling Prolog system , 2017, J. Syst. Softw..

[39]  Alsayed Algergawy,et al.  Accelerating relational database operations using both CPU and GPU co-processor , 2017, Comput. Electr. Eng..

[40]  Alin Deutsch,et al.  Datalography: Scaling datalog graph analytics on graph processing systems , 2016, 2016 IEEE International Conference on Big Data (Big Data).

[41]  Ricardo Rocha,et al.  On the Implementation of an Or-Parallel Prolog System for Clusters of Multicores , 2016, Theory Pract. Log. Program..

[42]  Temesghen Kahsai,et al.  JayHorn: A Framework for Verifying Java programs , 2016, CAV.

[43]  Bernhard Scholz,et al.  Soufflé: On Synthesis of Program Analyzers , 2016, CAV.

[44]  Carlo Zaniolo,et al.  Big Data Analytics with Datalog Queries on Spark , 2016, SIGMOD Conference.

[45]  Sudhakar Yalamanchili,et al.  General-purpose join algorithms for large graph triangle listing on heterogeneous systems , 2016, GPGPU@PPoPP.

[46]  Agostino Dovier,et al.  A GPU Implementation of the ASP Computation , 2016, PADL.

[47]  Neng-Fa Zhou,et al.  The Picat-SAT Compiler , 2016, PADL.

[48]  Alexander Shkapsky,et al.  A Declarative Language for Advanced Analytics and its Scalable Implementation , 2016 .

[49]  Neng-Fa Zhou,et al.  Constraint Solving and Planning with Picat , 2015, SpringerBriefs in Intelligent Systems.

[50]  Yin-Fu Huang,et al.  Parallel Query on the In-Memory Database in a CUDA Platform , 2015, 2015 10th International Conference on P2P, Parallel, Grid, Cloud and Internet Computing (3PGCIC).

[51]  Magdalena Balazinska,et al.  Asynchronous and Fault-Tolerant Recursive Datalog Evaluation in Shared-Nothing Engines , 2015, Proc. VLDB Endow..

[52]  Jorge A. Navas,et al.  The SeaHorn Verification Framework , 2015, CAV.

[53]  Alberto Pettorossi,et al.  Semantics-based generation of verification conditions by program specialization , 2015, PPDP.

[54]  Tom Schrijvers,et al.  Tabling as a Library with Delimited Control , 2016, IJCAI.

[55]  Manuel V. Hermenegildo,et al.  Practical run-time checking via unobtrusive property caching , 2015, Theory and Practice of Logic Programming.

[56]  Ricardo Rocha,et al.  Batched Evaluation of Full-Sharing Multithreaded Tabling , 2015, SLATE.

[57]  Alessandro Dal Palù,et al.  CUD@SAT: SAT solving on GPUs , 2015, J. Exp. Theor. Artif. Intell..

[58]  John P. Gallagher,et al.  Inferring Parametric Energy Consumption Functions at Different Software Levels: ISA vs. LLVM IR , 2015, FOPARA.

[59]  Haicheng Wu,et al.  Relational Learning with GPUs: Accelerating Rule Coverage , 2015, International Journal of Parallel Programming.

[60]  Sudhakar Yalamanchili,et al.  A portable benchmark suite for highly parallel data intensive query processing , 2015 .

[61]  Fernando Pereira,et al.  Yedalog: Exploring Knowledge at Scale , 2015, SNAPL.

[62]  Agostino Dovier,et al.  Parallel Execution of the ASP Computation - an Investigation on GPUs , 2015, ICLP.

[63]  Carlo Zaniolo,et al.  Parallel Bottom-Up Evaluation of Logic Programs: DeALS on Shared-Memory Multicore Machines , 2015, ICLP.

[64]  Marius Thomas Lindauer,et al.  AutoFolio: An Automatically Configured Algorithm Selector , 2015, J. Artif. Intell. Res..

[65]  Manuel V. Hermenegildo,et al.  Resource Usage Analysis of Logic Programs via Abstract Interpretation Using Sized Types* , 2014, Theory and Practice of Logic Programming.

[66]  Wolfgang Faber,et al.  Efficient Computation of the Well-Founded Semantics over Big Data , 2014, Theory Pract. Log. Program..

[67]  Marius Thomas Lindauer,et al.  claspfolio 2: Advances in Algorithm Selection for Answer Set Programming , 2014, Theory and Practice of Logic Programming.

[68]  Michael Gelfond,et al.  Knowledge Representation, Reasoning, and the Design of Intelligent Agents: The Answer-Set Programming Approach , 2014 .

[69]  Marius Thomas Lindauer,et al.  aspeed: Solver scheduling via answer set programming 1 , 2014, Theory and Practice of Logic Programming.

[70]  Sudhakar Yalamanchili,et al.  Red Fox: An Execution Environment for Relational Query Processing on GPUs , 2014, CGO '14.

[71]  Maurizio Gabbrielli,et al.  SUNNY: a Lazy Portfolio Approach for Constraint Solving , 2014, Theory Pract. Log. Program..

[72]  Ricardo Rocha,et al.  On Scaling Dynamic Programming Problems with a Multithreaded Tabling System , 2014 .

[73]  Andrea Formisano,et al.  On multiple learning schemata in conflict driven solvers , 2014, ICTCS.

[74]  M. G. D. L. Banda Independence, Global analysis, and parallelism, in dinamically scheduled constraint logic programming. , 2013 .

[75]  Carlos Alberto Martinez-Angeles,et al.  A Datalog Engine for GPUs , 2013, KDPD.

[76]  Monica S. Lam,et al.  Distributed SociaLite: A Datalog-Based Language for Large-Scale Graph Analysis , 2013, Proc. VLDB Endow..

[77]  Grigoris Antoniou,et al.  Computing the Stratified Semantics of Logic Programs over Big Data through Mass Parallelization , 2013, RuleML.

[78]  Luca Pulina,et al.  A multi-engine approach to answer-set programming* , 2013, Theory and Practice of Logic Programming.

[79]  Sudhakar Yalamanchili,et al.  Relational algorithms for multi-bulk-synchronous processors , 2013, PPoPP '13.

[80]  Ricardo Rocha,et al.  On Comparing Alternative Splitting Strategies for Or-Parallel Prolog Execution on Multicores , 2013, ArXiv.

[81]  Ricardo Rocha,et al.  Or-Parallel Prolog Execution on Clusters of Multicores , 2013, SLATE.

[82]  Manuel V. Hermenegildo,et al.  Energy Consumption Analysis of Programs Based on XMOS ISA-Level Models , 2013, LOPSTR.

[83]  Martin Gebser,et al.  Answer Set Solving in Practice , 2012, Answer Set Solving in Practice.

[84]  Yuri Malitsky,et al.  Parallel SAT Solver Selection and Scheduling , 2012, CP.

[85]  T. L. McCluskey,et al.  Large-scale Parallel Stratified Defeasible Reasoning , 2012, ECAI.

[86]  Ricardo Rocha,et al.  Towards multi-threaded local tabling using a common table space , 2012, Theory Pract. Log. Program..

[87]  Germán Vidal,et al.  Annotation of logic programs for independent AND-parallelism by partial evaluation* , 2012, Theory and Practice of Logic Programming.

[88]  Andrey Rybalchenko,et al.  Synthesizing software verifiers from proof rules , 2012, PLDI.

[89]  Jeffrey D. Ullman,et al.  Transitive closure and recursive Datalog implemented on clusters , 2012, EDBT '12.

[90]  Ricardo Rocha,et al.  Or-parallel prolog execution on multicores based on stack splitting , 2012, DAMP '12.

[91]  Peter Schachte,et al.  Controlling loops in parallel mercury code , 2012, DAMP '12.

[92]  Manuel V. Hermenegildo,et al.  A Segment-Swapping Approach for Executing Trapped Computations , 2012, PADL.

[93]  Frank van Harmelen,et al.  WebPIE: A Web-scale Parallel Inference Engine using MapReduce , 2012, J. Web Semant..

[94]  Francesco Ricca,et al.  Parallel instantiation of ASP programs: techniques and experiments , 2013, Theory Pract. Log. Program..

[95]  Tom White,et al.  Hadoop - The Definitive Guide: Storage and Analysis at Internet Scale (4. ed., revised & updated) , 2012 .

[96]  Enrico Pontelli,et al.  ASP at Work: An ASP Implementation of PhyloWS , 2012, ICLP.

[97]  Manuel V. Hermenegildo,et al.  Parallel backtracking with answer memoing for independent and-parallelism , 2011, Theory and Practice of Logic Programming.

[98]  Marius Thomas Lindauer,et al.  A Portfolio Solver for Answer Set Programming: Preliminary Report , 2011, LPNMR.

[99]  Marius Thomas Lindauer,et al.  Potassco: The Potsdam Answer Set Solving Collection , 2011, AI Commun..

[100]  Jeffrey D. Ullman,et al.  Map-reduce extensions and recursive queries , 2011, EDBT/ICDT '11.

[101]  Neng-Fa Zhou,et al.  The language features and architecture of B-Prolog , 2011, Theory and Practice of Logic Programming.

[102]  Manuel V. Hermenegildo,et al.  An overview of Ciao and its design philosophy , 2011, Theory and Practice of Logic Programming.

[103]  V. S. Costa,et al.  The YAP Prolog system , 2011, Theory and Practice of Logic Programming.

[104]  David Scott Warren,et al.  XSB: Extending Prolog with Tabled Logic Programming , 2010, Theory and Practice of Logic Programming.

[105]  Mats Carlsson,et al.  SICStus Prolog—The first 25 years , 2010, Theory and Practice of Logic Programming.

[106]  Tom Schrijvers,et al.  Under Consideration for Publication in Theory and Practice of Logic Programming Swi-prolog , 2022 .

[107]  Paul Bone Automatic Parallelism in Mercury , 2011, ICLP.

[108]  Trung Le,et al.  CDAO-Store: Ontology-driven Data Integration for Phylogenetic Analysis , 2011, BMC Bioinformatics.

[109]  Michael D. Ernst,et al.  HaLoop , 2010, Proc. VLDB Endow..

[110]  Enrico Pontelli,et al.  An investigation in parallel execution of answer set programs on distributed memory platforms: Task sharing and dynamic scheduling , 2010, Comput. Lang. Syst. Struct..

[111]  Ricardo Rocha,et al.  Threads and or-parallelism unified , 2010, Theory Pract. Log. Program..

[112]  Geoffrey C. Fox,et al.  Twister: a runtime for iterative MapReduce , 2010, HPDC '10.

[113]  Aart J. C. Bik,et al.  Pregel: a system for large-scale graph processing , 2010, SIGMOD Conference.

[114]  Jeffrey D. Ullman,et al.  Optimizing joins in a map-reduce environment , 2010, EDBT '10.

[115]  José C. Cunha,et al.  A Simple and Efficient Implementation of Concurrent Local Tabling , 2010, PADL.

[116]  V. S. Costa,et al.  Theory and Practice of Logic Programming , 2010 .

[117]  Susana Muñoz-Hernández,et al.  Towards Fuzzy Granularity Control in Parallel/Distributed Computing , 2010, IJCCI.

[118]  Jorge A. Navas,et al.  User-Definable Resource Usage Bounds Analysis for Java Bytecode , 2009, BYTECODE@ETAPS.

[119]  Manuel V. Hermenegildo,et al.  Non-strict independence-based program parallelization using sharing and freeness information , 2009, Theor. Comput. Sci..

[120]  Elvira Albert,et al.  Decompilation of Java bytecode to Prolog by partial evaluation , 2009, Inf. Softw. Technol..

[121]  Enrico Pontelli,et al.  Applications of parallel processing technologies in heuristic search planning: methodologies and experiments , 2009, Concurr. Comput. Pract. Exp..

[122]  Bettina Schnor,et al.  Experiences Running a Parallel Answer Set Solver on Blue Gene , 2009, PVM/MPI.

[123]  Bettina Schnor,et al.  A Simple Distributed Conflict-Driven Answer Set Solver , 2009, LPNMR.

[124]  Alessandro Dal Palù,et al.  GASP: Answer Set Programming with Lazy Grounding , 2009, Fundam. Informaticae.

[125]  Deepak Kapur,et al.  Identification of logically related heap regions , 2009, ISMM '09.

[126]  Desh Ranjan,et al.  On the complexity of or-parallelism , 2009, New Generation Computing.

[127]  Seif Haridi,et al.  The Aurora or-parallel Prolog system , 1990, New Generation Computing.

[128]  Michael Codish,et al.  Compiling OR-parallelism into AND-parallelism , 1986, New Generation Computing.

[129]  David Scott Warren,et al.  Efficient Prolog memory management for flexible control strategies , 1984, New Generation Computing.

[130]  W. F. Clocksin,et al.  A method for efficiently executing horn clause programs using multiple processors , 2009, New Generation Computing.

[131]  J. Xu OpenCL – The Open Standard for Parallel Programming of Heterogeneous Systems , 2009 .

[132]  Ashwin Srinivasan,et al.  Parallel ILP for distributed-memory architectures , 2009, Machine Learning.

[133]  Jorge A. Navas,et al.  Negative Ternary Set-Sharing , 2008, ICLP.

[134]  Theresa Swift,et al.  Concurrent and Local Evaluation of Normal Programs , 2008, ICLP.

[135]  Manuel V. Hermenegildo,et al.  A High-Level Implementation of Non-deterministic, Unrestricted, Independent And-Parallelism , 2008, ICLP.

[136]  Deepak Kapur,et al.  Identification of Heap-Carried Data Dependence Via Explicit Store Heap Models , 2008, LCPC.

[137]  Ondrej Lhoták,et al.  Efficient Set Sharing Using ZBDDs , 2008, LCPC.

[138]  Deepak Kapur,et al.  Sharing analysis of arrays, collections, and recursive structures , 2008, PASTE '08.

[139]  Manuel V. Hermenegildo,et al.  Towards execution time estimation in abstract machine-based languages , 2008, PPDP.

[140]  Enrico Pontelli,et al.  Credulous Resolution for Answer Set Programming , 2008, AAAI.

[141]  Kevin Leyton-Brown,et al.  SATzilla: Portfolio-based Algorithm Selection for SAT , 2008, J. Artif. Intell. Res..

[142]  Jorge A. Navas,et al.  Safe upper-bounds inference of energy consumption for java bytecode applications , 2008, FM'08 2008.

[143]  Deepak Kapur,et al.  Efficient Context-Sensitive Shape Analysis with Graph Based Heap Models , 2008, CC.

[144]  Manuel V. Hermenegildo,et al.  Towards a High-Level Implementation of Execution Primitives for Unrestricted, Independent And-Parallelism , 2008, PADL.

[145]  Manuel V. Hermenegildo,et al.  An Improved Continuation Call-Based Implementation of Tabling , 2008, PADL.

[146]  Manuel V. Hermenegildo,et al.  Precise Set Sharing Analysis for Java-Style Programs , 2008, VMCAI.

[147]  Neng-Fa Zhou,et al.  Linear tabling strategies and optimizations , 2007, Theory and Practice of Logic Programming.

[148]  Amadeo Casas,et al.  Automatic unrestricted independent and-parallelism in declarative multiparadigm languages , 2008 .

[149]  Francesco Ricca,et al.  Experimenting with parallelism for the instantiation of ASP programs , 2008, J. Algorithms.

[150]  Manuel V. Hermenegildo,et al.  Annotation Algorithms for Unrestricted Independent And-Parallelism in Logic Programs , 2008, LOPSTR.

[151]  Jorge A. Navas,et al.  A Flexible, (C)LP-Based Approach to the Analysis of Object-Oriented Programs , 2008, LOPSTR.

[152]  Karen Villaverde,et al.  PALS: Efficient Or-Parallel execution of Prolog on Beowulf clusters , 2007, Theory and Practice of Logic Programming.

[153]  Jorge A. Navas,et al.  User-Definable Resource Bounds Analysis for Logic Programs , 2007, ICLP.

[154]  Miroslaw Truszczynski,et al.  Logic programs with abstract constraint atoms: The role of computations , 2007, Artif. Intell..

[155]  Enrico Pontelli,et al.  Dynamic scheduling in parallel answer set programming solvers , 2007, SpringSim '07.

[156]  Elvira Albert,et al.  Cost Analysis of Java Bytecode , 2007, ESOP.

[157]  Jonathan W. Berry,et al.  Challenges in Parallel Graph Processing , 2007, Parallel Process. Lett..

[158]  Enrico Pontelli,et al.  Planning for Biochemical Pathways : A Case Study of Answer Set Planning in Large Planning Problem Instances , 2007 .

[159]  Deepak Kapur,et al.  A Static Heap Analysis for Shape and Connectivity: Unified Memory Analysis: The Base Framework , 2006, LCPC.

[160]  Karen Villaverde,et al.  Stack splitting: A technique for efficient exploitation of search parallelism on share-nothing platforms , 2006, J. Parallel Distributed Comput..

[161]  John P. Gallagher,et al.  Abstract Interpretation of PIC Programs through Logic Programming , 2006, 2006 Sixth IEEE International Workshop on Source Code Analysis and Manipulation.

[162]  Nuno A. Fonseca,et al.  April - An Inductive Logic Programming System , 2006, JELIA.

[163]  Xuan Li,et al.  Lazy Set-Sharing Analysis , 2006, FLOPS.

[164]  Konstantinos Sagonas,et al.  Tabling in Mercury: Design and Implementation , 2006, PADL.

[165]  Jorge A. Navas,et al.  Efficient Top-Down Set-Sharing Analysis Using Cliques , 2006, PADL.

[166]  Torsten Schaub,et al.  Graphs and colorings for answer set programming , 2005, Theory and Practice of Logic Programming.

[167]  Herman J. ter Horst,et al.  Completeness, decidability and complexity of entailment for RDF Schema and a semantic extension involving the OWL vocabulary , 2005, J. Web Semant..

[168]  Manuel V. Hermenegildo,et al.  Integrated program debugging, verification, and optimization using abstract interpretation (and the Ciao system preprocessor) , 2005, Sci. Comput. Program..

[169]  Stefano Secci,et al.  Pair-Sharing Analysis of Object-Oriented Programs , 2005, SAS.

[170]  Enrico Pontelli,et al.  An Investigation of Sharing Strategies for Answer Set Solvers and SAT Solvers , 2005, Euro-Par.

[171]  Enrico Pontelli,et al.  Issues in parallel execution of non-monotonic reasoning systems , 2005, Parallel Comput..

[172]  Ricardo Rocha,et al.  On applying or-parallelism and tabling to logic programs , 2003, Theory and Practice of Logic Programming.

[173]  Khayri A. M. Ali,et al.  Scheduling speculative work in MUSE and performance results , 1992, International Journal of Parallel Programming.

[174]  Khayri A. M. Ali,et al.  The muse approach to Or-parallel prolog , 1990, International Journal of Parallel Programming.

[175]  Maria Garcia de la Banda,et al.  Set-Sharing Is Not Always Redundant for Pair-Sharing , 2004, FLOPS.

[176]  Manuel V. Hermenegildo,et al.  Multivariant Non-failure Analysis via Standard Abstract Interpretation , 2004, FLOPS.

[177]  Enrico Pontelli,et al.  Parallel symbolic computation in ACE , 1997, Annals of Mathematics and Artificial Intelligence.

[178]  Ricardo Lopes,et al.  Exploiting parallelism in the extended andorra model , 2004, Parallel and Distributed Computing and Networks.

[179]  D. Cabezas,et al.  Un sistema de programación lógica extensible y con soporte para análisis global (an extensible, global analysis friendly logic programming system) , 2004 .

[180]  Karen Villaverde,et al.  An Investigation of Scheduling in Distributed Constraint Logic Programming , 2004, Parallel and Distributed Computing Systems (ISCA).

[181]  Ricardo Lopes,et al.  On the BEAM Implementation , 2003, EPIA.

[182]  Ricardo Rocha,et al.  YapDss: An Or-Parallel Prolog System for Scalable Beowulf Clusters , 2003, EPIA.

[183]  Karen Villaverde,et al.  A Methodology for Order-Sensitive Execution of Non-deterministic Languages on Beowulf Platforms , 2003, Euro-Par.

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

[185]  Chitta Baral,et al.  Knowledge Representation, Reasoning and Declarative Problem Solving , 2003 .

[186]  Desh Ranjan,et al.  An optimal data structure to handle dynamic environments in non-deterministic computations , 2002, Comput. Lang. Syst. Struct..

[187]  Peter J. Stuckey,et al.  Precise pair-sharing analysis of logic programs , 2002, PPDP '02.

[188]  E. Goldberg,et al.  BerkMin: A fast and robust SAT-solver , 2002, Proceedings 2002 Design, Automation and Test in Europe Conference and Exhibition.

[189]  Roberto Bagnara,et al.  Soundness, idempotence and commutativity of set-sharing , 2001, Theory and Practice of Logic Programming.

[190]  Timo Soininen,et al.  Extending and implementing the stable model semantics , 2000, Artif. Intell..

[191]  Ricardo Rocha,et al.  On a Tabling Engine That Can Exploit Or-Parallelism , 2001, ICLP.

[192]  Gopal Gupta,et al.  A Simple Scheme for Implementing Tabled Logic Programming Systems Based on Dynamic Reordering of Alternatives , 2001, ICLP.

[193]  Karen Villaverde,et al.  PALS: An Or-Parallel Implementation of Prolog on Beowulf Architectures , 2001, ICLP.

[194]  Enrico Pontelli,et al.  Backtracking in Independent And-Parallel Implementations of Logic Programming Languages , 2001, IEEE Trans. Parallel Distributed Syst..

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

[196]  Mats Carlsson,et al.  Parallel execution of prolog programs: a survey , 2001, TOPL.

[197]  Enrico Pontelli Experiments in Parallel Execution of Answer Set Programs , 2001, IPDPS.

[198]  Bart Selman,et al.  Algorithm portfolios , 2001, Artif. Intell..

[199]  Jürgen Dix,et al.  Transformation-based bottom-up computation of the well-founded model , 1996, Theory and Practice of Logic Programming.

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

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

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

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

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

[205]  Roberto Bagnara,et al.  Widening Sharing , 1999, APPIA-GULP-PRODE.

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

[207]  Manuel V. Hermenegildo,et al.  Using Global Analysis, Partial Specifications, and an Extensible Assertion Language for Program Validation and Debugging , 1999, The Logic Programming Paradigm.

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

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

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

[211]  John P. Gallagher,et al.  Analysis of Imperative Programs through Analysis of Constraint Logic Programs , 1998, SAS.

[212]  Konstantinos Sagonas,et al.  An abstract machine for tabled execution of fixed-order stratified logic programs , 1998, TOPL.

[213]  Peter J. Stuckey,et al.  A practical object‐oriented analysis engine for CLP , 1998 .

[214]  Peter J. Stuckey,et al.  A Practical Object-Oriented Analysis Engine for CLP , 1998, Softw. Pract. Exp..

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

[216]  Michael Codish,et al.  An Algebraic Approach to Sharing Analysis of Logic Programs , 1997, SAS.

[217]  Ilkka Niemelä,et al.  Smodels - An Implementation of the Stable Model and Well-Founded Semantics for Normal LP , 1997, LPNMR.

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

[219]  Wlodzimierz Drabent,et al.  On the Role of Semantic Approximations on Validation and Diagnosis of Contraint Logic Programs , 1997, AADEBUG.

[220]  Wolfgang Faber,et al.  The dlv System: Model Generator and Application Frontends , 1997 .

[221]  Rui Hu,et al.  Efficient tabled evaluation of normal logic programs in a distributed environment , 1997 .

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

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

[224]  Christian Fecht An Efficient and Precise Sharing Domain for Logic Programs , 1996, PLILP.

[225]  Juliana Freire,et al.  Beyond Depth-First: Improving Tabled Logic Programs through Alternative Scheduling Strategies , 1996, PLILP.

[226]  Gerda Janssens,et al.  Global analysis of constraint logic programs , 1996, TOPL.

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

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

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

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

[231]  David Scott Warren,et al.  Tabled evaluation with delaying for general logic programs , 1996, JACM.

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

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

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

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

[236]  Ke Wang,et al.  Data Partition and Parallel Evaluation of Datalog Programs , 1995, IEEE Trans. Knowl. Data Eng..

[237]  Matthias Felleisen,et al.  The semantics of future and its use in program optimization , 1995, POPL '95.

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

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

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

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

[242]  Pascal Van Hentenryck,et al.  Experimental Evaluation of a Generic Abstract Interpretation Algorithm for PROLOG , 1992, ACM Trans. Program. Lang. Syst..

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

[244]  Kang Zhang,et al.  Exploiting OR-parallelism in logic programs: A review , 1993, Future Gener. Comput. Syst..

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

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

[247]  Abraham Silberschatz,et al.  Parallel Bottom-Up Processing of Datalog Queries , 1992, J. Log. Program..

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

[249]  Kenneth A. Ross,et al.  The well-founded semantics for general logic programs , 1991, JACM.

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

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

[252]  V. S. Costa,et al.  Andorra-I: A Parallel Prolog System that Transparently Exploits both And- and Or-Parallelism , 1991, PPOPP.

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

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

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

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

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

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

[259]  Khayri A. M. Ali,et al.  The Muse Or-Parallel Prolog Model and its Performance , 1990, NACLP.

[260]  Gopal Gupta,et al.  On Criteria for Or-Parallel Execution Models of Logic Programs , 1990, NACLP.

[261]  Mi Lu A Parallel Unification , 1990 .

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

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

[264]  Péter Kacsuk,et al.  CS-PROLOG on multitransputer systems , 1989, Microprocess. Microsystems.

[265]  Friedemann Mattern,et al.  Global Quiescence Detection Based on Credit Distribution and Recovery , 1989, Inf. Process. Lett..

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

[267]  Zheng Lin,et al.  Expected Performance of the Randomized Parallel Backtracking Method , 1989, NACLP.

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

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

[270]  Saumya K. Debray,et al.  On the Practicality of Global Flow Analysis of Logic Programs , 1988, ICLP/SLP.

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

[272]  John L. Gustafson,et al.  Reevaluating Amdahl's law , 1988, CACM.

[273]  Seif Haridi,et al.  ANDORRA Prolog - An Integration of Prolog and Committed Choice Languages , 1988, FGCS.

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

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

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

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

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

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

[280]  Harald Søndergaard,et al.  An Application of Abstract Interpretation of Logic Programs: Occur Check Reduction , 1986, ESOP.

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

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

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

[284]  Robert H. Halstead,et al.  MULTILISP: a language for concurrent symbolic computation , 1985, TOPL.

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

[286]  Luís Moniz Pereira,et al.  Delta-Prolog: A Distributed Logic Programming Language , 1984, FGCS.

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

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

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

[290]  G. Amdhal,et al.  Validity of the single processor approach to achieving large scale computing capabilities , 1967, AFIPS '67 (Spring).