Software and Computer Systems

This paper presents a model and implementation techniques for speeding up constraint propagation. Three fundamental approaches to improving constraint propagation based on propagators as implementations of constraints are explored: keeping track of which propagators are at fixpoint, choosing which propagator to apply next, and how to combine several propagators for the same constraint.

When implementing a propagator for a constraint, one must decide about variants: When implementing min, should one also implement max? Should one implement linear equations both with and without coefficients? Constraint variants are ubiquitous: implementing them requires considerable effort, but yields better performance. This paper shows how to use variable views to derive perfect propagator variants: derived propagators inherit essential properties such as correctness and domain and bounds completeness.

We present a higher-order module discipline with separate compilation and concurrent dynamic linking. Based on first-order modules one can program security policies for systems that link modules from untrusted locations (e.g., Java). We introduce a pickling operation that writes persistent clones of volatile, possibly higher-order data structures on the file system. Our pickling operation respects lexical binding. Our module discipline is based on functors, which are annotated functions that are applied to modules and return modules. Pickled computed functors can be used interchangeably with compiled functors. In contrast to compiled functors, pickled computed functors can carry computed data structures with them, which has significant practical applications.

A central service of a constraint programming system is search. In almost all constraint programming systems search is based on trailing, which is well understood and known to be efficient. This paper compares trailing to copying. Copying offers more expressiveness as required by parallel and concurrent systems. However, little is known how trailing compares to copying as it comes to implementation effort, runtime efficiency, and memory requirements. This paper discusses these issues.

This paper introduces propagator groups as an abstraction for controlling the execution of propagators as implementations of constraints. Propagator groups enable users of a constraint programming system to program how propagators within a group are executed. The paper exemplifies propagator groups for controlling both propagation order and propagator interaction. Controlling propagation order is applied to debugging constraint propagation and optimal constraint propagation for Berge-acyclic propagator graphs. Controlling propagator interaction by encapsulating failure and entailment is applied to general reification and constructive disjunction. The paper describes an implementation of propagator groups (based on Gecode) that is applicable to any propagator-centered constraint programming system. Experiments show that groups incur little to no overhead and that the applications of groups are practically usable and efficient.

Flow Java integrates single assignment variables (logic variables) into Java. This paper presents and compares three implementation strategies for single assignment variables in Flow Java. One strategy uses forwarding and dereferencing while the two others are variants of Taylor's scheme. The paper introduces how to adapt Taylor's scheme for a concurrent language based on operating system threads, token equality, and update of data structures. Evaluation of the strategies clarifies that the key issue for efficiency is reducing memory usage.

The present study addresses the modal synthesis of dynamic responses or receptances, which can be considered as a major issue in vibratory or acoustic design. A new method termed ''method of orthocomplement'' offers to increase the accuracy of modal superposition. Two apparently independent domains are considered: first, the numerical control of round-off errors in finite-dimensional models; second, the regularization of modal boundary discontinuities in infinitedimensional formulations. Concerning the finite-dimensional systems, using the proposed method in conjunction with pseudo-inversion theorems, proves that ''inertia relief corrections'' remedy modal truncation problems in singular floating systems, just as static corrections do for simply supported systems. The proof is based on hitherto unpublished expressions of inertial contributions in terms of orthogonal projectors. It is worth noting that such expressions present by themselves some technical interest. Modal formulae being delivered in closed form, a thorough analysis of errors becomes possible. Special ''spectrograms'' are introduced to appraise the convergence of ordinary or modified modal sums. When applied to infinite-dimensional modal boundary discontinuities, the method of orthocomplement eliminates the Gibbs oscillations that affect the ordinary spectral sums, and produces the same corrected formulae as it did for finite-dimensional examples. Effective solutions for the computation of vibratory or acoustic boundary receptances, are developed in that way. The paper once again illustrates how orthogonal projectors can contribute to the determination of static corrections. Future applications to coupling problems, model reduction and modal synthesis are briefly presented at the end of the text. r

This chapter addresses the integration of constraints and search into programming languages from three different points of views. It first focuses on the use of constraints to model combinatorial optimization problem and to easily implement search procedures, then it considers the use of constraints for supporting concurrent computations and finally turns to the use of constraints to enable open implementations of constraints solvers.

Ideally, programming propagators as implementations of constraints should be an entirely declarative specification process for a large class of constraints: a high-level declarative specification is automatically translated into an efficient propagator. This paper introduces the use of existential monadic secondorder logic as declarative specification language for finite set propagators. The approach taken in the paper is to automatically derive projection propagators (involving a single variable only) implementing constraints described by formulas. By this, the paper transfers the ideas of indexicals to finite set constraints while considerably increasing the level of abstraction available with indexicals. The paper proves soundness and completeness of the derived propagators and presents a run-time analysis, including techniques for efficiently executing projectors for n-ary constraints.

We present a higher-order module discipline with separate compilation and concurrent dynamic linking. Based on first-order modules one can program security policies for systems that link modules from untrusted locations (e.g., Java). We introduce a pickling operation that writes persistent clones of volatile, possibly higher-order data structures on the file system. Our pickling operation respects lexical binding. Our module discipline is based on functors, which are annotated functions that are applied to modules and return modules. Pickled computed functors can be used interchangeably with compiled functors. In contrast to compiled functors, pickled computed functors can carry computed data structures with them, which has significant practical applications.