Check more preconditions in Debug mode

low bits of lcg have low periods

ConflictSet.cpp

@@ -2912,9 +2912,8 @@ checkMaxBetweenExclusiveImpl<true>(Node *n, int begin, int end,
 // of the result will have `maxVersion` set to `writeVersion` as a
 // postcondition. Nodes along the search path may be invalidated. Callers must
 // ensure that the max version of the self argument is updated.
-[[nodiscard]]
+[[nodiscard]] Node **insert(Node **self, std::span<const uint8_t> key,
-Node **insert(Node **self, std::span<const uint8_t> key,
+                            InternalVersionT writeVersion, WriteContext *tls) {
-              InternalVersionT writeVersion, WriteContext *tls) {
 
   for (; key.size() != 0; ++tls->accum.insert_iterations) {
     self = &getOrCreateChild(*self, key, writeVersion, tls);
@@ -3149,6 +3148,8 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
     tls.impl = this;
     int64_t check_byte_accum = 0;
     for (int i = 0; i < count; ++i) {
+      assert(reads[i].readVersion >= 0);
+      assert(reads[i].readVersion <= newestVersionFullPrecision);
       const auto &r = reads[i];
       check_byte_accum += r.begin.len + r.end.len;
       auto begin = std::span<const uint8_t>(r.begin.p, r.begin.len);
@@ -3205,7 +3206,10 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
 
       newestVersionFullPrecision = writeVersion;
       newest_version.set(newestVersionFullPrecision);
-      setOldestVersion(newestVersionFullPrecision - kNominalVersionWindow);
+      if (newestVersionFullPrecision - kNominalVersionWindow >
+          oldestVersionFullPrecision) {
+        setOldestVersion(newestVersionFullPrecision - kNominalVersionWindow);
+      }
       while (oldestExtantVersion <
              newestVersionFullPrecision - kMaxCorrectVersionWindow) {
         gcScanStep(1000);
@@ -3213,7 +3217,10 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
     } else {
       newestVersionFullPrecision = writeVersion;
       newest_version.set(newestVersionFullPrecision);
-      setOldestVersion(newestVersionFullPrecision - kNominalVersionWindow);
+      if (newestVersionFullPrecision - kNominalVersionWindow >
+          oldestVersionFullPrecision) {
+        setOldestVersion(newestVersionFullPrecision - kNominalVersionWindow);
+      }
     }
 
     for (int i = 0; i < count; ++i) {
@@ -3298,12 +3305,18 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
     return fuel;
   }
 
-  void setOldestVersion(int64_t o) {
+  void setOldestVersion(int64_t newOldestVersion) {
-    if (o <= oldestVersionFullPrecision) {
+    assert(newOldestVersion >= 0);
+    assert(newOldestVersion <= newestVersionFullPrecision);
+    // If addWrites advances oldestVersion to keep within valid window, a
+    // subsequent setOldestVersion can be legitimately called with a version
+    // older than `oldestVersionFullPrecision`. < instead of <= so that we can
+    // do garbage collection work without advancing the oldest version.
+    if (newOldestVersion < oldestVersionFullPrecision) {
       return;
     }
-    InternalVersionT oldestVersion{o};
+    InternalVersionT oldestVersion{newOldestVersion};
-    this->oldestVersionFullPrecision = o;
+    this->oldestVersionFullPrecision = newOldestVersion;
     this->oldestVersion = oldestVersion;
 #if !USE_64_BIT
     InternalVersionT::zero = tls.zero = oldestVersion;
@@ -3364,6 +3377,7 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
   }
 
   explicit Impl(int64_t oldestVersion) {
+    assert(oldestVersion >= 0);
     init(oldestVersion);
     initMetrics();
   }
@@ -3758,13 +3772,13 @@ std::string getSearchPath(Node *n) {
         fprintf(file,
                 " k_%p [label=\"m=%" PRId64 " p=%" PRId64 " r=%" PRId64
                 "\n%s\", pos=\"%d,%d!\"];\n",
-                (void *)n, maxVersion(n).toInt64(),
+                (void *)n, n->parent == nullptr ? -1 : maxVersion(n).toInt64(),
                 n->entry.pointVersion.toInt64(),
                 n->entry.rangeVersion.toInt64(),
                 getPartialKeyPrintable(n).c_str(), x, y);
       } else {
         fprintf(file, " k_%p [label=\"m=%" PRId64 "\n%s\", pos=\"%d,%d!\"];\n",
-                (void *)n, maxVersion(n).toInt64(),
+                (void *)n, n->parent == nullptr ? -1 : maxVersion(n).toInt64(),
                 getPartialKeyPrintable(n).c_str(), x, y);
       }
       x += kSeparation;

Internal.h

@@ -20,7 +20,6 @@ using namespace weaselab;
 #include <thread>
 #include <unordered_set>
 #include <utility>
-#include <vector>
 
 #include <callgrind.h>
 

SkipList.cpp

@@ -25,6 +25,7 @@
 
 #include <algorithm>
 #include <span>
+#include <vector>
 
 std::span<const uint8_t> keyAfter(Arena &arena, std::span<const uint8_t> key) {
   auto result =
@@ -115,15 +116,6 @@ bool operator==(const KeyInfo &lhs, const KeyInfo &rhs) {
   return !(lhs < rhs || rhs < lhs);
 }
 
-void swapSort(std::vector<KeyInfo> &points, int a, int b) {
-  if (points[b] < points[a]) {
-    KeyInfo temp;
-    temp = points[a];
-    points[a] = points[b];
-    points[b] = temp;
-  }
-}
-
 struct SortTask {
   int begin;
   int size;
@@ -183,13 +175,6 @@ void sortPoints(std::vector<KeyInfo> &points) {
   }
 }
 
-static thread_local uint32_t g_seed = 0;
-
-static inline int skfastrand() {
-  g_seed = g_seed * 1664525L + 1013904223L;
-  return g_seed;
-}
-
 static int compare(const StringRef &a, const StringRef &b) {
   int c = memcmp(a.data(), b.data(), std::min(a.size(), b.size()));
   if (c < 0)
@@ -215,20 +200,24 @@ struct ReadConflictRange {
   }
 };
 
+static constexpr int MaxLevels = 26;
+
+struct RandomLevel {
+  explicit RandomLevel(uint32_t seed) : seed(seed) {}
+
+  int next() {
+    int result = __builtin_clz(seed | (uint32_t(-1) >> (MaxLevels - 1)));
+    seed = seed * 1664525L + 1013904223L;
+    return result;
+  }
+
+private:
+  uint32_t seed;
+};
+
 class SkipList {
 private:
-  static constexpr int MaxLevels = 26;
+  RandomLevel randomLevel{0};
-
-  int randomLevel() const {
-    uint32_t i = uint32_t(skfastrand()) >> (32 - (MaxLevels - 1));
-    int level = 0;
-    while (i & 1) {
-      i >>= 1;
-      level++;
-    }
-    assert(level < MaxLevels);
-    return level;
-  }
 
   // Represent a node in the SkipList. The node has multiple (i.e., level)
   // pointers to other nodes, and keeps a record of the max versions for each
@@ -426,18 +415,23 @@ public:
   }
   void swap(SkipList &other) { std::swap(header, other.header); }
 
-  void addConflictRanges(const Finger *fingers, int rangeCount,
+  // Returns the change in the number of entries
-                         Version version) {
+  int64_t addConflictRanges(const Finger *fingers, int rangeCount,
+                            Version version) {
+    int64_t result = rangeCount;
     for (int r = rangeCount - 1; r >= 0; r--) {
       const Finger &startF = fingers[r * 2];
       const Finger &endF = fingers[r * 2 + 1];
 
-      if (endF.found() == nullptr)
+      if (endF.found() == nullptr) {
+        ++result;
         insert(endF, endF.finger[0]->getMaxVersion(0));
+      }
 
-      remove(startF, endF);
+      result -= remove(startF, endF);
       insert(startF, version);
     }
+    return result;
   }
 
   void detectConflicts(ReadConflictRange *ranges, int count,
@@ -567,9 +561,10 @@ public:
   }
 
 private:
-  void remove(const Finger &start, const Finger &end) {
+  // Returns the number of entries removed
+  int64_t remove(const Finger &start, const Finger &end) {
     if (start.finger[0] == end.finger[0])
-      return;
+      return 0;
 
     Node *x = start.finger[0]->getNext(0);
 
@@ -578,17 +573,20 @@ private:
       if (start.finger[i] != end.finger[i])
         start.finger[i]->setNext(i, end.finger[i]->getNext(i));
 
+    int64_t result = 0;
     while (true) {
       Node *next = x->getNext(0);
       x->destroy();
+      ++result;
       if (x == end.finger[0])
         break;
       x = next;
     }
+    return result;
   }
 
   void insert(const Finger &f, Version version) {
-    int level = randomLevel();
+    int level = randomLevel.next();
     // std::cout << std::string((const char*)value,length) << " level: " <<
     // level << std::endl;
     Node *x = Node::create(f.value, level);
@@ -704,8 +702,6 @@ private:
   };
 };
 
-struct SkipListConflictSet {};
-
 struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
   Impl(int64_t oldestVersion)
       : oldestVersion(oldestVersion), newestVersion(oldestVersion),
@@ -775,17 +771,20 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
     StringRef values[stripeSize];
     int64_t writeVersions[stripeSize / 2];
     int ss = stringCount - (stripes - 1) * stripeSize;
+    int64_t entryDelta = 0;
     for (int s = stripes - 1; s >= 0; s--) {
       for (int i = 0; i * 2 < ss; ++i) {
         const auto &w = combinedWriteConflictRanges[s * stripeSize / 2 + i];
         values[i * 2] = w.first;
         values[i * 2 + 1] = w.second;
-        keyUpdates += 3;
       }
       skipList.find(values, fingers, temp, ss);
-      skipList.addConflictRanges(fingers, ss / 2, writeVersion);
+      entryDelta += skipList.addConflictRanges(fingers, ss / 2, writeVersion);
       ss = stripeSize;
     }
+
+    // Run gc at least 200% the rate we're inserting entries
+    keyUpdates += std::max<int64_t>(entryDelta, 0) * 2;
   }
 
   void setOldestVersion(int64_t oldestVersion) {
@@ -795,7 +794,7 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
     int temp;
     std::span<const uint8_t> key = removalKey;
     skipList.find(&key, &finger, &temp, 1);
-    skipList.removeBefore(oldestVersion, finger, std::exchange(keyUpdates, 10));
+    skipList.removeBefore(oldestVersion, finger, std::exchange(keyUpdates, 0));
     removalArena = Arena();
     removalKey = copyToArena(
         removalArena, {finger.getValue().data(), finger.getValue().size()});
@@ -804,7 +803,7 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
   int64_t totalBytes = 0;
 
 private:
-  int64_t keyUpdates = 10;
+  int64_t keyUpdates = 0;
   Arena removalArena;
   std::span<const uint8_t> removalKey;
   int64_t oldestVersion;

include/ConflictSet.h

@@ -54,8 +54,9 @@ struct __attribute__((__visibility__("default"))) ConflictSet {
     /** `end` having length 0 denotes that this range is the single key {begin}.
      * Otherwise this denotes the range [begin, end), and begin must be < end */
     Key end;
-    /** `readVersion` older than the the oldestVersion or the version of the
+    /** `readVersion` older than the oldestVersion or the version of the
-     * latest call to `addWrites` minus two billion will result in `TooOld` */
+     * latest call to `addWrites` minus two billion will result in `TooOld`.
+     * Must be <= the version of the latest call to `addWrites` */
     int64_t readVersion;
   };
 
@@ -72,11 +73,13 @@ struct __attribute__((__visibility__("default"))) ConflictSet {
 
   /** Reads intersecting writes where readVersion < `writeVersion` will result
    * in `Conflict` (or `TooOld`, eventually).  `writeVersion` must be greater
-   * than or equal to all previous write versions. */
+   * than or equal to all previous write versions. Call `addWrites` with `count`
+   * zero to only advance the version. */
   void addWrites(const WriteRange *writes, int count, int64_t writeVersion);
 
-  /** Reads where readVersion < oldestVersion will result in `TooOld`. Must be
+  /** Reads where readVersion < `oldestVersion` will result in `TooOld`. Must be
-   * greater than or equal to all previous oldest versions. */
+   * greater than or equal to all previous oldest versions. Must be <= the
+   * version of the latest call to `addWrites` */
   void setOldestVersion(int64_t oldestVersion);
 
   /** Reads where readVersion < oldestVersion will result in `TooOld`. There are
@@ -170,8 +173,9 @@ typedef struct {
   /** `end` having length 0 denotes that this range is the single key {begin}.
    * Otherwise this denotes the range [begin, end), and begin must be < end */
   ConflictSet_Key end;
-  /** `readVersion` older than the the oldestVersion or the version of the
+  /** `readVersion` older than the oldestVersion or the version of the
-   * latest call to `addWrites` minus two billion will result in `TooOld` */
+   * latest call to `addWrites` minus two billion will result in `TooOld`.
+   * Must be <= the version of the latest call to `addWrites` */
   int64_t readVersion;
 } ConflictSet_ReadRange;
 
@@ -188,15 +192,17 @@ void ConflictSet_check(const ConflictSet *cs,
                        const ConflictSet_ReadRange *reads,
                        ConflictSet_Result *results, int count);
 
-/** Reads intersecting writes where readVersion < `writeVersion` will result in
+/** Reads intersecting writes where readVersion < `writeVersion` will result
- * `Conflict` (or `TooOld`, eventually).  `writeVersion` must be greater than or
+ * in `Conflict` (or `TooOld`, eventually).  `writeVersion` must be greater
- * equal to all previous write versions.  */
+ * than or equal to all previous write versions. Call `addWrites` with `count`
+ * zero to only advance the version. */
 void ConflictSet_addWrites(ConflictSet *cs,
                            const ConflictSet_WriteRange *writes, int count,
                            int64_t writeVersion);
 
-/** Reads where readVersion < oldestVersion will result in `TooOld`. Must be
+/** Reads where readVersion < `oldestVersion` will result in `TooOld`. Must be
- * greater than or equal to all previous oldest versions. */
+ * greater than or equal to all previous oldest versions. Must be <= the
+ * version of the latest call to `addWrites` */
 void ConflictSet_setOldestVersion(ConflictSet *cs, int64_t oldestVersion);
 
 /** Reads where readVersion < oldestVersion will result in `TooOld`. There are

test_conflict_set.py

@@ -96,6 +96,7 @@ def test_inner_full_words():
 
 def test_internal_version_zero():
     with DebugConflictSet() as cs:
+        cs.addWrites(0xFFFFFFF0)
         cs.setOldestVersion(0xFFFFFFF0)
         for i in range(24):
             cs.addWrites(0xFFFFFFF1, write(bytes([i])))