cadical 0.9.0

data/ext/cadical/cadical/src/rephase.cpp

@@ -0,0 +1,402 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// We experimented with resetting and reinitializing the saved phase with
+// many solvers. Actually RSAT had already such a scheme.  Our newest
+// version seems to be quite beneficial for satisfiable instances.  In an
+// arithmetic increasing interval in the number of conflicts we either use
+// the original phase (set by the option 'phase'), its inverted value, flip
+// the current phase, pick random phases, then pick the best since the last
+// time a best phase was picked and finally also use local search to find
+// phases which minimize the number of falsified clauses.  During
+// stabilization (see 'stabilizing' in 'restart.cpp' when 'stable' is true)
+// we execute a different rephasing schedule.  The same applies if local
+// search is disabled.
+
+/*------------------------------------------------------------------------*/
+
+bool Internal::rephasing () {
+  if (!opts.rephase)
+    return false;
+  if (opts.forcephase)
+    return false;
+  if (opts.rephase == 2) {
+    if (stable)
+      return stats.stabconflicts > lim.rephase;
+    else
+      return false;
+  }
+  return stats.conflicts > lim.rephase;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Pick the original default phase.
+
+char Internal::rephase_original () {
+  stats.rephased.original++;
+  signed char val = opts.phase ? 1 : -1; // original = initial
+  PHASE ("rephase", stats.rephased.total, "switching to original phase %d",
+         val);
+  for (auto idx : vars)
+    phases.saved[idx] = val;
+  return 'O';
+}
+
+// Pick the inverted original default phase.
+
+char Internal::rephase_inverted () {
+  stats.rephased.inverted++;
+  signed char val = opts.phase ? -1 : 1; // original = -initial
+  PHASE ("rephase", stats.rephased.total,
+         "switching to inverted original phase %d", val);
+  for (auto idx : vars)
+    phases.saved[idx] = val;
+  return 'I';
+}
+
+// Flip the current phase.
+
+char Internal::rephase_flipping () {
+  stats.rephased.flipped++;
+  PHASE ("rephase", stats.rephased.total,
+         "flipping all phases individually");
+  for (auto idx : vars)
+    phases.saved[idx] *= -1;
+  return 'F';
+}
+
+// Complete random picking of phases.
+
+char Internal::rephase_random () {
+  stats.rephased.random++;
+  PHASE ("rephase", stats.rephased.total, "resetting all phases randomly");
+  Random random (opts.seed);       // global seed
+  random += stats.rephased.random; // different every time
+  for (auto idx : vars)
+    phases.saved[idx] = random.generate_bool () ? -1 : 1;
+  return '#';
+}
+
+// Best phases are those saved at the largest trail height without conflict.
+// See code and comments in 'update_target_and_best' in 'backtrack.cpp'
+
+char Internal::rephase_best () {
+  stats.rephased.best++;
+  PHASE ("rephase", stats.rephased.total,
+         "overwriting saved phases by best phases");
+  signed char val;
+  for (auto idx : vars)
+    if ((val = phases.best[idx]))
+      phases.saved[idx] = val;
+  return 'B';
+}
+
+// Trigger local search 'walk' in 'walk.cpp'.
+
+char Internal::rephase_walk () {
+  stats.rephased.walk++;
+  PHASE ("rephase", stats.rephased.total,
+         "starting local search to improve current phase");
+  if (opts.walkfullocc)
+    walk_full_occs ();
+  else
+    walk ();
+  return 'W';
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::rephase () {
+
+  stats.rephased.total++;
+  last.stabilize.rephased++;
+  assert (last.stabilize.rephased <= stats.rephased.total);
+  PHASE ("rephase", stats.rephased.total,
+         "reached rephase limit %" PRId64 " after %" PRId64 " conflicts",
+         lim.rephase,
+         opts.rephase == 2 ? stats.stabconflicts : stats.conflicts);
+
+  // Report current 'target' and 'best' and then set 'rephased' below, which
+  // will trigger reporting the new 'target' and 'best' after updating it in
+  // the next 'update_target_and_best' called from the next 'backtrack'.
+  //
+  report ('~', 1);
+
+  backtrack ();
+
+  size_t count = lim.rephased[stable]++;
+  bool single;
+  char type;
+
+  if (opts.stabilize && opts.stabilizeonly)
+    single = true;
+  else
+    single = !opts.stabilize;
+
+  if (single && !opts.walk) {
+    // (inverted,best,flipping,best,random,best,original,best)^\omega
+    switch (count % 8) {
+    case 0:
+      type = rephase_inverted ();
+      break;
+    case 1:
+      type = rephase_best ();
+      break;
+    case 2:
+      type = rephase_flipping ();
+      break;
+    case 3:
+      type = rephase_best ();
+      break;
+    case 4:
+      type = rephase_random ();
+      break;
+    case 5:
+      type = rephase_best ();
+      break;
+    case 6:
+      type = rephase_original ();
+      break;
+    case 7:
+      type = rephase_best ();
+      break;
+    default:
+      type = 0;
+      break;
+    }
+  } else if (single && opts.walk) {
+    // (inverted,best,walk,
+    //  flipping,best,walk,
+    //    random,best,walk,
+    //  original,best,walk)^\omega
+    switch (count % 12) {
+    case 0:
+      type = rephase_inverted ();
+      break;
+    case 1:
+      type = rephase_best ();
+      break;
+    case 2:
+      type = rephase_walk ();
+      break;
+    case 3:
+      type = rephase_flipping ();
+      break;
+    case 4:
+      type = rephase_best ();
+      break;
+    case 5:
+      type = rephase_walk ();
+      break;
+    case 6:
+      type = rephase_random ();
+      break;
+    case 7:
+      type = rephase_best ();
+      break;
+    case 8:
+      type = rephase_walk ();
+      break;
+    case 9:
+      type = rephase_original ();
+      break;
+    case 10:
+      type = rephase_best ();
+      break;
+    case 11:
+      type = rephase_walk ();
+      break;
+    default:
+      type = 0;
+      break;
+    }
+  } else if (opts.rephase == 2 && opts.walk) {
+    // (inverted,best,walk,
+    //  flipping,best,walk,
+    //    random,best,walk,
+    //  original,best,walk)^\omega
+    switch (count % 12) {
+    case 0:
+      type = rephase_inverted ();
+      break;
+    case 1:
+      type = rephase_best ();
+      break;
+    case 2:
+      type = rephase_walk ();
+      break;
+    case 3:
+      type = rephase_flipping ();
+      break;
+    case 4:
+      type = rephase_best ();
+      break;
+    case 5:
+      type = rephase_walk ();
+      break;
+    case 6:
+      type = rephase_random ();
+      break;
+    case 7:
+      type = rephase_best ();
+      break;
+    case 8:
+      type = rephase_walk ();
+      break;
+    case 9:
+      type = rephase_original ();
+      break;
+    case 10:
+      type = rephase_best ();
+      break;
+    case 11:
+      type = rephase_walk ();
+      break;
+    default:
+      type = 0;
+      break;
+    }
+  } else if (stable && !opts.walk) {
+    // original,inverted,(best,original,best,inverted)^\omega
+    if (!count)
+      type = rephase_original ();
+    else if (count == 1)
+      type = rephase_inverted ();
+    else
+      switch ((count - 2) % 4) {
+      case 0:
+        type = rephase_best ();
+        break;
+      case 1:
+        type = rephase_original ();
+        break;
+      case 2:
+        type = rephase_best ();
+        break;
+      case 3:
+        type = rephase_inverted ();
+        break;
+      default:
+        type = 0;
+        break;
+      }
+  } else if (stable && opts.walk) {
+    // original,inverted,(best,walk,original,best,walk,inverted)^\omega
+    if (!count)
+      type = rephase_original ();
+    else if (count == 1)
+      type = rephase_inverted ();
+    else
+      switch ((count - 2) % 6) {
+      case 0:
+        type = rephase_best ();
+        break;
+      case 1:
+        type = rephase_walk ();
+        break;
+      case 2:
+        type = rephase_original ();
+        break;
+      case 3:
+        type = rephase_best ();
+        break;
+      case 4:
+        type = rephase_walk ();
+        break;
+      case 5:
+        type = rephase_inverted ();
+        break;
+      default:
+        type = 0;
+        break;
+      }
+  } else if (!stable && (!opts.walk || !opts.walknonstable)) {
+    // flipping,(random,best,flipping,best)^\omega
+    if (!count)
+      type = rephase_flipping ();
+    else
+      switch ((count - 1) % 4) {
+      case 0:
+        type = rephase_random ();
+        break;
+      case 1:
+        type = rephase_best ();
+        break;
+      case 2:
+        type = rephase_flipping ();
+        break;
+      case 3:
+        type = rephase_best ();
+        break;
+      default:
+        type = 0;
+        break;
+      }
+  } else {
+    assert (!stable && opts.walk && opts.walknonstable);
+    // flipping,(random,best,walk,flipping,best,walk)^\omega
+    if (!count)
+      type = rephase_original ();
+    else
+      switch ((count - 1) % 6) {
+      case 0:
+        type = rephase_random ();
+        break;
+      case 1:
+        type = rephase_best ();
+        break;
+      case 2:
+        type = rephase_walk ();
+        break;
+      case 3:
+        type = rephase_flipping ();
+        break;
+      case 4:
+        type = rephase_best ();
+        break;
+      case 5:
+        type = rephase_walk ();
+        break;
+      default:
+        type = 0;
+        break;
+      }
+  }
+  assert (type);
+
+  // clear after walk such that random walk can still access the target
+  // by using the saved phases
+  copy_phases (phases.target);
+  target_assigned = 0;
+
+  int64_t delta = opts.rephaseint * (stats.rephased.total + 1);
+  lim.rephase =
+      (opts.rephase == 2 ? stats.stabconflicts : stats.conflicts) + delta;
+
+  PHASE ("rephase", stats.rephased.total,
+         "new rephase limit %" PRId64 " after %" PRId64 " conflicts",
+         lim.rephase, delta);
+
+  // This will trigger to report the effect of this new set of phases at the
+  // 'backtrack' (actually 'update_target_and_best') after the next
+  // conflict, as well as resetting 'best_assigned' then to allow to compute
+  // a new "best" assignment at that point.
+  //
+  last.rephase.conflicts = stats.conflicts;
+  rephased = type;
+
+  if (!marked_failed || unsat_constraint) {
+    assert (opts.warmup);
+    return;
+  }
+  if (stable)
+    shuffle_scores ();
+  else
+    shuffle_queue ();
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/report.cpp

@@ -0,0 +1,313 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+#ifndef QUIET
+
+/*------------------------------------------------------------------------*/
+
+// Provide nicely formatted progress report messages while running through
+// the 'report' function below.  The code is so complex, because it should
+// be easy to add and remove reporting of certain statistics, while still
+// providing a nicely looking format with automatically aligned headers.
+
+/*------------------------------------------------------------------------*\
+
+The 'reports' are shown as 'c <char> ...' with '<char>' as follows:
+
+i  propagated learned unit clause
+O  backtracked after phases reset to original phase
+F  backtracked after flipping phases
+#  backtracked after randomly setting phases
+B  backtracked after resetting to best phases
+W  backtracked after local search improved phases
+b  blocked clause elimination
+G  before garbage collection
+C  after garbage collection
+/  compacted internal literals and remapped external to internal
+c  covered clause elimination
+d  decomposed binary implication graph and substituted equivalent literals
+2  removed duplicated binary clauses
+e  bounded variable elimination round
+^  variable elimination bound increased
+I  variable instantiation
+[  start of stable search phase
+]  end of stable search phase
+{  start of unstable search phase
+}  end of unstable search phase
+P  preprocessing round (capital 'P')
+L  local search round
+*  start of solving without the need to restore clauses
++  start of solving before restoring clauses
+r  start of solving after restoring clauses
+1  end of solving returns satisfiable
+0  end of solving returns unsatisfiable
+?  end of solving due to interrupt
+k  binary backbone extraction ('kernel')
+l  lucky phase solving
+p  failed literal probing round (lower case 'p')
+.  before reducing redundant clauses
+f  flushed redundant clauses
+-  reduced redundant clauses
+~  start of resetting phases
+R  restart
+s  subsumed clause removal round
+3  ternary resolution round
+t  transition reduction of binary implication graph
+u  vivified tier1 clauses
+v  vivified tier2 clauses
+x  vivified tier3 clauses
+w  vivified irredundant clauses
+
+The order of the list follows the occurrences of 'report' in the source
+files, i.e., obtained from "grep 'report (' *.cpp".   Note that some of the
+reports are only printed for higher verbosity level (for instance 'R').
+
+\*------------------------------------------------------------------------*/
+
+struct Report {
+
+  const char *header;
+  char buffer[32];
+  int pos;
+
+  Report (const char *h, int precision, int min, double value);
+  Report () {}
+
+  void print_header (char *line);
+};
+
+/*------------------------------------------------------------------------*/
+
+void Report::print_header (char *line) {
+  int len = strlen (header);
+  for (int i = -1, j = pos - (len + 1) / 2 - 3; i < len; i++, j++)
+    line[j] = i < 0 ? ' ' : header[i];
+}
+
+Report::Report (const char *h, int precision, int min, double value)
+    : header (h) {
+  char fmt[32];
+  if (precision < 0)
+    snprintf (fmt, sizeof fmt, "%%.%df", -precision - 1);
+  else
+    snprintf (fmt, sizeof fmt, "%%.%df", precision);
+  snprintf (buffer, sizeof buffer, fmt, value);
+  const int width = strlen (buffer);
+  if (precision < 0)
+    strcat (buffer, "%");
+  if (width >= min)
+    return;
+  if (precision < 0)
+    snprintf (fmt, sizeof fmt, "%%%d.%df%%%%", min, -precision - 1);
+  else
+    snprintf (fmt, sizeof fmt, "%%%d.%df", min, precision);
+  snprintf (buffer, sizeof buffer, fmt, value);
+}
+
+/*------------------------------------------------------------------------*/
+
+// The following statistics are printed in columns, whenever 'report' is
+// called.  For instance 'reduce' with prefix '-' will call it.  The other
+// more interesting report is due to learning a unit, called iteration, with
+// prefix 'i'.  To add another statistics column, add a corresponding line
+// here.  If you want to report something else add 'report (..)' functions.
+
+#define TIME opts.reportsolve ? solve_time () : time ()
+
+#define MB (current_resident_set_size () / (double) (1l << 20))
+
+#define REMAINING (percent (active (), stats.variables_original))
+
+#define TRAIL (percent (averages.current.trail.slow, max_var))
+
+#define TARGET (percent (target_assigned, max_var))
+
+#define BEST (percent (best_assigned, max_var))
+
+#define REPORTS \
+  /*     HEADER, PRECISION, MIN, VALUE */ \
+  REPORT ("seconds", 2, 5, TIME) \
+  REPORT ("MB", 0, 2, MB) \
+  REPORT ("level", 0, 2, averages.current.level) \
+  REPORT ("reductions", 0, 1, stats.reductions) \
+  REPORT ("restarts", 0, 3, stats.restarts) \
+  REPORT ("rate", 0, 2, averages.current.decisions) \
+  REPORT ("conflicts", 0, 4, stats.conflicts) \
+  REPORT ("redundant", 0, 4, stats.current.redundant) \
+  REPORT ("size/glue", 1, 2, \
+          relative (averages.current.size, averages.current.glue.slow)) \
+  REPORT ("size", 0, 1, averages.current.size) \
+  REPORT ("glue", 0, 1, averages.current.glue.slow) \
+  REPORT ("tier1", 0, 1, tier1[stable]) \
+  REPORT ("tier2", 0, 1, tier2[stable]) \
+  REPORT ("trail", -1, 2, TRAIL) \
+  REPORT ("irredundant", 0, 4, stats.current.irredundant) \
+  REPORT ("variables", 0, 3, active ()) \
+  REPORT ("remaining", -1, 2, REMAINING)
+
+// Note, keep an empty line before this line (because of '\')!
+
+#if 0 // ADDITIONAL STATISTICS TO REPORT
+
+REPORT("best",        -1, 2, BEST) \
+REPORT("target",      -1, 2, TARGET) \
+REPORT("maxvar",       0, 2, external->max_var)
+
+#endif
+
+static const int num_reports = // as compile time constant
+#define REPORT(HEAD, PREC, MIN, EXPR) 1 +
+    REPORTS
+#undef REPORT
+    0;
+
+/*------------------------------------------------------------------------*/
+
+void Internal::report (char type, int verbose) {
+  if (!opts.report)
+    return;
+#ifdef LOGGING
+  if (!opts.log)
+#endif
+    if (opts.quiet || (verbose > opts.verbose))
+      return;
+  if (!reported) {
+    assert (!lim.report);
+    reported = true;
+    MSG ("%stime measured in %s time %s%s", tout.magenta_code (),
+         internal->opts.realtime ? "real" : "process",
+         internal->opts.reportsolve ? "in solving" : "since initialization",
+         tout.normal_code ());
+  }
+  Report reports[num_reports];
+  int n = 0;
+#define REPORT(HEAD, PREC, MIN, EXPR) \
+  assert (n < num_reports); \
+  reports[n++] = Report (HEAD, PREC, MIN, (double) (EXPR));
+  REPORTS
+#undef REPORT
+  if (!lim.report) {
+    print_prefix ();
+    fputc ('\n', stdout);
+    int pos = 4;
+    for (int i = 0; i < n; i++) {
+      int len = strlen (reports[i].buffer);
+      reports[i].pos = pos + (len + 1) / 2;
+      pos += len + 1;
+    }
+    const int max_line = pos + 20, nrows = 3;
+    char *line = new char[max_line];
+    for (int start = 0; start < nrows; start++) {
+      int i;
+      for (i = 0; i < max_line; i++)
+        line[i] = ' ';
+      for (i = start; i < n; i += nrows)
+        reports[i].print_header (line);
+      for (i = max_line - 1; line[i - 1] == ' '; i--)
+        ;
+      line[i] = 0;
+      print_prefix ();
+      tout.yellow ();
+      fputs (line, stdout);
+      tout.normal ();
+      fputc ('\n', stdout);
+    }
+    print_prefix ();
+    fputc ('\n', stdout);
+    delete[] line;
+    lim.report = 19;
+  } else
+    lim.report--;
+  print_prefix ();
+  switch (type) {
+  case '[':
+  case ']':
+    tout.magenta (true);
+    break;
+  case 's':
+  case 'b':
+  case 'c':
+    tout.green (false);
+    break;
+  case 'e':
+    tout.green (true);
+    break;
+  case 'p':
+  case '2':
+  case '3':
+  case 'u':
+  case 'v':
+  case 'w':
+  case 'x':
+  case 'f':
+  case '=':
+    tout.blue (false);
+    break;
+  case 't':
+    tout.cyan (false);
+    break;
+  case 'd':
+    tout.blue (true);
+    break;
+  case 'z':
+  case '!':
+    tout.cyan (true);
+    break;
+  case '-':
+    tout.normal ();
+    break;
+  case '/':
+    tout.yellow (true);
+    break;
+  case 'a':
+  case 'n':
+    tout.red (false);
+    break;
+  case '0':
+  case '1':
+  case '?':
+  case 'i':
+    tout.bold ();
+    break;
+  case 'L':
+  case 'P':
+    tout.bold ();
+    tout.underline ();
+    break;
+  case '(':
+  case ')':
+    tout.bold ();
+    tout.yellow ();
+    break;
+  case '{':
+  case '}':
+    tout.normal ();
+    break;
+  default:
+    break;
+  }
+  fputc (type, stdout);
+  if (stable || type == ']')
+    tout.magenta ();
+  else if (preprocessing || type == ')')
+    tout.bold (), tout.yellow ();
+  else if (type != 'L' && type != 'P')
+    tout.normal ();
+  for (int i = 0; i < n; i++) {
+    fputc (' ', stdout);
+    fputs (reports[i].buffer, stdout);
+  }
+  if (stable || type == 'L' || type == 'P' || type == ']')
+    tout.normal ();
+  fputc ('\n', stdout);
+  fflush (stdout);
+}
+
+#else // ifndef QUIET
+
+void Internal::report (char, int) {}
+
+#endif
+
+} // namespace CaDiCaL