cadical 0.9.0

data/ext/cadical/cadical/src/queue.cpp

@@ -0,0 +1,90 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// Slightly different than 'bump_variable' since the variable is not
+// enqueued at all.
+
+inline void Internal::init_enqueue (int idx) {
+  Link &l = links[idx];
+  if (opts.reverse) {
+    l.prev = 0;
+    if (queue.first) {
+      assert (!links[queue.first].prev);
+      links[queue.first].prev = idx;
+      btab[idx] = btab[queue.first] - 1;
+    } else {
+      assert (!queue.last);
+      queue.last = idx;
+      btab[idx] = 0;
+    }
+    assert (btab[idx] <= stats.bumped);
+    l.next = queue.first;
+    queue.first = idx;
+    if (!queue.unassigned)
+      update_queue_unassigned (queue.last);
+  } else {
+    l.next = 0;
+    if (queue.last) {
+      assert (!links[queue.last].next);
+      links[queue.last].next = idx;
+    } else {
+      assert (!queue.first);
+      queue.first = idx;
+    }
+    btab[idx] = ++stats.bumped;
+    l.prev = queue.last;
+    queue.last = idx;
+    update_queue_unassigned (queue.last);
+  }
+}
+
+// Initialize VMTF queue from current 'old_max_var + 1' to 'new_max_var'.
+// This incorporates an initial variable order.  We currently simply assume
+// that variables with smaller index are more important.  This is the same
+// as in MiniSAT (implicitly) and also matches the 'scores' initialization.
+//
+void Internal::init_queue (int old_max_var, int new_max_var) {
+  LOG ("initializing VMTF queue from %d to %d", old_max_var + 1,
+       new_max_var);
+  assert (old_max_var < new_max_var);
+  // New variables can be created that can invoke enlarge anytime (eg via
+  // calls during ipasir-up call-backs), thus assuming (!level) is not
+  // correct
+  for (int idx = old_max_var; idx < new_max_var; idx++)
+    init_enqueue (idx + 1);
+}
+
+// Shuffle the VMTF queue.
+
+void Internal::shuffle_queue () {
+  if (!opts.shuffle)
+    return;
+  if (!opts.shufflequeue)
+    return;
+  stats.shuffled++;
+  LOG ("shuffling queue");
+  vector<int> shuffle;
+  if (opts.shufflerandom) {
+    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 {
+    for (int idx = queue.last; idx; idx = links[idx].prev)
+      shuffle.push_back (idx);
+  }
+  queue.first = queue.last = 0;
+  for (const int idx : shuffle)
+    queue.enqueue (links, idx);
+  int64_t bumped = queue.bumped;
+  for (int idx = queue.last; idx; idx = links[idx].prev)
+    btab[idx] = bumped--;
+  queue.unassigned = queue.last;
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/queue.hpp

@@ -0,0 +1,74 @@
+#ifndef _queue_hpp_INCLUDED
+#define _queue_hpp_INCLUDED
+
+#include <vector>
+
+namespace CaDiCaL {
+
+// Links for double linked decision queue.
+
+struct Link {
+
+  int prev, next; // variable indices
+
+  // initialized explicitly in 'init_queue'
+};
+
+typedef std::vector<Link> Links;
+
+// Variable move to front (VMTF) decision queue ordered by 'bumped'.  See
+// our SAT'15 paper for an explanation on how this works.
+
+struct Queue {
+
+  // We use integers instead of variable pointers.  This is more compact and
+  // also avoids issues due to moving the variable table during 'resize'.
+
+  int first, last; // anchors (head/tail) for doubly linked list
+  int unassigned;  // all variables after this one are assigned
+  int64_t bumped;  // see 'Internal.update_queue_unassigned'
+
+  Queue () : first (0), last (0), unassigned (0), bumped (0) {}
+
+  // We explicitly provide the mapping of integer indices to links to the
+  // following two (inlined) functions.  This avoids including
+  // 'internal.hpp' and breaks a cyclic dependency, so we can keep their
+  // code here in this header file.  Otherwise they are just ordinary doubly
+  // linked list 'dequeue' and 'enqueue' operations.
+
+  inline void dequeue (Links &links, int idx) {
+    Link &l = links[idx];
+    if (l.prev)
+      links[l.prev].next = l.next;
+    else
+      first = l.next;
+    if (l.next)
+      links[l.next].prev = l.prev;
+    else
+      last = l.prev;
+  }
+
+  inline void enqueue (Links &links, int idx) {
+    Link &l = links[idx];
+    if ((l.prev = last))
+      links[last].next = idx;
+    else
+      first = idx;
+    last = idx;
+    l.next = 0;
+  }
+
+  inline void bury (Links &links, int idx) {
+    Link &l = links[idx];
+    if ((l.next = first))
+      links[first].prev = idx;
+    else
+      last = idx;
+    first = idx;
+    l.prev = 0;
+  }
+};
+
+} // namespace CaDiCaL
+
+#endif

data/ext/cadical/cadical/src/radix.hpp

@@ -0,0 +1,180 @@
+#ifndef _radix_hpp_INCLUDED
+#define _radix_hpp_INCLUDED
+
+#include <cassert>
+#include <cstring>
+#include <iterator>
+#include <vector>
+
+namespace CaDiCaL {
+
+using namespace std;
+
+// This provides an implementation of a generic radix sort algorithm. The
+// reason for having it is that for certain benchmarks and certain parts of
+// CaDiCaL where sorting is used, the standard sorting algorithm 'sort'
+// turned out to be a hot-spot. Up to 30% of the total running time was for
+// instance used for some benchmarks in sorting variables during bumping
+// to make sure to bump them in 'enqueued' order.
+//
+// Further, in most cases, where we need to sort something, sorting is
+// actually performed on positive numbers (such as the 'enqueued' time stamp
+// during bumping), which allows to use radix sort or variants. At least
+// starting with medium sized arrays to be sorted (say above 1000 elements,
+// but see discussion on 'MSORT' below), radix sort can be way faster.
+//
+// Finally it is stable, which is actually preferred most of the time too.
+//
+// This template algorithm 'rsort' takes as first template parameter the
+// iterator class similar to the standard 'sort' algorithm template, but
+// then as second parameter a function class (similar to the second 'less
+// than' parameter of 'sort') which can obtain a 'rank' from each element,
+// on which they are compared.  The 'rank' should be able to turn an element
+// into a number.  The type of these ranks is determined automatically but
+// should be 'unsigned'.
+
+struct pointer_rank {
+  typedef size_t Type;
+  Type operator() (void *ptr) { return (size_t) ptr; }
+};
+
+template <class I, class Rank> void rsort (I first, I last, Rank rank) {
+  typedef typename iterator_traits<I>::value_type T;
+  typedef typename Rank::Type R;
+
+  assert (first <= last);
+  const size_t n = last - first;
+  if (n <= 1)
+    return;
+
+  const size_t l = 8;        // Radix 8, thus byte-wise.
+  const size_t w = (1 << l); // So many buckets.
+
+  const unsigned mask = w - 1; // Fast mod 'w'.
+
+// Uncomment the following define for large values of 'w' in order to keep
+// the large bucket array 'count' on the heap instead of the stack.
+//
+// #define CADICAL_RADIX_BUCKETS_ON_THE_HEAP
+//
+#ifdef CADICAL_RADIX_BUCKETS_ON_THE_HEAP
+  size_t *count = new size_t[w]; // Put buckets on the heap.
+#else
+  size_t count[w]; // Put buckets on the stack.
+#endif
+
+  I a = first, b = last, c = a;
+  bool initialized = false;
+  std::vector<T> v;
+
+  R upper = 0, lower = ~upper;
+  R shifted = mask;
+  bool bounded = false;
+
+  R masked_lower = 0, masked_upper = mask;
+
+  for (size_t i = 0; i < 8 * sizeof (rank (*first));
+       i += l, shifted <<= l) {
+
+    if (bounded && (lower & shifted) == (upper & shifted))
+      continue;
+
+    memset (count + masked_lower, 0,
+            (masked_upper - masked_lower + 1) * sizeof *count);
+
+    const I end = c + n;
+    bool sorted = true;
+    R last = 0;
+
+    for (I p = c; p != end; p++) {
+      const auto r = rank (*p);
+      if (!bounded)
+        lower &= r, upper |= r;
+      const auto s = r >> i;
+      const auto m = s & mask;
+      if (sorted && last > m)
+        sorted = false;
+      else
+        last = m;
+      count[m]++;
+    }
+
+    masked_lower = (lower >> i) & mask;
+    masked_upper = (upper >> i) & mask;
+
+    if (!bounded) {
+      bounded = true;
+      if ((lower & shifted) == (upper & shifted))
+        continue;
+    }
+
+    if (sorted)
+      continue;
+
+    size_t pos = 0;
+    for (R j = masked_lower; j <= masked_upper; j++) {
+      const size_t delta = count[j];
+      count[j] = pos;
+      pos += delta;
+    }
+
+    if (!initialized) {
+      assert (&*c == &*a); // MS VC++
+      v.resize (n);
+      b = v.begin ();
+      initialized = true;
+    }
+
+    I d = (&*c == &*a) ? b : a; // MS VC++
+
+    for (I p = c; p != end; p++) {
+      const auto r = rank (*p);
+      const auto s = r >> i;
+      const auto m = s & mask;
+      d[count[m]++] = *p;
+    }
+    c = d;
+  }
+
+  if (c == b) {
+    for (size_t i = 0; i < n; i++)
+      a[i] = b[i];
+  }
+
+#ifdef CADICAL_RADIX_BUCKETS_ON_THE_HEAP
+  delete[] count;
+#endif
+
+#ifndef NDEBUG
+  for (I p = first; p + 1 != last; p++)
+    assert (rank (p[0]) <= rank (p[1]));
+#endif
+}
+
+// It turns out that for small number of elements (like '100') and in
+// particular for large value ranges the standard sorting function is
+// considerably faster than our radix sort (like 2.5x). This negative effect
+// vanishes at around 800 elements (sorting integers) and thus we provide a
+// function 'MSORT' which selects between standard sort and radix sort based
+// on the number of elements.  However we failed to put this into proper C++
+// style template code and thus have to use a macro instead.  We also do not
+// use it everywhere instead of 'rsort' since it requires a fourth
+// parameter, which is awkward, particular in those situation where we
+// expect large arrays to be sorted anyhow (such as during sorting the
+// clauses in an arena or the probes during probing).  The first argument
+// is the limit up to which we use the standard sort.  Above the limit we
+// use radix sort.  As usual we do not want to hard code it here (default
+// is '800') in order to make fuzzing and delta debugging more effective.
+
+#define MSORT(LIMIT, FIRST, LAST, RANK, LESS) \
+  do { \
+    const size_t N = LAST - FIRST; \
+    if (N <= (size_t) (LIMIT)) \
+      sort (FIRST, LAST, LESS); \
+    else \
+      rsort (FIRST, LAST, RANK); \
+  } while (0)
+
+} // namespace CaDiCaL
+
+#endif

data/ext/cadical/cadical/src/random.cpp

@@ -0,0 +1,207 @@
+#include "internal.hpp"
+
+/*------------------------------------------------------------------------*/
+
+// Our random number generator is seeded by default (i.e., in the default
+// constructor) with random seeds, which should be unique across machines,
+// processes and time.  This makes this code below rather operating system
+// dependent.  We also use in essence defensive programming, overlaying
+// several methods to get randomness since in the past we were bitten a
+// couple of times (and got the same seeds).  Having several methods makes
+// it also simpler to port randomly initializing seeds to different
+// operating systems (even though currently it is only tested on Linux).
+// This functionality is only used in the 'Mobical' model based tester at
+// this point, since the main solver explicitly sets a random seed ('0' by
+// default in 'options.hpp') and also currently only uses this seed in the
+// local search procedure explicitly without using the default constructor.
+// It is crucial for 'Mobical' to make sure that concurrent runs are really
+// independent.
+
+/*------------------------------------------------------------------------*/
+
+// Uncomment the following definition to force printing the computed hash
+// values for individual machine and process properties. This is only needed
+// for testing, porting and debugging different ports of this seeding and
+// hashing functions (uncomment and run 'mobical' for instance).
+
+/*
+#define DO_PRINT_HASH
+*/
+
+#ifdef DO_PRINT_HASH
+#define PRINT_HASH(H) \
+  do { \
+    printf ("c PRINT_HASH %32s () = %020" PRIu64 "\n", __func__, H); \
+    fflush (stdout); \
+  } while (0)
+#else
+#define PRINT_HASH(...) \
+  do { \
+  } while (0)
+#endif
+
+/*------------------------------------------------------------------------*/
+
+// This is Linux specific but if '/var/lib/dbus/machine-id' does not exist
+// does not have any effect.  TODO: add a similar machine identity hashing
+// function for other operating systems (Windows and macOS).
+
+namespace CaDiCaL {
+
+static uint64_t hash_machine_identifier () {
+  FILE *file = fopen ("/var/lib/dbus/machine-id", "r");
+  uint64_t res = 0;
+  if (file) {
+    char buffer[128];
+    memset (buffer, 0, sizeof buffer);
+    size_t bytes = fread (buffer, 1, sizeof buffer - 1, file);
+    assert (bytes);
+    fclose (file);
+    if (bytes && bytes < sizeof buffer) {
+      buffer[bytes] = 0;
+      res = hash_string (buffer);
+    }
+  }
+  PRINT_HASH (res);
+  return res;
+}
+
+} // namespace CaDiCaL
+
+/*------------------------------------------------------------------------*/
+
+// On our Linux cluster where we used an NFS mounted root disk the
+// 'machine-id' above (even on a locally mounted '/var' disk on each node)
+// was copied from '/etc/machine-id' which was shared among all nodes
+// (before figuring this out and fixing it). Thus the main idea of getting
+// different hash values through this machine identifier machines did not
+// work.  As an additional measure to increase the possibility to get
+// different seeds we are now also using network addresses (explicitly).
+
+#ifndef _WIN32
+
+extern "C" {
+#include <ifaddrs.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+}
+
+#endif
+
+namespace CaDiCaL {
+
+static uint64_t hash_network_addresses () {
+  uint64_t res = 0;
+
+  // We still need to properly port this to Windows, but since accessing the
+  // IP address is only required for better randomization during testing
+  // (running 'mobical' on a cluster for instance) it is not crucial unless
+  // you really need to run 'mobical' on a Windows cluster where each node
+  // has identical IP addresses.
+
+#ifndef _WIN32
+  struct ifaddrs *addrs;
+  if (!getifaddrs (&addrs)) {
+    for (struct ifaddrs *addr = addrs; addr; addr = addr->ifa_next) {
+      if (!addr->ifa_addr)
+        continue;
+      const int family = addr->ifa_addr->sa_family;
+      if (family == AF_INET || family == AF_INET6) {
+        const int size = (family == AF_INET) ? sizeof (struct sockaddr_in)
+                                             : sizeof (struct sockaddr_in6);
+        char buffer[128];
+        if (!getnameinfo (addr->ifa_addr, size, buffer, sizeof buffer, 0, 0,
+                          NI_NUMERICHOST)) {
+          uint64_t tmp = hash_string (buffer);
+#ifdef DO_PRINT_HASH
+          printf ("c PRINT_HASH %35s = %020" PRIu64 "\n", buffer, tmp);
+          fflush (stdout);
+#endif
+          res ^= tmp;
+          res *= 10000000000000000051ul;
+        }
+      }
+    }
+    freeifaddrs (addrs);
+  }
+#endif
+
+  PRINT_HASH (res);
+  return res;
+}
+
+} // namespace CaDiCaL
+
+/*------------------------------------------------------------------------*/
+
+// Hash the current wall-clock time in seconds.
+
+extern "C" {
+#include <time.h>
+}
+
+namespace CaDiCaL {
+
+static uint64_t hash_time () {
+  uint64_t res = ::time (0);
+  PRINT_HASH (res);
+  return res;
+}
+
+} // namespace CaDiCaL
+
+/*------------------------------------------------------------------------*/
+
+// Hash the process identified.
+
+extern "C" {
+#include <sys/types.h>
+#include <unistd.h>
+}
+
+namespace CaDiCaL {
+
+static uint64_t hash_process () {
+  uint64_t res = getpid ();
+  PRINT_HASH (res);
+  return res;
+}
+
+} // namespace CaDiCaL
+
+/*------------------------------------------------------------------------*/
+
+// Hash the current number of clock cycles.
+
+#include <ctime>
+
+namespace CaDiCaL {
+
+static uint64_t hash_clock_cycles () {
+  uint64_t res = std::clock ();
+  PRINT_HASH (res);
+  return res;
+}
+
+} // namespace CaDiCaL
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+Random::Random () : state (1) {
+  add (hash_machine_identifier ());
+  add (hash_network_addresses ());
+  add (hash_clock_cycles ());
+  add (hash_process ());
+  add (hash_time ());
+#ifdef DO_PRINT_HASH
+  printf ("c PRINT_HASH %32s    = %020" PRIu64 "\n", "combined", state);
+  fflush (stdout);
+#endif
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/random.h

@@ -0,0 +1,44 @@
+#ifndef _random_h_INCLUDED
+#define _random_h_INCLUDED
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+typedef uint64_t generator;
+
+static inline uint64_t kissat_next_random64 (generator *rng) {
+  *rng *= 6364136223846793005ul;
+  *rng += 1442695040888963407ul;
+  return *rng;
+}
+
+static inline unsigned kissat_next_random32 (generator *rng) {
+  return kissat_next_random64 (rng) >> 32;
+}
+
+static inline unsigned kissat_pick_random (generator *rng, unsigned l,
+                                           unsigned r) {
+  assert (l <= r);
+  if (l == r)
+    return l;
+  const unsigned delta = r - l;
+  const unsigned tmp = kissat_next_random32 (rng);
+  const double fraction = tmp / 4294967296.0;
+  assert (0 <= fraction), assert (fraction < 1);
+  const unsigned scaled = delta * fraction;
+  assert (scaled < delta);
+  const unsigned res = l + scaled;
+  assert (l <= res), assert (res < r);
+  return res;
+}
+
+static inline bool kissat_pick_bool (generator *rng) {
+  return kissat_pick_random (rng, 0, 2);
+}
+
+static inline double kissat_pick_double (generator *rng) {
+  return kissat_next_random32 (rng) / 4294967296.0;
+}
+
+#endif

data/ext/cadical/cadical/src/random.hpp

@@ -0,0 +1,98 @@
+#ifndef _random_hpp_INCLUDED
+#define _random_hpp_INCLUDED
+
+#include <cstdint>
+
+// Random number generator.
+
+namespace CaDiCaL {
+
+class Random {
+
+  uint64_t state;
+
+  void add (uint64_t a) {
+    if (!(state += a))
+      state = 1;
+    next ();
+  }
+
+public:
+  // Without argument use a machine, process and time dependent seed.
+  //
+  Random ();
+
+  Random (uint64_t seed) : state (seed) {}
+  void operator= (uint64_t seed) { state = seed; }
+  Random (const Random &other) : state (other.seed ()) {}
+
+  void operator+= (uint64_t a) { add (a); }
+  uint64_t seed () const { return state; }
+
+  uint64_t next () {
+    state *= 6364136223846793005ul;
+    state += 1442695040888963407ul;
+    assert (state);
+    return state;
+  }
+
+  uint32_t generate () {
+    next ();
+    return state >> 32;
+  }
+  int generate_int () { return (int) generate (); }
+  bool generate_bool () { return generate () < 2147483648u; }
+
+  // Generate 'double' value in the range '[0,1]' excluding '1'.
+  //
+  double generate_double () { return generate () / 4294967295.0; }
+
+  // Generate 'int' value in the range '[l,r]'.
+  //
+  int pick_int (int l, int r) {
+    assert (l <= r);
+    const unsigned delta = 1 + r - (unsigned) l;
+    unsigned tmp = generate (), scaled;
+    if (delta) {
+      const double fraction = tmp / 4294967296.0;
+      scaled = delta * fraction;
+    } else
+      scaled = tmp;
+    const int res = scaled + l;
+    assert (l <= res);
+    assert (res <= r);
+    return res;
+  }
+
+  int pick_log (int l, int r) {
+    assert (l <= r);
+    const unsigned delta = 1 + r - (unsigned) l;
+    int log_delta = delta ? 0 : 32;
+    while (log_delta < 32 && (1u << log_delta) < delta)
+      log_delta++;
+    const int log_res = pick_int (0, log_delta);
+    unsigned tmp = generate ();
+    if (log_res < 32)
+      tmp &= (1u << log_res) - 1;
+    if (delta)
+      tmp %= delta;
+    const int res = l + tmp;
+    assert (l <= res), assert (res <= r);
+    return res;
+  }
+
+  // Generate 'double' value in the range '[l,r]'.
+  //
+  double pick_double (double l, double r) {
+    assert (l <= r);
+    double res = (r - l) * generate_double ();
+    res += l;
+    assert (l <= res);
+    assert (res <= r);
+    return res;
+  }
+};
+
+} // namespace CaDiCaL
+
+#endif