Implement setOldestVersion

Bench.cpp

@@ -3,6 +3,7 @@
 #include <byteswap.h>
 #include <cstdint>
 #include <cstring>
+#include <string>
 
 #define ANKERL_NANOBENCH_IMPLEMENT
 #include "third_party/nanobench.h"
@@ -552,10 +553,9 @@ struct SkipListConflictSet {
     auto *ranges = new (arena) ReadConflictRange[count];
     for (int i = 0; i < count; ++i) {
       ranges[i].begin = {reads[i].begin.p, size_t(reads[i].begin.len)};
-      ranges[i].end = reads[i].end.len > 0
-                          ? std::span<const uint8_t>{reads[i].end.p,
-                                                     size_t(reads[i].end.len)}
-                          : keyAfter(arena, ranges[i].begin);
+      ranges[i].end = {reads[i].end.p,
+                       size_t(reads[i].end.len == 0 ? reads[i].begin.len + 1
+                                                    : reads[i].end.len)};
       ranges[i].version = reads[i].readVersion;
       if (reads[i].readVersion < oldestVersion) {
         results[i] = ConflictSet::TooOld;
@@ -581,12 +581,10 @@ struct SkipListConflictSet {
       for (int i = 0; i * 2 < ss; ++i) {
         const auto &w = writes[s * stripeSize / 2 + i];
         values[i * 2] = {w.begin.p, size_t(w.begin.len)};
-        if (w.end.len > 0) {
-          values[i * 2 + 1] = {w.end.p, size_t(w.end.len)};
-        } else {
-          values[i * 2 + 1] = keyAfter(arena, values[i * 2]);
-        }
+        values[i * 2 + 1] = {
+            w.end.p, size_t(w.end.len == 0 ? w.begin.len + 1 : w.end.len)};
         writeVersions[i] = w.writeVersion;
+        keyUpdates += 2;
       }
       skipList.find(values, fingers, temp, ss);
       skipList.addConflictRanges(fingers, ss / 2, writeVersions);
@@ -594,11 +592,32 @@ struct SkipListConflictSet {
     }
   }
 
+  void setOldestVersion(int64_t oldestVersion) {
+    this->oldestVersion = oldestVersion;
+    SkipList::Finger finger;
+    int temp;
+    std::span<const uint8_t> key = removalKey;
+    skipList.find(&key, &finger, &temp, 1);
+    skipList.removeBefore(oldestVersion, finger, std::exchange(keyUpdates, 0));
+    removalKey = std::basic_string<uint8_t>(finger.getValue().data(),
+                                            finger.getValue().size());
+  }
+
 private:
+  int64_t keyUpdates = 0;
+  std::basic_string<uint8_t> removalKey;
   int64_t oldestVersion;
   SkipList skipList;
 };
 
+ConflictSet::ReadRange singleton(Arena &arena, std::span<const uint8_t> key) {
+  auto r =
+      std::span<uint8_t>(new (arena) uint8_t[key.size() + 1], key.size() + 1);
+  memcpy(r.data(), key.data(), key.size());
+  r[key.size()] = 0;
+  return {key.data(), int(key.size()), r.data(), int(r.size())};
+}
+
 ConflictSet::ReadRange prefixRange(Arena &arena, std::span<const uint8_t> key) {
   int index;
   for (index = key.size() - 1; index >= 0; index--)
@@ -625,6 +644,8 @@ constexpr int kOpsPerTx = 100;
 
 constexpr int kPrefixLen = 0;
 
+constexpr int kMvccWindow = 100000;
+
 std::span<const uint8_t> makeKey(Arena &arena, int index) {
 
   auto result =
@@ -652,12 +673,13 @@ template <class ConflictSet_> void benchConflictSet(const std::string &name) {
     writes.reserve(kNumKeys);
     for (int i = 0; i < kNumKeys; ++i) {
       auto key = makeKey(arena, i);
-      ConflictSet::WriteRange conflict;
-      conflict.begin.p = key.data();
-      conflict.begin.len = key.size();
-      conflict.end.len = 0;
-      conflict.writeVersion = version + 1;
-      writes.push_back(conflict);
+      ConflictSet::WriteRange w;
+      auto r = singleton(arena, key);
+      w.begin.p = r.begin.p;
+      w.begin.len = r.begin.len;
+      w.end.p = r.end.p;
+      w.end.len = 0;
+      writes.push_back(w);
     }
     cs.addWrites(writes.data(), writes.size());
     ++version;
@@ -701,9 +723,7 @@ template <class ConflictSet_> void benchConflictSet(const std::string &name) {
     std::vector<ConflictSet::ReadRange> reads;
     auto iter = points.begin();
     for (int i = 0; i < kOpsPerTx; ++i) {
-      ConflictSet::ReadRange r;
-      r.begin.p = iter->data();
-      r.begin.len = iter->size();
+      auto r = singleton(arena, *iter);
       r.end.len = 0;
       r.readVersion = version - 1;
       reads.push_back(r);
@@ -758,8 +778,10 @@ template <class ConflictSet_> void benchConflictSet(const std::string &name) {
     auto iter = points.begin();
     for (int i = 0; i < kOpsPerTx; ++i) {
       ConflictSet::WriteRange w;
-      w.begin.p = iter->data();
-      w.begin.len = iter->size();
+      auto r = singleton(arena, *iter);
+      w.begin.p = r.begin.p;
+      w.begin.len = r.begin.len;
+      w.end.p = r.end.p;
       w.end.len = 0;
       writes.push_back(w);
       ++iter;
@@ -771,6 +793,7 @@ template <class ConflictSet_> void benchConflictSet(const std::string &name) {
         w.writeVersion = v;
       }
       cs.addWrites(writes.data(), writes.size());
+      cs.setOldestVersion(std::max<int64_t>(version - kMvccWindow, 0));
     });
   }
 
@@ -794,6 +817,7 @@ template <class ConflictSet_> void benchConflictSet(const std::string &name) {
         w.writeVersion = v;
       }
       cs.addWrites(writes.data(), writes.size());
+      cs.setOldestVersion(std::max<int64_t>(version - kMvccWindow, 0));
     });
   }
 
@@ -817,6 +841,7 @@ template <class ConflictSet_> void benchConflictSet(const std::string &name) {
         w.writeVersion = v;
       }
       cs.addWrites(writes.data(), writes.size());
+      cs.setOldestVersion(std::max<int64_t>(version - kMvccWindow, 0));
     });
   }
 }