最早使用cmt的minisat改进版求解器2——vsids-master-1\minisat-performance

位置：

E:\CNKI E-Study\localestudy\Literature\SAT求解器学习_6B1FE1DF69904FE2AEC3542DCF408574\VSIDS paper\VISDS-solvers\vsids-master-1\vsids-master-1\minisat-performance\core

 

代码分析

---

Solver.h

//============================================
// Solver -- the main class:

class Solver {
public:
  ...

    bool      save_decision_trail;   // Whether to save decision trail
    bool      save_learned_clauses;   // Whether to save learned clauses
    bool      conflicting_vars_analysis;
 ...
    void    writeDecisionVar(Var next);
    void    writeLearnedClause(vec<Lit>& out_learnt);
    void    updateConflictAnalysis(Var v);
    void    updateConflictAnalysis(vec<Lit>& c);

    // Track solver behavior
    FILE* decision_trail_file;
    FILE* learned_clauses_file;
 ... 
    //XXX EXPERIMENT
    std::vector<int> conflicting_vars_count;
    std::vector< std::vector<double> > conflicting_vars_graph;
...
};

inline void Solver::writeDecisionVar(Var next) {
    if (save_decision_trail) {
        assert((next != var_Undef) && (next>=0) && (next<=nVars()));
        // +1 is necessary because MiniSAT stores variables naming from 0 not 1
        //fprintf(decision_trail_file, "%d ", next+1);
        fprintf(decision_trail_file, "%d\n", next);
    }
}

inline void Solver::writeLearnedClause(vec<Lit>& out_learnt) {
    if (save_learned_clauses) {
        for(int i = 0; i < out_learnt.size(); i++)
            fprintf(learned_clauses_file, "%d ", var(out_learnt[i]));
        fprintf(learned_clauses_file, "\n");
    }
}

inline void Solver::updateConflictAnalysis(Var v) {
    if (conflicting_vars_analysis) {
        // +1 at end is necessary because MiniSAT stores variables naming from 0 not 1
        conflicting_vars_count[v] += 1;
    }
}

inline void Solver::updateConflictAnalysis(vec<Lit>& c) {
    if (conflicting_vars_analysis) {
        int l,h;
        //printf("asdf\n");
        // +1 at end is necessary because MiniSAT stores variables naming from 0 not 1
        for(int i = 0; i < c.size()-1; i++)
            for(int j = i + 1; j < c.size(); j++){
                if(var(c[i]) < var(c[j])){
                    l = var(c[i]);
                    h = var(c[j]);
                }
                else{
                    l = var(c[j]);
                    h = var(c[i]);
                }
                //printf("%d %d\n",l,h);
                //XXX probably should change increment to correlate with clause size
                conflicting_vars_graph[l][h-l-1] += 1;
            }

    }
}

Solver.h中新增用于观察性能的代码段

 

Solver.cc

lbool Solver::search(int nof_conflicts)
{
    assert(ok);
    int         backtrack_level;
    int         conflictC = 0;
    vec<Lit>    learnt_clause;
    starts++;

    for (;;){
        CRef confl = propagate();
        if (confl != CRef_Undef){
            // CONFLICT
            conflicts++; conflictC++;
            if (decisionLevel() == 0) return l_False;

            learnt_clause.clear();
            analyze(confl, learnt_clause, backtrack_level);
            cancelUntil(backtrack_level);

            if (learnt_clause.size() == 1){
                uncheckedEnqueue(learnt_clause[0]);
            }else{
                CRef cr = ca.alloc(learnt_clause, true);
                learnts.push(cr);
                attachClause(cr);
                claBumpActivity(ca[cr]);
                uncheckedEnqueue(learnt_clause[0], cr);
            }

            varDecayActivity();
            claDecayActivity();

            if (--learntsize_adjust_cnt == 0){
                learntsize_adjust_confl *= learntsize_adjust_inc;
                learntsize_adjust_cnt    = (int)learntsize_adjust_confl;
                max_learnts             *= learntsize_inc;

                if (verbosity >= 1)
                    printf("| %9d | %7d %8d %8d | %8d %8d %6.0f | %6.3f %% |\n", 
                           (int)conflicts, 
                           (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]), nClauses(), (int)clauses_literals, 
                           (int)max_learnts, nLearnts(), (double)learnts_literals/nLearnts(), progressEstimate()*100);
            }

        }else{
            // NO CONFLICT
            if (nof_conflicts >= 0 && conflictC >= nof_conflicts || !withinBudget()){
                // Reached bound on number of conflicts:
                progress_estimate = progressEstimate();
                cancelUntil(0);
                return l_Undef; }

            // Simplify the set of problem clauses:
            if (decisionLevel() == 0 && !simplify())
                return l_False;

            if (learnts.size()-nAssigns() >= max_learnts)
                // Reduce the set of learnt clauses:
                reduceDB();

            Lit next = lit_Undef;
            while (decisionLevel() < assumptions.size()){
                // Perform user provided assumption:
                Lit p = assumptions[decisionLevel()];
                if (value(p) == l_True){
                    // Dummy decision level:
                    newDecisionLevel();
                }else if (value(p) == l_False){
                    analyzeFinal(~p, conflict);
                    return l_False;
                }else{
                    next = p;
                    break;
                }
            }

            if (next == lit_Undef){
                // New variable decision:
                decisions++;
                next = pickBranchLit();


                if (next == lit_Undef)
                    // Model found:
                    return l_True;
                else
                    writeDecisionVar(var(next));
            }

            // Increase decision level and enqueue 'next'
            newDecisionLevel();
            uncheckedEnqueue(next);
        }
    }
}

 函数writeDecisionVar(var(next))调用

 

