Update GCOVR annotations now that jenkins agent has avx512

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

CMakeLists.txt

@@ -276,9 +276,15 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
 
   find_program(VALGRIND_EXE valgrind)
   if(VALGRIND_EXE AND NOT CMAKE_CROSSCOMPILING)
-    add_test(NAME conflict_set_blackbox_valgrind
-             COMMAND ${VALGRIND_EXE} --error-exitcode=99 --
-                     $<TARGET_FILE:driver> ${CORPUS_TESTS})
+    list(LENGTH CORPUS_TESTS len)
+    math(EXPR last "${len} - 1")
+    set(partition_size 100)
+    foreach(i RANGE 0 ${last} ${partition_size})
+      list(SUBLIST CORPUS_TESTS ${i} ${partition_size} partition)
+      add_test(NAME conflict_set_blackbox_valgrind_${i}
+               COMMAND ${VALGRIND_EXE} --error-exitcode=99 --
+                       $<TARGET_FILE:driver> ${partition})
+    endforeach()
   endif()
 
   # api smoke tests

Internal.h

@@ -273,6 +273,16 @@ template <class T> struct Vector {
     size_ += slice.size();
   }
 
+  // Caller must write to the returned slice
+  std::span<T> unsafePrepareAppend(int appendSize) {
+    if (size_ + appendSize > capacity) {
+      grow(std::max<int>(size_ + appendSize, capacity * 2));
+    }
+    auto result = std::span<T>(t + size_, appendSize);
+    size_ += appendSize;
+    return result;
+  }
+
   void push_back(const T &t) { append(std::span<const T>(&t, 1)); }
 
   T *begin() { return t; }
@@ -738,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`
-|               15.00 |       66,687,691.68 |    0.4% |          278.44 |           76.44 |  3.642 |          55.56 |    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`
-|               18.14 |       55,137,674.01 |    1.2% |          338.19 |           92.86 |  3.642 |          42.81 |    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`
-|               37.37 |       26,759,432.70 |    1.9% |          779.70 |          195.45 |  3.989 |         114.21 |    0.0% |      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`
-|          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`
-|               75.26 |       13,286,517.16 |    0.5% |        1,590.01 |          386.67 |  4.112 |         258.00 |    0.0% |      0.01 | `create and destroy`
-
+|               11.18 |       89,455,125.34 |    0.6% |          185.37 |           57.08 |  3.248 |          41.51 |    0.4% |      0.01 | `point reads`
+|               14.53 |       68,800,688.89 |    0.4% |          282.41 |           74.80 |  3.776 |          55.06 |    0.3% |      0.01 | `prefix reads`
+|               36.54 |       27,367,576.87 |    0.2% |          798.06 |          188.90 |  4.225 |         141.69 |    0.2% |      0.01 | `range reads`
+|               16.69 |       59,912,106.02 |    0.6% |          314.57 |           86.29 |  3.645 |          39.84 |    0.4% |      0.01 | `point writes`
+|               30.09 |       33,235,744.07 |    0.5% |          591.33 |          155.92 |  3.793 |          82.69 |    0.2% |      0.01 | `prefix writes`
+|               35.77 |       27,956,388.03 |    1.4% |          682.25 |          187.63 |  3.636 |          96.12 |    0.1% |      0.01 | `range writes`
+|               74.04 |       13,505,408.41 |    2.7% |        1,448.95 |          392.10 |  3.695 |         260.53 |    0.1% |      0.01 | `monotonic increasing point writes`
+|          330,984.50 |            3,021.29 |    1.9% |    3,994,153.50 |    1,667,309.00 |  2.396 |     806,019.50 |    0.0% |      0.01 | `worst case for radix tree`
+|               92.46 |       10,814,961.65 |    0.5% |        1,800.00 |          463.41 |  3.884 |         297.00 |    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.953012 seconds, 1710.94 MB/s, Add: 1.30025 seconds, 431.188 MB/s, Gc ratio: 43.9816%, Peak idle memory: 2.28375e+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::basic_string<uint8_t> result;
+std::string numToKey(int64_t num) {
+  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())},
-              {endK.data(), int(endK.size())},
+              {(const uint8_t *)beginK.data(), int(beginK.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,6 +168,68 @@ double toSeconds(timeval t) {
   return double(t.tv_sec) + double(t.tv_usec) * 1e-6;
 }
 
+#ifdef __linux__
+#include <linux/perf_event.h>
+struct PerfCounter {
+  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 = type;
+    pe.size = sizeof(pe);
+    pe.config = config;
+    pe.inherit = 1;
+    pe.exclude_kernel = 1;
+    pe.exclude_hv = 1;
+
+    fd = perf_event_open(&pe, 0, -1, groupLeaderFd, 0);
+    if (fd < 0 && errno != ENOENT && errno != EINVAL) {
+      perror(labels.c_str());
+    }
+  }
+
+  int64_t total() const {
+    int64_t count;
+    if (read(fd, &count, sizeof(count)) != sizeof(count)) {
+      perror("read instructions from perf");
+      abort();
+    }
+    return count;
+  }
+
+  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;
+
+    ret = syscall(SYS_perf_event_open, hw_event, pid, cpu, group_fd, flags);
+    return ret;
+  }
+};
+#endif
+
 int main(int argc, char **argv) {
   if (argc != 3) {
     goto fail;
@@ -176,6 +242,50 @@ int main(int argc, char **argv) {
     int metricsCount;
     cs.getMetricsV1(&metrics, &metricsCount);
 
+#ifdef __linux__
+    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 (;;) {
@@ -203,6 +313,24 @@ 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 ";
+      body += std::to_string(instructions.total());
+      body += "\n";
+      body += "# HELP cycles_total Total number of cycles\n"
+              "# TYPE cycles_total counter\n"
+              "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 ";