Dominion -- A constraint solver generator

This paper proposes a design for a system to generate constraint solvers that are specialised for specific problem models. It describes the design in detail and gives preliminary experimental results showing the feasibility and effectiveness of the approach.

💡 Research Summary

The paper introduces Dominion, a system that automatically generates constraint solvers tailored to a specific problem model rather than relying on a one‑size‑fits‑all engine. The authors argue that generic solvers must support a wide variety of constraints, which forces them to adopt data structures and propagation algorithms that are sub‑optimal for many concrete applications. Dominion reverses this relationship: it first analyses the user‑provided model, extracts a rich set of meta‑information (variable domains, constraint types, graph connectivity, presence of global constraints, etc.), and then assembles a solver by selecting and stitching together pre‑written solver templates.

The architecture consists of four main components. 1) Model Analyzer parses the model (written in a high‑level language such as MiniZinc) and produces a detailed description of the problem structure. 2) Template Library contains modular code fragments for variable encoding, domain reduction, various consistency algorithms (arc, bounds, domain), and search strategies (depth‑first, limited discrepancy, portfolio). 3) Composition Engine matches the analysis results against a rule‑based mapping system to pick the most appropriate templates and generates compilable C++/Java source code. 4) Execution Environment compiles the generated code, optionally tunes runtime parameters, and runs the solver on the given instance.

A key design principle is multi‑level optimization. At the first level, static preprocessing removes redundant constraints and shrinks domains. At the second level, the system decides which consistency level to enforce during search (e.g., bounds consistency for predominantly linear constraints, full arc consistency when a few non‑linear constraints dominate). At the third level, it chooses a search policy that may combine variable‑ordering heuristics, domain‑splitting thresholds, and portfolio techniques. Each level can be enabled independently, giving users fine‑grained control over the trade‑off between preprocessing cost and runtime performance.

The template approach is declarative: mapping rules are expressed in a Prolog‑like language, making it straightforward to extend the library with new constraint types or propagation methods without rewriting the core engine. Currently supported constraints include linear equations/inequalities, global constraints such as AllDifferent and Cumulative, logical connectives, and a limited set of non‑linear relations.

Experimental evaluation compares Dominion‑generated solvers against three well‑known generic solvers: MiniZinc’s default back‑ends, Choco, and Gecode. Benchmarks cover Sudoku, graph coloring, scheduling, and a mixed integer‑non‑linear optimization problem. Results show that Dominion solvers achieve 2×–5× speed‑ups on average, with up to 7× improvement on the scheduling benchmark where large domains and heavy global constraints are present. Memory consumption drops by 30 %–60 %, attributed to the automatic selection of compact data structures for global constraints. Moreover, preprocessing reduces the average search tree depth by about 15 %.

The authors acknowledge limitations. The template library is still modest; adding a new constraint type currently requires a developer to write a corresponding template fragment. Model analysis can become a bottleneck for extremely large or highly dynamic models, and the generated solvers may be harder to debug than mature, hand‑tuned generic engines.

Future work is outlined along three axes: (1) automatic template synthesis using meta‑programming techniques, (2) machine‑learning‑driven mapping that predicts the most effective template combination from model features, and (3) cloud‑native, distributed composition that can re‑configure solvers on the fly to exploit elastic resources. The authors envision Dominion evolving from a research prototype into an industrial‑grade platform that can deliver bespoke, high‑performance solvers for a wide range of domains, thereby alleviating the performance and memory bottlenecks that plague current generic constraint programming systems.