void Solver::analyze(CRef confl, vec<Lit>& out_learnt, int& out_btlevel)
{
    int pathC = 0;
    Lit p     = lit_Undef;

    // Generate conflict clause:
    //
    out_learnt.push();      // (leave room for the asserting literal)
    int index   = trail.size() - 1;

    do{
        assert(confl != CRef_Undef); // (otherwise should be UIP)
        Clause& c = ca[confl];

        if (c.learnt())
            claBumpActivity(c);

        for (int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++){
            Lit q = c[j];

            if (!seen[var(q)] && level(var(q)) > 0){
                varBumpActivity(var(q));
                seen[var(q)] = 1;
                if (level(var(q)) >= decisionLevel())
                    pathC++;
                else
                    out_learnt.push(q);
            }
        }
        
        // Select next clause to look at:
        while (!seen[var(trail[index--])]);
        p     = trail[index+1];
        confl = reason(var(p));
        seen[var(p)] = 0;
        pathC--;

    }while (pathC > 0);
    out_learnt[0] = ~p;

    // Simplify conflict clause:
    //
    int i, j;
    out_learnt.copyTo(analyze_toclear);
    if (ccmin_mode == 2){
        uint32_t abstract_level = 0;
        for (i = 1; i < out_learnt.size(); i++)
            abstract_level |= abstractLevel(var(out_learnt[i])); 
               // (maintain an abstraction of levels involved in conflict)

        for (i = j = 1; i < out_learnt.size(); i++)
            if (reason(var(out_learnt[i])) == CRef_Undef 
                                                   || !litRedundant(out_learnt[i], abstract_level))
                out_learnt[j++] = out_learnt[i];
        
    }else if (ccmin_mode == 1){
        for (i = j = 1; i < out_learnt.size(); i++){
            Var x = var(out_learnt[i]);

            if (reason(x) == CRef_Undef)
                out_learnt[j++] = out_learnt[i];
            else{
                Clause& c = ca[reason(var(out_learnt[i]))];
                for (int k = 1; k < c.size(); k++)
                    if (!seen[var(c[k])] && level(var(c[k])) > 0){
                        out_learnt[j++] = out_learnt[i];
                        break; }
            }
        }
    }else
        i = j = out_learnt.size();

    max_literals += out_learnt.size();
    out_learnt.shrink(i - j);
    tot_literals += out_learnt.size();

    // Find correct backtrack level:
    //
    if (out_learnt.size() == 1)
        out_btlevel = 0;
    else{
        int max_i = 1;
        // Find the first literal assigned at the next-highest level:
        for (int i = 2; i < out_learnt.size(); i++)
            if (level(var(out_learnt[i])) > level(var(out_learnt[max_i])))
                max_i = i;
        // Swap-in this literal at index 1:
        Lit p             = out_learnt[max_i];
        out_learnt[max_i] = out_learnt[1];
        out_learnt[1]     = p;
        out_btlevel       = level(var(p));
    }

    //XXX EXPERIMENT
    for(int i = 0; i < out_learnt.size(); i++)
        updateConflictAnalysis(var(out_learnt[i]));
    updateConflictAnalysis(out_learnt);
    writeLearnedClause(out_learnt);

    for (int j = 0; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0;
       // ('seen[]' is now cleared)
}

 

发生以下函数调用：

updateConflictAnalysis(var(out_learnt[i]));  updateConflictAnalysis(out_learnt);  writeLearnedClause(out_learnt)；

 

Solver::~Solver()
{
    if(save_decision_trail)
        fclose(decision_trail_file);
}

备注：    bool   save_decision_trail;   // Whether to save decision trail