cadical 0.9.0

data/ext/cadical/cadical/src/range.hpp

@@ -0,0 +1,125 @@
+#ifndef _range_hpp_INCLUDED
+#define _range_hpp_INCLUDED
+
+#include <cassert>
+
+namespace CaDiCaL {
+
+struct Clause;
+
+/*----------------------------------------------------------------------*/
+
+// Used for compact and safe iteration over positive ranges of integers,
+// particularly for iterating over all variable indices.
+//
+//   Range vars (max_var);
+//   for (auto idx : vars) ...
+//
+// This iterates over '1, ..., max_var' and is safe for non-negative
+// numbers, thus also for 'max_var == 0' or 'max_var == INT_MAX'.
+//
+// Note that
+//
+//   for (int idx = 1; idx <= max_var; idx++) ...
+//
+// leads to an overflow if 'max_var == INT_MAX' and thus depending on what
+// the compiler does ('int' overflow is undefined) might lead to any
+// behaviour (infinite loop or worse array access way out of bounds).
+//
+// If we make 'idx' in this last 'for' loop an 'unsigned' then it is safe to
+// use this idiom, but we would need to cast 'max_var' explicitly to 'int'
+// in order to avoid a warning in the loop condition and actually everywhere
+// where 'idx' is compared to a 'signed' expression.  Worse for instance
+// 'vals[-idx]' will lead to out of bounds access too.  This is awkward and
+// using the range iterator provided here is safer in general.
+//
+// Another issue is that the dereferencing operator '*' below is required to
+// return a reference to the internal index of the iterator.  Thus the 'idx'
+// in the auto loop is actually of the same type as the internal state of
+// the iterator.  To keep it 'signed' and still avoid overflow issues we
+// just have to make sure to use the proper increment (with two implicit
+// casts, i.e., from 'int' to 'unsigned', then 'unsigned' addition and the
+// result is cast back from 'unsigned' to 'int').
+//
+// For simplicity we keep a reference to the actual maximum integer, e.g.,
+// 'max_var', which makes the idiom 'for (auto idx : vars) ...' possible.
+// Further note that the referenced integer has to be non-negative before
+// starting to iterate (it can be zero though), otherwise it breaks.
+
+class Range {
+  static unsigned inc (unsigned u) { return u + 1u; }
+  static unsigned dec (unsigned u) { return u - 1u; }
+  class iterator {
+    int idx;
+
+  public:
+    iterator (int i) : idx (i) {}
+    void operator++ () { idx = inc (idx); }
+    const int &operator* () const { return idx; }
+    friend bool operator!= (const iterator &a, const iterator &b) {
+      return a.idx != b.idx;
+    }
+  };
+
+  // Reverse iterator for iterating from max_var down to 1
+  class reverse_iterator {
+    int idx;
+
+  public:
+    reverse_iterator (int i) : idx (i) {}
+    void operator++ () { idx = dec (idx); }
+    const int &operator* () const { return idx; }
+    friend bool operator!= (const reverse_iterator &a,
+                            const reverse_iterator &b) {
+      return a.idx != b.idx;
+    }
+  };
+
+  int &n;
+
+public:
+  // forward iterator
+  iterator begin () const { return assert (n >= 0), iterator (inc (0)); }
+  iterator end () const { return assert (n >= 0), iterator (inc (n)); }
+
+  // Reverse iteration methods
+  reverse_iterator rbegin () const {
+    return assert (n >= 0), reverse_iterator (n);
+  }
+  reverse_iterator rend () const {
+    return assert (n >= 0), reverse_iterator (0);
+  }
+
+  Range (int &m) : n (m) { assert (m >= 0); }
+};
+
+// Same, but iterating over literals '-1,1,-2,2,....,-max_var,max_var'.
+//
+// The only difference to 'Range' is the 'inc' function, but I am too lazy
+// to figure out how to properly factor the code into a generic range
+// template with 'inc' as only parameter.  This gives at least clean code.
+
+class Sange {
+  static unsigned inc (unsigned u) { return ~u + (u >> 31); }
+  class iterator {
+    int lit;
+
+  public:
+    iterator (int i) : lit (i) {}
+    void operator++ () { lit = inc (lit); }
+    const int &operator* () const { return lit; }
+    friend bool operator!= (const iterator &a, const iterator &b) {
+      return a.lit != b.lit;
+    }
+  };
+  int &n;
+
+public:
+  iterator begin () const { return assert (n >= 0), iterator (inc (0)); }
+  iterator end () const { return assert (n >= 0), iterator (inc (n)); }
+  Sange (int &m) : n (m) { assert (m >= 0); }
+};
+
+} // namespace CaDiCaL
+
+#endif

