Remove redundant cast

Bench.cpp

@@ -17,26 +17,26 @@ constexpr int kPrefixLen = 0;
 
 constexpr int kMvccWindow = 100000;
 
-TrivialSpan makeKey(Arena &arena, int index) {
+std::span<const uint8_t> makeKey(Arena &arena, int index) {
 
-  uint8_t *buf = new (arena) uint8_t[4 + kPrefixLen];
-  auto result = TrivialSpan{buf, 4 + kPrefixLen};
+  auto result =
+      std::span<uint8_t>{new (arena) uint8_t[4 + kPrefixLen], 4 + kPrefixLen};
   index = __builtin_bswap32(index);
-  memset(buf, 0, kPrefixLen);
-  memcpy(buf, &index, 4);
+  memset(result.data(), 0, kPrefixLen);
+  memcpy(result.data() + kPrefixLen, &index, 4);
 
   return result;
 }
 
-ConflictSet::ReadRange singleton(Arena &arena, TrivialSpan key) {
-  uint8_t *buf = new (arena) uint8_t[key.size() + 1];
-  auto r = TrivialSpan(buf, key.size() + 1);
-  memcpy(buf, key.data(), key.size());
-  buf[key.size()] = 0;
+ConflictSet::ReadRange singleton(Arena &arena, std::span<const uint8_t> key) {
+  auto r =
+      std::span<uint8_t>(new (arena) uint8_t[key.size() + 1], key.size() + 1);
+  memcpy(r.data(), key.data(), key.size());
+  r[key.size()] = 0;
   return {{key.data(), int(key.size())}, {r.data(), int(r.size())}, 0};
 }
 
-ConflictSet::ReadRange prefixRange(Arena &arena, TrivialSpan key) {
+ConflictSet::ReadRange prefixRange(Arena &arena, std::span<const uint8_t> key) {
   int index;
   for (index = key.size() - 1; index >= 0; index--)
     if ((key[index]) != 255)
@@ -48,10 +48,9 @@ ConflictSet::ReadRange prefixRange(Arena &arena, TrivialSpan key) {
     assert(false);
   }
 
-  uint8_t *buf = new (arena) uint8_t[index + 1];
-  auto r = TrivialSpan(buf, index + 1);
-  memcpy(buf, key.data(), index + 1);
-  buf[r.size() - 1]++;
+  auto r = std::span<uint8_t>(new (arena) uint8_t[index + 1], index + 1);
+  memcpy(r.data(), key.data(), index + 1);
+  r[r.size() - 1]++;
   return {{key.data(), int(key.size())}, {r.data(), int(r.size())}, 0};
 }
 
@@ -82,7 +81,14 @@ void benchConflictSet() {
     ++version;
   }
 
-  auto points = set<TrivialSpan, std::less<>>(arena);
+  // I don't know why std::less didn't work /shrug
+  struct Less {
+    bool operator()(const std::span<const uint8_t> &lhs,
+                    const std::span<const uint8_t> &rhs) const {
+      return lhs < rhs;
+    }
+  };
+  auto points = set<std::span<const uint8_t>, Less>(arena);
 
   while (points.size() < kOpsPerTx * 2 + 1) {
     // TODO don't use rand?
@@ -326,22 +332,16 @@ void benchWorstCaseForRadixRangeRead() {
   auto end = std::vector<uint8_t>(kKeyLenForWorstCase - 1, 255);
   end.push_back(254);
 
-  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]));
+  weaselab::ConflictSet::Result result;
+  weaselab::ConflictSet::ReadRange r{
+      {begin.data(), int(begin.size())}, {end.data(), int(end.size())}, 0};
 
   bench.run("worst case for radix tree", [&]() {
     for (int i = 0; i < 256; ++i) {
-      cs[i]->check(r, results, sizeof(r) / sizeof(r[0]));
-      for (auto result : results) {
-        if (result != weaselab::ConflictSet::Commit) {
-          abort();
-        }
+      result = weaselab::ConflictSet::TooOld;
+      cs[i]->check(&r, &result, 1);
+      if (result != weaselab::ConflictSet::Commit) {
+        abort();
       }
     }
   });

CMakeLists.txt

@@ -33,15 +33,6 @@ endif()
 
 add_compile_options(-fdata-sections -ffunction-sections -Wswitch-enum
                     -Werror=switch-enum -fPIC)
-
-if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-  add_link_options("-Wno-unused-command-line-argument")
-endif()
-
-if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  add_compile_options("-Wno-maybe-uninitialized")
-endif()
-
 if(NOT APPLE)
   # This causes some versions of clang to crash on macos
   add_compile_options(-g -fno-omit-frame-pointer)
@@ -104,23 +95,12 @@ 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 ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.o)
+add_library(${PROJECT_NAME} SHARED $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
 set_target_properties(
   ${PROJECT_NAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY
                              "${CMAKE_CURRENT_BINARY_DIR}/radix_tree")
-if(CMAKE_BUILD_TYPE STREQUAL Debug)
-  set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE CXX)
-else()
+if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
   set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE C)
 endif()
 
@@ -130,13 +110,19 @@ if(HAS_VERSION_SCRIPT)
     LINKER:--version-script=${CMAKE_CURRENT_SOURCE_DIR}/linker.map)
 endif()
 
-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()
+add_library(${PROJECT_NAME}-static STATIC
+            $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
+if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
   set_target_properties(${PROJECT_NAME}-static PROPERTIES LINKER_LANGUAGE C)
 endif()
-if(NOT APPLE)
+
+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()
   add_custom_command(
     TARGET ${PROJECT_NAME}-static
     POST_BUILD
@@ -191,13 +177,10 @@ 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)
 
-  # 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()
+  foreach(TEST ${CORPUS_TESTS})
+    get_filename_component(hash ${TEST} NAME)
+    add_test(NAME skip_list_${hash} COMMAND driver_skip_list ${TEST})
+  endforeach()
 
   # ad hoc testing
   add_executable(conflict_set_main ConflictSet.cpp)
@@ -265,19 +248,6 @@ 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)
@@ -298,14 +268,19 @@ 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})
-      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()
+
+  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()
 
