cadical 0.9.0

data/ext/cadical/cadical/src/resources.cpp

@@ -0,0 +1,160 @@
+#include "internal.hpp"
+
+/*------------------------------------------------------------------------*/
+
+// This is operating system specific code.  We mostly develop on Linux and
+// there it should be fine and mostly works out-of-the-box on MacOS too but
+// Windows needs special treatment (as probably other operating systems
+// too).
+
+extern "C" {
+
+#ifdef _WIN32
+
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0600
+#endif
+
+// Clang-format would reorder the includes which breaks the Windows code
+// as it expects 'windows.h' to be included first.  So disable it here.
+
+// clang-format off
+
+#include <windows.h>
+#include <psapi.h>
+
+// clang-format on
+
+#else
+
+#include <sys/resource.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#endif
+
+#include <string.h>
+}
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+#ifdef _WIN32
+
+double absolute_real_time () {
+  FILETIME f;
+  GetSystemTimeAsFileTime (&f);
+  ULARGE_INTEGER t;
+  t.LowPart = f.dwLowDateTime;
+  t.HighPart = f.dwHighDateTime;
+  double res = (__int64) t.QuadPart;
+  res *= 1e-7;
+  return res;
+}
+
+double absolute_process_time () {
+  double res = 0;
+  FILETIME fc, fe, fu, fs;
+  if (GetProcessTimes (GetCurrentProcess (), &fc, &fe, &fu, &fs)) {
+    ULARGE_INTEGER u, s;
+    u.LowPart = fu.dwLowDateTime;
+    u.HighPart = fu.dwHighDateTime;
+    s.LowPart = fs.dwLowDateTime;
+    s.HighPart = fs.dwHighDateTime;
+    res = (__int64) u.QuadPart + (__int64) s.QuadPart;
+    res *= 1e-7;
+  }
+  return res;
+}
+
+#else
+
+double absolute_real_time () {
+  struct timeval tv;
+  if (gettimeofday (&tv, 0))
+    return 0;
+  return 1e-6 * tv.tv_usec + tv.tv_sec;
+}
+
+// We use 'getrusage' for 'process_time' and 'maximum_resident_set_size'
+// which is pretty standard on Unix but probably not available on Windows
+// etc.  For different variants of Unix not all fields are meaningful.
+
+double absolute_process_time () {
+  double res;
+  struct rusage u;
+  if (getrusage (RUSAGE_SELF, &u))
+    return 0;
+  res = u.ru_utime.tv_sec + 1e-6 * u.ru_utime.tv_usec;  // user time
+  res += u.ru_stime.tv_sec + 1e-6 * u.ru_stime.tv_usec; // + system time
+  return res;
+}
+
+#endif
+
+double Internal::real_time () const {
+  return absolute_real_time () - stats.time.real;
+}
+
+double Internal::process_time () const {
+  return absolute_process_time () - stats.time.process;
+}
+
+/*------------------------------------------------------------------------*/
+
+#ifdef _WIN32
+
+uint64_t current_resident_set_size () {
+  PROCESS_MEMORY_COUNTERS pmc;
+  if (GetProcessMemoryInfo (GetCurrentProcess (), &pmc, sizeof (pmc))) {
+    return pmc.WorkingSetSize;
+  } else
+    return 0;
+}
+
+uint64_t maximum_resident_set_size () {
+  PROCESS_MEMORY_COUNTERS pmc;
+  if (GetProcessMemoryInfo (GetCurrentProcess (), &pmc, sizeof (pmc))) {
+    return pmc.PeakWorkingSetSize;
+  } else
+    return 0;
+}
+
+#else
+
+// This seems to work on Linux (man page says since Linux 2.6.32).
+
+uint64_t maximum_resident_set_size () {
+  struct rusage u;
+  if (getrusage (RUSAGE_SELF, &u))
+    return 0;
+  return ((uint64_t) u.ru_maxrss) << 10;
+}
+
+// Unfortunately 'getrusage' on Linux does not support current resident set
+// size (the field 'ru_ixrss' is there but according to the man page
+// 'unused'). Thus we fall back to use the '/proc' file system instead.  So
+// this is not portable at all and needs to be replaced on other systems
+// The code would still compile though (assuming 'sysconf' and
+// '_SC_PAGESIZE' are available).
+
+uint64_t current_resident_set_size () {
+  char path[64];
+  snprintf (path, sizeof path, "/proc/%" PRId64 "/statm",
+            (int64_t) getpid ());
+  FILE *file = fopen (path, "r");
+  if (!file)
+    return 0;
+  uint64_t dummy, rss;
+  int scanned = fscanf (file, "%" PRIu64 " %" PRIu64 "", &dummy, &rss);
+  fclose (file);
+  return scanned == 2 ? rss * sysconf (_SC_PAGESIZE) : 0;
+}
+
+#endif
+
+/*------------------------------------------------------------------------*/
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/resources.hpp

