Parallel consistency in constraint programming

Program parallelization becomes increasingly important when new multi-core architectures provide ways to improve performance. One of the greatest challenges of this development lies in programming parallel applications. Using declarative languages, such as constraint programming, can make the transition to parallelism easier by hiding the parallelization details in a framework. Automatic parallelization in constraint programming has previously focused on data parallelism. In this paper, we look at task parallelism, specifically the case of parallel consistency. We have developed two models of parallel consistency, one that shares intermediate results and one that does not. We evaluate which model is better in our experiments. Our results show that parallelizing consistency can provide the programmer with a robust scalability for regular problems with global constraints

Independence in CLP Languages

Studying independence of goals has proven very useful in the context of logic programming. In particular, it has provided a formal basis for powerful automatic parallelization tools, since independence ensures that two goals may be evaluated in parallel while preserving correctness and eciency. We extend the concept of independence to constraint logic programs (CLP) and prove that it also ensures the correctness and eciency of the parallel evaluation of independent goals. Independence for CLP languages is more complex than for logic programming as search space preservation is necessary but no longer sucient for ensuring correctness and eciency. Two additional issues arise. The rst is that the cost of constraint solving may depend upon the order constraints are encountered. The second is the need to handle dynamic scheduling. We clarify these issues by proposing various types of search independence and constraint solver independence, and show how they can be combined to allow dierent optimizations, from parallelism to intelligent backtracking. Sucient conditions for independence which can be evaluated \a priori" at run-time are also proposed. Our study also yields new insights into independence in logic programming languages. In particular, we show that search space preservation is not only a sucient but also a necessary condition for ensuring correctness and eciency of parallel execution

Combining parallel search and parallel consistency in constraint programming

Program parallelization becomes increasingly important when new multi-core architectures provide ways to improve performance. One of the greatest challenges of this development lies in programming parallel applications. Declarative languages, such as constraint programming, can make the transition to parallelism easier by hiding the parallelization details in a framework. Automatic parallelization in constraint programming has mostly focused on parallel search. While search and consistency are intrinsically linked, the consistency part of the solving process is often more time-consuming. We have previously looked at parallel consistency and found it to be quite promising. In this paper we investigate how to combine parallel search with parallel consistency. We evaluate which problems are suitable and which are not. Our results show that parallelizing the entire solving process in constraint programming is a major challenge as parallel search and parallel consistency typically suit different types of problems

A Multicore Tool for Constraint Solving

*** To appear in IJCAI 2015 proceedings *** In Constraint Programming (CP), a portfolio solver uses a variety of different solvers for solving a given Constraint Satisfaction / Optimization Problem. In this paper we introduce sunny-cp2: the first parallel CP portfolio solver that enables a dynamic, cooperative, and simultaneous execution of its solvers in a multicore setting. It incorporates state-of-the-art solvers, providing also a usable and configurable framework. Empirical results are very promising. sunny-cp2 can even outperform the performance of the oracle solver which always selects the best solver of the portfolio for a given problem

Some methodological issues in the design of CIAO, a generic, parallel concurrent constraint system

We informally discuss several issues related to the parallel execution of logic programming systems and concurrent logic programming systems, and their generalization to constraint programming. We propose a new view of these systems, based on a particular definition of parallelism. We argüe that, under this view, a large number of the actual systems and models can be explained through the application, at different levéis of granularity, of only a few basic principies: determinism, non-failure, independence (also referred to as stability), granularity, etc. Also, and based on the convergence of concepts that this view brings, we sketch a model for the implementation of several parallel constraint logic programming source languages and models based on a common, generic abstract machine and an intermedíate kernel language

Preface Volume 30, Issue 3

AbstractOne of the main areas of research in logic programming is the design and implementation of sequential and parallel (constraint) logic programming systems. This research goes broadly from the design and specification of novel implementation technology to its actual evaluation in real life situations. A series of workshops on Implementations of Logic Programming Systems, previously held in Budapest (1993), Ithaca (1994), Portland (1995), Bonn (1996), Port Jefferson (1997), Manchester (1998) and Las Cruces (1999) provided a forum for ongoing research on the design and implementation of sequential and parallel (constraint) logic programming systems.This volume contains a collection of papers presented at the Workshop on Parallelism and Implementation Technology for (Constraint) Logic Programming, held in Las Cruces on December 1st, 1999, in conjunction with ICLP'99. The workshop was sponsored and organised by COMPULOG AMERICAS. The workshop also received support from the Association for Logic Programming and from the Department of Computer Science, New Mexico State University.Papers from both academia and industry were invited. Preference was given to the analysis and description of implemented systems (or currently under implementation) and their associated techniques, problems found in their development or design, and steps taken towards the solution of these problems.Topics included, but were not limited to: •standard and non—standard sequential implementation schemes (e.g., generalization/modification of WAM, translation to C, etc.);implementation of parallel logic programming systems;balance between compile-time effort and run-time machinery;techniques for the implementation of different declarative programming paradigms based on, or extending, logic programming (e.g., constraint logic programming, concurrent constraint languages, equational-logic languages);performance evaluation of sequential and parallel logic programming systems, both through benchmarking and using real world applications;other implementation-related issues, such as memory management, register allocation, use of global optimisations, etc.We were very fortunate to have so many interesting research papers, ranging over widely different subjects and giving a broad coverage of current research in sequential and parallel implementation of logic programming systems. Papers on sequential logic programming systems, focus on varied topics: constraint evaluation, support for extensions to logic programming, and abstract machines for performance evaluation. Papers on parallel logic programming systems also focus on diverse topics ranging from distributed implementations, garbage collection, to optimisations for exploiting and-or parallelism.The editors would like to thank all authors that chose to submit their work to this book, and also for their cooperation in making this document possible. We would also like to thank all referees involved in assessing the papers in this special volume.This volume will be published as volume 30, Issue 3 in the series Electronic Notes in Theoretical Computer Science (ENTCS). This series is published electronically through the facilities of Elsevier Science B.V. and its auspices. The volumes in the ENTCS series can be accessed at the URL http://www.elsevier.nl/locate/entcs March 14, 2000Horst Reiche