Use clang for building packages

Would be great to find a way to make this all more readable

Bench.cpp

@@ -7,7 +7,6 @@
 void showMemory(const ConflictSet &cs);
 #endif
 
-#define ANKERL_NANOBENCH_IMPLEMENT
 #include "third_party/nanobench.h"
 
 constexpr int kNumKeys = 1000000;
@@ -333,16 +332,22 @@ void benchWorstCaseForRadixRangeRead() {
   auto end = std::vector<uint8_t>(kKeyLenForWorstCase - 1, 255);
   end.push_back(254);
 
-  weaselab::ConflictSet::Result result;
-  weaselab::ConflictSet::ReadRange r{
-      {begin.data(), int(begin.size())}, {end.data(), int(end.size())}, 0};
+  weaselab::ConflictSet::ReadRange r[] = {
+      {{begin.data(), int(begin.size())}, {end.data(), int(end.size())}, 0},
+  };
+  weaselab::ConflictSet::Result results[sizeof(r) / sizeof(r[0])];
+  for (auto &result : results) {
+    result = weaselab::ConflictSet::TooOld;
+  }
+  bench.batch(sizeof(r) / sizeof(r[0]));
 
   bench.run("worst case for radix tree", [&]() {
     for (int i = 0; i < 256; ++i) {
-      result = weaselab::ConflictSet::TooOld;
-      cs[i]->check(&r, &result, 1);
-      if (result != weaselab::ConflictSet::Commit) {
-        abort();
+      cs[i]->check(r, results, sizeof(r) / sizeof(r[0]));
+      for (auto result : results) {
+        if (result != weaselab::ConflictSet::Commit) {
+          abort();
+        }
       }
     }
   });

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.18)
 project(
   conflict-set
-  VERSION 0.0.13
+  VERSION 0.0.14
   DESCRIPTION
     "A data structure for optimistic concurrency control on ranges of bitwise-lexicographically-ordered keys."
   HOMEPAGE_URL "https://git.weaselab.dev/weaselab/conflict-set"
@@ -72,12 +72,6 @@ else()
   add_link_options(-Wl,--gc-sections)
 endif()
 
-if(EMSCRIPTEN)
-  # https://github.com/emscripten-core/emscripten/issues/15377#issuecomment-1285167486
-  add_link_options(-lnodefs.js -lnoderawfs.js)
-  add_link_options(-s ALLOW_MEMORY_GROWTH)
-endif()
-
 if(NOT USE_SIMD_FALLBACK)
   cmake_push_check_state()
   list(APPEND CMAKE_REQUIRED_FLAGS -mavx)
@@ -101,12 +95,23 @@ target_compile_options(${PROJECT_NAME}-object PRIVATE -fno-exceptions
                                                       -fvisibility=hidden)
 target_include_directories(${PROJECT_NAME}-object
                            PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+if(NOT LD_EXE)
+  set(LD_EXE ld)
+endif()
+add_custom_command(
+  OUTPUT ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.o
+  COMMAND ${LD_EXE} -r $<TARGET_OBJECTS:${PROJECT_NAME}-object> -o
+          ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.o
+  DEPENDS $<TARGET_OBJECTS:${PROJECT_NAME}-object>
+  COMMAND_EXPAND_LISTS)
 
-add_library(${PROJECT_NAME} SHARED $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
+add_library(${PROJECT_NAME} SHARED ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.o)
 set_target_properties(
   ${PROJECT_NAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY
                              "${CMAKE_CURRENT_BINARY_DIR}/radix_tree")
-if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
+if(CMAKE_BUILD_TYPE STREQUAL Debug)
+  set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE CXX)
+else()
   set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE C)
 endif()
 
@@ -116,19 +121,13 @@ if(HAS_VERSION_SCRIPT)
     LINKER:--version-script=${CMAKE_CURRENT_SOURCE_DIR}/linker.map)
 endif()
 
-add_library(${PROJECT_NAME}-static STATIC
-            $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
-if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
+add_library(${PROJECT_NAME}-static STATIC ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.o)
+if(CMAKE_BUILD_TYPE STREQUAL Debug)
+  set_target_properties(${PROJECT_NAME}-static PROPERTIES LINKER_LANGUAGE CXX)
+else()
   set_target_properties(${PROJECT_NAME}-static PROPERTIES LINKER_LANGUAGE C)
 endif()
-
-if(APPLE)
-  add_custom_command(
-    TARGET ${PROJECT_NAME}-static
-    PRE_LINK
-    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/privatize_symbols_macos.sh
-            $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
-else()
+if(NOT APPLE)
   add_custom_command(
     TARGET ${PROJECT_NAME}-static
     POST_BUILD
@@ -144,6 +143,8 @@ include(CTest)
 # disable tests if this is being used through e.g. FetchContent
 if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
 
+  add_library(nanobench ${CMAKE_CURRENT_SOURCE_DIR}/nanobench.cpp)
+
   set(TEST_FLAGS -Wall -Wextra -Wunreachable-code -Wpedantic -UNDEBUG)
 
   # corpus tests, which are tests curated by libfuzzer. The goal is to get broad
@@ -181,16 +182,20 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
   target_compile_options(driver_skip_list PRIVATE ${TEST_FLAGS})
   target_link_libraries(driver_skip_list PRIVATE skip_list)
 
-  foreach(TEST ${CORPUS_TESTS})
-    get_filename_component(hash ${TEST} NAME)
-    add_test(NAME skip_list_${hash} COMMAND driver_skip_list ${TEST})
-  endforeach()
+  # enable to test skip list
+  if(0)
+    foreach(TEST ${CORPUS_TESTS})
+      get_filename_component(hash ${TEST} NAME)
+      add_test(NAME skip_list_${hash} COMMAND driver_skip_list ${TEST})
+    endforeach()
+  endif()
 
   # ad hoc testing
   add_executable(conflict_set_main ConflictSet.cpp)
   target_include_directories(conflict_set_main
                              PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
   target_compile_definitions(conflict_set_main PRIVATE ENABLE_MAIN)
+  target_link_libraries(conflict_set_main PRIVATE nanobench)
 
   if(NOT APPLE)
     # libfuzzer target, to generate/manage corpus
@@ -251,6 +256,19 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
     add_test(NAME conflict_set_blackbox_${hash} COMMAND driver ${TEST})
   endforeach()
 
+  find_program(VALGRIND_EXE valgrind)
+  if(VALGRIND_EXE AND NOT CMAKE_CROSSCOMPILING)
+    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()
+
   # scripted tests. Written manually to fill in anything libfuzzer couldn't
   # find.
   if(NOT CMAKE_CROSSCOMPILING)
@@ -271,19 +289,14 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
           ${Python3_EXECUTABLE}
           ${CMAKE_CURRENT_SOURCE_DIR}/test_conflict_set.py test ${TEST}
           --build-dir ${CMAKE_CURRENT_BINARY_DIR})
-    endforeach()
-  endif()
-
-  find_program(VALGRIND_EXE valgrind)
-  if(VALGRIND_EXE AND NOT CMAKE_CROSSCOMPILING)
-    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})
+      if(VALGRIND_EXE AND NOT CMAKE_CROSSCOMPILING)
+        add_test(
+          NAME script_test_${TEST}_valgrind
+          COMMAND
+            ${VALGRIND_EXE} ${Python3_EXECUTABLE}
+            ${CMAKE_CURRENT_SOURCE_DIR}/test_conflict_set.py test ${TEST}
+            --build-dir ${CMAKE_CURRENT_BINARY_DIR})
+      endif()
     endforeach()
   endif()
 
@@ -336,7 +349,7 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
 
   # bench
   add_executable(conflict_set_bench Bench.cpp)
-  target_link_libraries(conflict_set_bench PRIVATE ${PROJECT_NAME})
+  target_link_libraries(conflict_set_bench PRIVATE ${PROJECT_NAME} nanobench)
   set_target_properties(conflict_set_bench PROPERTIES SKIP_BUILD_RPATH ON)
   add_executable(real_data_bench RealDataBench.cpp)
   target_link_libraries(real_data_bench PRIVATE ${PROJECT_NAME})
@@ -351,6 +364,14 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
   add_executable(server_bench ServerBench.cpp)
   target_link_libraries(server_bench PRIVATE ${PROJECT_NAME})
   set_target_properties(server_bench PROPERTIES SKIP_BUILD_RPATH ON)
+
+  add_executable(interleaving_test InterleavingTest.cpp)
+  # work around lack of musttail for gcc
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_BUILD_TYPE STREQUAL "Debug")
+    target_compile_options(interleaving_test PRIVATE -Og
+                                                     -foptimize-sibling-calls)
+  endif()
+  target_link_libraries(interleaving_test PRIVATE nanobench)
 endif()
 
 # packaging

Dockerfile

@@ -8,6 +8,7 @@ RUN chmod -R 777 /tmp
 RUN apt-get update
 RUN apt-get upgrade -y
 RUN TZ=America/Los_Angeles DEBIAN_FRONTEND=noninteractive apt-get install -y \
+    binutils-aarch64-linux-gnu \
     build-essential \
     ccache \
     clang \

InterleavingTest.cpp

@@ -0,0 +1,256 @@
+#include <alloca.h>
+#include <cassert>
+#ifdef __x86_64__
+#include <immintrin.h>
+#endif
+
+#include "third_party/nanobench.h"
+
+struct Job {
+  int *input;
+  // Returned void* is a function pointer to the next continuation. We have to
+  // use void* because otherwise the type would be recursive.
+  typedef void *(*continuation)(Job *);
+  continuation next;
+};
+
+void *stepJob(Job *j) {
+  auto done = --(*j->input) == 0;
+#ifdef __x86_64__
+  _mm_clflush(j->input);
+#endif
+  return done ? nullptr : (void *)stepJob;
+}
+
+void sequential(Job **jobs, int count) {
+  for (int i = 0; i < count; ++i) {
+    do {
+      jobs[i]->next = (Job::continuation)jobs[i]->next(jobs[i]);
+    } while (jobs[i]->next);
+  }
+}
+
+void sequentialNoFuncPtr(Job **jobs, int count) {
+  for (int i = 0; i < count; ++i) {
+    while (stepJob(jobs[i]))
+      ;
+  }
+}
+
+void interleaveSwapping(Job **jobs, int remaining) {
+  int current = 0;
+  while (remaining > 0) {
+    auto next = (Job::continuation)jobs[current]->next(jobs[current]);
+    jobs[current]->next = next;
+    if (next == nullptr) {
+      jobs[current] = jobs[remaining - 1];
+      --remaining;
+    } else {
+      ++current;
+    }
+    if (current == remaining) {
+      current = 0;
+    }
+  }
+}
+
+void interleaveBoundedCyclicList(Job **jobs, int count) {
+  if (count == 0) {
+    return;
+  }
+
+  constexpr int kConcurrent = 32;
+  Job *inProgress[kConcurrent];
+  int nextJob[kConcurrent];
+
+  int started = std::min(kConcurrent, count);
+  for (int i = 0; i < started; i++) {
+    inProgress[i] = jobs[i];
+    nextJob[i] = i + 1;
+  }
+  nextJob[started - 1] = 0;
+
+  int prevJob = started - 1;
+  int job = 0;
+  for (;;) {
+    auto next = (Job::continuation)inProgress[job]->next(inProgress[job]);
+    inProgress[job]->next = next;
+    if (next == nullptr) {
+      if (started == count) {
+        if (prevJob == job)
+          break;
+        nextJob[prevJob] = nextJob[job];
+        job = prevJob;
+      } else {
+        int temp = started++;
+        inProgress[job] = jobs[temp];
+      }
+    }
+    prevJob = job;
+    job = nextJob[job];
+  }
+}
+
+#ifndef __has_attribute
+#define __has_attribute(x) 0
+#endif
+
+#if __has_attribute(musttail)
+#define MUSTTAIL __attribute__((musttail))
+#else
+#define MUSTTAIL
+#endif
+
+struct Context {
+  constexpr static int kConcurrent = 32;
+  Job **jobs;
+  Job *inProgress[kConcurrent];
+  void (*continuation[kConcurrent])(Context *, int64_t prevJob, int64_t job,
+                                    int64_t started, int64_t count);
+  int nextJob[kConcurrent];
+};
+
+void keepGoing(Context *context, int64_t prevJob, int64_t job, int64_t started,
+               int64_t count) {
+  prevJob = job;
+  job = context->nextJob[job];
+  MUSTTAIL return context->continuation[job](context, prevJob, job, started,
+                                             count);
+}
+
+void stepJobTailCall(Context *context, int64_t prevJob, int64_t job,
+                     int64_t started, int64_t count);
+
+void complete(Context *context, int64_t prevJob, int64_t job, int64_t started,
+              int64_t count) {
+  if (started == count) {
+    if (prevJob == job) {
+      return;
+    }
+    context->nextJob[prevJob] = context->nextJob[job];
+    job = prevJob;
+  } else {
+    context->inProgress[job] = context->jobs[started++];
+    context->continuation[job] = stepJobTailCall;
+  }
+  prevJob = job;
+  job = context->nextJob[job];
+  MUSTTAIL return context->continuation[job](context, prevJob, job, started,
+                                             count);
+}
+
+void stepJobTailCall(Context *context, int64_t prevJob, int64_t job,
+                     int64_t started, int64_t count) {
+  auto *j = context->inProgress[job];
+  auto done = --(*j->input) == 0;
+#ifdef __x86_64__
+  _mm_clflush(j->input);
+#endif
+  if (done) {
+    MUSTTAIL return complete(context, prevJob, job, started, count);
+  } else {
+    context->continuation[job] = stepJobTailCall;
+    MUSTTAIL return keepGoing(context, prevJob, job, started, count);
+  }
+}
+
+void useTailCalls(Job **jobs, int count) {
+  if (count == 0) {
+    return;
+  }
+  Context context;
+  context.jobs = jobs;
+  int64_t started = std::min(Context::kConcurrent, count);
+  for (int i = 0; i < started; i++) {
+    context.inProgress[i] = jobs[i];
+    context.nextJob[i] = i + 1;
+    context.continuation[i] = stepJobTailCall;
+  }
+  context.nextJob[started - 1] = 0;
+  int prevJob = started - 1;
+  int job = 0;
+  return context.continuation[job](&context, prevJob, job, started, count);
+}
+
+void interleaveCyclicList(Job **jobs, int count) {
+  auto *nextJob = (int *)alloca(sizeof(int) * count);
+
+  for (int i = 0; i < count - 1; ++i) {
+    nextJob[i] = i + 1;
+  }
+  nextJob[count - 1] = 0;
+
+  int prevJob = count - 1;
+  int job = 0;
+  for (;;) {
+    auto next = (Job::continuation)jobs[job]->next(jobs[job]);
+    jobs[job]->next = next;
+    if (next == nullptr) {
+      if (prevJob == job)
+        break;
+      nextJob[prevJob] = nextJob[job];
+      job = prevJob;
+    }
+    prevJob = job;
+    job = nextJob[job];
+  }
+}
+
+int main() {
+  ankerl::nanobench::Bench bench;
+
+  constexpr int kNumJobs = 10000;
+  bench.relative(true);
+
+  Job jobs[kNumJobs];
+  Job jobsCopy[kNumJobs];
+  int iters = 0;
+  int originalInput[kNumJobs];
+  for (int i = 0; i < kNumJobs; ++i) {
+    originalInput[i] = rand() % 5 + 3;
+    jobs[i].input = new int{originalInput[i]};
+    jobs[i].next = stepJob;
+    iters += *jobs[i].input;
+  }
+  bench.batch(iters);
+
+  for (auto [scheduler, name] :
+       {std::make_pair(sequentialNoFuncPtr, "sequentialNoFuncPtr"),
+        std::make_pair(sequential, "sequential"),
+        std::make_pair(useTailCalls, "useTailCalls"),
+        std::make_pair(interleaveSwapping, "interleavingSwapping"),
+        std::make_pair(interleaveBoundedCyclicList,
+                       "interleaveBoundedCyclicList"),
+        std::make_pair(interleaveCyclicList, "interleaveCyclicList")}) {
+    for (int i = 0; i < kNumJobs; ++i) {
+      *jobs[i].input = originalInput[i];
+    }
+    memcpy(jobsCopy, jobs, sizeof(jobs));
+    Job *ps[kNumJobs];
+    for (int i = 0; i < kNumJobs; ++i) {
+      ps[i] = jobsCopy + i;
+    }
+    scheduler(ps, kNumJobs);
+    for (int i = 0; i < kNumJobs; ++i) {
+      if (*jobsCopy[i].input != 0) {
+        fprintf(stderr, "%s failed\n", name);
+        abort();
+      }
+    }
+
+    bench.run(name, [&]() {
+      for (int i = 0; i < kNumJobs; ++i) {
+        *jobs[i].input = originalInput[i];
+      }
+      memcpy(jobsCopy, jobs, sizeof(jobs));
+      Job *ps[kNumJobs];
+      for (int i = 0; i < kNumJobs; ++i) {
+        ps[i] = jobsCopy + i;
+      }
+      scheduler(ps, kNumJobs);
+    });
+  }
+  for (int i = 0; i < kNumJobs; ++i) {
+    delete jobs[i].input;
+  }
+}

Internal.h

@@ -538,7 +538,7 @@ struct ReferenceImpl {
 
 using Key = ConflictSet::Key;
 
-inline Key operator"" _s(const char *str, size_t size) {
+inline Key operator""_s(const char *str, size_t size) {
   return {reinterpret_cast<const uint8_t *>(str), int(size)};
 }
 

Jenkinsfile

@@ -81,7 +81,7 @@ pipeline {
                 CleanBuildAndTest("-DUSE_SIMD_FALLBACK=ON")
             }
         }
-        stage('Release [gcc]') {
+        stage('Release [clang]') {
             agent {
                 dockerfile {
                     args '-v /home/jenkins/ccache:/ccache'
@@ -89,8 +89,8 @@ pipeline {
                 }
             }
             steps {
-                CleanBuildAndTest("-DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_CXX_FLAGS=-DNVALGRIND")
-                recordIssues(tools: [gcc()])
+                CleanBuildAndTest("-DCMAKE_CXX_FLAGS=-DNVALGRIND")
+                recordIssues(tools: [clang()])
                 sh '''
                 cd build
                 cpack -G DEB
@@ -103,7 +103,19 @@ 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,aarch64]') {
+        stage('Release [gcc]') {
+            agent {
+                dockerfile {
+                    args '-v /home/jenkins/ccache:/ccache'
+                    reuseNode true
+                }
+            }
+            steps {
+                CleanBuildAndTest("-DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_CXX_FLAGS=-DNVALGRIND")
+                recordIssues(tools: [gcc()])
+            }
+        }
+        stage('Release [clang,aarch64]') {
             agent {
                 dockerfile {
                     args '-v /home/jenkins/ccache:/ccache'
@@ -129,7 +141,7 @@ pipeline {
             }
             steps {
                 script {
-                    filter_args = "-f ConflictSet.cpp -f LongestCommonPrefix.h"
+                    filter_args = "-f ConflictSet.cpp -f LongestCommonPrefix.h -f Metrics.h"
                 }
                 CleanBuildAndTest("-DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_C_FLAGS=--coverage -DCMAKE_CXX_FLAGS=--coverage -DCMAKE_BUILD_TYPE=Debug -DDISABLE_TSAN=ON")
                 sh """

Metrics.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "ConflictSet.h"
+#include "Internal.h"
+
+#include <assert.h>
+#include <atomic>
+#include <tuple>
+
+struct Metric {
+  Metric *prev;
+  const char *name;
+  const char *help;
+  weaselab::ConflictSet::MetricsV1::Type type;
+  std::atomic<int64_t> value;
+
+protected:
+  Metric(Metric *&metricList, int &metricsCount, const char *name,
+         const char *help, weaselab::ConflictSet::MetricsV1::Type type)
+      : prev(std::exchange(metricList, this)), name(name), help(help),
+        type(type), value(0) {
+    ++metricsCount;
+  }
+};
+
+struct Gauge : private Metric {
+  Gauge(Metric *&metricList, int &metricsCount, const char *name,
+        const char *help)
+      : Metric(metricList, metricsCount, name, help,
+               weaselab::ConflictSet::MetricsV1::Gauge) {}
+
+  void set(int64_t value) {
+    this->value.store(value, std::memory_order_relaxed);
+  }
+};
+
+struct Counter : private Metric {
+  Counter(Metric *&metricList, int &metricsCount, const char *name,
+          const char *help)
+      : Metric(metricList, metricsCount, name, help,
+               weaselab::ConflictSet::MetricsV1::Counter) {}
+  // Expensive. Accumulate locally and then call add instead of repeatedly
+  // calling add.
+  void add(int64_t value) {
+    assert(value >= 0);
+    static_assert(std::atomic<int64_t>::is_always_lock_free);
+    this->value.fetch_add(value, std::memory_order_relaxed);
+  }
+};
+
+inline weaselab::ConflictSet::MetricsV1 *initMetrics(Metric *metricsList,
+                                                     int metricsCount) {
+  weaselab::ConflictSet::MetricsV1 *metrics =
+      (weaselab::ConflictSet::MetricsV1 *)safe_malloc(metricsCount *
+                                                      sizeof(metrics[0]));
+  for (auto [i, m] = std::make_tuple(metricsCount - 1, metricsList); i >= 0;
+       --i, m = m->prev) {
+    metrics[i].name = m->name;
+    metrics[i].help = m->help;
+    metrics[i].p = m;
+    metrics[i].type = m->type;
+  }
+  return metrics;
+}

README.md

@@ -24,15 +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
 |--------------------:|--------------------:|--------:|----------------:|----------------:|-------:|---------------:|--------:|----------:|:----------
-|               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`
+|               12.88 |       77,653,350.77 |    0.5% |          185.37 |           64.45 |  2.876 |          41.51 |    0.4% |      0.01 | `point reads`
+|               14.67 |       68,179,354.49 |    0.1% |          271.44 |           73.40 |  3.698 |          53.70 |    0.3% |      0.01 | `prefix reads`
+|               34.84 |       28,701,444.36 |    0.3% |          715.74 |          175.27 |  4.084 |         127.30 |    0.2% |      0.01 | `range reads`
+|               17.12 |       58,422,988.28 |    0.2% |          314.30 |           86.11 |  3.650 |          39.82 |    0.4% |      0.01 | `point writes`
+|               31.42 |       31,830,804.65 |    0.1% |          591.06 |          158.07 |  3.739 |          82.67 |    0.2% |      0.01 | `prefix writes`
+|               37.37 |       26,759,432.70 |    2.2% |          681.98 |          188.95 |  3.609 |          96.10 |    0.1% |      0.01 | `range writes`
+|               76.72 |       13,035,140.63 |    2.3% |        1,421.28 |          387.17 |  3.671 |         257.76 |    0.1% |      0.01 | `monotonic increasing point writes`
+|          297,452.00 |            3,361.89 |    0.9% |    3,508,083.00 |    1,500,834.67 |  2.337 |     727,525.33 |    0.1% |      0.01 | `worst case for radix tree`
+|               87.70 |       11,402,490.60 |    1.0% |        1,795.00 |          442.09 |  4.060 |         297.00 |    0.0% |      0.01 | `create and destroy`
 
 # "Real data" test
 

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 = 32;
 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));
-  memset(result.data(), 0, kBaseSearchDepth);
+  result.resize(sizeof(int64_t) + suffixLen);
   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
-    {
-      auto beginK = numToKey(version - kWindowSize);
-      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();
-      //   }
-      // }
+    std::vector<std::string> keys(kNumReads);
+    for (auto &k : keys) {
+      k = makeKey(rand() % kNumPrefixes, 49);
     }
-    // Writes
-    {
-      weaselab::ConflictSet::WriteRange w;
-      auto k = numToKey(version);
-      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) {
-          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);
-      }
+    std::vector<weaselab::ConflictSet::ReadRange> reads(kNumReads);
+    for (int i = 0; i < reads.size(); ++i) {
+      reads[i].begin.p = (const uint8_t *)(keys[i].data());
+      reads[i].begin.len = keys[i].size();
+      reads[i].end.len = 0;
+      reads[i].readVersion = version - 1;
     }
-    // GC
-    cs->setOldestVersion(version - kWindowSize);
-    ++version;
+    cs->check(reads.data(), results.data(), kNumReads);
   }
 }
 

SkipList.cpp

@@ -22,6 +22,7 @@
 
 #include "ConflictSet.h"
 #include "Internal.h"
+#include "Metrics.h"
 
 #include <algorithm>
 #include <span>
@@ -434,13 +435,14 @@ public:
     return result;
   }
 
-  void detectConflicts(ReadConflictRange *ranges, int count,
-                       ConflictSet::Result *transactionConflictStatus) const {
+  // Return number of iterations of main loop
+  int detectConflicts(ReadConflictRange *ranges, int count,
+                      ConflictSet::Result *transactionConflictStatus) const {
     const int M = 16;
     int nextJob[M];
     CheckMax inProgress[M];
     if (!count)
-      return;
+      return 0;
 
     int started = std::min(M, count);
     for (int i = 0; i < started; i++) {
@@ -451,8 +453,9 @@ public:
 
     int prevJob = started - 1;
     int job = 0;
+    int iters = 0;
     // vtune: 340 parts
-    while (true) {
+    for (;; ++iters) {
       if (inProgress[job].advance()) {
         if (started == count) {
           if (prevJob == job)
@@ -468,6 +471,7 @@ public:
       prevJob = job;
       job = nextJob[job];
     }
+    return iters;
   }
 
   void find(const StringRef *values, Finger *results, int *temp, int count) {
@@ -702,15 +706,27 @@ private:
   };
 };
 
+struct ReadContext {
+  int64_t commits_accum = 0;
+  int64_t conflicts_accum = 0;
+  int64_t too_olds_accum = 0;
+  int64_t check_bytes_accum = 0;
+};
+
 struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
   Impl(int64_t oldestVersion)
       : oldestVersion(oldestVersion), newestVersion(oldestVersion),
-        skipList(oldestVersion) {}
+        skipList(oldestVersion) {
+    metrics = initMetrics(metricsList, metricsCount);
+  }
+  ~Impl() { safe_free(metrics, metricsCount * sizeof(metrics[0])); }
   void check(const ConflictSet::ReadRange *reads, ConflictSet::Result *results,
-             int count) const {
+             int count) {
+    ReadContext tls;
     Arena arena;
     auto *ranges = new (arena) ReadConflictRange[count];
     for (int i = 0; i < count; ++i) {
+      tls.check_bytes_accum += reads[i].begin.len + reads[i].end.len;
       ranges[i].begin = {reads[i].begin.p, size_t(reads[i].begin.len)};
       ranges[i].end = reads[i].end.len > 0
                           ? StringRef{reads[i].end.p, size_t(reads[i].end.len)}
@@ -718,13 +734,22 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
       ranges[i].version = reads[i].readVersion;
       results[i] = ConflictSet::Commit;
     }
-    skipList.detectConflicts(ranges, count, results);
+    int iters = skipList.detectConflicts(ranges, count, results);
     for (int i = 0; i < count; ++i) {
       if (reads[i].readVersion < oldestVersion ||
           reads[i].readVersion < newestVersion - 2e9) {
         results[i] = TooOld;
       }
+      tls.commits_accum += results[i] == Commit;
+      tls.conflicts_accum += results[i] == Conflict;
+      tls.too_olds_accum += results[i] == TooOld;
     }
+    range_read_iterations_total.add(iters);
+    range_read_total.add(count);
+    commits_total.add(tls.commits_accum);
+    conflicts_total.add(tls.conflicts_accum);
+    too_olds_total.add(tls.too_olds_accum);
+    check_bytes_total.add(tls.check_bytes_accum);
   }
 
   void addWrites(const ConflictSet::WriteRange *writes, int count,
@@ -788,6 +813,9 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
   }
 
   void setOldestVersion(int64_t oldestVersion) {
+    // This isn't 100% accurate. It overcounts if you hit the end
+    gc_iterations_total.add(keyUpdates);
+
     assert(oldestVersion >= this->oldestVersion);
     this->oldestVersion = oldestVersion;
     SkipList::Finger finger;
@@ -802,6 +830,54 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
 
   int64_t totalBytes = 0;
 
+  MetricsV1 *metrics;
+  int metricsCount = 0;
+  Metric *metricsList = nullptr;
+
+#define GAUGE(name, help)                                                      \
+  Gauge name { metricsList, metricsCount, #name, help }
+#define COUNTER(name, help)                                                    \
+  Counter name { metricsList, metricsCount, #name, help }
+  // ==================== METRICS DEFINITIONS ====================
+  COUNTER(range_read_total, "Total number of range reads checked");
+  COUNTER(range_read_iterations_total,
+          "Total number of iterations of the main loops for range read checks");
+  COUNTER(commits_total,
+          "Total number of checks where the result is \"commit\"");
+  COUNTER(conflicts_total,
+          "Total number of checks where the result is \"conflict\"");
+  COUNTER(too_olds_total,
+          "Total number of checks where the result is \"too old\"");
+  COUNTER(check_bytes_total, "Total number of key bytes checked");
+  GAUGE(memory_bytes, "Total number of bytes in use");
+  COUNTER(nodes_allocated_total,
+          "The total number of physical tree nodes allocated");
+  COUNTER(nodes_released_total,
+          "The total number of physical tree nodes released");
+  COUNTER(insert_iterations_total,
+          "The total number of iterations of the main loop for insertion. "
+          "Includes searches where the entry already existed, and so insertion "
+          "did not take place");
+  COUNTER(entries_inserted_total,
+          "The total number of entries inserted in the tree");
+  COUNTER(entries_erased_total,
+          "The total number of entries erased from the tree");
+  COUNTER(
+      gc_iterations_total,
+      "The total number of iterations of the main loop for garbage collection");
+  COUNTER(write_bytes_total, "Total number of key bytes in calls to addWrites");
+  GAUGE(oldest_version,
+        "The lowest version that doesn't result in \"TooOld\" for checks");
+  GAUGE(newest_version, "The version of the most recent call to addWrites");
+  // ==================== END METRICS DEFINITIONS ====================
+#undef GAUGE
+#undef COUNTER
+
+  void getMetricsV1(MetricsV1 **metrics, int *count) {
+    *metrics = this->metrics;
+    *count = metricsCount;
+  }
+
 private:
   int64_t keyUpdates = 0;
   Arena removalArena;
@@ -824,6 +900,7 @@ void internal_addWrites(ConflictSet::Impl *impl,
   mallocBytesDelta = 0;
   impl->addWrites(writes, count, writeVersion);
   impl->totalBytes += mallocBytesDelta;
+  impl->memory_bytes.set(impl->totalBytes);
 #if SHOW_MEMORY
   if (impl->totalBytes != mallocBytes) {
     abort();
@@ -835,6 +912,7 @@ void internal_setOldestVersion(ConflictSet::Impl *impl, int64_t oldestVersion) {
   mallocBytesDelta = 0;
   impl->setOldestVersion(oldestVersion);
   impl->totalBytes += mallocBytesDelta;
+  impl->memory_bytes.set(impl->totalBytes);
 #if SHOW_MEMORY
   if (impl->totalBytes != mallocBytes) {
     abort();
@@ -858,12 +936,11 @@ int64_t internal_getBytes(ConflictSet::Impl *impl) { return impl->totalBytes; }
 
 void internal_getMetricsV1(ConflictSet::Impl *impl,
                            ConflictSet::MetricsV1 **metrics, int *count) {
-  *metrics = nullptr;
-  *count = 0;
+  return impl->getMetricsV1(metrics, count);
 }
 
 double internal_getMetricValue(const ConflictSet::MetricsV1 *metric) {
-  return 0;
+  return ((Metric *)metric->p)->value.load(std::memory_order_relaxed);
 }
 
 void ConflictSet::check(const ReadRange *reads, Result *results,

aarch64-toolchain.cmake

@@ -1,7 +1,8 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(CMAKE_SYSTEM_PROCESSOR aarch64)
-set(CMAKE_C_COMPILER "/usr/bin/aarch64-linux-gnu-gcc")
-set(CMAKE_CXX_COMPILER "/usr/bin/aarch64-linux-gnu-g++")
+set(CMAKE_C_COMPILER "clang;--target=aarch64-linux-gnu")
+set(CMAKE_CXX_COMPILER "clang++;--target=aarch64-linux-gnu")
 set(CMAKE_FIND_ROOT_PATH /usr/aarch64-linux-gnu)
 set(CMAKE_CROSSCOMPILING_EMULATOR "qemu-aarch64;-L;/usr/aarch64-linux-gnu/")
 set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE arm64)
+set(LD_EXE "/usr/bin/aarch64-linux-gnu-ld")