6.9 KiB
Parallel project notes
We track notes for updates to smt_parallel.cpp and possibly solver/parallel_tactic.cpp
Variable selection heuristics
- Lookahead solvers:
- lookahead in the smt directory performs a simplistic lookahead search using unit propagation.
- lookahead in the sat directory uses custom lookahead solver.
They both proxy on a cost model where the most useful variable to branch on is the one that minimizes the set of new clauses maximally
through unit propagation. In other words, if a literal p is set to true, and p occurs in clause
\neg p \vee q \vee r
, then it results in reducing the clause from size 3 to 2 (because\neg p
will be false after propagating p).
- VSIDS:
- As referenced in Matteo and Antti's solvers.
- Variable activity is a proxy for how useful it is to case split on a variable during search. Variables with a higher VSIDS are split first.
- VSIDS is updated dynamically during search. It was introduced in the paper with Moscovitz, Malik, et al in early 2000s. A good overview is in Armin's tutorial slides (also in my overview of SMT).
- VSIDS does not keep track of variable phases (if the variable was set to true or false).
- Proof prefix:
- Collect the literals that occur in learned clauses. Count their occurrences based on polarity. This gets tracked in a weighted score.
- The weight function can be formulated to take into account clause sizes.
- The score assignment may also decay similar to VSIDS.
- We could also use a doubly linked list for literals used in conflicts and keep reinsert literals into the list when they are used. This would be a "Variable move to front" (VMTF) variant.
- From local search:
- Note also that local search solvers can be used to assign variable branch priorities.
- We are not going to directly run a local search solver in the mix up front, but let us consider this heuristic for completeness.
- The heuristic is documented in Biere and Cai's journal paper on integrating local search for CDCL.
- Roughly, it considers clauses that move from the UNSAT set to the SAT set of clauses. It then keeps track of the literals involved.
- Assignment trails:
- We could also consider the assignments to variables during search.
- Variables that are always assigned to the same truth value could be considered to be safe to assign that truth value.
- The cubes resulting from such variables might be a direction towards finding satisfying solutions.
Algorithms
This section considers various possible algorithms.
In the following, F
refers to the original goal, T
is the number of CPU cores or CPU threads.
Base algorithm
The existing algorithm in smt_parallel is as follows:
- Run a solver on
F
with a bounded number of conflicts. - If the result is SAT/UNSAT, or UNKNOWN with an interrupt or timeout, return. If the maximal number of conflicts were reached continue.
- Spawn
T
solvers onF
with a bounded number of conflicts, wait until a thread returns UNSAT/SAT or all threads have reached a maximal number of conflicts. - Perform a similar check as in 2.
- Share unit literals learned by each thread.
- Compute unit cubes for each thread
T
. - Spawn
T
solvers withF \wedge \ell
, where\ell
is a unit literal determined by lookahead function in each thread. - Perform a similar check as in 2. But note that a thread can be UNSAT because the unit cube
\ell
contradictedF
. In this case learn the unit literal\neg \ell
. - Shared unit literals learned by each thread, increase the maximal number of conflicts, go to 3.
Algorithm Variants
- Instead of using lookahead solving to find unit cubes use the proof-prefix based scoring function.
- Instead of using independent unit cubes, perform a systematic (where systematic can mean many things) cube and conquer strategy.
- Spawn some threads to work in "SAT" mode, tuning to find models instead of short resolution proofs.
- Change the synchronization barrier discipline.
- [Future] Include in-processing
Cube and Conquer strategy
We could maintain a global decomposition of the search space by maintaing a list of cubes.
Initially, the list of cubes has just one element, the cube with no literals [ [] ]
.
By using a list of cubes instead of a set of cubes we can refer to an ordering.
For example, cubes can be ordered by a suffix traversal of the cube tree (the tree formed by
case splitting on the first literal, children of the true branch are the cubes where the first
literal is true, children of the false branch are the cubes where the first literal is false).
The main question is going to be how the cube decomposition is created.
Static cubing
We can aim for a static cube strategy that uses a few initial (concurrent) probes to find cube literals. This strategy would be a parallel implementaiton of proof-prefix approach. The computed cubes are inserted into the list of cubes and the list is consumed by a second round.
Growing cubes on demand
Based on experiences with cubing so far, there is high variance in how easy cubes are to solve. Some cubes will be harder than others to solve. For hard cubes, it is tempting to develop a recursive cubing strategy. Ideally, a recursive cubing strategy is symmetric to top-level cubing.
-
The solver would have to identify hard cubes vs. easy cubes.
-
It would have to know when to stop working on a hard cube and replace it in the list of cubes by a new list of sub-cubes.
-
Ideally, we don't need any static cubing and cubing is grown on demand while all threads are utilized.
- If we spawn
T
threads to initially work with empty cubes, we could extract up toT
indepenent cubes by examining the proof-prefix of their traces. This can form the basis for the first, up to2^T
cubes. - After a round of solving with each thread churning on some cubes, we may obtain more proof-prefixes from hard cubes. It is not obvious that we want to share cubes from different proof prefixes at this point. But a starting point is to split a hard cube into two by using the proof-prefix from attempting to solve it.
- Suppose we take the proof-prefix sampling algorithm at heart: It says to start with some initial cube prefix
and then sample for other cube literals. If we translate it to the case where multiple cubes are being processed
in parallel, then an analogy is to share candidates for new cube literals among cubes that are close to each-other.
For example, if thread
t_1
processes cubea, b, c
andt_2
processesa,b, \neg c
. They are close. They are only separated by Hamming distance 1. Ift_1
finds cube literald
andt_2
finds cube literale
, we could consider the cubesa, b, c, d, e
, anda, b, c, d, \neg e
,\ldots
,a, b, \neg c, \neg d, \neg e
.
- If we spawn
Representing cubes implicitly
We can represent a list of cubes by using intervals and only represent start and end-points of the intervals.
Batching
Threads can work on more than one cube in a batch.