@@ -0,0 +1,16 @@
+#ifndef _resources_hpp_INCLUDED
+#define _resources_hpp_INCLUDED
+
+#include <cstdint>
+
+namespace CaDiCaL {
+
+double absolute_real_time ();
+double absolute_process_time ();
+
+uint64_t maximum_resident_set_size ();
+uint64_t current_resident_set_size ();
+
+} // namespace CaDiCaL
+
+#endif // ifndef _resources_hpp_INCLUDED

data/ext/cadical/cadical/src/restart.cpp

@@ -0,0 +1,178 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// As observed by Chanseok Oh and implemented in MapleSAT solvers too,
+// various mostly satisfiable instances benefit from long quiet phases
+// with less or almost no restarts.  We implement this idea by prohibiting
+// the Glucose style restart scheme in a geometric fashion, which is very
+// similar to how originally restarts were scheduled in MiniSAT and earlier
+// solvers.  We start with say 1e3 = 1000 (opts.stabilizeinit) conflicts of
+// Glucose restarts.  Then in a "stabilizing" phase we disable these
+// until 1e4 = 2000 conflicts (if 'opts.stabilizefactor' is '200' percent)
+// have passed. After that we switch back to regular Glucose style restarts
+// until again 2 times more conflicts than the previous limit are reached.
+// Actually, in the latest version we still restarts during stabilization
+// but only in a reluctant doubling scheme with a rather high interval.
+
+bool Internal::stabilizing () {
+  if (!opts.stabilize)
+    return false;
+  if (stable && opts.stabilizeonly)
+    return true;
+  if (!inc.stabilize) {
+    assert (!stable);
+    if (stats.conflicts <= lim.stabilize)
+      return false;
+  } else if (stats.ticks.search[stable] <= lim.stabilize)
+    return stable;
+  report (stable ? ']' : '}');
+  if (stable)
+    STOP (stable);
+  else
+    STOP (unstable);
+
+  assert (last.stabilize.ticks >= 0);
+  assert (last.stabilize.conflicts >= 0 &&
+          last.stabilize.conflicts <= stats.conflicts);
+  assert (last.stabilize.ticks <= stats.ticks.search[stable]);
+  const int64_t delta_ticks =
+      stats.ticks.search[stable] - last.stabilize.ticks;
+#ifndef QUIET
+  const int64_t delta_conflicts =
+      stats.conflicts - last.stabilize.conflicts;
+  const char *current_mode = stable ? "stable" : "unstable";
+  const char *next_mode = stable ? "unstable" : "stable";
+#endif
+  PHASE ("stabilizing", stats.stabphases,
+         "reached %s stabilization limit %" PRId64 " after %" PRId64
+         " conflicts and %" PRId64 " ticks at %" PRId64
+         " conflicts and %" PRId64 " ticks",
+         current_mode, lim.stabilize, delta_conflicts, delta_ticks,
+         stats.conflicts, stats.ticks.search[stable]);
+  if (!inc.stabilize)
+    inc.stabilize = delta_ticks;
+  if (!inc.stabilize) // rare occurence in incremental calls requiring no
+                      // ticks
+    inc.stabilize = 1;
+
+  int64_t next_delta_ticks = inc.stabilize;
+  int64_t stabphases = stats.stabphases + 1;
+  next_delta_ticks *= stabphases * stabphases;
+
+  const bool next_stable = !stable;
+  lim.stabilize = stats.ticks.search[next_stable] + next_delta_ticks;
+  last.stabilize.ticks = stats.ticks.search[next_stable];
+  if (lim.stabilize <= stats.ticks.search[next_stable])
+    lim.stabilize = stats.ticks.search[next_stable] + 1;
+  PHASE ("stabilizing", stats.stabphases,
+         "next %s stabilization limit %" PRId64
+         " at ticks interval %" PRId64,
+         next_mode, lim.stabilize, next_delta_ticks);
+
+  stable = !stable; // Switch!!!!!
+
+  if (stable)
+    stats.stabphases++;
+
+  swap_averages ();
+  report (stable ? '[' : '{');
+  if (stable)
+    START (stable);
+  else
+    START (unstable);
+  return stable;
+}
+
+// Restarts are scheduled by a variant of the Glucose scheme as presented
+// in our POS'15 paper using exponential moving averages.  There is a slow
+// moving average of the average recent glucose level of learned clauses
+// as well as a fast moving average of those glues.  If the end of a base
+// restart conflict interval has passed and the fast moving average is
+// above a certain margin over the slow moving average then we restart.
+
+bool Internal::restarting () {
+  if (!opts.restart)
+    return false;
+  if ((size_t) level < assumptions.size () + 2)
+    return false;
+  if (stabilizing () && opts.reluctant)
+    return reluctant;
+  if (stats.conflicts <= lim.restart)
+    return false;
+  double f = averages.current.glue.fast;
+  int p = stable ? opts.restartmarginstable : opts.restartmarginfocused;
+  double m = (100.0 + p) / 100.0;
+  double s = averages.current.glue.slow;
+  double l = m * s;
+
+#ifndef QUIET
+  char c = l > f ? '>' : l < f ? '<' : '=';
+  VERBOSE (3,
+           "restart glue limit "
+           "%g = %.2f * %g (slow glue) %c %g (fast glue)",
+           l, m, s, c, f);
+#endif
+
+  return l <= f;
+}
+
+// This is Marijn's reuse trail idea.  Instead of always backtracking to
+// the top we figure out which decisions will be made again anyhow and
+// only backtrack to the level of the last such decision or to the top if
+// no such decision exists top (in which case we do not reuse any level).
+
+int Internal::reuse_trail () {
+  const int trivial_decisions =
+      assumptions.size ()
+      // Plus 1 if the constraint is satisfied via implications of
+      // assumptions and a pseudo-decision level was introduced.
+      + !control[assumptions.size () + 1].decision;
+  if (!opts.restartreusetrail)
+    return trivial_decisions;
+  int next_decision = next_decision_variable ();
+  assert (1 <= next_decision);
+  int res = trivial_decisions;
+  if (use_scores ()) {
+    while (res < level) {
+      int decision = control[res + 1].decision;
+      if (decision && score_smaller (this) (abs (decision), next_decision))
+        break;
+      res++;
+    }
+  } else {
+    int64_t limit = bumped (next_decision);
+    while (res < level) {
+      int decision = control[res + 1].decision;
+      if (decision && bumped (decision) < limit)
+        break;
+      res++;
+    }
+  }
+  int reused = res - trivial_decisions;
+  if (reused > 0) {
+    stats.reused++;
+    stats.reusedlevels += reused;
+    if (stable)
+      stats.reusedstable++;
+  }
+  return res;
+}
+
+void Internal::restart () {
+  START (restart);
+  stats.restarts++;
+  stats.restartlevels += level;
+  if (stable)
+    stats.restartstable++;
+  LOG ("restart %" PRId64 "", stats.restarts);
+  backtrack (reuse_trail ());
+
+  lim.restart = stats.conflicts + opts.restartint;
+  LOG ("new restart limit at %" PRId64 " conflicts", lim.restart);
+
+  report ('R', 2);
+  STOP (restart);
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/restore.cpp

@@ -0,0 +1,267 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// In incremental solving after a first call to 'solve' has finished and
+// before calling the internal 'solve' again incrementally we have to
+// restore clauses which have the negation of a literal as a witness literal
+// on the extension stack, which was added as original literal in a new
+// clause or in an assumption.  This procedure has to be applied
+// recursively, i.e., the literals of restored clauses are treated in the
+// same way as literals of a new original clause.
+//
+// To figure out whether literals are such witnesses we have a 'witness'
+// bit for each external literal, which is set in 'block', 'elim', and
+// 'decompose' if a clause is pushed on the extension stack.  The witness
+// bits are recomputed after restoring clauses.
+//
+// We further mark in the external solver newly internalized external
+// literals in 'add' and 'assume' since the last call to 'solve' as tainted
+// if they occur negated as a witness literal on the extension stack.  Then
+// we go through the extension stack and restore all clauses which have a
+// tainted literal (and its negation a marked as witness).
+//
+// Since the API contract disallows to call 'val' and 'failed' in an
+// 'UNKNOWN' state. We do not have to internalize literals there.
+//
+// In order to have tainted literals accepted by the internal solver they
+// have to be active and thus we might need to 'reactivate' them before
+// restoring clauses if they are inactive. In case they have completely
+// been eliminated and removed from the internal solver in 'compact', then
+// we just use a new internal variable.  This is performed in 'internalize'
+// during marking external literals as tainted.
+//
+// To check that this approach is correct the external solver can maintain a
+// stack of original clauses and current assumptions both in terms of
+// external literals.  Whenever 'solve' determines that the current
+// incremental call is satisfiable we check that the (extended) witness does
+// satisfy the saved original clauses, as well as all the assumptions. To
+// enable these checks set 'opts.check' as well as 'opts.checkwitness' and
+// 'opts.checkassumptions' all to 'true'.  The model based tester actually
+// prefers to enable the 'opts.check' option and the other two are 'true' by
+// default anyhow.
+//
+// See our SAT'19 paper [FazekasBiereScholl-SAT'19] for more details.
+
+/*------------------------------------------------------------------------*/
+
+void External::restore_clause (const vector<int>::const_iterator &begin,
+                               const vector<int>::const_iterator &end,
+                               const int64_t id) {
+  LOG (begin, end, "restoring external clause[%" PRId64 "]", id);
+  assert (eclause.empty ());
+  assert (id);
+  for (auto p = begin; p != end; p++) {
+    eclause.push_back (*p);
+    if (internal->proof && internal->lrat) {
+      const auto &elit = *p;
+      unsigned eidx = (elit > 0) + 2u * (unsigned) abs (elit);
+      assert ((size_t) eidx < ext_units.size ());
+      const int64_t id = ext_units[eidx];
+      bool added = ext_flags[abs (elit)];
+      if (id && !added) {
+        ext_flags[abs (elit)] = true;
+        internal->lrat_chain.push_back (id);
+      }
+    }
+    int ilit = internalize (*p);
+    internal->add_original_lit (ilit), internal->stats.restoredlits++;
+  }
+  if (internal->proof && internal->lrat) {
+    for (const auto &elit : eclause) {
+      ext_flags[abs (elit)] = false;
+    }
+  }
+  internal->finish_added_clause_with_id (id, true);
+  eclause.clear ();
+  internal->stats.restored++;
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::restore_clauses () {
+
+  assert (internal->opts.restoreall == 2 || !tainted.empty ());
+
+  START (restore);
+  internal->stats.restorations++;
+
+  struct {
+    int64_t weakened, satisfied, restored, removed;
+  } clauses;
+  memset (&clauses, 0, sizeof clauses);
+
+  if (internal->opts.restoreall && tainted.empty ())
+    PHASE ("restore", internal->stats.restorations,
+           "forced to restore all clauses");
+
+#ifndef QUIET
+  {
+    unsigned numtainted = 0;
+    for (const auto b : tainted)
+      if (b)
+        numtainted++;
+
+    PHASE ("restore", internal->stats.restorations,
+           "starting with %u tainted literals %.0f%%", numtainted,
+           percent (numtainted, 2u * max_var));
+  }
+#endif
+
+  auto end_of_extension = extension.end ();
+  auto p = extension.begin (), q = p;
+
+  // Go over all witness labelled clauses on the extension stack, restore
+  // those necessary, remove restored and flush satisfied clauses.
+  //
+  while (p != end_of_extension) {
+
+    clauses.weakened++;
+
+    assert (!*p);
+    const auto saved = q; // Save old start.
+    *q++ = *p++;          // Copy zero '0'.
+
+    // Copy witness part and try to find a tainted witness literal in it.
+    //
+    int tlit = 0; // Negation tainted.
+    int elit;
+    //
+    assert (p != end_of_extension);
+    //
+    while ((elit = *q++ = *p++)) {
+
+      if (marked (tainted, -elit)) {
+        tlit = elit;
+        LOG ("negation of witness literal %d tainted", tlit);
+      }
+
+      assert (p != end_of_extension);
+    }
+
+    // now copy the id of the clause
+    const int64_t id = ((int64_t) (*p) << 32) + (int64_t) * (p + 1);
+    LOG ("id is %" PRId64, id);
+    *q++ = *p++;
+    *q++ = *p++;
+    assert (id);
+    assert (!*p);
+    *q++ = *p++;
+
+    // Now find 'end_of_clause' (clause starts at 'p') and at the same time
+    // figure out whether the clause is actually root level satisfied.
+    //
+    int satisfied = 0;
+    auto end_of_clause = p;
+    while (end_of_clause != end_of_extension && (elit = *end_of_clause)) {
+      if (!satisfied && fixed (elit) > 0)
+        satisfied = elit;
+      end_of_clause++;
+    }
+    assert (id);
+
+    // Do not apply our 'FLUSH' rule to remove satisfied (implied) clauses
+    // if the corresponding option is set simply by resetting 'satisfied'.
+    //
+    if (satisfied && !internal->opts.restoreflush) {
+      LOG (p, end_of_clause, "forced to not remove %d satisfied",
+           satisfied);
+      satisfied = 0;
+    }
+
+    if (satisfied || tlit || internal->opts.restoreall) {
+
+      if (satisfied) {
+        LOG (p, end_of_clause,
+             "flushing implied clause satisfied by %d from extension stack",
+             satisfied);
+        clauses.satisfied++;
+      } else {
+        restore_clause (p, end_of_clause, id); // Might taint literals.
+        clauses.restored++;
+      }
+
+      clauses.removed++;
+      p = end_of_clause;
+      q = saved;
+
+    } else {
+
+      LOG (p, end_of_clause, "keeping clause on extension stack");
+
+      while (p != end_of_clause) // Copy clause too.
+        *q++ = *p++;
+    }
+  }
+
+  extension.resize (q - extension.begin ());
+  shrink_vector (extension);
+
+#ifndef QUIET
+  if (clauses.satisfied)
+    PHASE ("restore", internal->stats.restorations,
+           "removed %" PRId64 " satisfied %.0f%% of %" PRId64
+           " weakened clauses",
+           clauses.satisfied, percent (clauses.satisfied, clauses.weakened),
+           clauses.weakened);
+  else
+    PHASE ("restore", internal->stats.restorations,
+           "no satisfied clause removed out of %" PRId64
+           " weakened clauses",
+           clauses.weakened);
+
+  if (clauses.restored)
+    PHASE ("restore", internal->stats.restorations,
+           "restored %" PRId64 " clauses %.0f%% out of %" PRId64
+           " weakened clauses",
+           clauses.restored, percent (clauses.restored, clauses.weakened),
+           clauses.weakened);
+  else
+    PHASE ("restore", internal->stats.restorations,
+           "no clause restored out of %" PRId64 " weakened clauses",
+           clauses.weakened);
+  {
+    unsigned numtainted = 0;
+    for (const auto &b : tainted)
+      if (b)
+        numtainted++;
+
+    PHASE ("restore", internal->stats.restorations,
+           "finishing with %u tainted literals %.0f%%", numtainted,
+           percent (numtainted, 2u * max_var));
+  }
+
+#endif
+  LOG ("extension stack clean");
+  tainted.clear ();
+
+  // Finally recompute the witness bits.
+  //
+  witness.clear ();
+  const auto begin_of_extension = extension.begin ();
+  p = extension.end ();
+  while (p != begin_of_extension) {
+    while (*--p)
+      assert (p != begin_of_extension);
+    int elit;
+    assert (p != begin_of_extension);
+    --p;
+    assert (p != begin_of_extension);
+    assert (*p || *(p - 1));
+    --p;
+    assert (p != begin_of_extension);
+    assert (!*p);
+    --p;
+    assert (p != begin_of_extension);
+    while ((elit = *--p)) {
+      mark (witness, elit);
+      assert (p != begin_of_extension);
+    }
+  }
+
+  STOP (restore);
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/score.cpp

@@ -0,0 +1,51 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// This initializes variables on the binary 'scores' heap also with
+// smallest variable index first (thus picked first) and larger indices at
+// the end.
+//
+void Internal::init_scores (int old_max_var, int new_max_var) {
+  LOG ("initializing EVSIDS scores from %d to %d", old_max_var + 1,
+       new_max_var);
+  for (int i = old_max_var; i < new_max_var; i++)
+    scores.push_back (i + 1);
+}
+
+// Shuffle the EVSIDS heap.
+
+void Internal::shuffle_scores () {
+  if (!opts.shuffle)
+    return;
+  if (!opts.shufflescores)
+    return;
+  assert (!level);
+  stats.shuffled++;
+  LOG ("shuffling scores");
+  vector<int> shuffle;
+  if (opts.shufflerandom) {
+    scores.erase ();
+    for (int idx = max_var; idx; idx--)
+      shuffle.push_back (idx);
+    Random random (opts.seed); // global seed
+    random += stats.shuffled;  // different every time
+    for (int i = 0; i <= max_var - 2; i++) {
+      const int j = random.pick_int (i, max_var - 1);
+      swap (shuffle[i], shuffle[j]);
+    }
+  } else {
+    while (!scores.empty ()) {
+      int idx = scores.front ();
+      (void) scores.pop_front ();
+      shuffle.push_back (idx);
+    }
+  }
+  score_inc = 0;
+  for (const auto &idx : shuffle) {
+    stab[idx] = score_inc++;
+    scores.push_back (idx);
+  }
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/score.hpp

@@ -0,0 +1,16 @@
+#ifndef _score_hpp_INCLUDED
+#define _score_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+struct score_smaller {
+  Internal *internal;
+  score_smaller (Internal *i) : internal (i) {}
+  bool operator() (unsigned a, unsigned b);
+};
+
+typedef heap<score_smaller> ScoreSchedule;
+
+} // namespace CaDiCaL
+
+#endif