data/ext/cadical/cadical/src/reap.cpp

@@ -0,0 +1,127 @@
+#include "reap.hpp"
+#include <cassert>
+#include <climits>
+#include <cstring>
+
+void Reap::init () {
+  for (auto &bucket : buckets)
+    bucket = {0};
+  assert (!num_elements);
+  assert (!last_deleted);
+  min_bucket = 32;
+  assert (!max_bucket);
+}
+
+void Reap::release () {
+  num_elements = 0;
+  last_deleted = 0;
+  min_bucket = 32;
+  max_bucket = 0;
+}
+
+Reap::Reap () {
+  num_elements = 0;
+  last_deleted = 0;
+  min_bucket = 32;
+  max_bucket = 0;
+}
+
+static inline unsigned leading_zeroes_of_unsigned (unsigned x) {
+  return x ? __builtin_clz (x) : sizeof (unsigned) * 8;
+}
+
+void Reap::push (unsigned e) {
+  assert (last_deleted <= e);
+  const unsigned diff = e ^ last_deleted;
+  const unsigned bucket = 32 - leading_zeroes_of_unsigned (diff);
+  buckets[bucket].push_back (e);
+  if (min_bucket > bucket)
+    min_bucket = bucket;
+  if (max_bucket < bucket)
+    max_bucket = bucket;
+  assert (num_elements != UINT_MAX);
+  num_elements++;
+}
+
+unsigned Reap::pop () {
+  assert (num_elements > 0);
+  unsigned i = min_bucket;
+  for (;;) {
+    assert (i < 33);
+    assert (i <= max_bucket);
+    std::vector<unsigned> &s = buckets[i];
+    if (s.empty ()) {
+      min_bucket = ++i;
+      continue;
+    }
+    unsigned res;
+    if (i) {
+      res = UINT_MAX;
+      const auto begin = std::begin (s);
+      const auto end = std::end (s);
+      auto q = std::begin (s);
+      assert (begin < end);
+      for (auto p = begin; p != end; ++p) {
+        const unsigned tmp = *p;
+        if (tmp >= res)
+          continue;
+        res = tmp;
+        q = p;
+      }
+
+      for (auto p = begin; p != end; ++p) {
+        if (p == q)
+          continue;
+        const unsigned other = *p;
+        const unsigned diff = other ^ res;
+        assert (sizeof (unsigned) == 4);
+        const unsigned j = 32 - leading_zeroes_of_unsigned (diff);
+        assert (j < i);
+        buckets[j].push_back (other);
+        if (min_bucket > j)
+          min_bucket = j;
+      }
+
+      s.clear ();
+
+      if (i && max_bucket == i) {
+#ifndef NDEBUG
+        for (unsigned j = i + 1; j < 33; j++)
+          assert (buckets[j].empty ());
+#endif
+        if (s.empty ())
+          max_bucket = i - 1;
+      }
+    } else {
+      res = last_deleted;
+      assert (!buckets[0].empty ());
+      assert (buckets[0].at (0) == res);
+      buckets[0].pop_back ();
+    }
+
+    if (min_bucket == i) {
+#ifndef NDEBUG
+      for (unsigned j = 0; j < i; j++)
+        assert (buckets[j].empty ());
+#endif
+      if (s.empty ())
+        min_bucket = std::min ((int) (i + 1), 32);
+    }
+
+    --num_elements;
+    assert (last_deleted <= res);
+    last_deleted = res;
+
+    return res;
+  }
+}
+
+void Reap::clear () {
+  assert (max_bucket <= 32);
+  for (unsigned i = 0; i < 33; i++)
+    buckets[i].clear ();
+  num_elements = 0;
+  last_deleted = 0;
+  min_bucket = 32;
+  max_bucket = 0;
+}

