Distributed solving through model splitting

Constraint problems can be trivially solved in parallel by exploring different branches of the search tree concurrently. Previous approaches have focused on implementing this functionality in the solver, more or less transparently to the user. We propose a new approach, which modifies the constraint model of the problem. An existing model is split into new models with added constraints that partition the search space. Optionally, additional constraints are imposed that rule out the search already done. The advantages of our approach are that it can be implemented easily, computations can be stopped and restarted, moved to different machines and indeed solved on machines which are not able to communicate with each other at all.

💡 Research Summary

The paper introduces a novel paradigm for parallelizing constraint satisfaction problems (CSPs) that does not require any modification of the underlying solver or a sophisticated communication infrastructure. Traditional parallel CSP approaches embed parallelism directly into the solver (e.g., multi‑threaded search, master‑worker task queues) or rely on dynamic work stealing. While effective, these methods introduce considerable implementation complexity, incur communication overhead, and make fault‑tolerance difficult to achieve in practice.

The authors propose “model splitting” as an alternative. Starting from an existing CSP model M, they generate a set of sub‑models {M₁,…,Mₖ} by adding extra constraints that partition the search space. The process works as follows: (1) select one or more decision variables whose domains will be used for partitioning; (2) split each selected domain into k disjoint sub‑domains D₁,…,Dₖ (the split can be uniform or weighted according to heuristic estimates); (3) for each i create a new model Mᵢ that contains all original constraints plus a new constraint forcing the chosen variable(s) to lie in Dᵢ. Consequently, the union of the sub‑models’ search spaces exactly equals the original space, while the intersections are empty.

An optional “search‑exclusion” constraint can be added to each sub‑model to prune portions of the search tree that have already been explored. This is generated from a log of previously examined variable assignments; when a computation is paused, transferred, or restarted, the log is incorporated into the sub‑model, guaranteeing that no duplicate work is performed.

Because each sub‑model is a self‑contained CSP instance, it can be dispatched to any machine that runs a compatible solver, without any need for inter‑process communication. The authors demonstrate that this approach enables simple stop‑and‑resume, migration across heterogeneous hardware, and even execution on machines that cannot communicate with each other at all (e.g., isolated clusters).

Experimental evaluation uses classic benchmarks (n‑Queens, Sudoku, Job‑Shop Scheduling) and a real‑world industrial batch‑sizing problem. For each benchmark the authors create 2, 4, and 8 sub‑models and run them on separate nodes. The total wall‑clock time scales almost linearly with the number of nodes, confirming that the partitioning does not introduce significant overhead. Moreover, when a node fails or a computation is deliberately halted, the remaining work can be resumed on a different node simply by copying the appropriate sub‑model files; the overhead of this restart is negligible.

The paper also discusses limitations. Poor domain partitioning can lead to load imbalance, where some sub‑models finish quickly while others dominate the runtime. The accumulation of exclusion constraints can increase model size, potentially degrading solver performance for very large logs. Finally, because the splitting is performed statically before execution, dynamic load‑balancing mechanisms such as work stealing are not directly applicable. The authors suggest future work on automatic partitioning heuristics, adaptive re‑splitting during execution, and compact representations of exclusion constraints (e.g., using clause learning or constraint compression).

In conclusion, model splitting offers a clean, solver‑agnostic method for distributed CSP solving. By moving the parallelisation effort from the solver code to the model itself, it achieves high portability, fault tolerance, and ease of implementation. The approach is especially attractive for environments where network communication is limited or where heterogeneous resources must be leveraged without extensive software engineering. The authors anticipate that extending this technique to cloud and edge computing scenarios, as well as integrating it with existing parallel optimisation frameworks, will open new avenues for large‑scale, resilient combinatorial problem solving.