@@ -375,11 +350,6 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
   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()
 

Dockerfile

@@ -8,25 +8,25 @@ 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 \
     cmake \
     curl \
+    doxygen \
+    file \
     g++-aarch64-linux-gnu \
     gcovr \
     git \
-    gnupg \
+    gperf \
+    graphviz \
     libc6-dbg \
-    lsb-release \
     ninja-build \
     pre-commit \
     python3-requests \
     qemu-user \
     rpm \
-    software-properties-common \
     texlive-full \
-    wget \
     zstd
 
 # Install recent valgrind from source
@@ -42,11 +42,6 @@ RUN curl -Ls https://sourceware.org/pub/valgrind/valgrind-3.22.0.tar.bz2 -o valg
     cd .. && \
     rm -rf /tmp/*
 
-# Recent clang
-RUN wget https://apt.llvm.org/llvm.sh && chmod +x ./llvm.sh && ./llvm.sh 20
-
-RUN apt-get -y install clang llvm
-
 # Set after building valgrind, which doesn't build with clang for some reason
 ENV CC=clang
 ENV CXX=clang++

InterleavingTest.cpp

@@ -22,6 +22,9 @@ void *stepJob(Job *j) {
   return done ? nullptr : (void *)stepJob;
 }
 
+// So we can look at the disassembly more easily
+
+extern "C" {
 void sequential(Job **jobs, int count) {
   for (int i = 0; i < count; ++i) {
     do {
@@ -91,87 +94,6 @@ void interleaveBoundedCyclicList(Job **jobs, int count) {
   }
 }
 
-#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);
 
@@ -195,11 +117,12 @@ void interleaveCyclicList(Job **jobs, int count) {
     job = nextJob[job];
   }
 }
+}
 
 int main() {
   ankerl::nanobench::Bench bench;
 
-  constexpr int kNumJobs = 10000;
+  constexpr int kNumJobs = 100;
   bench.relative(true);
 
   Job jobs[kNumJobs];
@@ -217,7 +140,6 @@ int main() {
   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"),

Internal.h

@@ -26,38 +26,9 @@ using namespace weaselab;
 #define DEBUG_VERBOSE 0
 #define SHOW_MEMORY 0
 
-// std::span is not trivially constructible. We want a span that leaves its
-// members uninitialized for performance reasons.
-struct TrivialSpan {
-  TrivialSpan() = default;
-  TrivialSpan(const uint8_t *begin, int len) : begin(begin), len(len) {}
-
-  uint8_t back() const {
-    assert(len > 0);
-    return begin[len - 1];
-  }
-  uint8_t front() const {
-    assert(len > 0);
-    return begin[0];
-  }
-  uint8_t operator[](int i) const {
-    assert(0 <= i);
-    assert(i < len);
-    return begin[i];
-  }
-  int size() const { return len; }
-  TrivialSpan subspan(int offset, int len) { return {begin + offset, len}; }
-  const uint8_t *data() const { return begin; }
-
-private:
-  const uint8_t *begin;
-  int len;
-};
-
-static_assert(std::is_trivial_v<TrivialSpan>);
-
-[[nodiscard]] inline auto operator<=>(const TrivialSpan &lhs,
-                                      const TrivialSpan &rhs) noexcept {
+[[nodiscard]] inline auto
+operator<=>(const std::span<const uint8_t> &lhs,
+            const std::span<const uint8_t> &rhs) noexcept {
   int cl = std::min<int>(lhs.size(), rhs.size());
   if (cl > 0) {
     if (auto c = memcmp(lhs.data(), rhs.data(), cl) <=> 0; c != 0) {
@@ -67,7 +38,7 @@ static_assert(std::is_trivial_v<TrivialSpan>);
   return lhs.size() <=> rhs.size();
 }
 
-[[nodiscard]] inline auto operator<=>(const TrivialSpan &lhs,
+[[nodiscard]] inline auto operator<=>(const std::span<const uint8_t> &lhs,
                                       const ConflictSet::Key &rhs) noexcept {
   int cl = std::min<int>(lhs.size(), rhs.len);
   if (cl > 0) {
@@ -75,18 +46,7 @@ static_assert(std::is_trivial_v<TrivialSpan>);
       return c;
     }
   }
-  return lhs.size() <=> rhs.len;
-}
-
-[[nodiscard]] inline auto operator<=>(const ConflictSet::Key &lhs,
-                                      const ConflictSet::Key &rhs) noexcept {
-  int cl = std::min<int>(lhs.len, rhs.len);
-  if (cl > 0) {
-    if (auto c = memcmp(lhs.p, rhs.p, cl) <=> 0; c != 0) {
-      return c;
-    }
-  }
-  return lhs.len <=> rhs.len;
+  return lhs.size() <=> size_t(rhs.len);
 }
 
 // This header contains code that we want to reuse outside of ConflictSet.cpp or
@@ -578,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)};
 }
 
@@ -609,7 +569,7 @@ inline std::string printable(const Key &key) {
   return printable(std::string_view((const char *)key.p, key.len));
 }
 
-inline std::string printable(TrivialSpan key) {
+inline std::string printable(std::span<const uint8_t> key) {
   return printable(std::string_view((const char *)key.data(), key.size()));
 }
 
@@ -717,8 +677,10 @@ struct TestDriver {
             arbitrary->randomBytes(begin + prefixLen, keyLen - prefixLen);
             writes[i].end.len = keyLen;
             writes[i].end.p = begin;
-            auto c = TrivialSpan(writes[i].begin.p, writes[i].begin.len) <=>
-                     TrivialSpan(writes[i].end.p, writes[i].end.len);
+            auto c =
+                std::span<const uint8_t>(writes[i].begin.p,
+                                         writes[i].begin.len) <=>
+                std::span<const uint8_t>(writes[i].end.p, writes[i].end.len);
             if (c > 0) {
               using std::swap;
               swap(writes[i].begin, writes[i].end);

Jenkinsfile

@@ -36,6 +36,18 @@ pipeline {
                 sh 'pre-commit run --all-files --show-diff-on-failure'
             }
         }
+        stage('Clang') {
+            agent {
+                dockerfile {
+                    args '-v /home/jenkins/ccache:/ccache'
+                    reuseNode true
+                }
+            }
+            steps {
+                CleanBuildAndTest("")
+                recordIssues(tools: [clang()])
+            }
+        }
         stage('64 bit versions') {
             agent {
                 dockerfile {
@@ -69,7 +81,7 @@ pipeline {
                 CleanBuildAndTest("-DUSE_SIMD_FALLBACK=ON")
             }
         }
-        stage('Release [clang]') {
+        stage('Release [gcc]') {
             agent {
                 dockerfile {
                     args '-v /home/jenkins/ccache:/ccache'
@@ -77,8 +89,8 @@ pipeline {
                 }
             }
             steps {
-                CleanBuildAndTest("-DCMAKE_CXX_FLAGS=-DNVALGRIND")
-                recordIssues(tools: [clang()])
+                CleanBuildAndTest("-DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_CXX_FLAGS=-DNVALGRIND")
+                recordIssues(tools: [gcc()])
                 sh '''
                 cd build
                 cpack -G DEB
@@ -91,19 +103,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]') {
-            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]') {
+        stage('Release [gcc,aarch64]') {
             agent {
                 dockerfile {
                     args '-v /home/jenkins/ccache:/ccache'
@@ -129,16 +129,16 @@ pipeline {
             }
             steps {
                 script {
-                    gcov_args = "-f ConflictSet.cpp -f LongestCommonPrefix.h -f Metrics.h --gcov-executable 'llvm-cov gcov' --exclude-noncode-lines"
+                    filter_args = "-f ConflictSet.cpp -f LongestCommonPrefix.h -f Metrics.h"
                 }
-                CleanBuildAndTest("-DCMAKE_C_FLAGS=--coverage -DCMAKE_CXX_FLAGS=--coverage -DCMAKE_BUILD_TYPE=Debug -DDISABLE_TSAN=ON")
+                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 """
-                gcovr ${gcov_args} --cobertura > build/coverage.xml
+                gcovr ${filter_args} --cobertura > build/coverage.xml
                 """
                 recordCoverage qualityGates: [[criticality: 'NOTE', metric: 'MODULE']], tools: [[parser: 'COBERTURA', pattern: 'build/coverage.xml']]
                 sh """
-                gcovr ${gcov_args}
-                gcovr ${gcov_args} --fail-under-line 100 > /dev/null
+                gcovr ${filter_args}
+                gcovr ${filter_args} --fail-under-line 100 > /dev/null
                 """
             }
         }

LongestCommonPrefix.h

@@ -129,7 +129,7 @@ longestCommonPrefix(const uint8_t *ap, const uint8_t *bp, int cl) {
   }
 
   int i = 0;
-  int end; // GCOVR_EXCL_LINE
+  int end;
 
   // kStride * kUnrollCount at a time
   end = cl & ~(kStride * kUnrollFactor - 1);

ServerBench.cpp

@@ -1,6 +1,4 @@
 #include <atomic>
-#include <cstdint>
-#include <cstdlib>
 #include <errno.h>
 #include <netdb.h>
 #include <stdio.h>
@@ -23,33 +21,76 @@
 
 std::atomic<int64_t> transactions;
 
+constexpr int kBaseSearchDepth = 115;
 constexpr int kWindowSize = 10000000;
 
-constexpr int kNumPrefixes = 250000;
-
-std::string makeKey(int64_t num, int suffixLen) {
+std::string numToKey(int64_t num) {
   std::string result;
-  result.resize(sizeof(int64_t) + suffixLen);
+  result.resize(kBaseSearchDepth + sizeof(int64_t));
+  memset(result.data(), 0, kBaseSearchDepth);
   int64_t be = __builtin_bswap64(num);
-  memcpy(result.data(), &be, sizeof(int64_t));
-  memset(result.data() + sizeof(int64_t), 0, suffixLen);
+  memcpy(result.data() + kBaseSearchDepth, &be, sizeof(int64_t));
   return result;
 }
 
 void workload(weaselab::ConflictSet *cs) {
   int64_t version = kWindowSize;
-  constexpr int kNumWrites = 16;
+  cs->addWrites(nullptr, 0, version);
   for (;; transactions.fetch_add(1, std::memory_order_relaxed)) {
-    std::vector<std::string> keys;
-    std::vector<weaselab::ConflictSet::WriteRange> writes;
-    for (int i = 0; i < kNumWrites; ++i) {
-      keys.push_back(makeKey(rand() % kNumPrefixes, rand() % 50));
+    // 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();
+      //   }
+      // }
     }
-    for (int i = 0; i < kNumWrites; ++i) {
-      writes.push_back({{(const uint8_t *)keys[i].data(), int(keys[i].size())},
-                        {nullptr, 0}});
+    // 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);
+      }
     }
-    cs->addWrites(writes.data(), writes.size(), version);
+    // GC
     cs->setOldestVersion(version - kWindowSize);
     ++version;
   }

aarch64-symbol-imports.txt

@@ -5,7 +5,6 @@ __stack_chk_guard@GLIBC_2.17
 abort@GLIBC_2.17
 free@GLIBC_2.17
 malloc@GLIBC_2.17
-memcmp@GLIBC_2.17
 memcpy@GLIBC_2.17
 memmove@GLIBC_2.17
 memset@GLIBC_2.17

aarch64-toolchain.cmake

@@ -1,8 +1,7 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(CMAKE_SYSTEM_PROCESSOR aarch64)
-set(CMAKE_C_COMPILER "clang;--target=aarch64-linux-gnu")
-set(CMAKE_CXX_COMPILER "clang++;--target=aarch64-linux-gnu")
+set(CMAKE_C_COMPILER "/usr/bin/aarch64-linux-gnu-gcc")
+set(CMAKE_CXX_COMPILER "/usr/bin/aarch64-linux-gnu-g++")
 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")