Practical parallelism in constraint programming

Constraints, 2013

Concurrent Constraint Programming (CCP) has been used over the last two decades as an elegant and expressive model for concurrent systems. It models systems of agents communicating by posting and querying partial information, represented as constraints over the variables of the system. This covers a vast variety of systems as those arising in biological phenomena, reactive systems, netcentric computing and the advent of social networks and cloud computing. In this paper we survey the main applications, developments and current trends of CCP.

Lecture Notes in Computer Science, 2001

Although constraint programming offers a wealth of strong, generalpurpose methods, in practice a complex, real application demands a person who selects, combines, and refines various available techniques for constraint satisfaction and optimization. Although such tuning produces efficient code, the scarcity of human experts slows commercialization. The necessary expertise is of two forms: constraint programming expertise and problem-domain expertise. The former is in short supply, and even experts can be reduced to trial and error prototyping; the latter is difficult to extract. The project described here seeks to automate both the application of constraint programming expertise and the extraction of domain-specific expertise. It applies FORR, an architecture for learning and problem-solving, to constraint solving. FORR develops expertise from multiple heuristics. A successful case study is presented on coloring problems. * This work was performed while this author was at the University of New Hampshire. number of different problem domains. Each solver will incorporate a learned, collaborative "community" of heuristics appropriate for their problem or problem class. Both the way in which they collaborate and some of the heuristics themselves will be learned. This paper reports initial steps toward that goal in the form of a case study that applies FORR, a well-tested, collaborative, problem-solving architecture, to a subset of constraint programming: graph coloring. The FORR architecture permits swift establishment of a well-provisioned base camp from which to explore this research frontier more deeply. Section 2 presents some minimal background, including a description of FORR. Section 3 presents the initial, successful case study. Section 4 outlines further opportunities and challenges. Section 5 is a brief conclusion. 2 The Problem We provide here some minimal background information on CSP's and on the FORR (FOr the Right Reasons) architecture. Further details will be provided on a need-toknow basis during our description of the case study. 2.1 CSP Constraint satisfaction problems involve a set of variables, a domain of values for each variable, and a set of constraints that specify which combinations of values are allowed [5-8]. A solution is a value for each variable, such that all the constraints are satisfied. For example, graph coloring problems are CSP's: the variables are the graph vertices, the values are the available colors, and the constraints specify that neighboring vertices cannot have the same color. The basic CSP paradigm can be extended in various directions, for example to encompass optimization or uncertainty. Solution methods generally involve some form of search, often interleaved with some form of inference. Many practical problems-such as resource allocation, scheduling, configuration, design, and diagnosis-can be modeled as constraint satisfaction problems. The technology has been widely commercialized, in Europe even more so than in the U.S. This is, of course, an NP-hard problem area, but there are powerful methods for solving difficult problems. Artificial intelligence, operations research, and algorithmics all have made contributions. There is considerable interest in constraint programming languages. Although we take an artificial intelligence approach, we expect our results to have implications for constraint programming generally. Constraint satisfaction problem classes can be defined by "structural" or "semantic" features of the problem. These parameterize the problem and establish a multidimensional problem space. We will seek to synthesize specialized solvers that operate efficiently in different portions of that space.

Handbook of Constraint Programming, 2006

A number of operations research (OR) methods have found their way into constraint programming (CP). This development is entirely natural, since OR and CP have similar goals.

1996

This paper describes the rst results from research on the compilation of constraint systems into task level procedural parallel programs. Algorithms are expressed as constraint systems. A data ow graph is derived from the constraint system and a set of input variables. The data ow graph, which exploits the parallelism in the constraints, is mapped to the target language CODE 2.0, which represents parallel computation structures as generalized dependence graphs. Finally, parallel C programs are generated. The granularity of the derived data ow graphs depends upon the complexity of the operations directly represented in the constraint system. To extract parallel programs of appropriate granularity, the following features have been included: (i) modularity, (ii) operations over structured types as primitives, (iii) de nition of sequential C functions. A prototype of the compiler has been implemented. The domain of matrix computations has been targeted for applications. Some examples have been programmed. Initial results are encouraging.

EPiC series in computing, 2018

The inherent complexity of parallel computing makes development, resource monitoring, and debugging for parallel constraint-solving-based applications difficult. This paper presents SMTS, a framework for parallelizing sequential constraint solving algorithms and running them in distributed computing environments. The design (i) is based on a general parallelization technique that supports recursively combining algorithm portfolios and divide-and-conquer with the exchange of learned information, (ii) provides monitoring by visually inspecting the parallel execution steps, and (iii) supports interactive guidance of the algorithm through a web interface. We report positive experiences on instantiating the framework for one SMT solver and one IC3 solver, debugging parallel executions, and visualizing solving, structure, and learned clauses of SMT instances.