cloud-sat/workers/basekissat.cpp

#include "basekissat.hpp"

extern "C" {
   #include "src/application.h"
   #include "src/parse.h"
   #include "src/internal.h"
   #include "src/witness.h"
   #include "src/import.h"
}

basekissat::basekissat(int id, light* light) : basesolver(id, light) {
    solver = kissat_init();
}

basekissat::~basekissat(){
    delete solver;
}

void kissat_export_clause(void *solver, int lbd, cvec* c) {
    basekissat* S = (basekissat *) solver;
    if (lbd > S->good_clause_lbd) return;
    clause_store* cls = new clause_store(c->sz);
    for (int i = 0; i < c->sz; i++) {
        int v = cvec_data(c, i);
        int eidx = PEEK_STACK(S->solver->exportk, (v >> 1));
        cls->data[i] = v & 1 ? -eidx : eidx;
    }
    cls->lbd = lbd;
    S->export_clause.push(cls);
}

int kissat_import_clause(void *solver, int *lbd, cvec* c) {
    basekissat* S = (basekissat *) solver;
    clause_store* cls = NULL;
    if (S->import_clause.pop(&cls) == false) return -1;

    bool eliminated = false;
    for (int i = 0; i < cls->size; i++) {
        int eidx = abs(cls->data[i]);
        import *import = &PEEK_STACK (S->solver->import, eidx);
        if (import->eliminated) {
            eliminated = true;
        }
        else {
            int ilit = import->lit;
            if (cls->data[i] < 0) ilit = ilit ^ 1;
            cvec_push(c, ilit);
        }
    }
    *lbd = cls->lbd;
    cls->free_clause();
    if (eliminated) return -10;
    return 1;
} 

void basekissat::parse_dimacs(char* filename) {
    kissat_mab_parse(solver);
    strictness strict = NORMAL_PARSING;
    file in;
    uint64_t lineno;
    kissat_open_to_read_file(&in, filename);
    kissat_parse_dimacs(solver, strict, &in, &lineno, &solver->max_var);
    kissat_close_file(&in);
}

void basekissat::import_original_clause(preprocess* pre) {
    solver->max_var = pre->vars;
    kissat_mab_parse(solver);
    kissat_reserve(solver, pre->vars);
    for (int i = 1; i <= pre->clauses; i++) {
        int l = pre->clause[i].size();
        for (int j = 0; j < l; j++)
            kissat_add(solver, pre->clause[i][j]);
        kissat_add(solver, 0);
    }
}

void basekissat::diversity(int id) {
    if (id) solver->order_reset = id;
}

int  basekissat::solve() {
    return kissat_solve(solver);
}

void basekissat::terminate() {
    kissat_terminate(solver);
}

void basekissat::get_model(vec<int> &model) {
    model.clear();
    for (int i = 1; i <= solver->max_var; i++) {
      int tmp = kissat_value(solver, i);
      if (!tmp) tmp = i;
      model.push(tmp);
   }
}

int basekissat::get_reset_data() {
    return solver->best_assigned;
}

void basekissat::reset() {
    solver->reseting = 1;
}

void basekissat::export_clauses_to(vec<clause_store *> &clauses) {

}

void basekissat::import_clauses_from(vec<clause_store *> &clauses) {
    
}