void DistillerLongWithImpl::str_and_sub_using_watch( Clause& cl , const Lit lit , const bool alsoStrengthen ) { //Go through the watchlist watch_subarray thisW = solver->watches[lit]; timeAvailable -= (long)thisW.size()*2 + 5; for(Watched* wit = thisW.begin(), *wend = thisW.end() ; wit != wend ; wit++ ) { //Can't do anything with a clause if (wit->isClause()) continue; timeAvailable -= 5; if (alsoStrengthen) { strengthen_clause_with_watch(lit, wit); } const bool subsumed = subsume_clause_with_watch(lit, wit, cl); if (subsumed) return; } }
bool CNF::redundant(const Watched& ws) const { return ( (ws.isBin() && ws.red()) || (ws.isTri() && ws.red()) || (ws.isClause() && cl_alloc.ptr(ws.get_offset())->red() ) ); }
bool CNF::redundant(const Watched& ws) const { return ( (ws.isBinary() && ws.red()) || (ws.isTri() && ws.red()) || (ws.isClause() && clAllocator.getPointer(ws.getOffset())->red() ) ); }
bool CNF::redundant_or_removed(const Watched& ws) const { if (ws.isBin() || ws.isTri()) { return ws.red(); } assert(ws.isClause()); const Clause* cl = cl_alloc.ptr(ws.get_offset()); return cl->red() || cl->getRemoved(); }
bool CNF::redundant_or_removed(const Watched& ws) const { if (ws.isBinary() || ws.isTri()) { return ws.red(); } assert(ws.isClause()); const Clause* cl = clAllocator.getPointer(ws.getOffset()); return cl->red() || cl->getRemoved(); }
ClOffset GateFinder::find_pair_for_and_gate_reduction( const Watched& ws , const size_t minSize , const size_t maxSize , const cl_abst_type general_abst , const OrGate& gate , const bool only_irred ) { //Only long clauses if (!ws.isClause()) return CL_OFFSET_MAX; const ClOffset this_cl_offs = ws.get_offset(); Clause& this_cl = *solver->cl_alloc.ptr(this_cl_offs); if ((ws.getAbst() | general_abst) != general_abst || (this_cl.red() && only_irred) || (!this_cl.red() && gate.red) || this_cl.size() > solver->conf.maxGateBasedClReduceSize || this_cl.size() > maxSize //Size must be smaller or equal to maxSize || this_cl.size() < minSize //Size must be larger or equal than minsize || sizeSortedOcc[this_cl.size()].empty()) //this bracket for sizeSortedOcc must be non-empty { //cout << "Not even possible, this clause cannot match any other" << endl; return CL_OFFSET_MAX; } if (!check_seen_and_gate_against_cl(this_cl, gate)) return CL_OFFSET_MAX; const cl_abst_type this_cl_abst = calc_abst_and_set_seen(this_cl, gate); const ClOffset other_cl_offs = findAndGateOtherCl( sizeSortedOcc[this_cl.size()] //in this occur list that contains clauses of specific size , ~(gate.lit2) //this is the LIT that is meant to be in the clause , this_cl_abst //clause MUST match this abst , gate.red , only_irred ); //Clear 'seen' from bits set *(simplifier->limit_to_decrease) -= this_cl.size(); for (const Lit lit: this_cl) { seen[lit.toInt()] = 0; } return other_cl_offs; }
Lit HyperEngine::prop_larger_than_bin_cl_dfs( StampType stampType , PropBy& confl , Lit& root , bool& restart ) { PropResult ret = PROP_NOTHING; const Lit p = toPropNorm.top(); watch_subarray ws = watches[~p]; propStats.bogoProps += 1; Watched* i = ws.begin(); Watched* j = ws.begin(); Watched* end = ws.end(); for(; i != end; i++) { propStats.bogoProps += 1; if (i->isBin()) { *j++ = *i; continue; } if (i->isTri()) { *j++ = *i; ret = prop_tri_clause_with_acestor_info(i, p, confl); if (ret == PROP_SOMETHING || ret == PROP_FAIL) { i++; break; } else { assert(ret == PROP_NOTHING); continue; } } if (i->isClause()) { ret = prop_normal_cl_with_ancestor_info(i, j, p, confl); if (ret == PROP_SOMETHING || ret == PROP_FAIL) { i++; break; } else { assert(ret == PROP_NOTHING); continue; } } } while(i != end) *j++ = *i++; ws.shrink_(end-j); switch(ret) { case PROP_FAIL: close_all_timestamps(stampType); return analyzeFail(confl); case PROP_SOMETHING: propStats.bogoProps += 8; stamp.stampingTime++; #ifdef DEBUG_STAMPING cout << "From (long-reduced) " << p << " enqueued << " << trail.back() << " for stamp.stampingTime " << stamp.stampingTime << endl; #endif stamp.tstamp[trail.back().toInt()].start[stampType] = stamp.stampingTime; if (stampType == STAMP_IRRED) { //Root for literals propagated afterwards will be this literal root = trail.back(); toPropRedBin.push(trail.back()); } toPropNorm.push(trail.back()); toPropBin.push(trail.back()); propStats.bogoProps += ws.size()*8; restart = true; return lit_Undef; case PROP_NOTHING: break; default: assert(false); break; } //Finished with this literal propStats.bogoProps += ws.size()*8; toPropNorm.pop(); return lit_Undef; }
Lit HyperEngine::propagate_bfs(const uint64_t timeout) { timedOutPropagateFull = false; propStats.otfHyperPropCalled++; #ifdef VERBOSE_DEBUG_FULLPROP cout << "Prop full BFS started" << endl; #endif PropBy confl; //Assert startup: only 1 enqueued, uselessBin is empty assert(uselessBin.empty()); //assert(decisionLevel() == 1); //The toplevel decision has to be set specifically //If we came here as part of a backtrack to decision level 1, then //this is already set, and there is no need to set it if (trail.size() - trail_lim.back() == 1) { //Set up root node Lit root = trail[qhead]; varData[root.var()].reason = PropBy(~lit_Undef, false, false, false); } uint32_t nlBinQHead = qhead; uint32_t lBinQHead = qhead; needToAddBinClause.clear(); PropResult ret = PROP_NOTHING; start: //Early-abort if too much time was used (from prober) if (propStats.otfHyperTime + propStats.bogoProps > timeout) { timedOutPropagateFull = true; return lit_Undef; } //Propagate binary irred while (nlBinQHead < trail.size()) { const Lit p = trail[nlBinQHead++]; watch_subarray_const ws = watches[~p]; propStats.bogoProps += 1; for(const Watched *k = ws.begin(), *end = ws.end() ; k != end ; k++ ) { //If something other than irred binary, skip if (!k->isBin() || k->red()) continue; ret = prop_bin_with_ancestor_info(p, k, confl); if (ret == PROP_FAIL) return analyzeFail(confl); } propStats.bogoProps += ws.size()*4; } //Propagate binary redundant ret = PROP_NOTHING; while (lBinQHead < trail.size()) { const Lit p = trail[lBinQHead]; watch_subarray_const ws = watches[~p]; propStats.bogoProps += 1; size_t done = 0; for(const Watched *k = ws.begin(), *end = ws.end(); k != end; k++, done++) { //If something other than redundant binary, skip if (!k->isBin() || !k->red()) continue; ret = prop_bin_with_ancestor_info(p, k, confl); if (ret == PROP_FAIL) { return analyzeFail(confl); } else if (ret == PROP_SOMETHING) { propStats.bogoProps += done*4; goto start; } else { assert(ret == PROP_NOTHING); } } lBinQHead++; propStats.bogoProps += done*4; } ret = PROP_NOTHING; while (qhead < trail.size()) { const Lit p = trail[qhead]; watch_subarray ws = watches[~p]; propStats.bogoProps += 1; Watched* i = ws.begin(); Watched* j = ws.begin(); Watched* end = ws.end(); for(; i != end; i++) { if (i->isBin()) { *j++ = *i; continue; } if (i->isTri()) { *j++ = *i; ret = prop_tri_clause_with_acestor_info(i, p, confl); if (ret == PROP_SOMETHING || ret == PROP_FAIL) { i++; break; } else { assert(ret == PROP_NOTHING); continue; } } if (i->isClause()) { ret = prop_normal_cl_with_ancestor_info(i, j, p, confl); if (ret == PROP_SOMETHING || ret == PROP_FAIL) { i++; break; } else { assert(ret == PROP_NOTHING); continue; } } } propStats.bogoProps += ws.size()*4; while(i != end) *j++ = *i++; ws.shrink_(end-j); if (ret == PROP_FAIL) { return analyzeFail(confl); } else if (ret == PROP_SOMETHING) { propStats.bogoProps += ws.size()*4; goto start; } qhead++; propStats.bogoProps += ws.size()*4; } return lit_Undef; }