Lock-free State Merging in Parallel CSP Solvers
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Traditional sequential algorithms for constraint satisfaction problem (CSP) solvers, such as Boolean satisfiability (SAT) solvers, face difficulties in effectively utilizing shared-memory parallel processors due to challenges in merging conflict-free solver states in parallel processing systems.
Innovation Solution
The architecture represents the state of a computational thread as a set of support graphs and merges them pairwise to create a new conflict-free graph, allowing for efficient parallel propagation of constraints and reducing the problem solver state, while avoiding conventional locking mechanisms through lock-free state merging.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If traditional sequential algorithms are used in parallel processing systems, then algorithm simplicity is maintained, but effectiveness in utilizing shared-memory parallel processors deteriorates
Solution Approach 1:
The solver state is segmented into multiple independent support graphs, each representing a different computational thread's state. This segmentation allows parallel processing while maintaining the ability to merge results through the pairwise merging operation, resolving the contradiction between adaptability to parallel systems and algorithm complexity.
Solution Approach 2:
The patent introduces a pairwise merging operation that combines multiple support graphs into a single conflict-free graph. This merging mechanism enables the system to utilize parallel processors effectively by aggregating results from multiple threads, thereby improving adaptability to parallel processing without requiring complete redesign of the underlying algorithm.
2Speed
If multiple parallel computations propagate constraints simultaneously, then processing speed increases, but conflict resolution complexity increases
Solution Approach 1:
Each parallel computational thread maintains its own support graph, segmenting the overall state management. This allows simultaneous constraint propagation across multiple threads (increasing speed) while isolating conflicts to individual graphs, reducing the complexity of conflict resolution during merging.
Solution Approach 2:
The patent converts the harmful effect of conflicts into a beneficial filtering mechanism. By merging support graphs pairwise and removing conflicting literals, the system uses conflict detection as a means to produce cleaner, more reliable solver states, thereby managing the complexity increase through a systematic approach to conflict resolution.
3Reliability
If conventional locking mechanisms are used for state merging, then data consistency is ensured, but processing efficiency deteriorates
Solution Approach 1:
The support graph merging operation is designed to be lock-free, allowing multiple threads to perform constraint propagation and state updates independently. The graphs self-manage their own consistency through the pairwise merging process, eliminating the need for external locking mechanisms and thereby improving processing efficiency while maintaining data consistency through the structured merging algorithm.
Data Source
AI summary
Solver state merging in parallel constraint satisfaction problem (CSP) solvers. Solver state during processing of a computational thread of parallel CSP solvers is represented as a set of support graphs. The support graphs are merged in a pairwise fashion, yielding a new conflict-free graph. The merge process is free of cycles, conflicts are removed, and thread processing is lock-free. The architecture can be applied, generally, in any CSP solver (e.g., a Boolean SAT solver) having certain formal properties. A system is provided that facilitates solver processing, the system comprising a bookkeeping component for representing input solver state of a computational thread as a set of graphs, and a merge component for pairwise merging of at least two input graphs of the set of graphs into a merged graph that represents final state of the computational thread.