data/ext/cadical/cadical/src/reap.hpp

@@ -0,0 +1,28 @@
+#ifndef _reap_h_INCLUDED
+#define _reap_h_INCLUDED
+
+#include <cstddef>
+#include <vector>
+
+class Reap {
+public:
+  Reap ();
+  void init ();
+  void release ();
+  inline bool empty () { return !num_elements; }
+
+  inline size_t size () { return num_elements; }
+
+  void push (unsigned);
+  void clear ();
+  unsigned pop ();
+
+private:
+  size_t num_elements;
+  unsigned last_deleted;
+  unsigned min_bucket;
+  unsigned max_bucket;
+  std::vector<unsigned> buckets[33];
+};
+
+#endif

data/ext/cadical/cadical/src/reduce.cpp

@@ -0,0 +1,278 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Once in a while we reduce, e.g., we remove learned clauses which are
+// supposed to be less useful in the future.  This is done in increasing
+// intervals, which has the effect of allowing more and more learned clause
+// to be kept for a longer period.  The number of learned clauses kept
+// in memory corresponds to an upper bound on the 'space' of a resolution
+// proof needed to refute a formula in proof complexity sense.
+
+bool Internal::reducing () {
+  if (!opts.reduce)
+    return false;
+  if (!stats.current.redundant)
+    return false;
+  return stats.conflicts >= lim.reduce;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Even less regularly we are flushing all redundant clauses.
+
+bool Internal::flushing () {
+  if (!opts.flush)
+    return false;
+  return stats.conflicts >= lim.flush;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::mark_clauses_to_be_flushed () {
+  const int tier1limit = tier1[false];
+  const int tier2limit = max (tier1limit, tier2[false]);
+  for (const auto &c : clauses) {
+    if (!c->redundant)
+      continue; // keep irredundant
+    if (c->garbage)
+      continue; // already marked as garbage
+    if (c->reason)
+      continue; // need to keep reasons
+    const unsigned used = c->used;
+    if (used)
+      c->used--;
+    if (c->glue <= tier1limit && used)
+      continue;
+    if (c->glue <= tier2limit && used >= max_used - 1)
+      continue;
+    mark_garbage (c); // flush unused clauses
+    if (c->hyper)
+      stats.flush.hyper++;
+    else
+      stats.flush.learned++;
+  }
+  // No change to 'lim.kept{size,glue}'.
+}
+
+/*------------------------------------------------------------------------*/
+
+// Clauses of larger glue or larger size are considered less useful.
+//
+// We also follow the observations made by the Glucose team in their
+// IJCAI'09 paper and keep all low glue clauses limited by
+// 'options.keepglue' (typically '2').
+//
+// In earlier versions we pre-computed a 64-bit sort key per clause and
+// wrapped a pointer to the clause and the 64-bit sort key into a separate
+// data structure for sorting.  This was probably faster but awkward and
+// so we moved back to a simpler scheme which also uses 'stable_sort'
+// instead of 'rsort' below.  Sorting here is not a hot-spot anyhow.
+
+struct reduce_less_useful {
+  bool operator() (const Clause *c, const Clause *d) const {
+    if (c->glue > d->glue)
+      return true;
+    if (c->glue < d->glue)
+      return false;
+    return c->size > d->size;
+  }
+};
+
+// This function implements the important reduction policy. It determines
+// which redundant clauses are considered not useful and thus will be
+// collected in a subsequent garbage collection phase.
+
+void Internal::mark_useless_redundant_clauses_as_garbage () {
+
+  // We use a separate stack for sorting candidates for removal.  This uses
+  // (slightly) more memory but has the advantage to keep the relative order
+  // in 'clauses' intact, which actually due to using stable sorting goes
+  // into the candidate selection (more recently learned clauses are kept if
+  // they otherwise have the same glue and size).
+
+  vector<Clause *> stack;
+  const int tier1limit = tier1[false];
+  const int tier2limit = max (tier1limit, tier2[false]);
+
+  stack.reserve (stats.current.redundant);
+
+  for (const auto &c : clauses) {
+    if (!c->redundant)
+      continue; // Keep irredundant.
+    if (c->garbage)
+      continue; // Skip already marked.
+    if (c->reason)
+      continue; // Need to keep reasons.
+    const unsigned used = c->used;
+    if (used)
+      c->used--;
+    if (c->glue <= tier1limit && used)
+      continue;
+    if (c->glue <= tier2limit && used >= max_used - 1)
+      continue;
+    if (c->hyper) {          // Hyper binary and ternary resolvents
+      assert (c->size <= 3); // are only kept for one reduce round
+      if (!used)
+        mark_garbage (c); // unless
+      continue;           //  used recently.
+    }
+    stack.push_back (c);
+  }
+
+  stable_sort (stack.begin (), stack.end (), reduce_less_useful ());
+  size_t target = 1e-2 * opts.reducetarget * stack.size ();
+
+  // This is defensive code, which I usually consider a bug, but here I am
+  // just not sure that using floating points in the line above is precise
+  // in all situations and instead of figuring that out, I just use this.
+  //
+  if (target > stack.size ())
+    target = stack.size ();
+
+  PHASE ("reduce", stats.reductions, "reducing %zd clauses %.0f%%", target,
+         percent (target, stats.current.redundant));
+
+  auto i = stack.begin ();
+  const auto t = i + target;
+  while (i != t) {
+    Clause *c = *i++;
+    LOG (c, "marking useless to be collected");
+    mark_garbage (c);
+    stats.reduced++;
+  }
+
+  lim.keptsize = lim.keptglue = 0;
+
+  const auto end = stack.end ();
+  for (i = t; i != end; i++) {
+    Clause *c = *i;
+    LOG (c, "keeping");
+    if (c->size > lim.keptsize)
+      lim.keptsize = c->size;
+    if (c->glue > lim.keptglue)
+      lim.keptglue = c->glue;
+  }
+
+  erase_vector (stack);
+
+  PHASE ("reduce", stats.reductions, "maximum kept size %d glue %d",
+         lim.keptsize, lim.keptglue);
+}
+
+/*------------------------------------------------------------------------*/
+
+// If chronological backtracking produces out-of-order assigned units, then
+// it is necessary to completely propagate them at the root level in order
+// to derive all implied units.  Otherwise the blocking literals in
+// 'flush_watches' are messed up and assertion 'FW1' fails.
+
+bool Internal::propagate_out_of_order_units () {
+  if (!level)
+    return true;
+  int oou = 0;
+  for (size_t i = control[1].trail; !oou && i < trail.size (); i++) {
+    const int lit = trail[i];
+    assert (val (lit) > 0);
+    if (var (lit).level)
+      continue;
+    LOG ("found out-of-order assigned unit %d", oou);
+    oou = lit;
+  }
+  if (!oou)
+    return true;
+  assert (opts.chrono || external_prop || did_external_prop);
+  backtrack (0);
+  if (propagate ())
+    return true;
+  learn_empty_clause ();
+  return false;
+}
+
+/*------------------------------------------------------------------------*/
+
+// reduction is scheduled with reduceint, reducetarget and reduceopt.
+// with reduceopt=1 the number of learnt clauses scale with
+// sqrt of conflicts times reduceint
+// the scaling is the same as with reduceopt=0 (the classical default)
+// however, the constants are different. To avoid this (and get roughly the
+// same behaviour with reduceopt=0 and reduceopt=1) we need to scale the
+// interval, namely (reduceint^2/2)
+// Lastly, reduceopt=2 just replaces sqrt conflicts with log conflicts.
+// The learnt clauses should not be bigger than
+// 1/reducetarget * reduceint * function (conflicts)
+// for function being log if reduceint=2 an sqrt otherwise.
+// This is however only the theoretical target and second chance for
+// tier2 clauses and very long lifespan of tier1 clauses (through used flag)
+// make this behave differently.
+// reduceinit shifts the curve to the right, increasing the number of
+// clauses in the solver. This impact will decrease over time.
+
+void Internal::reduce () {
+  START (reduce);
+
+  stats.reductions++;
+  report ('.', 1);
+
+  bool flush = flushing ();
+  if (flush)
+    stats.flush.count++;
+
+  if (!propagate_out_of_order_units ())
+    goto DONE;
+
+  mark_satisfied_clauses_as_garbage ();
+  protect_reasons ();
+  if (flush)
+    mark_clauses_to_be_flushed ();
+  else
+    mark_useless_redundant_clauses_as_garbage ();
+  garbage_collection ();
+
+  {
+    int64_t delta = opts.reduceint;
+    double factor = stats.reductions + 1;
+    if (opts.reduceopt ==
+        0) // adjust delta such this is the same as reduceopt=1
+      delta = delta * delta / 2;
+    else if (opts.reduceopt == 1) {
+      // this is the same as reduceopt=0 if reduceint = sqrt (reduceint) =
+      // 17
+      factor = sqrt ((double) stats.conflicts);
+    } else if (opts.reduceopt == 2)
+      // log scaling instead
+      factor = log ((double) stats.conflicts);
+    if (factor < 1)
+      factor = 1;
+    delta = delta * factor;
+    if (irredundant () > 1e5) {
+      delta *= log (irredundant () / 1e4) / log (10);
+    }
+    if (delta < 1)
+      delta = 1;
+    lim.reduce = stats.conflicts + delta;
+    PHASE ("reduce", stats.reductions,
+           "new reduce limit %" PRId64 " after %" PRId64 " conflicts",
+           lim.reduce, delta);
+  }
+
+  if (flush) {
+    PHASE ("flush", stats.flush.count, "new flush increment %" PRId64 "",
+           inc.flush);
+    inc.flush *= opts.flushfactor;
+    lim.flush = stats.conflicts + inc.flush;
+    PHASE ("flush", stats.flush.count, "new flush limit %" PRId64 "",
+           lim.flush);
+  }
+
+  last.reduce.conflicts = stats.conflicts;
+
+DONE:
+
+  report (flush ? 'f' : '-');
+  STOP (reduce);
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/reluctant.hpp

@@ -0,0 +1,82 @@
+#ifndef _reluctant_hpp_INCLUDED
+#define _reluctant_hpp_INCLUDED
+
+#include <cassert>
+#include <cstdint>
+
+namespace CaDiCaL {
+
+// This is Donald Knuth's version of the Luby restart sequence which he
+// called 'reluctant doubling'.  His bit-twiddling formulation in line (DK)
+// requires to keep two words around which are updated every time the
+// reluctant doubling sequence is advanced.  The original version in the
+// literature uses a complex recursive function which computes the length of
+// the next inactive sub-sequence every time (but is state-less).
+//
+// In our code we incorporate a base interval 'period' and only after period
+// many calls to 'tick' times the current sequence value we update the
+// reluctant doubling sequence value.  The 'tick' call is decoupled from
+// the activation signal of the sequence (the 'bool ()' operator) through
+// 'trigger'.  It is also possible to set an upper limit to the length of an
+// inactive sub-sequence.  If that limit is reached the whole reluctant
+// doubling sequence starts over with the initial values.
+
+class Reluctant {
+
+  uint64_t u, v, limit;
+  uint64_t period, countdown;
+  bool trigger, limited;
+
+public:
+  Reluctant () : period (0), trigger (false) {}
+
+  void enable (int p, int64_t l) {
+    assert (p > 0);
+    u = v = 1;
+    period = countdown = p;
+    trigger = false;
+    if (l <= 0)
+      limited = false;
+    else
+      limited = true, limit = l;
+  };
+
+  void disable () { period = 0, trigger = false; }
+
+  // Increments the count until the 'period' is hit.  Then it performs the
+  // actual increment of reluctant doubling.  This gives the common 'Luby'
+  // sequence with the specified base interval period.  As soon the limit is
+  // reached (countdown goes to zero) we remember this event and then
+  // disable updating the reluctant sequence until the signal is delivered.
+
+  void tick () {
+
+    if (!period)
+      return; // disabled
+    if (trigger)
+      return; // already triggered
+    if (--countdown)
+      return; // not there yet
+
+    if ((u & -u) == v)
+      u = u + 1, v = 1;
+    else
+      v = 2 * v; // (DK)
+
+    if (limited && v >= limit)
+      u = v = 1;
+    countdown = v * period;
+    trigger = true;
+  }
+
+  operator bool () {
+    if (!trigger)
+      return false;
+    trigger = false;
+    return true;
+  }
+};
+
+} // namespace CaDiCaL
+
+#endif