// Creates a new SAT variable in the solver. If 'decision_var' is cleared, variable will not be // used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result). // Var Solver::newVar(bool sign, bool dvar) { int v = nVars(); watches .push(); // (list for positive literal) watches .push(); // (list for negative literal) watchesBin .push(); // (list for negative literal) watchesBin .push(); // (list for negative literal) watchBackup.ws.push(); watchBackup.ws.push(); watchBackup.flags.push(false); watchBackup.flags.push(false); reason .push(NULL); assigns .push(toInt(l_Undef)); level .push(-1); activity .push(0); seen .push(0); permDiff .push(0); polarity .push((char)sign); decision_var.push((char)dvar); insertVarOrder(v); return v; }
int SAT::newVar(int n, ChannelInfo ci) { int s = assigns.size(); watches .growBy(n); watches .growBy(n); assigns .growBy(n, toInt(l_Undef)); reason .growBy(n, NULL); trailpos .growBy(n, -1); seen .growBy(n, 0); if(so.rnd_init){ for(int i = 0 ; i < n ; i++) activity.growBy(1, ((double)(rand()%0xFFFFFF))/0xFFFFFF); } else activity .growBy(n, 0); polarity .growBy(n, 1); flags .growBy(n, 7); for (int i = 0; i < n; i++) { c_info.push(ci); ci.val++; insertVarOrder(s+i); } return s; }
// Revert to the state at given level (keeping all assignment at 'level' but not beyond). // void Solver::cancelUntil(int level) { if (decisionLevel() > level){ for (int c = trail.size()-1; c >= trail_lim[level]; c--){ Var x = var(trail[c]); assigns[x] = toInt(l_Undef); insertVarOrder(x); } qhead = trail_lim[level]; trail.shrink(trail.size() - trail_lim[level]); trail_lim.shrink(trail_lim.size() - level); } }
inline void SAT::untrailToPos(vec<Lit>& t, int p) { int dl = decisionLevel(); for (int i = t.size(); i-- > p; ) { int x = var(t[i]); assigns[x] = toInt(l_Undef); #if PHASE_SAVING if (so.phase_saving >= 1 || (so.phase_saving == 1 && dl >= l0)) polarity[x] = sign(t[i]); #endif insertVarOrder(x); } t.resize(p); }
// Revert to the state at given level (keeping all assignment at 'level' but not beyond). // void Solver::cancelUntil(int level) { #ifdef RESTORE printf("------------ Canceling until level %d\n", level); #endif if (decisionLevel() > level){ for (int c = trail.size()-1; c >= trail_lim[level]; c--){ Var x = var(trail[c]); assigns[x] = toInt(l_Undef); insertVarOrder(x); #ifdef RESTORE printf("Canceling lit ");printLit(trail[c]); printf("\n"); #endif } qhead = trail_lim[level]; trail.shrink(trail.size() - trail_lim[level]); trail_lim.shrink(trail_lim.size() - level); } }
// Creates a new SAT variable in the solver. If 'decision_var' is cleared, variable will not be // used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result). // Var Solver::newVar(bool sign, double act, bool dvar) { int v = nVars(); watches .push(); // (list for positive literal) watches .push(); // (list for negative literal) reason .push(NULL); assigns .push(toInt(l_Undef)); level .push(-1); activity .push(act); original_activity .push(act); seen .push(0); polarity .push((char)sign); decision_var.push((char)dvar); insertVarOrder(v); return v; }
int SAT::newVar(int n, ChannelInfo ci) { int s = assigns.size(); watches .growBy(n); watches .growBy(n); assigns .growBy(n, toInt(l_Undef)); reason .growBy(n, NULL); trailpos .growBy(n, -1); seen .growBy(n, 0); activity .growBy(n, 0); polarity .growBy(n, 1); flags .growBy(n, 7); for (int i = 0; i < n; i++) { c_info.push(ci); ci.val++; insertVarOrder(s+i); } return s; }
// Creates a new SAT variable in the solver. If 'decision_var' is cleared, variable will not be // used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result). // Var MiniSATP::newVar(bool sign, bool dvar) { int v = nVars(); watches .push(); // (list for positive literal) watches .push(); // (list for negative literal) reason .push(NULL); assigns .push(toInt(l_Undef)); level .push(-1); activity .push(0); seen .push(0); polarity .push((char)sign); decision_var.push((char)dvar); insertVarOrder(v); // Added Lines undo_stack_oper.push_back( NEWVAR ); // undo_stack_elem.push_back( (void *)&v ); undo_stack_elem.push_back( reinterpret_cast< void * >( v ) ); return v; }
void MiniSATP::popBacktrackPoint ( ) { // // Force restart, but retain assumptions // cancelUntil(0); // // Shrink back trail // int new_trail_size = undo_trail_size.back( ); undo_trail_size.pop_back( ); for ( int i = trail.size( ) - 1 ; i >= new_trail_size ; i -- ) { Var x = var(trail[i]); assigns[x] = toInt(l_Undef); reason [x] = NULL; insertVarOrder(x); } trail.shrink(trail.size( ) - new_trail_size); assert( trail_lim.size( ) == 0 ); qhead = trail.size( ); // // Undo operations // size_t new_stack_size = undo_stack_size.back( ); undo_stack_size.pop_back( ); while ( undo_stack_oper.size( ) > new_stack_size ) { const oper_t op = undo_stack_oper.back( ); if ( op == NEWVAR ) { #ifdef BUILD_64 long xl = reinterpret_cast< long >( undo_stack_elem.back( ) ); const Var x = static_cast< Var >( xl ); #else const Var x = reinterpret_cast< int >( undo_stack_elem.back( ) ); #endif // Undoes insertVarOrder( ) assert( order_heap.inHeap(x) ); order_heap .remove(x); // Undoes decision_var ... watches decision_var.pop(); polarity .pop(); seen .pop(); activity .pop(); level .pop(); assigns .pop(); reason .pop(); watches .pop(); watches .pop(); } else if ( op == NEWUNIT ) { } else if ( op == NEWCLAUSE ) { Clause * c = (Clause *)undo_stack_elem.back( ); assert( clauses.last( ) == c ); // assert( c->id + 1 == (int)clause_id_to_enode.size( ) ); clauses.pop( ); removeClause( *c ); // clause_id_to_enode.pop_back( ); } else { opensmt_error2( "unknown undo operation in BitBlaster", op ); } undo_stack_oper.pop_back( ); undo_stack_elem.pop_back( ); } while( learnts.size( ) > 0 ) { Clause * c = learnts.last( ); learnts.pop( ); removeClause( *c ); } while( removed.size( ) > 0 ) { Clause * c = removed.last( ); removed.pop( ); free( c ); } assert( undo_stack_elem.size( ) == undo_stack_oper.size( ) ); assert( learnts.size( ) == 0 ); assert( removed.size( ) == 0 ); }