Update README

The freelist doesn't seem to get a good hit rate. Policies other than
capacity = minCapacity did not improve the rate we were resizing nodes,
but did increase memory usage, so get rid of that too. Add a
nodes_resized_total counter.

Bench.cpp

@@ -57,6 +57,7 @@ ConflictSet::ReadRange prefixRange(Arena &arena, TrivialSpan key) {
 
 void benchConflictSet() {
   ankerl::nanobench::Bench bench;
+  bench.minEpochIterations(10000);
   ConflictSet cs{0};
 
   bench.batch(kOpsPerTx);

CMakeLists.txt

@@ -32,7 +32,12 @@ if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
 endif()
 
 add_compile_options(
-  -Werror=switch-enum -Wswitch-enum -fPIC -fdata-sections -ffunction-sections
+  -Werror=switch-enum
+  -Wswitch-enum
+  -Wunused-variable
+  -fPIC
+  -fdata-sections
+  -ffunction-sections
   -fno-jump-tables # https://github.com/llvm/llvm-project/issues/54247
 )
 
@@ -64,7 +69,8 @@ if(HAS_FULL_RELRO)
 endif()
 cmake_pop_check_state()
 
-if(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64)
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL
+                                              arm64)
   add_compile_options(-mbranch-protection=standard)
 else()
   add_compile_options(-fcf-protection)
@@ -104,19 +110,11 @@ else()
   add_link_options(-Wl,--gc-sections)
 endif()
 
-if(NOT USE_SIMD_FALLBACK)
-  cmake_push_check_state()
-  list(APPEND CMAKE_REQUIRED_FLAGS -mavx)
-  check_include_file_cxx("immintrin.h" HAS_AVX)
-  if(HAS_AVX)
+if(USE_SIMD_FALLBACK)
+  add_compile_definitions(USE_SIMD_FALLBACK)
+else()
+  if(CMAKE_SYSTEM_PROCESSOR STREQUAL x86_64)
     add_compile_options(-mavx)
-    add_compile_definitions(HAS_AVX)
-  endif()
-  cmake_pop_check_state()
-
-  check_include_file_cxx("arm_neon.h" HAS_ARM_NEON)
-  if(HAS_ARM_NEON)
-    add_compile_definitions(HAS_ARM_NEON)
   endif()
 endif()
 
@@ -346,8 +344,7 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
   # c++98
   add_executable(conflict_set_cxx_api_test conflict_set_cxx_api_test.cpp)
   target_compile_options(conflict_set_cxx_api_test PRIVATE ${TEST_FLAGS})
-  target_link_libraries(conflict_set_cxx_api_test
-                        PRIVATE ${PROJECT_NAME}-static)
+  target_link_libraries(conflict_set_cxx_api_test PRIVATE ${PROJECT_NAME})
   set_target_properties(conflict_set_cxx_api_test PROPERTIES CXX_STANDARD 98)
   set_target_properties(conflict_set_cxx_api_test
                         PROPERTIES CXX_STANDARD_REQUIRED ON)

Internal.h

@@ -18,7 +18,6 @@ using namespace weaselab;
 #include <span>
 #include <string>
 #include <thread>
-#include <unordered_set>
 #include <utility>
 
 #include <callgrind.h>
@@ -368,23 +367,6 @@ template <class T, class C = std::less<T>> auto set(Arena &arena) {
   return Set<T, C>(ArenaAlloc<T>(&arena));
 }
 
-template <class T> struct MyHash;
-
-template <class T> struct MyHash<T *> {
-  size_t operator()(const T *t) const noexcept {
-    size_t result;
-    memcpy(&result, &t, sizeof(result));
-    return result;
-  }
-};
-
-template <class T>
-using HashSet =
-    std::unordered_set<T, MyHash<T>, std::equal_to<T>, ArenaAlloc<T>>;
-template <class T> auto hashSet(Arena &arena) {
-  return HashSet<T>(ArenaAlloc<T>(&arena));
-}
-
 template <class T, class U>
 bool operator==(const ArenaAlloc<T> &lhs, const ArenaAlloc<U> &rhs) {
   return lhs.arena == rhs.arena;

Jenkinsfile

@@ -91,7 +91,7 @@ pipeline {
                 minio bucket: 'jenkins', credentialsId: 'jenkins-minio', excludes: '', host: 'minio.weaselab.dev', includes: 'build/*.deb,build/*.rpm,paper/*.pdf', targetFolder: '${JOB_NAME}/${BUILD_NUMBER}/${STAGE_NAME}/'
             }
         }
-        stage('Release [gcc]') {
+        stage('gcc') {
             agent {
                 dockerfile {
                     args '-v /home/jenkins/ccache:/ccache'
@@ -99,7 +99,7 @@ pipeline {
                 }
             }
             steps {
-                CleanBuildAndTest("-DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_CXX_FLAGS=-DNVALGRIND")
+                CleanBuildAndTest("-DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++")
                 recordIssues(tools: [gcc()])
             }
         }

README.md

@@ -4,7 +4,14 @@ Intended as an alternative to FoundationDB's skip list.
 
 Hardware for all benchmarks is an AMD Ryzen 9 7900 with (2x32GB) 5600MT/s CL28-34-34-89 1.35V RAM.
 
-Compiler is `Ubuntu clang version 20.0.0 (++20241029082144+7544d3af0e28-1~exp1~20241029082307.506)`.
+```
+$ clang++ --version
+
+Ubuntu clang version 20.0.0 (++20241119082716+7e85cb8a8a9d-1~exp1~20241119082825.551)
+Target: x86_64-pc-linux-gnu
+Thread model: posix
+InstalledDir: /usr/lib/llvm-20/bin
+```
 
 # Microbenchmark
 
@@ -12,44 +19,45 @@ Compiler is `Ubuntu clang version 20.0.0 (++20241029082144+7544d3af0e28-1~exp1~2
 
 |               ns/op |                op/s |    err% |          ins/op |          cyc/op |    IPC |         bra/op |   miss% |     total | benchmark
 |--------------------:|--------------------:|--------:|----------------:|----------------:|-------:|---------------:|--------:|----------:|:----------
-|              159.65 |        6,263,576.52 |    1.6% |        2,972.36 |          820.37 |  3.623 |         504.59 |    0.0% |      0.01 | `point reads`
-|              156.32 |        6,397,320.65 |    0.7% |        2,913.62 |          806.87 |  3.611 |         490.19 |    0.0% |      0.01 | `prefix reads`
-|              229.18 |        4,363,293.65 |    1.2% |        3,541.05 |        1,219.75 |  2.903 |         629.33 |    0.0% |      0.01 | `range reads`
-|              363.37 |        2,752,026.30 |    0.3% |        5,273.63 |        1,951.54 |  2.702 |         851.66 |    1.7% |      0.01 | `point writes`
-|              364.99 |        2,739,787.02 |    0.3% |        5,250.92 |        1,958.54 |  2.681 |         839.24 |    1.7% |      0.01 | `prefix writes`
-|              242.26 |        4,127,796.58 |    2.9% |        3,117.33 |        1,304.41 |  2.390 |         541.07 |    2.8% |      0.02 | `range writes`
-|              562.48 |        1,777,855.27 |    0.8% |        7,305.21 |        3,034.34 |  2.408 |       1,329.30 |    1.3% |      0.01 | `monotonic increasing point writes`
-|          122,688.57 |            8,150.72 |    0.7% |      798,766.00 |      666,842.00 |  1.198 |     144,584.50 |    0.1% |      0.01 | `worst case for radix tree`
-|               41.71 |       23,976,459.34 |    1.7% |          885.00 |          219.17 |  4.038 |         132.00 |    0.0% |      0.01 | `create and destroy`
+|              175.88 |        5,685,575.81 |    0.0% |        3,014.03 |          883.13 |  3.413 |         504.59 |    0.0% |      2.10 | `point reads`
+|              173.35 |        5,768,718.52 |    0.0% |        2,954.16 |          869.59 |  3.397 |         490.17 |    0.0% |      2.07 | `prefix reads`
+|              251.74 |        3,972,274.68 |    0.1% |        3,592.41 |        1,265.71 |  2.838 |         629.31 |    0.0% |      3.01 | `range reads`
+|              472.13 |        2,118,079.83 |    0.2% |        4,450.57 |        2,377.84 |  1.872 |         707.92 |    2.3% |      5.60 | `point writes`
+|              471.34 |        2,121,609.91 |    0.0% |        4,410.22 |        2,372.55 |  1.859 |         694.74 |    2.3% |      5.61 | `prefix writes`
+|              306.69 |        3,260,650.68 |    0.0% |        2,315.38 |        1,550.33 |  1.493 |         396.69 |    3.3% |      3.68 | `range writes`
+|              502.70 |        1,989,277.15 |    0.9% |        6,999.33 |        2,527.47 |  2.769 |       1,251.74 |    1.3% |      0.06 | `monotonic increasing point writes`
+|          138,097.67 |            7,241.25 |    0.7% |      807,445.67 |      699,899.00 |  1.154 |     144,584.50 |    0.8% |      0.01 | `worst case for radix tree`
+|               46.29 |       21,605,126.00 |    1.0% |          902.00 |          230.73 |  3.909 |         132.00 |    0.0% |      0.01 | `create and destroy`
 
 ## Radix tree (this implementation)
 
+
 |               ns/op |                op/s |    err% |          ins/op |          cyc/op |    IPC |         bra/op |   miss% |     total | benchmark
 |--------------------:|--------------------:|--------:|----------------:|----------------:|-------:|---------------:|--------:|----------:|:----------
-|               12.63 |       79,186,868.18 |    1.4% |          241.61 |           64.76 |  3.731 |          31.64 |    0.8% |      0.01 | `point reads`
-|               14.48 |       69,078,073.40 |    0.3% |          292.42 |           74.69 |  3.915 |          41.49 |    0.5% |      0.01 | `prefix reads`
-|               34.37 |       29,094,694.11 |    0.2% |          759.53 |          179.77 |  4.225 |         100.38 |    0.2% |      0.01 | `range reads`
-|               19.34 |       51,713,896.36 |    0.7% |          369.70 |          101.81 |  3.631 |          47.88 |    0.6% |      0.01 | `point writes`
-|               39.16 |       25,538,968.61 |    0.2% |          653.16 |          206.77 |  3.159 |          89.62 |    0.8% |      0.01 | `prefix writes`
-|               40.58 |       24,642,681.12 |    4.7% |          718.44 |          216.44 |  3.319 |          99.28 |    0.6% |      0.01 | `range writes`
-|               78.77 |       12,694,520.69 |    3.8% |        1,395.55 |          421.73 |  3.309 |         249.81 |    0.1% |      0.01 | `monotonic increasing point writes`
-|          287,760.50 |            3,475.11 |    0.5% |    3,929,266.50 |    1,550,225.50 |  2.535 |     639,064.00 |    0.0% |      0.01 | `worst case for radix tree`
-|              104.76 |        9,545,250.65 |    3.1% |        2,000.00 |          552.82 |  3.618 |         342.00 |    0.0% |      0.01 | `create and destroy`
+|               14.04 |       71,216,855.01 |    0.1% |          245.98 |           70.38 |  3.495 |          31.49 |    0.6% |      0.17 | `point reads`
+|               14.57 |       68,630,592.89 |    0.1% |          297.83 |           72.93 |  4.084 |          40.34 |    0.5% |      0.17 | `prefix reads`
+|               35.28 |       28,347,588.39 |    0.2% |          783.70 |          176.57 |  4.438 |         107.65 |    0.2% |      0.42 | `range reads`
+|               20.64 |       48,453,280.08 |    0.0% |          378.97 |          103.31 |  3.668 |          49.92 |    0.7% |      0.25 | `point writes`
+|               39.14 |       25,551,096.17 |    0.0% |          672.00 |          196.08 |  3.427 |         101.28 |    0.3% |      0.47 | `prefix writes`
+|               39.88 |       25,075,121.85 |    0.0% |          738.26 |          199.71 |  3.697 |         111.59 |    0.1% |      0.49 | `range writes`
+|               79.36 |       12,601,312.65 |    0.5% |        1,447.65 |          398.77 |  3.630 |         275.61 |    0.1% |      0.01 | `monotonic increasing point writes`
+|          307,037.33 |            3,256.93 |    0.3% |    4,043,060.50 |    1,549,199.33 |  2.610 |     714,828.00 |    0.1% |      0.01 | `worst case for radix tree`
+|               97.00 |       10,309,246.47 |    0.2% |        1,986.00 |          487.06 |  4.078 |         315.00 |    0.0% |      0.01 | `create and destroy`
 
 # "Real data" test
 
-Point queries only, best of three runs. Gc ratio is the ratio of time spent doing garbage collection to time spent adding writes or doing garbage collection. Lower is better.
+Point queries only. Gc ratio is the ratio of time spent doing garbage collection to time spent adding writes or doing garbage collection. Lower is better.
 
 ## skip list
 
 ```
-Check: 4.39702 seconds, 370.83 MB/s, Add: 4.50025 seconds, 124.583 MB/s, Gc ratio: 29.1333%, Peak idle memory: 5.51852e+06
+Check: 4.66163 seconds, 361.716 MB/s, Add: 3.97534 seconds, 144.726 MB/s, Gc ratio: 33.3998%, Peak idle memory: 5.61007e+06
 ```
 
 ## radix tree
 
 ```
-Check: 0.987757 seconds, 1650.76 MB/s, Add: 1.24815 seconds, 449.186 MB/s, Gc ratio: 41.4675%, Peak idle memory: 2.02872e+06
+Check: 1.01776 seconds, 1656.77 MB/s, Add: 1.2718 seconds, 452.38 MB/s, Gc ratio: 38.626%, Peak idle memory: 2.05667e+06
 ```
 
 ## hash table
@@ -57,5 +65,6 @@ Check: 0.987757 seconds, 1650.76 MB/s, Add: 1.24815 seconds, 449.186 MB/s, Gc ra
 (The hash table implementation doesn't work on range queries, and its purpose is to provide an idea of how fast point queries can be)
 
 ```
-Check: 0.84256 seconds, 1935.23 MB/s, Add: 0.697204 seconds, 804.146 MB/s, Gc ratio: 35.4091%
+Check: 0.859188 seconds, 1962.54 MB/s, Add: 0.714174 seconds, 805.596 MB/s, Gc ratio: 34.9552%, Peak idle memory: 0
 ```
+

RealDataBench.cpp

@@ -5,7 +5,7 @@
 #include <cstdio>
 #include <cstring>
 #include <fcntl.h>
-#include <string_view>
+#include <span>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <unistd.h>
@@ -64,7 +64,7 @@ int main(int argc, const char **argv) {
     auto *const mapOriginal = begin;
     const auto sizeOriginal = size;
 
-    using StringView = std::basic_string_view<uint8_t>;
+    using StringView = std::span<const uint8_t>;
 
     StringView write;
     std::vector<StringView> reads;
@@ -78,9 +78,9 @@ int main(int argc, const char **argv) {
       end = (uint8_t *)memchr(begin, '\n', size);
 
       if (line.size() > 0 && line[0] == 'P') {
-        write = line.substr(2, line.size());
+        write = line.subspan(2, line.size());
       } else if (line.size() > 0 && line[0] == 'L') {
-        reads.push_back(line.substr(2, line.size()));
+        reads.push_back(line.subspan(2, line.size()));
       } else if (line.empty()) {
         {
           readRanges.resize(reads.size());
@@ -133,10 +133,10 @@ int main(int argc, const char **argv) {
   int metricsCount;
   cs.getMetricsV1(&metrics, &metricsCount);
   for (int i = 0; i < metricsCount; ++i) {
-    printf("# HELP %s %s\n", metrics[i].name, metrics[i].help);
-    printf("# TYPE %s %s\n", metrics[i].name,
-           metrics[i].type == metrics[i].Counter ? "counter" : "gauge");
-    printf("%s %g\n", metrics[i].name, metrics[i].getValue());
+    fprintf(stderr, "# HELP %s %s\n", metrics[i].name, metrics[i].help);
+    fprintf(stderr, "# TYPE %s %s\n", metrics[i].name,
+            metrics[i].type == metrics[i].Counter ? "counter" : "gauge");
+    fprintf(stderr, "%s %g\n", metrics[i].name, metrics[i].getValue());
   }
 
   printf("Check: %g seconds, %g MB/s, Add: %g seconds, %g MB/s, Gc ratio: "

ServerBench.cpp

@@ -23,6 +23,97 @@
 #include "Internal.h"
 #include "third_party/nadeau.h"
 
+constexpr int kCacheLine = 64; // TODO mac m1 is 128
+
+template <class T> struct TxQueue {
+
+  explicit TxQueue(int lgSlotCount)
+      : slotCount(1 << lgSlotCount), slotCountMask(slotCount - 1),
+        slots(new T[slotCount]) {
+    // Otherwise we can't tell the difference between full and empty.
+    assert(!(slotCountMask & 0x80000000));
+  }
+
+  /// Call from producer thread, after ensuring consumer is no longer accessing
+  /// it somehow
+  ~TxQueue() { delete[] slots; }
+
+  /// Must be called from the producer thread
+  void push(T t) {
+    if (wouldBlock()) {
+      // Wait for pops to change and try again
+      consumer.pops.wait(producer.lastPopRead, std::memory_order_relaxed);
+      producer.lastPopRead = consumer.pops.load(std::memory_order_acquire);
+    }
+    slots[producer.pushesNonAtomic++ & slotCountMask] = std::move(t);
+    // seq_cst so that the notify can't be ordered before the store
+    producer.pushes.store(producer.pushesNonAtomic, std::memory_order_seq_cst);
+    // We have to notify every time, since we don't know if this is the last
+    // push ever
+    producer.pushes.notify_one();
+  }
+
+  /// Must be called from the producer thread
+  uint32_t outstanding() {
+    return producer.pushesNonAtomic -
+           consumer.pops.load(std::memory_order_relaxed);
+  }
+
+  /// Returns true if a call to push might block. Must be called from the
+  /// producer thread.
+  bool wouldBlock() {
+    // See if we can determine that overflow won't happen entirely from state
+    // local to the producer
+    if (producer.pushesNonAtomic - producer.lastPopRead == slotCount - 1) {
+      // Re-read pops with memory order
+      producer.lastPopRead = consumer.pops.load(std::memory_order_acquire);
+      return producer.pushesNonAtomic - producer.lastPopRead == slotCount - 1;
+    }
+    return false;
+  }
+
+  /// Valid until the next pop, or until this queue is destroyed.
+  T *pop() {
+    // See if we can determine that there's an entry we can pop entirely from
+    // state local to the consumer
+    if (consumer.lastPushRead - consumer.popsNonAtomic == 0) {
+      // Re-read pushes with memory order and try again
+      consumer.lastPushRead = producer.pushes.load(std::memory_order_acquire);
+      if (consumer.lastPushRead - consumer.popsNonAtomic == 0) {
+        // Wait for pushes to change and try again
+        producer.pushes.wait(consumer.lastPushRead, std::memory_order_relaxed);
+        consumer.lastPushRead = producer.pushes.load(std::memory_order_acquire);
+      }
+    }
+    auto result = &slots[consumer.popsNonAtomic++ & slotCountMask];
+    // We only have to write pops with memory order if we've run out of items.
+    // We know that we'll eventually run out.
+    if (consumer.lastPushRead - consumer.popsNonAtomic == 0) {
+      // seq_cst so that the notify can't be ordered before the store
+      consumer.pops.store(consumer.popsNonAtomic, std::memory_order_seq_cst);
+      consumer.pops.notify_one();
+    }
+    return result;
+  }
+
+private:
+  const uint32_t slotCount;
+  const uint32_t slotCountMask;
+  T *slots;
+  struct alignas(kCacheLine) ProducerState {
+    std::atomic<uint32_t> pushes{0};
+    uint32_t pushesNonAtomic{0};
+    uint32_t lastPopRead{0};
+  };
+  struct alignas(kCacheLine) ConsumerState {
+    std::atomic<uint32_t> pops{0};
+    uint32_t popsNonAtomic{0};
+    uint32_t lastPushRead{0};
+  };
+  ProducerState producer;
+  ConsumerState consumer;
+};
+
 std::atomic<int64_t> transactions;
 
 int64_t safeUnaryMinus(int64_t x) {
@@ -47,13 +138,17 @@ void tupleAppend(std::string &output, int64_t value) {
 
 void tupleAppend(std::string &output, std::string_view value) {
   output.push_back('\x02');
-  for (auto c : value) {
-    if (c == '\x00') {
-      output.push_back('\x00');
-      output.push_back('\xff');
-    } else {
-      output.push_back(c);
+  if (memchr(value.data(), '\x00', value.size()) != nullptr) {
+    for (auto c : value) {
+      if (c == '\x00') {
+        output.push_back('\x00');
+        output.push_back('\xff');
+      } else {
+        output.push_back(c);
+      }
     }
+  } else {
+    output.insert(output.end(), value.begin(), value.end());
   }
   output.push_back('\x00');
 }
@@ -66,49 +161,69 @@ template <class... Ts> std::string tupleKey(const Ts &...ts) {
 
 constexpr int kTotalKeyRange = 1'000'000'000;
 constexpr int kWindowSize = 1'000'000;
-constexpr int kNumKeys = 10;
+constexpr int kNumReadKeysPerTx = 10;
+constexpr int kNumWriteKeysPerTx = 5;
 
-void workload(weaselab::ConflictSet *cs) {
-  int64_t version = kWindowSize;
-  for (;; transactions.fetch_add(1, std::memory_order_relaxed)) {
+struct Transaction {
+  std::vector<std::string> keys;
+  std::vector<weaselab::ConflictSet::ReadRange> reads;
+  std::vector<weaselab::ConflictSet::WriteRange> writes;
+  int64_t version;
+  int64_t oldestVersion;
+  Transaction() = default;
+  explicit Transaction(int64_t version)
+      : version(version), oldestVersion(version - kWindowSize) {
     std::vector<int64_t> keyIndices;
-    for (int i = 0; i < kNumKeys; ++i) {
+    for (int i = 0; i < std::max(kNumReadKeysPerTx, kNumWriteKeysPerTx); ++i) {
       keyIndices.push_back(rand() % kTotalKeyRange);
     }
     std::sort(keyIndices.begin(), keyIndices.end());
-    std::vector<std::string> keys;
     constexpr std::string_view fullString =
         "this is a string, where a prefix of it is used as an element of the "
         "tuple forming the key";
-    for (int i = 0; i < kNumKeys; ++i) {
+    for (int i = 0; i < int(keyIndices.size()); ++i) {
       keys.push_back(
           tupleKey(0x100, keyIndices[i] / fullString.size(),
                    fullString.substr(0, keyIndices[i] % fullString.size())));
       // printf("%s\n", printable(keys.back()).c_str());
     }
-
-    std::vector<weaselab::ConflictSet::ReadRange> reads;
-    std::vector<weaselab::ConflictSet::WriteRange> writes;
-    std::vector<weaselab::ConflictSet::Result> results;
-    for (int i = 0; i < kNumKeys; ++i) {
+    for (int i = 0; i < kNumWriteKeysPerTx; ++i) {
       writes.push_back({{(const uint8_t *)keys[i].data(), int(keys[i].size())},
                         {nullptr, 0}});
+    }
+    reads.push_back({{(const uint8_t *)keys[0].data(), int(keys[0].size())},
+                     {(const uint8_t *)keys[1].data(), int(keys[1].size())},
+                     version - std::min(10, kWindowSize)});
+    static_assert(kNumReadKeysPerTx >= 3);
+    for (int i = 2; i < kNumReadKeysPerTx; ++i) {
       reads.push_back({{(const uint8_t *)keys[i].data(), int(keys[i].size())},
                        {nullptr, 0},
                        version - kWindowSize});
     }
-    results.resize(reads.size());
-
-    cs->check(reads.data(), results.data(), reads.size());
-    bool ok = true;
-    for (auto result : results) {
-      ok &= result == weaselab::ConflictSet::Commit;
-    }
-    cs->addWrites(writes.data(), ok ? writes.size() : 0, version);
-    cs->setOldestVersion(version - kWindowSize);
-    ++version;
   }
-}
+
+  Transaction(Transaction &&) = default;
+  Transaction &operator=(Transaction &&) = default;
+  Transaction(Transaction const &) = delete;
+  Transaction const &operator=(Transaction const &) = delete;
+};
+
+struct Resolver {
+
+  void resolve(const weaselab::ConflictSet::ReadRange *reads, int readCount,
+               const weaselab::ConflictSet::WriteRange *writes, int writeCount,
+               int64_t newVersion, int64_t newOldestVersion) {
+    results.resize(readCount);
+    cs.check(reads, results.data(), readCount);
+    cs.addWrites(writes, writeCount, newVersion);
+    cs.setOldestVersion(newOldestVersion);
+  }
+
+  ConflictSet cs{0};
+
+private:
+  std::vector<weaselab::ConflictSet::Result> results;
+};
 
 // Adapted from getaddrinfo man page
 int getListenFd(const char *node, const char *service) {
@@ -251,7 +366,8 @@ int main(int argc, char **argv) {
   {
     int listenFd = getListenFd(argv[1], argv[2]);
 
-    weaselab::ConflictSet cs{0};
+    Resolver resolver;
+    auto &cs = resolver.cs;
     weaselab::ConflictSet::MetricsV1 *metrics;
     int metricsCount;
     cs.getMetricsV1(&metrics, &metricsCount);
@@ -300,7 +416,22 @@ int main(int argc, char **argv) {
     }
 #endif
 
-    auto w = std::thread{workload, &cs};
+    TxQueue<Transaction> queue{10};
+
+    auto workloadThread = std::thread{[&]() {
+      for (int64_t version = kWindowSize;;
+           ++version, transactions.fetch_add(1, std::memory_order_relaxed)) {
+        queue.push(Transaction(version));
+      }
+    }};
+
+    auto resolverThread = std::thread{[&]() {
+      for (;;) {
+        auto tx = queue.pop();
+        resolver.resolve(tx->reads.data(), tx->reads.size(), tx->writes.data(),
+                         tx->writes.size(), tx->version, tx->oldestVersion);
+      }
+    }};
 
     for (;;) {
       struct sockaddr_storage peer_addr = {};

SkipList.cpp

@@ -796,7 +796,6 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
     int temp[stripeSize];
     int stripes = (stringCount + stripeSize - 1) / stripeSize;
     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--) {

apple-symbol-imports.txt

@@ -1,3 +1,4 @@
+___chkstk_darwin
 ___stack_chk_fail
 ___stack_chk_guard
 __tlv_bootstrap
@@ -5,6 +6,7 @@ _abort
 _bzero
 _free
 _malloc
+_memcmp
 _memcpy
 _memmove
 dyld_stub_binder

package_macos.sh

@@ -8,7 +8,7 @@ SRC_DIR="${0%/*}"
 BUILD_ARM="$(mktemp -d -t conflict-set-arm)"
 BUILD_X86="$(mktemp -d -t conflict-set-x86)"
 
-cmake_args=(-DCMAKE_CXX_FLAGS=-DNVALGRIND -DCPACK_PACKAGING_INSTALL_PREFIX=/usr/local)
+cmake_args=(-DCMAKE_CXX_FLAGS=-DNVALGRIND -DCPACK_PACKAGING_INSTALL_PREFIX=/usr/local -DCMAKE_CXX_COMPILER=/opt/homebrew/opt/llvm/bin/clang++)
 
 cmake -S"$SRC_DIR" -B"$BUILD_ARM" -DCMAKE_OSX_ARCHITECTURES=arm64 "${cmake_args[@]}"
 cmake --build "$BUILD_ARM" --target conflict-set --target conflict-set-static