mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-07-19 10:52:02 +00:00
Code Activity

include chronological backtracking, two-phase sat, xor inprocessing, probsat, ddfw

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2019-06-13 03:34:31 -07:00
parent 46d23ea8d7
commit d17248821a
32 changed files with 3246 additions and 654 deletions
Download patch file Download diff file Expand all files Collapse all files

91
src/sat/sat_parallel.cpp
View file

@ -16,10 +16,9 @@ Author:
Revision History:
--*/
#include "sat_parallel.h"
#include "sat_clause.h"
#include "sat_solver.h"
#include "sat/sat_parallel.h"
#include "sat/sat_clause.h"
#include "sat/sat_solver.h"
namespace sat {
@ -205,27 +204,7 @@ namespace sat {
return (c.size() <= 40 && c.glue() <= 8) || c.glue() <= 2;
}
void parallel::_set_phase(solver& s) {
if (!m_phase.empty()) {
m_phase.reserve(s.num_vars(), l_undef);
for (unsigned i = 0; i < s.num_vars(); ++i) {
if (s.value(i) != l_undef) {
m_phase[i] = s.value(i);
continue;
}
switch (s.m_phase[i]) {
case POS_PHASE:
m_phase[i] = l_true;
break;
case NEG_PHASE:
m_phase[i] = l_false;
break;
default:
m_phase[i] = l_undef;
break;
}
}
}
void parallel::_from_solver(solver& s) {
if (m_consumer_ready && (m_num_clauses == 0 || (m_num_clauses > s.m_clauses.size()))) {
// time to update local search with new clauses.
// there could be multiple local search engines running at the same time.
@ -236,47 +215,53 @@ namespace sat {
}
}
void parallel::set_phase(solver& s) {
std::lock_guard<std::mutex> lock(m_mux);
_set_phase(s);
bool parallel::_to_solver(solver& s) {
if (m_priorities.empty()) {
return false;
}
for (bool_var v = 0; v < m_priorities.size(); ++v) {
s.update_activity(v, m_priorities[v]);
}
return true;
}
void parallel::get_phase(solver& s) {
void parallel::from_solver(solver& s) {
std::lock_guard<std::mutex> lock(m_mux);
_get_phase(s);
_from_solver(s);
}
void parallel::_get_phase(solver& s) {
if (!m_phase.empty()) {
m_phase.reserve(s.num_vars(), l_undef);
for (unsigned i = 0; i < s.num_vars(); ++i) {
switch (m_phase[i]) {
case l_false: s.m_phase[i] = NEG_PHASE; break;
case l_true: s.m_phase[i] = POS_PHASE; break;
default: break;
}
}
bool parallel::to_solver(solver& s) {
std::lock_guard<std::mutex> lock(m_mux);
return _to_solver(s);
}
void parallel::_to_solver(i_local_search& s) {
m_priorities.reset();
for (bool_var v = 0; m_solver_copy && v < m_solver_copy->num_vars(); ++v) {
m_priorities.push_back(s.get_priority(v));
}
}
bool parallel::get_phase(local_search& s) {
bool parallel::_from_solver(i_local_search& s) {
bool copied = false;
{
std::lock_guard<std::mutex> lock(m_mux);
m_consumer_ready = true;
if (m_solver_copy && s.num_non_binary_clauses() > m_solver_copy->m_clauses.size()) {
copied = true;
s.import(*m_solver_copy.get(), true);
}
for (unsigned i = 0; i < m_phase.size(); ++i) {
s.set_phase(i, m_phase[i]);
m_phase[i] = l_undef;
}
m_phase.reserve(s.num_vars(), l_undef);
m_consumer_ready = true;
if (m_solver_copy) {
copied = true;
s.reinit(*m_solver_copy.get());
}
return copied;
}
bool parallel::from_solver(i_local_search& s) {
std::lock_guard<std::mutex> lock(m_mux);
return _from_solver(s);
}
void parallel::to_solver(i_local_search& s) {
std::lock_guard<std::mutex> lock(m_mux);
_to_solver(s);
}
bool parallel::copy_solver(solver& s) {
bool copied = false;