Abstract not found

Constraint Logic Programming (CLP) languages extend logic programming by allowing constraints from different domains such as real numbers or Boolean functions. They have proved to be ideal for expressing problems that require interactive mathematical modelling and complex combinatorial optimization problems. However, CLP languages have mainly been considered as research systems, useful for rapid prototyping, but not really competitive with more conventional programming languages when performance is crucial. One promising approach to improving the performance of CLP systems is the use of powerful program optimizations to reduce the cost of constraint solving. We extend work in this area by describing a new optimizing compiler for the CLP language CLP(R). The compiler implements six powerful optimizations: reordering of constraints, bypass of the constraint solver, splitting and dead code elimination, removal of redundant constraints, removal of redundant variables, and specialization of...

Finite domain constraint problems with hidden variables are very natural to use, for example, when one has to deal with a complex real-life situation, described as a set of constraints over a set of variables, and desires to (re-)use such description several times selecting each time a different subset of variables of interest. In this paper we study finite domain constraint problems with hidden variables and the possible redundancy of some of the hidden variables. Here for redundancy we mean that the elimination of such variables, together with all the constraints connecting them, does not change the set of solutions of the given problem. We propose several sufficient conditions for variable redundancy and we develop algorithms, based on such conditions, which remove the variables found to be redundant. This, combined with other preprocessing techniques which remove other kinds of redundancy (tuple redundancy, such as the local consistency algorithms, or also constraint redundancy), c...

A number of Constraint logic Programming systems, including CLP(R) and Prolog III, decide simultaneous linear inequalities as part of the fundamental operational step of constraint solving. While this can contribute tremendously to the usefulness of the systems, it is computationally quite expensive. Non-ground inequalities must generally be tested for consistency with the collected constraint set and then added to it, increasing its size, and thus making the next such test more expensive. Future redundant inequalities in a program are those that are guaranteed to be subsumed after no more than one subsequent procedure call, usually in the context of a recursive procedure. It has been noted that such inequalities need only be tested for consistency with the current constraint set, thus resulting in dramatic savings in execution speed and space usage. In this paper we generalize the notion of future redundancy in a number of ways and thus broaden its applicability. Thus we show how to d...

Constraint Logic Programming (CLP) is a recent innovation in programming language design. CLP languages extend logic programming by allowing constraints from different domains such as real numbers or Boolean functions. This gives considerable expressive power and flexibility and CLP programs have proven to be a high-level programming paradigm for applications based on interactive mathematical modeling. These advantages, however, are not without cost. Implementations of CLP languages must include expensive constraint solving algorithms tailored to the specific domains. Indeed, performance of the current generation of CLP compilers and interpreters is one of the main obstacles to the widespread use of CLP. Here we outline the design of a highly optimizing compiler for CLP(R) , a CLP language which extends Prolog by allowing linear arithmetic constraints. This compiler is intended to overcome the efficiency problems of the current implementation technology. The main innovation in the comp...

A central issue in the optimizing compilation of Constraint Logic Programming (CLP) languages is how to compile away as much general constraint solving as possible. Most such work relies on obtaining mode and type information by global analysis, and uses it to generate specialized code for individual constraints and calls, often with the aid of multiple specialization. Some recent work has augmented these techniques with procedure-level analysis of the inter-relationships between constraints, to detect constraints that subsume other constraints, and variables that cease to be reachable at some point in a computation. In combination, these techniques have been shown to dramatically improve performance for a number of programs. Here we continue this line of investigation by considering a class of programs that accumulate and simplify systems of linear arithmetic constraints. The programs contain procedures that relate their parameters by an affine transform. For some calling patterns, th...

. During the evaluation of a constraint logic program, many local variables become inaccessible, or dead . In Prolog and other programming languages, the data bound to local variables can be removed automatically by garbage collection. The case of CLP is more complex, as the variables may be involved in several constraints. We can consider dead variables to be existentially quantified. Removing an existential variable from a set of constraints is then a problem of quantifier elimination, or projection. Eliminating variables not only allows recovery of space but also can decrease the cost of further consistency tests. Surprisingly, the existing systems do not exploit these advantages. Instead, the primary use of projection is as a mechanism for obtaining answer constraints. In this paper, we will give a general system architecture for automatic early projection and specify the heuristics for CLP(R) together with an in-situ removal method. We then show the effectiveness of early projecti...

We study the systematic development of Constraint Logic Programs from the viewpoint of Skeletons and Techniques as described by Kirschenbaum and Sterling. We describe a number of fundamental skeleton classes for CLP, and generalize the notion of skeletons to deal with non-structural recursion. Then we describe a range of useful techniques for extending these skeletons. Furthermore, we introduce important classes of techniques that alter the control flow of skeletons in certain well-defined and desirable ways. This work represents a step towards understanding how to develop complex CLP programs easily, and is expected to contribute to the adoption of CLP for applications projects. It may also lead to the development of semi-automated program development tools. Finally, it helps to justify a substantial body of present work on CLP compiler optimizations that depends on the procedure level structure of programs. A preliminary version of this paper appears in the Proceedings of the Inte...

In most Constraint Logic Programming (CLP) languages, procedures can be transformed to improve the efficiency of constraint solving for a particular set of calling patterns. In particular, it is often possible to take advantage of groundness information to replace a considerable amount of constraint solving with ground imperative computation. We present an efficient algorithm for identifying the specializations of a procedure that allow such optimization. This algorithm generates efficiently a concise representation of information flow in a procedure. This representation can be used to produce a set of calling patterns for which specialization is likely to be fruitful, together with the suitably transformed procedure for each specialization. 1 Introduction Many Constraint Logic Programming (CLP) [8] languages incorporate complex and potentially expensive constraint solving as a basic operational step. However, in most of them constraints can be solved easily and efficiently if...

Abstract not found