regression fix to ackerman gc and memory smash, perf fix for handling bv2int axioms, perf fix for filtering ackerman

this update addresses some perf regressions introduced when handling axioms for bv2int and a memory smash regression when decoupling bv-ackerman from in-processing. It adds a filter based on bv_eq_axioms for disabling ackerman reductions on disequalities.

src/sat/smt/bv_ackerman.cpp

@@ -49,16 +49,19 @@ namespace bv {
         update_glue(*other);
 
         vv::push_to_front(m_queue, other);
-        if (other == n) {
+        bool do_gc = other == n;
+        if (other == n) 
             new_tmp();        
-            gc();
-        }
+               
         if (other->m_glue == 0) {
+            do_gc = false;
             remove(other);
             add_cc(v1, v2);
         }
         else if (other->m_count > 2*m_propagate_high_watermark) 
             propagate();
+        if (do_gc)
+            gc();
     }
 
     void ackerman::used_diseq_eh(euf::theory_var v1, euf::theory_var v2) {

src/sat/smt/bv_internalize.cpp

@@ -429,6 +429,8 @@ namespace bv {
             args.push_back(m.mk_ite(b, m_autil.mk_int(power2(i++)), zero));        
         expr_ref sum(m_autil.mk_add(sz, args.data()), m);
         sat::literal lit = eq_internalize(n, sum);
+        m_bv2ints.push_back(expr2enode(n));
+        ctx.push(push_back_vector<euf::enode_vector>(m_bv2ints));
 	add_unit(lit);
     }
 

src/sat/smt/bv_solver.cpp

@@ -211,9 +211,8 @@ namespace bv {
             return;
         }
         euf::enode* n1 = var2enode(eq.v1());
-        for (euf::enode* bv2int : euf::enode_class(n1)) {
-            if (!bv.is_bv2int(bv2int->get_expr()))
-                continue;
+
+        auto propagate_bv2int = [&](euf::enode* bv2int) {
             euf::enode* bv2int_arg = bv2int->get_arg(0);
             for (euf::enode* p : euf::enode_parents(n1->get_root())) {
                 if (bv.is_int2bv(p->get_expr()) && p->get_sort() == bv2int_arg->get_sort() && p->get_root() != bv2int_arg->get_root()) {
@@ -224,6 +223,19 @@ namespace bv {
                     break;
                 }
             }
+        };
+
+        if (m_bv2ints.size() < n1->class_size()) {
+            for (auto* bv2int : m_bv2ints) {
+                if (bv2int->get_root() == n1->get_root())
+                    propagate_bv2int(bv2int);
+            }
+        }
+        else {
+            for (euf::enode* bv2int : euf::enode_class(n1)) {                
+                if (bv.is_bv2int(bv2int->get_expr()))
+                    propagate_bv2int(bv2int);
+            }
         }
     }
 
@@ -279,6 +291,8 @@ namespace bv {
             ++m_stats.m_num_ne2bit;
             s().assign(consequent, mk_ne2bit_justification(undef_idx, v1, v2, consequent, antecedent));
         }
+        else if (!get_config().m_bv_eq_axioms) 
+            ;
         else if (s().at_search_lvl()) {
             force_push();
             assert_ackerman(v1, v2);

src/sat/smt/bv_solver.h

@@ -207,8 +207,9 @@ namespace bv {
         literal_vector             m_tmp_literals;
         svector<propagation_item>  m_prop_queue;
         unsigned_vector            m_prop_queue_lim;
-        unsigned                   m_prop_queue_head { 0 };
-        sat::literal               m_true { sat::null_literal };
+        unsigned                   m_prop_queue_head = 0;
+        sat::literal               m_true = sat::null_literal;
+        euf::enode_vector          m_bv2ints;
 
         // internalize
         void insert_bv2a(bool_var bv, atom * a) { m_bool_var2atom.setx(bv, a, 0); }

src/sat/smt/euf_solver.cpp

@@ -527,7 +527,7 @@ namespace euf {
         bool merged = false;
         for (unsigned i = m_egraph.nodes().size(); i-- > 0; ) {
             euf::enode* n = m_egraph.nodes()[i];
-            if (!is_shared(n) || !m.is_bool(n->get_expr()))
+            if (!m.is_bool(n->get_expr()) || !is_shared(n))
                 continue;
             if (n->value() == l_true && !m.is_true(n->get_root()->get_expr())) {
                 m_egraph.merge(n, mk_true(), to_ptr(sat::literal(n->bool_var())));

src/smt/theory_bv.cpp

@@ -599,6 +599,8 @@ namespace smt {
         TRACE("bv", tout << mk_bounded_pp(n, m) << "\n";);
         process_args(n);
         mk_enode(n);
+        m_bv2int.push_back(ctx.get_enode(n));
+        ctx.push_trail(push_back_vector<enode_vector>(m_bv2int));
         if (!ctx.relevancy()) 
             assert_bv2int_axiom(n);
     }
@@ -1496,12 +1498,10 @@ namespace smt {
         unsigned sz  = m_bits[v1].size();
         bool changed = true;
         TRACE("bv", tout << "bits size: " << sz << "\n";);
-        if (sz == 0) {
+        if (sz == 0 && !m_bv2int.empty()) {
             // int2bv(bv2int(x)) = x when int2bv(bv2int(x)) has same sort as x
             enode* n1 = get_enode(r1);
-            for (enode* bv2int : *n1) {
-                if (!m_util.is_bv2int(bv2int->get_expr())) 
-                    continue;
+            auto propagate_bv2int = [&](enode* bv2int) {
                 enode* bv2int_arg = bv2int->get_arg(0);
                 for (enode* p : enode::parents(n1->get_root())) {
                     if (m_util.is_int2bv(p->get_expr()) && p->get_root() != bv2int_arg->get_root() && p->get_sort() == bv2int_arg->get_sort()) {                        
@@ -1514,6 +1514,18 @@ namespace smt {
                         break;
                     }                    
                 }
+            };
+
+            if (m_bv2int.size() < n1->get_class_size()) {
+                for (enode* bv2int : m_bv2int)
+                    if (bv2int->get_root() == n1->get_root())
+                        propagate_bv2int(bv2int);
+            }
+            else {
+                for (enode* bv2int : *n1) {
+                    if (m_util.is_bv2int(bv2int->get_expr())) 
+                        propagate_bv2int(bv2int);
+                }
             }
         }
         do {

src/smt/theory_bv.h

@@ -112,6 +112,7 @@ namespace smt {
         svector<unsigned>        m_wpos;     // per var, watch position for fixed variable detection. 
         vector<zero_one_bits>    m_zero_one_bits; // per var, see comment in the struct zero_one_bit
         bool_var2atom            m_bool_var2atom;
+        enode_vector             m_bv2int;
         typedef svector<theory_var> vars;
 
         typedef std::pair<numeral, unsigned> value_sort_pair;