Commit to non-simd Node3 implementations

Events in the same group should be associated with the same set of
instructions

Bench.cpp

@@ -361,21 +361,7 @@ void benchWorstCaseForRadixRangeRead() {
 void benchCreateAndDestroy() {
   ankerl::nanobench::Bench bench;
 
-  bench.run("create and destroy", [&]() {
+  bench.run("create and destroy", [&]() { ConflictSet cs{0}; });
-    ConflictSet cs{0};
-    ConflictSet::WriteRange w;
-    uint8_t b[9];
-    b[8] = 0;
-    for (int64_t i = 0; i < 1000; i += 7) {
-      auto x = __builtin_bswap64(i);
-      memcpy(b, &x, 8);
-      w.begin.p = b;
-      w.begin.len = 8;
-      w.end.len = 0;
-      w.end.p = b;
-      cs.addWrites(&w, 1, 1);
-    }
-  });
 }
 
 int main(void) {

Internal.h

@@ -748,7 +748,10 @@ struct TestDriver {
       fprintf(stderr, "%p Set oldest version: %" PRId64 "\n", this,
               oldestVersion);
 #endif
+      CALLGRIND_START_INSTRUMENTATION;
       cs.setOldestVersion(oldestVersion);
+      CALLGRIND_STOP_INSTRUMENTATION;
+
       if constexpr (kEnableAssertions) {
         refImpl.setOldestVersion(oldestVersion);
       }

README.md

@@ -24,16 +24,15 @@ Hardware for all benchmarks is an AMD Ryzen 9 7900 with (2x32GB) 5600MT/s CL28-3
 
 |               ns/op |                op/s |    err% |          ins/op |          cyc/op |    IPC |         bra/op |   miss% |     total | benchmark
 |--------------------:|--------------------:|--------:|----------------:|----------------:|-------:|---------------:|--------:|----------:|:----------
-|               10.80 |       92,600,541.52 |    0.6% |          180.38 |           54.49 |  3.310 |          41.51 |    0.4% |      0.01 | `point reads`
+|               11.04 |       90,614,308.12 |    0.8% |          180.38 |           55.13 |  3.272 |          41.51 |    0.4% |      0.01 | `point reads`
-|               15.00 |       66,687,691.68 |    0.4% |          278.44 |           76.44 |  3.642 |          55.56 |    0.3% |      0.01 | `prefix reads`
+|               14.96 |       66,843,629.12 |    0.4% |          274.41 |           74.73 |  3.672 |          55.05 |    0.3% |      0.01 | `prefix reads`
-|               36.81 |       27,163,394.61 |    0.4% |          795.06 |          187.91 |  4.231 |         142.67 |    0.2% |      0.01 | `range reads`
+|               37.06 |       26,982,847.61 |    0.2% |          791.04 |          185.28 |  4.269 |         142.67 |    0.2% |      0.01 | `range reads`
-|               18.14 |       55,137,674.01 |    1.2% |          338.19 |           92.86 |  3.642 |          42.81 |    0.4% |      0.01 | `point writes`
+|               17.89 |       55,887,365.73 |    0.6% |          335.54 |           89.79 |  3.737 |          43.84 |    0.4% |      0.01 | `point writes`
-|               33.19 |       30,127,119.71 |    0.1% |          681.03 |          170.05 |  4.005 |          98.68 |    0.2% |      0.01 | `prefix writes`
+|               31.85 |       31,394,336.65 |    0.3% |          615.32 |          159.63 |  3.855 |          87.69 |    0.2% |      0.01 | `prefix writes`
-|               37.37 |       26,759,432.70 |    1.9% |          779.70 |          195.45 |  3.989 |         114.21 |    0.0% |      0.01 | `range writes`
+|               36.17 |       27,647,221.45 |    0.6% |          705.11 |          182.80 |  3.857 |         100.62 |    0.1% |      0.01 | `range writes`
-|               74.36 |       13,448,582.47 |    1.9% |        1,425.68 |          389.08 |  3.664 |         258.88 |    0.1% |      0.01 | `monotonic increasing point writes`
+|               79.01 |       12,656,457.78 |    0.7% |        1,498.35 |          402.46 |  3.723 |         270.50 |    0.1% |      0.01 | `monotonic increasing point writes`
-|          316,928.00 |            3,155.29 |    1.5% |    3,992,986.00 |    1,699,813.00 |  2.349 |     806,226.50 |    0.0% |      0.01 | `worst case for radix tree`
+|          303,667.50 |            3,293.08 |    1.1% |    3,931,273.00 |    1,612,702.50 |  2.438 |     806,223.33 |    0.0% |      0.01 | `worst case for radix tree`
-|               75.26 |       13,286,517.16 |    0.5% |        1,590.01 |          386.67 |  4.112 |         258.00 |    0.0% |      0.01 | `create and destroy`
+|               83.70 |       11,947,443.83 |    0.7% |        1,738.03 |          429.06 |  4.051 |         270.01 |    0.0% |      0.01 | `create and destroy`
-
 
 # "Real data" test
 
@@ -48,7 +47,7 @@ Check: 4.47891 seconds, 364.05 MB/s, Add: 4.55599 seconds, 123.058 MB/s, Gc rati
 ## radix tree
 
 ```
-Check: 0.910234 seconds, 1791.35 MB/s, Add: 1.25908 seconds, 445.287 MB/s, Gc ratio: 44.0415%
+Check: 0.958985 seconds, 1700.28 MB/s, Add: 1.35083 seconds, 415.044 MB/s, Gc ratio: 44.4768%, Peak idle memory: 2.33588e+06
 ```
 
 ## hash table

ServerBench.cpp

@@ -6,11 +6,15 @@
 #include <string.h>
 #include <string>
 #include <string_view>
+#include <sys/ioctl.h>
 #include <sys/resource.h>
 #include <sys/socket.h>
+#include <sys/types.h>
 #include <sys/uio.h>
 #include <thread>
 #include <unistd.h>
+#include <utility>
+#include <vector>
 
 #include "ConflictSet.h"
 #include "third_party/nadeau.h"
@@ -20,8 +24,8 @@ std::atomic<int64_t> transactions;
 constexpr int kBaseSearchDepth = 32;
 constexpr int kWindowSize = 10000000;
 
-std::basic_string<uint8_t> numToKey(int64_t num) {
+std::string numToKey(int64_t num) {
-  std::basic_string<uint8_t> result;
+  std::string result;
   result.resize(kBaseSearchDepth + sizeof(int64_t));
   memset(result.data(), 0, kBaseSearchDepth);
   int64_t be = __builtin_bswap64(num);
@@ -41,13 +45,13 @@ void workload(weaselab::ConflictSet *cs) {
       auto pointK = numToKey(pointRv);
       weaselab::ConflictSet::ReadRange reads[] = {
           {
-              {pointK.data(), int(pointK.size())},
+              {(const uint8_t *)pointK.data(), int(pointK.size())},
               {nullptr, 0},
               pointRv,
           },
           {
-              {beginK.data(), int(beginK.size())},
+              {(const uint8_t *)beginK.data(), int(beginK.size())},
-              {endK.data(), int(endK.size())},
+              {(const uint8_t *)endK.data(), int(endK.size())},
               version - 2,
           },
       };
@@ -66,7 +70,7 @@ void workload(weaselab::ConflictSet *cs) {
     {
       weaselab::ConflictSet::WriteRange w;
       auto k = numToKey(version);
-      w.begin.p = k.data();
+      w.begin.p = (const uint8_t *)k.data();
       w.end.len = 0;
       if (version % (kWindowSize / 2) == 0) {
         for (int l = 0; l <= k.size(); ++l) {
@@ -79,9 +83,9 @@ void workload(weaselab::ConflictSet *cs) {
         int64_t beginN = version - kWindowSize + rand() % kWindowSize;
         auto b = numToKey(beginN);
         auto e = numToKey(beginN + 1000);
-        w.begin.p = b.data();
+        w.begin.p = (const uint8_t *)b.data();
         w.begin.len = b.size();
-        w.end.p = e.data();
+        w.end.p = (const uint8_t *)e.data();
         w.end.len = e.size();
         cs->addWrites(&w, 1, version);
       }
@@ -164,36 +168,29 @@ double toSeconds(timeval t) {
   return double(t.tv_sec) + double(t.tv_usec) * 1e-6;
 }
 
-#include <linux/perf_event.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/ioctl.h>
-#include <sys/syscall.h>
-#include <sys/types.h>
-#include <unistd.h>
-
 #ifdef __linux__
+#include <linux/perf_event.h>
 struct PerfCounter {
-  explicit PerfCounter(int event) {
+  PerfCounter(int type, int config, const std::string &labels = {},
+              int groupLeaderFd = -1)
+      : labels(labels) {
     struct perf_event_attr pe;
 
     memset(&pe, 0, sizeof(pe));
-    pe.type = PERF_TYPE_HARDWARE;
+    pe.type = type;
     pe.size = sizeof(pe);
-    pe.config = event;
+    pe.config = config;
     pe.inherit = 1;
     pe.exclude_kernel = 1;
     pe.exclude_hv = 1;
 
-    fd = perf_event_open(&pe, 0, -1, -1, 0);
+    fd = perf_event_open(&pe, 0, -1, groupLeaderFd, 0);
-    if (fd == -1) {
+    if (fd < 0 && errno != ENOENT && errno != EINVAL) {
-      fprintf(stderr, "Error opening leader %llx\n", pe.config);
+      perror(labels.c_str());
-      exit(EXIT_FAILURE);
     }
   }
 
-  int64_t total() {
+  int64_t total() const {
     int64_t count;
     if (read(fd, &count, sizeof(count)) != sizeof(count)) {
       perror("read instructions from perf");
@@ -202,10 +199,27 @@ struct PerfCounter {
     return count;
   }
 
-  ~PerfCounter() { close(fd); }
+  PerfCounter(PerfCounter &&other)
+      : fd(std::exchange(other.fd, -1)), labels(std::move(other.labels)) {}
+  PerfCounter &operator=(PerfCounter &&other) {
+    fd = std::exchange(other.fd, -1);
+    labels = std::move(other.labels);
+    return *this;
+  }
+
+  ~PerfCounter() {
+    if (fd >= 0) {
+      close(fd);
+    }
+  }
+
+  bool ok() const { return fd >= 0; }
+  const std::string &getLabels() const { return labels; }
+  int getFd() const { return fd; }
 
 private:
   int fd;
+  std::string labels;
   static long perf_event_open(struct perf_event_attr *hw_event, pid_t pid,
                               int cpu, int group_fd, unsigned long flags) {
     int ret;
@@ -214,11 +228,6 @@ private:
     return ret;
   }
 };
-#else
-struct PerfCounter {
-  explicit PerPerfCounter(int) {}
-  int64_t total() { return 0; }
-};
 #endif
 
 int main(int argc, char **argv) {
@@ -233,8 +242,50 @@ int main(int argc, char **argv) {
     int metricsCount;
     cs.getMetricsV1(&metrics, &metricsCount);
 
-    PerfCounter instructions{PERF_COUNT_HW_INSTRUCTIONS};
+#ifdef __linux__
-    PerfCounter cycles{PERF_COUNT_HW_CPU_CYCLES};
+    PerfCounter instructions{PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS};
+    PerfCounter cycles{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES, "",
+                       instructions.getFd()};
+
+    std::vector<PerfCounter> cacheCounters;
+    for (auto [id, idStr] : std::initializer_list<std::pair<int, std::string>>{
+             {PERF_COUNT_HW_CACHE_L1D, "l1d"},
+             {PERF_COUNT_HW_CACHE_L1I, "l1i"},
+             {PERF_COUNT_HW_CACHE_LL, "ll"},
+             {PERF_COUNT_HW_CACHE_DTLB, "dtlb"},
+             {PERF_COUNT_HW_CACHE_ITLB, "itlb"},
+             {PERF_COUNT_HW_CACHE_BPU, "bpu"},
+             {PERF_COUNT_HW_CACHE_NODE, "node"},
+         }) {
+      for (auto [op, opStr] :
+           std::initializer_list<std::pair<int, std::string>>{
+               {PERF_COUNT_HW_CACHE_OP_READ, "read"},
+               {PERF_COUNT_HW_CACHE_OP_WRITE, "write"},
+               {PERF_COUNT_HW_CACHE_OP_PREFETCH, "prefetch"},
+           }) {
+        int groupLeaderFd = -1;
+        for (auto [result, resultStr] :
+             std::initializer_list<std::pair<int, std::string>>{
+                 {PERF_COUNT_HW_CACHE_RESULT_MISS, "miss"},
+                 {PERF_COUNT_HW_CACHE_RESULT_ACCESS, "access"},
+             }) {
+          auto labels = "{id=\"" + idStr + "\", op=\"" + opStr +
+                        "\", result=\"" + resultStr + "\"}";
+          cacheCounters.emplace_back(PERF_TYPE_HW_CACHE,
+                                     id | (op << 8) | (result << 16), labels,
+                                     groupLeaderFd);
+          if (!cacheCounters.back().ok()) {
+            cacheCounters.pop_back();
+          } else {
+            if (groupLeaderFd == -1) {
+              groupLeaderFd = cacheCounters.back().getFd();
+            }
+          }
+        }
+      }
+    }
+#endif
+
     auto w = std::thread{workload, &cs};
 
     for (;;) {
@@ -262,6 +313,7 @@ int main(int argc, char **argv) {
               "transactions_total ";
       body += std::to_string(transactions.load(std::memory_order_relaxed));
       body += "\n";
+#ifdef __linux__
       body += "# HELP instructions_total Total number of instructions\n"
               "# TYPE instructions_total counter\n"
               "instructions_total ";
@@ -272,6 +324,13 @@ int main(int argc, char **argv) {
               "cycles_total ";
       body += std::to_string(cycles.total());
       body += "\n";
+      body += "# HELP cache_event_total Total number of cache events\n"
+              "# TYPE cache_event_total counter\n";
+      for (const auto &counter : cacheCounters) {
+        body += "cache_event_total" + counter.getLabels() + " " +
+                std::to_string(counter.total()) + "\n";
+      }
+#endif
 
       for (int i = 0; i < metricsCount; ++i) {
         body += "# HELP ";