Remove dead code

ConflictSet.cpp

@@ -2416,49 +2416,6 @@ bool checkMaxBetweenExclusiveImpl(Node256 *n, int begin, int end,
   return scan16<kAVX512>(self->maxOfMax, firstPage + 1, lastPage, readVersion);
 }
 
-template <bool kAVX512>
-bool checkMaxBetweenExclusiveImpl(Node *n, int begin, int end,
-                                  InternalVersionT readVersion,
-                                  ReadContext *tls) {
-  switch (n->getType()) {
-  case Type_Node0:
-    return checkMaxBetweenExclusiveImpl<kAVX512>(static_cast<Node0 *>(n), begin,
-                                                 end, readVersion, tls);
-  case Type_Node3: {
-    return checkMaxBetweenExclusiveImpl<kAVX512>(static_cast<Node3 *>(n), begin,
-                                                 end, readVersion, tls);
-  }
-  case Type_Node16: {
-    return checkMaxBetweenExclusiveImpl<kAVX512>(static_cast<Node16 *>(n),
-                                                 begin, end, readVersion, tls);
-  }
-  case Type_Node48: {
-    return checkMaxBetweenExclusiveImpl<kAVX512>(static_cast<Node48 *>(n),
-                                                 begin, end, readVersion, tls);
-  }
-  case Type_Node256: {
-    return checkMaxBetweenExclusiveImpl<kAVX512>(static_cast<Node256 *>(n),
-                                                 begin, end, readVersion, tls);
-  }
-  default:                   // GCOVR_EXCL_LINE
-    __builtin_unreachable(); // GCOVR_EXCL_LINE
-  }
-}
-
-#if defined(HAS_AVX) && !defined(__SANITIZE_THREAD__)
-__attribute__((target("avx512f"))) bool
-checkMaxBetweenExclusive(Node *n, int begin, int end,
-                         InternalVersionT readVersion, ReadContext *tls) {
-  return checkMaxBetweenExclusiveImpl<true>(n, begin, end, readVersion, tls);
-}
-__attribute__((target("default")))
-#endif
-
-bool checkMaxBetweenExclusive(Node *n, int begin, int end,
-                         InternalVersionT readVersion, ReadContext *tls) {
-  return checkMaxBetweenExclusiveImpl<false>(n, begin, end, readVersion, tls);
-}
-
 bool checkMaxBetweenExclusive(Node0 *n, int begin, int end,
                               InternalVersionT readVersion, ReadContext *tls) {
   return checkMaxBetweenExclusiveImpl<false>(n, begin, end, readVersion, tls);
@@ -2610,9 +2567,6 @@ template __attribute__((target("avx512f"))) bool
 scan16<true>(const InternalVersionT *vs, int begin, int end,
              InternalVersionT readVersion);
 template __attribute__((target("avx512f"))) bool
-checkMaxBetweenExclusiveImpl<true>(Node *n, int begin, int end,
-                                   InternalVersionT readVersion, ReadContext *);
-template __attribute__((target("avx512f"))) bool
 checkMaxBetweenExclusiveImpl<true>(Node16 *n, int begin, int end,
                                    InternalVersionT readVersion, ReadContext *);
 template __attribute__((target("avx512f"))) bool

ServerBench.cpp

@@ -1,4 +1,5 @@
 #include <atomic>
+#include <cstdint>
 #include <errno.h>
 #include <netdb.h>
 #include <stdio.h>
@@ -21,78 +22,56 @@
 
 std::atomic<int64_t> transactions;
 
-constexpr int kBaseSearchDepth = 115;
 constexpr int kWindowSize = 10000000;
 
-std::string numToKey(int64_t num) {
+constexpr int kNumPrefixes = 250000;
+
+std::string makeKey(int64_t num, int suffixLen) {
   std::string result;
-  result.resize(kBaseSearchDepth + sizeof(int64_t));
+  result.resize(sizeof(int64_t) + suffixLen);
-  memset(result.data(), 0, kBaseSearchDepth);
   int64_t be = __builtin_bswap64(num);
-  memcpy(result.data() + kBaseSearchDepth, &be, sizeof(int64_t));
+  memcpy(result.data(), &be, sizeof(int64_t));
+  memset(result.data() + sizeof(int64_t), 0, suffixLen);
   return result;
 }
 
 void workload(weaselab::ConflictSet *cs) {
   int64_t version = kWindowSize;
-  cs->addWrites(nullptr, 0, version);
+  for (int i = 0; i < kNumPrefixes; ++i) {
+    for (int j = 0; j < 50; ++j) {
+      weaselab::ConflictSet::WriteRange wr;
+      auto k = makeKey(i, j);
+      wr.begin.p = (const uint8_t *)k.data();
+      wr.begin.len = k.size();
+      wr.end.len = 0;
+      cs->addWrites(&wr, 1, version);
+    }
+  }
+  ++version;
+  for (int i = 0; i < kNumPrefixes; ++i) {
+    weaselab::ConflictSet::WriteRange wr;
+    auto k = makeKey(i, 50);
+    wr.begin.p = (const uint8_t *)k.data();
+    wr.begin.len = k.size();
+    wr.end.len = 0;
+    cs->addWrites(&wr, 1, version);
+  }
+
+  constexpr int kNumReads = 1;
+  std::vector<weaselab::ConflictSet::Result> results(kNumReads);
   for (;; transactions.fetch_add(1, std::memory_order_relaxed)) {
-    // Reads
+    std::vector<std::string> keys(kNumReads);
-    {
+    for (auto &k : keys) {
-      auto beginK = numToKey(version - kWindowSize);
+      k = makeKey(rand() % kNumPrefixes, 49);
-      auto endK = numToKey(version - 1);
-      auto pointRv = version - kWindowSize + rand() % kWindowSize + 1;
-      auto pointK = numToKey(pointRv);
-      weaselab::ConflictSet::ReadRange reads[] = {
-          {
-              {(const uint8_t *)pointK.data(), int(pointK.size())},
-              {nullptr, 0},
-              pointRv,
-          },
-          {
-              {(const uint8_t *)beginK.data(), int(beginK.size())},
-              {(const uint8_t *)endK.data(), int(endK.size())},
-              version - 2,
-          },
-      };
-      weaselab::ConflictSet::Result result[sizeof(reads) / sizeof(reads[0])];
-      cs->check(reads, result, sizeof(reads) / sizeof(reads[0]));
-      // for (int i = 0; i < sizeof(reads) / sizeof(reads[0]); ++i) {
-      //   if (result[i] != weaselab::ConflictSet::Commit) {
-      //     fprintf(stderr, "Unexpected conflict: [%s, %s) @ %" PRId64 "\n",
-      //             printable(reads[i].begin).c_str(),
-      //             printable(reads[i].end).c_str(), reads[i].readVersion);
-      //     abort();
-      //   }
-      // }
     }
-    // Writes
+    std::vector<weaselab::ConflictSet::ReadRange> reads(kNumReads);
-    {
+    for (int i = 0; i < reads.size(); ++i) {
-      weaselab::ConflictSet::WriteRange w;
+      reads[i].begin.p = (const uint8_t *)(keys[i].data());
-      auto k = numToKey(version);
+      reads[i].begin.len = keys[i].size();
-      w.begin.p = (const uint8_t *)k.data();
+      reads[i].end.len = 0;
-      w.end.len = 0;
+      reads[i].readVersion = version - 1;
-      if (version % (kWindowSize / 2) == 0) {
-        for (int l = 0; l <= k.size(); ++l) {
-          w.begin.len = l;
-          cs->addWrites(&w, 1, version);
-        }
-      } else {
-        w.begin.len = k.size();
-        cs->addWrites(&w, 1, version);
-        int64_t beginN = version - kWindowSize + rand() % kWindowSize;
-        auto b = numToKey(beginN);
-        auto e = numToKey(beginN + 1000);
-        w.begin.p = (const uint8_t *)b.data();
-        w.begin.len = b.size();
-        w.end.p = (const uint8_t *)e.data();
-        w.end.len = e.size();
-        cs->addWrites(&w, 1, version);
-      }
     }
-    // GC
+    cs->check(reads.data(), results.data(), kNumReads);
-    cs->setOldestVersion(version - kWindowSize);
-    ++version;
   }
 }