size_t CNF::cl_size(const Watched& ws) const
{
switch(ws.getType()) {
case watch_binary_t:
return 2;
case CMSat::watch_tertiary_t:
return 3;
case watch_clause_t: {
const Clause* cl = cl_alloc.ptr(ws.get_offset());
return cl->size();
}
default:
assert(false);
return 0;
}
}
string CNF::watched_to_string(Lit otherLit, const Watched& ws) const
{
std::stringstream ss;
switch(ws.getType()) {
case watch_binary_t:
ss << otherLit << ", " << ws.lit2();
if (ws.red()) {
ss << "(red)";
}
break;
case CMSat::watch_tertiary_t:
ss << otherLit << ", " << ws.lit2() << ", " << ws.lit3();
if (ws.red()) {
ss << "(red)";
}
break;
case watch_clause_t: {
const Clause* cl = cl_alloc.ptr(ws.get_offset());
for(size_t i = 0; i < cl->size(); i++) {
ss << (*cl)[i];
if (i + 1 < cl->size())
ss << ", ";
}
if (cl->red()) {
ss << "(red)";
}
break;
}
default:
assert(false);
break;
}
return ss.str();
}
size_t CNF::cl_size(const Watched& ws) const
{
switch(ws.getType()) {
case watch_binary_t:
return 2;
break;
case CMSat::watch_tertiary_t:
return 3;
break;
case watch_clause_t: {
const Clause* cl = clAllocator.getPointer(ws.getOffset());
return cl->size();
break;
}
default:
assert(false);
return 0;
break;
}
}
void FeaturesCalc::for_one_clause(
const Watched& cl
, const Lit lit
, Function func_each_cl
, Function2 func_each_lit
) const {
unsigned neg_vars = 0;
unsigned pos_vars = 0;
unsigned size = 0;
switch (cl.getType()) {
case CMSat::watch_binary_t: {
if (cl.red()) {
//only irred cls
break;
}
if (lit > cl.lit2()) {
//only count once
break;
}
pos_vars += !lit.sign();
pos_vars += !cl.lit2().sign();
size = 2;
neg_vars = size - pos_vars;
func_each_cl(size, pos_vars, neg_vars);
func_each_lit(lit, size, pos_vars, neg_vars);
func_each_lit(cl.lit2(), size, pos_vars, neg_vars);
break;
}
case CMSat::watch_tertiary_t: {
if (cl.red()) {
//only irred cls
break;
}
if (lit > cl.lit2()) {
//only count once
break;
}
assert(cl.lit2() < cl.lit3());
pos_vars += !lit.sign();
pos_vars += !cl.lit2().sign();
pos_vars += !cl.lit3().sign();
size = 3;
neg_vars = size - pos_vars;
func_each_cl(size, pos_vars, neg_vars);
func_each_lit(lit, size, pos_vars, neg_vars);
func_each_lit(cl.lit2(), size, pos_vars, neg_vars);
func_each_lit(cl.lit3(), size, pos_vars, neg_vars);
break;
}
case CMSat::watch_clause_t: {
const Clause& clause = *solver->cl_alloc.ptr(cl.get_offset());
if (clause.red()) {
//only irred cls
break;
}
if (clause[0] < clause[1]) {
//only count once
break;
}
for (const Lit cl_lit : clause) {
pos_vars += !cl_lit.sign();
}
size = clause.size();
neg_vars = size - pos_vars;
func_each_cl(size, pos_vars, neg_vars);
for (const Lit cl_lit : clause) {
func_each_lit(cl_lit, size, pos_vars, neg_vars);
}
break;
}
case CMSat::watch_idx_t: {
// This should never be here
assert(false);
exit(-1);
break;
}
}
}
void SubsumeImplicit::subsume_implicit(const bool check_stats)
{
assert(solver->okay());
const double myTime = cpuTime();
const uint64_t orig_timeAvailable =
1000LL*1000LL*solver->conf.subsume_implicit_time_limitM
*solver->conf.global_timeout_multiplier;
timeAvailable = orig_timeAvailable;
const bool doStamp = solver->conf.doStamp;
runStats.clear();
//For randomization, we must have at least 1
if (solver->watches.size() == 0) {
return;
}
//Randomize starting point
const size_t rnd_start = solver->mtrand.randInt(solver->watches.size()-1);
size_t numDone = 0;
for (;numDone < solver->watches.size() && timeAvailable > 0 && !solver->must_interrupt_asap()
;numDone++
) {
const size_t at = (rnd_start + numDone) % solver->watches.size();
runStats.numWatchesLooked++;
const Lit lit = Lit::toLit(at);
watch_subarray ws = solver->watches[lit.toInt()];
//We can't do much when there is nothing, or only one
if (ws.size() < 2)
continue;
if (ws.size() > 1) {
timeAvailable -= ws.size()*std::ceil(std::log((double)ws.size())) + 20;
std::sort(ws.begin(), ws.end(), WatchSorterBinTriLong());
}
/*cout << "---> Before" << endl;
print_watch_list(ws, lit);*/
Watched* i = ws.begin();
Watched* j = i;
clear();
for (Watched* end = ws.end(); i != end; i++) {
if (timeAvailable < 0) {
*j++ = *i;
continue;
}
switch(i->getType()) {
case CMSat::watch_clause_t:
*j++ = *i;
break;
case CMSat::watch_tertiary_t:
try_subsume_tri(lit, i, j, doStamp);
break;
case CMSat::watch_binary_t:
try_subsume_bin(lit, i, j);
break;
default:
assert(false);
break;
}
}
ws.shrink(i-j);
}
const double time_used = cpuTime() - myTime;
const bool time_out = (timeAvailable <= 0);
const double time_remain = float_div(timeAvailable, orig_timeAvailable);
runStats.numCalled++;
runStats.time_used += time_used;
runStats.time_out += time_out;
if (solver->conf.verbosity >= 1) {
runStats.print_short(solver);
}
if (solver->sqlStats) {
solver->sqlStats->time_passed(
solver
, "subsume implicit"
, time_used
, time_out
, time_remain
);
}
if (check_stats) {
#ifdef DEBUG_IMPLICIT_STATS
solver->check_stats();
#endif
}
globalStats += runStats;
}
void SubsumeImplicit::subsume_implicit(const bool check_stats)
{
assert(solver->okay());
const double myTime = cpuTime();
timeAvailable = 1900LL*1000LL*1000LL;
const bool doStamp = solver->conf.doStamp;
runStats.clear();
//Randomize starting point
const size_t rnd_start = solver->mtrand.randInt(solver->watches.size()-1);
size_t numDone = 0;
for (;numDone < solver->watches.size() && timeAvailable > 0
;numDone++
) {
const size_t at = (rnd_start + numDone) % solver->watches.size();
runStats.numWatchesLooked++;
const Lit lit = Lit::toLit(at);
watch_subarray ws = solver->watches[lit.toInt()];
//We can't do much when there is nothing, or only one
if (ws.size() < 2)
continue;
if (ws.size() > 1) {
timeAvailable -= ws.size()*std::ceil(std::log((double)ws.size())) + 20;
std::sort(ws.begin(), ws.end(), WatchSorter());
}
/*cout << "---> Before" << endl;
printWatchlist(ws, lit);*/
Watched* i = ws.begin();
Watched* j = i;
clear();
for (Watched* end = ws.end(); i != end; i++) {
if (timeAvailable < 0) {
*j++ = *i;
continue;
}
switch(i->getType()) {
case CMSat::watch_clause_t:
*j++ = *i;
break;
case CMSat::watch_tertiary_t:
try_subsume_tri(lit, i, j, doStamp);
break;
case CMSat::watch_binary_t:
try_subsume_bin(lit, i, j);
break;
default:
assert(false);
break;
}
}
ws.shrink(i-j);
}
if (check_stats) {
solver->checkStats();
}
runStats.numCalled++;
runStats.time_used += cpuTime() - myTime;
runStats.time_out += (timeAvailable <= 0);
if (solver->conf.verbosity >= 1) {
runStats.printShort();
}
globalStats += runStats;
}
