Compiling Constraints in clp(FD
Daniel Diaz1996, Journal of Logic Programming
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
We present the clp(FD) system: a Constraint Logic Programming language with finite domain constraints. We detail its implementation and present an abstract instruction set for the constraint solver that can be smoothly integrated into the WAM architecture. It is based on the use of a single primitive constraint X in r that embeds the core propagation mechanism. Complex user constraints such as linear equations or inequations are compiled into X in r expressions that encode the propagation scheme chosen to solve the constraint. The uniform treatment of a single primitive constraint leads to a better understanding of the overall constraint solving process and allows three main general optimizations that encompass many previous particular optimizations of "black-box" finite domain solvers. Implementation results show that this approach combines both simplicity and efficiency. Our clp(FD) system is about four times faster than CHIP on average, with peak speedup reaching eight. We also show that, following the "glass-box" approach, clp(FD) can be naturally enhanced with various new constraints such as constructive disjunction, boolean constraints, non-linear constraints and symbolic constraints. ¡ Address correspondence toPhilippe Codognet and Daniel Diaz, INRIA-Rocquencourt,
Related papers
A Simple and Efficient Boolean Solver for Constraint Logic Programming
Journal of Automated Reasoning, 1996
We study in this paper the use of consistency techniques and local propagation methods, originally developed for constraints over finite domains, for solving boolean constraints in Constraint Logic Programming (CLP). To this aim, we first present a boolean CLP language clp(B/FD) built upon a CLP language over finite domains clp(FD) which uses a propagation-based constraint solver. It is based on a single primitive constraint which allows the boolean solver to be encoded at a low level. The boolean solver obtained in this way is both very simple and very efficient: on average it is eight times faster than the CHIP propagation-based boolean solver, i.e. nearly an order of magnitude faster, and infinitely better than the CHIP boolean unification solver. It also performs on average several times faster than special-purpose stand-alone boolean solvers. We then present in a second time several simplifications of the above approach, leading to the design of a very simple and compact dedicated boolean solver. This solver can be implemented in a WAM-based logical engine with a minimal extension limited to four new abstract instructions. This clp(B) system provides a further factor two speedup w.r.t. clp(B/FD).
Clp(B): Combining simplicity and efficiency in boolean Constraint solving
Lecture Notes in Computer Science, 1994
We present the design and the implementation of clp(B): a boolean constraint solver inside the Constraint Logic Programming paradigm. This solver is based on local propagation methods and follows the "glass-box" approach of compiling high-level constraints into primitive low-level ones. We detail its integration into the WAM showing that the necessary extension is truly minimal since only four new instructions are added. The resulting solver is around an order of magnitude faster than other existing boolean solvers.
The 3 R's of optimizing constraint logic programs
Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL '93, 1993
Central to constraint logic programming (CLP) languages is the notion of a global constraint solver which is queried to direct execution and to which constraints are monotonically added. We present a methodology for use in the compilation of CLP languages which is designed to reduce the overhead of the global constraint solver. This methodology is based on three optimizations. The first, refinement, involves adding new constraints, which in effect make information available earlier in the computation, guiding subsequent execution away from unprofitable choices. The second, removal, involves eliminating constraints from the solver when they are redundant. The last, reordering, involves moving constraint addition later and constraint remowd earlier in the computation. Determining the applicability of each optimization requires sophisticated global analysis. These analyses are based on abstract interpretation and provide information about potential and definite interaction between constraints.
An efficient finite-domain constraint solver for circuits
Proceedings of the 41st annual conference on Design automation - DAC '04
This paper presents a novel hybrid finite-domain constraint solving engine for RTL circuits. We describe how DPLL search is modified for search in combined integer and Boolean domains by using efficient finite-domain constraint propagation. This enables efficient combination of Boolean SAT and linear integer arithmetic solving techniques. We automatically use control and data-path abstraction in RTL descriptions. We use conflict-based learning using the variables on the boundary of control and data-path for additional performance benefits. Finally, we analyze the hybrid constraint solver experimentally using some example circuits.
An open-ended finite domain constraint solver
1997
We describe the design and implementation of a nite domain constraint solver embedded in a Prolog system using an extended uni cation mechanism via attributed variables as a generic constraint interface. The solver is essentially a scheduler for indexicals, i.e. reactive functional rules encoding local consistency methods performing incremental constraint solving or entailment checking, and global constraints, i.e. general propagators which may use specialized algorithms to achieve a higher degree of consistency or better time and space complexity. The solver has an open-ended design: the user can introduce new constraints, either in terms of indexicals by writing rules in a functional notation, or as global constraints via a Prolog programming interface. Constraints de ned in terms of indexicals can be linked to 0/1-variables modeling entailment; thus indexicals are used for constraint solving as well as for entailment testing. Constraints can be arbitrarily combined using the propositional connectives by automatic expansion to systems of rei ed constraints.
Related topics
Related papers
Dominion: An Architecture-Driven Approach to Generating Efficient Constraint Solvers
Working IEEE/IFIP Conference on Software Architecture, 2011
Constraints are used to solve combinatorial prob- lems in a variety of industrial and academic disciplines. However most constraint solvers are designed to be general and monolithic, leading to problems with efficiency, scalability and extensibil- ity. We propose a novel, architecture-driven constraint solver generation framework called Dominion to tackle these issues. For any given problem, Dominion generates a lean and
A Minimal Extension of the WAM for Clp (FD)
Proceedings of the International Conference on …, 1993
We present an abstract instruction set for a constraint solver over nite domains, which can be smoothly integrated in the WAM architecture. It is based on the use of a single primitive constraint X in r which embeds the core propagation mechanism. Complex user constraints such as ...
Design, implementation, and evaluation of the constraint language cc(FD)
The Journal of Logic Programming, 1998
This paper describes the design, implementation, and applications of the constraint logic language cc(FD). cc(FD) is a declarative nondeterministic constraint logic language over nite domains based on the cc framework 33], an extension of the CLP scheme 21]. Its constraint s o l v er includes (non-linear) arithmetic constraints over natural numbers which are approximated using domain and interval consistency. The main novelty o f cc(FD) is the inclusion of a number of general-purpose combinators, in particular cardinality, constructive disjunction, and blocking implication, in conjunction with new constraint operations such as constraint e n tailment a n d generalization. These combinators signi cantly improve the operational expressiveness, extensibility, and exibility of CLP languages and allow issues such as the de nition of non-primitive constraints and disjunctions to be tackled at the language level. The implementation o f cc(FD) (about 40,000 lines of C) includes a WAM-based engine 44], optimal arc-consistency algorithms based on AC-5 40], and incremental implementation of the combinators. Results on numerous problems, including scheduling, resource allocation, sequencing, packing, and hamiltonian paths are reported and indicate that cc(FD) comes close to procedural languages on a number of combinatorial problems. In addition, a small cc(FD) program was able to nd the optimal solution and prove optimality to a famous 10/10 disjunctive s c heduling problem 29], which w as left open for more than 20 years and nally solved in 1986.
Proceedings of CICLOPS 2007 7thInternational Colloquium on Implementation of Constraint and LOgic Programming Systems
2007
The last years have witnessed continuous progress in the technology available both for academic and commercial computing environments. Examples include more processor performance, increased memory capacity and bandwidth, faster networking technology, operating system support for cluster computing and the generalized use of mutiprocessor systems, including in particular multicore microprocessors.
Minion: A Fast Scalable Constraint Solver
2006
We present Minion, a new constraint solver. Empirical results on standard benchmarks show orders of magnitude performance gains over state-of-the-art constraint toolkits. These gains increase with problem size -Minion delivers scalable constraint solving. Minion is a general-purpose constraint solver, with an expressive input language based on the common constraint modelling device of matrix models. Focussing on matrix models supports a highly-optimised implementation, exploiting the properties of modern processors. This contrasts with current constraint toolkits, which, in order to provide ever more modelling and solving options, have become progressively more complex at the cost of both performance and usability. Minion is a black box from the user point of view, deliberately providing few options. This, combined with its raw speed, makes Minion a substantial step towards Puget's 'Model and Run' constraint solving paradigm.
A Comparative Study of Eight Constraint Programming Languages Over the Boolean and Finite Domains
Constraints
This paper compares the efficiency of a number of Constraint Logic Programming (CLP) systems in the setting of finite domains as well as a specific aspect of their expressiveness (that concerning reification and meta-constraints). There are two key reasons for adopting CLP technology for solving a problem. The first is its expressiveness enabling a declarative solution with readable code which is vital for maintenance and the second is the provision of an efficient implementation for the computationally expensive procedures. However, CLP systems differ significantly both in how solutions may be expressed and the efficiency of their execution and it is important that both these factors are taken into account when choosing the best CLP system for a particular application. This paper aids this choice by illustrating differences between the systems, indicating their particular strengths and weaknesses.
An open automated framework for constraint solver extension: the SoleX approach
In declarative programming languages based on the constraint programming paradigm, computations can be viewed as deductions enhanced with the use of constraint solvers. However, admissible constraints are restricted to formulae handled by solvers and thus, declarativity may be jeopardized. We propose a domain-independent scheme to extend constraint solvers so that they can handle alien constraints, i.e., constraint involving new function symbols. This mechanism, called SoleX, consists of a set of symbolic rule-based transformations: they add and deduce syntactical as well as semantic information related to alien constraints, complete the computation domain, and purify constraints in order to allow solvers to cope with alien constraints. These transformations can be seen as elementary solvers, and thus, SoleX is a collaboration of these several solvers with the initial solver. Some extensions of computation domains have already been studied to demonstrate the broad scope of SoleX potential applications.
An automated approach to generating efficient constraint solvers
2012
Abstract Combinatorial problems appear in numerous settings, from timetabling to industrial design. Constraint solving aims to find solutions to such problems efficiently and automatically. Current constraint solvers are monolithic in design, accepting a broad range of problems. The cost of this convenience is a complex architecture, inhibiting efficiency, extensibility and scalability. Solver components are also tightly coupled with complex restrictions on their configuration, making automated generation of solvers difficult.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.