Skip sorting if already sorted for skip list

This works around a weird error I was getting when trying to link a
translation unit that included Internal.h with libconflict-set-static.a
with clang + gnu objcopy

Bench.cpp

@@ -17,26 +17,26 @@ constexpr int kPrefixLen = 0;
 
 constexpr int kMvccWindow = 100000;
 
-std::span<const uint8_t> makeKey(Arena &arena, int index) {
+TrivialSpan makeKey(Arena &arena, int index) {
 
-  auto result =
+  uint8_t *buf = new (arena) uint8_t[4 + kPrefixLen];
-      std::span<uint8_t>{new (arena) uint8_t[4 + kPrefixLen], 4 + kPrefixLen};
+  auto result = TrivialSpan{buf, 4 + kPrefixLen};
   index = __builtin_bswap32(index);
-  memset(result.data(), 0, kPrefixLen);
+  memset(buf, 0, kPrefixLen);
-  memcpy(result.data() + kPrefixLen, &index, 4);
+  memcpy(buf, &index, 4);
 
   return result;
 }
 
-ConflictSet::ReadRange singleton(Arena &arena, std::span<const uint8_t> key) {
+ConflictSet::ReadRange singleton(Arena &arena, TrivialSpan key) {
-  auto r =
+  uint8_t *buf = new (arena) uint8_t[key.size() + 1];
-      std::span<uint8_t>(new (arena) uint8_t[key.size() + 1], key.size() + 1);
+  auto r = TrivialSpan(buf, key.size() + 1);
-  memcpy(r.data(), key.data(), key.size());
+  memcpy(buf, key.data(), key.size());
-  r[key.size()] = 0;
+  buf[key.size()] = 0;
   return {{key.data(), int(key.size())}, {r.data(), int(r.size())}, 0};
 }
 
-ConflictSet::ReadRange prefixRange(Arena &arena, std::span<const uint8_t> key) {
+ConflictSet::ReadRange prefixRange(Arena &arena, TrivialSpan key) {
   int index;
   for (index = key.size() - 1; index >= 0; index--)
     if ((key[index]) != 255)
@@ -48,9 +48,10 @@ ConflictSet::ReadRange prefixRange(Arena &arena, std::span<const uint8_t> key) {
     assert(false);
   }
 
-  auto r = std::span<uint8_t>(new (arena) uint8_t[index + 1], index + 1);
+  uint8_t *buf = new (arena) uint8_t[index + 1];
-  memcpy(r.data(), key.data(), index + 1);
+  auto r = TrivialSpan(buf, index + 1);
-  r[r.size() - 1]++;
+  memcpy(buf, key.data(), index + 1);
+  buf[r.size() - 1]++;
   return {{key.data(), int(key.size())}, {r.data(), int(r.size())}, 0};
 }
 
@@ -81,14 +82,7 @@ void benchConflictSet() {
     ++version;
   }
 
-  // I don't know why std::less didn't work /shrug
+  auto points = set<TrivialSpan, std::less<>>(arena);
-  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?

CMakeLists.txt

@@ -31,8 +31,25 @@ if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
                                                "MinSizeRel" "RelWithDebInfo")
 endif()
 
-add_compile_options(-fdata-sections -ffunction-sections -Wswitch-enum
+add_compile_options(
-                    -Werror=switch-enum -fPIC)
+  -Werror=switch-enum -Wswitch-enum -fPIC -fdata-sections -ffunction-sections
+  -fno-jump-tables # https://github.com/llvm/llvm-project/issues/54247
+)
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+  add_link_options("-Wno-unused-command-line-argument")
+  find_program(LLVM_OBJCOPY llvm-objcopy)
+  if(LLVM_OBJCOPY)
+    set(CMAKE_OBJCOPY
+        ${LLVM_OBJCOPY}
+        CACHE FILEPATH "path to objcopy binary" FORCE)
+  endif()
+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)
@@ -47,6 +64,21 @@ if(HAS_FULL_RELRO)
 endif()
 cmake_pop_check_state()
 
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64)
+  add_compile_options(-mbranch-protection=standard)
+else()
+  add_compile_options(-fcf-protection)
+  set(rewrite_endbr_flags "-fuse-ld=mold;LINKER:-z,rewrite-endbr")
+  cmake_push_check_state()
+  list(APPEND CMAKE_REQUIRED_LINK_OPTIONS ${rewrite_endbr_flags})
+  check_cxx_source_compiles("int main(){}" HAS_REWRITE_ENDBR FAIL_REGEX
+                            "warning:")
+  if(HAS_REWRITE_ENDBR)
+    add_link_options(${rewrite_endbr_flags})
+  endif()
+  cmake_pop_check_state()
+endif()
+
 set(version_script_flags
     LINKER:--version-script=${CMAKE_CURRENT_SOURCE_DIR}/linker.map)
 cmake_push_check_state()
@@ -314,7 +346,8 @@ 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})
+  target_link_libraries(conflict_set_cxx_api_test
+                        PRIVATE ${PROJECT_NAME}-static)
   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)
@@ -347,6 +380,15 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
         ${symbol_imports})
   endif()
 
+  if(NOT CMAKE_CROSSCOMPILING)
+    find_program(HARDENING_CHECK hardening-check)
+    if(HARDENING_CHECK)
+      add_test(NAME hardening_check
+               COMMAND ${HARDENING_CHECK} $<TARGET_FILE:${PROJECT_NAME}>
+                       --nofortify --nostackprotector)
+    endif()
+  endif()
+
   # bench
   add_executable(conflict_set_bench Bench.cpp)
   target_link_libraries(conflict_set_bench PRIVATE ${PROJECT_NAME} nanobench)

Dockerfile

@@ -11,23 +11,24 @@ RUN TZ=America/Los_Angeles DEBIAN_FRONTEND=noninteractive apt-get install -y \
     binutils-aarch64-linux-gnu \
     build-essential \
     ccache \
-    clang \
     cmake \
     curl \
-    doxygen \
+    devscripts \
-    file \
     g++-aarch64-linux-gnu \
     gcovr \
     git \
-    gperf \
+    gnupg \
-    graphviz \
     libc6-dbg \
+    lsb-release \
+    mold \
     ninja-build \
     pre-commit \
     python3-requests \
     qemu-user \
     rpm \
+    software-properties-common \
     texlive-full \
+    wget \
     zstd
 
 # Install recent valgrind from source
@@ -43,6 +44,11 @@ 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++

Internal.h

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

@@ -11,11 +11,11 @@ def CleanBuildAndTest(String cmakeArgs) {
     catchError {
         sh '''
         cd build
-        ctest --no-compress-output --test-output-size-passed 100000 --test-output-size-failed 100000 -T Test -j `nproc` --timeout 90
+        ctest --no-compress-output --test-output-size-passed 100000 --test-output-size-failed 100000 -T Test -j `nproc` --timeout 90 > /dev/null
         zstd Testing/*/Test.xml
         '''
     }
-    xunit tools: [CTest(pattern: 'build/Testing/*/Test.xml')], reduceLog: false, skipPublishingChecks: false
+    xunit tools: [CTest(pattern: 'build/Testing/*/Test.xml')], skipPublishingChecks: false
     minio bucket: 'jenkins', credentialsId: 'jenkins-minio', excludes: '', host: 'minio.weaselab.dev', includes: 'build/Testing/*/Test.xml.zst', targetFolder: '${JOB_NAME}/${BUILD_NUMBER}/${STAGE_NAME}/'
 }
 
@@ -129,16 +129,16 @@ pipeline {
             }
             steps {
                 script {
-                    filter_args = "-f ConflictSet.cpp -f LongestCommonPrefix.h -f Metrics.h"
+                    gcov_args = "-f ConflictSet.cpp -f LongestCommonPrefix.h -f Metrics.h --gcov-executable 'llvm-cov gcov' --exclude-noncode-lines"
                 }
-                CleanBuildAndTest("-DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_C_FLAGS=--coverage -DCMAKE_CXX_FLAGS=--coverage -DCMAKE_BUILD_TYPE=Debug -DDISABLE_TSAN=ON")
+                CleanBuildAndTest("-DCMAKE_C_FLAGS=--coverage -DCMAKE_CXX_FLAGS=--coverage -DCMAKE_BUILD_TYPE=Debug -DDISABLE_TSAN=ON")
                 sh """
-                gcovr ${filter_args} --cobertura > build/coverage.xml
+                gcovr ${gcov_args} --cobertura > build/coverage.xml
                 """
                 recordCoverage qualityGates: [[criticality: 'NOTE', metric: 'MODULE']], tools: [[parser: 'COBERTURA', pattern: 'build/coverage.xml']]
                 sh """
-                gcovr ${filter_args}
+                gcovr ${gcov_args}
-                gcovr ${filter_args} --fail-under-line 100 > /dev/null
+                gcovr ${gcov_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;
+  int end; // GCOVR_EXCL_LINE
 
   // kStride * kUnrollCount at a time
   end = cl & ~(kStride * kUnrollFactor - 1);

README.md

@@ -2,7 +2,9 @@ A data structure for optimistic concurrency control on ranges of bitwise-lexicog
 
 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
+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)`.
 
 # Microbenchmark
 
@@ -10,29 +12,29 @@ 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
 |--------------------:|--------------------:|--------:|----------------:|----------------:|-------:|---------------:|--------:|----------:|:----------
-|              172.03 |        5,812,791.77 |    0.4% |        3,130.62 |          879.00 |  3.562 |         509.23 |    0.0% |      0.01 | `point reads`
+|              159.65 |        6,263,576.52 |    1.6% |        2,972.36 |          820.37 |  3.623 |         504.59 |    0.0% |      0.01 | `point reads`
-|              167.44 |        5,972,130.71 |    0.2% |        3,065.14 |          862.27 |  3.555 |         494.30 |    0.0% |      0.01 | `prefix reads`
+|              156.32 |        6,397,320.65 |    0.7% |        2,913.62 |          806.87 |  3.611 |         490.19 |    0.0% |      0.01 | `prefix reads`
-|              238.77 |        4,188,130.84 |    0.9% |        3,589.93 |        1,259.30 |  2.851 |         637.12 |    0.0% |      0.01 | `range 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`
-|              424.01 |        2,358,426.70 |    0.2% |        5,620.05 |        2,242.35 |  2.506 |         854.80 |    1.7% |      0.01 | `point writes`
+|              363.37 |        2,752,026.30 |    0.3% |        5,273.63 |        1,951.54 |  2.702 |         851.66 |    1.7% |      0.01 | `point writes`
-|              418.45 |        2,389,780.56 |    0.4% |        5,525.07 |        2,211.05 |  2.499 |         831.71 |    1.7% |      0.01 | `prefix 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`
-|              254.87 |        3,923,568.88 |    2.6% |        3,187.01 |        1,366.50 |  2.332 |         529.11 |    2.7% |      0.02 | `range 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`
-|              675.96 |        1,479,374.50 |    3.3% |        7,735.41 |        3,468.60 |  2.230 |       1,386.02 |    1.8% |      0.01 | `monotonic increasing point 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`
-|          137,986.20 |            7,247.10 |    0.6% |      789,752.33 |      699,462.00 |  1.129 |     144,824.14 |    0.0% |      0.01 | `worst case for radix tree`
+|          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`
-|               21.63 |       46,231,564.03 |    1.0% |          448.00 |          107.14 |  4.181 |          84.00 |    0.0% |      0.01 | `create and destroy`
+|               41.71 |       23,976,459.34 |    1.7% |          885.00 |          219.17 |  4.038 |         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.88 |       77,653,350.77 |    0.5% |          185.37 |           64.45 |  2.876 |          41.51 |    0.4% |      0.01 | `point reads`
+|               12.63 |       79,186,868.18 |    1.4% |          241.61 |           64.76 |  3.731 |          31.64 |    0.8% |      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`
+|               14.48 |       69,078,073.40 |    0.3% |          292.42 |           74.69 |  3.915 |          41.49 |    0.5% |      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`
+|               34.37 |       29,094,694.11 |    0.2% |          759.53 |          179.77 |  4.225 |         100.38 |    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`
+|               19.34 |       51,713,896.36 |    0.7% |          369.70 |          101.81 |  3.631 |          47.88 |    0.6% |      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`
+|               39.16 |       25,538,968.61 |    0.2% |          653.16 |          206.77 |  3.159 |          89.62 |    0.8% |      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`
+|               40.58 |       24,642,681.12 |    4.7% |          718.44 |          216.44 |  3.319 |          99.28 |    0.6% |      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`
+|               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`
-|          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`
+|          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`
-|               87.70 |       11,402,490.60 |    1.0% |        1,795.00 |          442.09 |  4.060 |         297.00 |    0.0% |      0.01 | `create and destroy`
+|              104.76 |        9,545,250.65 |    3.1% |        2,000.00 |          552.82 |  3.618 |         342.00 |    0.0% |      0.01 | `create and destroy`
 
 # "Real data" test
 
@@ -41,13 +43,13 @@ Point queries only, best of three runs. Gc ratio is the ratio of time spent doin
 ## skip list
 
 ```
-Check: 4.47891 seconds, 364.05 MB/s, Add: 4.55599 seconds, 123.058 MB/s, Gc ratio: 37.1145%
+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
 ```
 
 ## radix tree
 
 ```
-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
+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
 ```
 
 ## hash table
@@ -55,5 +57,5 @@ Check: 0.953012 seconds, 1710.94 MB/s, Add: 1.30025 seconds, 431.188 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.804094 seconds, 2027.81 MB/s, Add: 0.652952 seconds, 858.645 MB/s, Gc ratio: 35.3885%
+Check: 0.84256 seconds, 1935.23 MB/s, Add: 0.697204 seconds, 804.146 MB/s, Gc ratio: 35.4091%
 ```

ServerBench.cpp

@@ -1,5 +1,7 @@
+#include <algorithm>
 #include <atomic>
 #include <cstdint>
+#include <cstdlib>
 #include <errno.h>
 #include <netdb.h>
 #include <stdio.h>
@@ -18,60 +20,93 @@
 #include <vector>
 
 #include "ConflictSet.h"
+#include "Internal.h"
 #include "third_party/nadeau.h"
 
 std::atomic<int64_t> transactions;
 
-constexpr int kWindowSize = 10000000;
+int64_t safeUnaryMinus(int64_t x) {
+  return x == std::numeric_limits<int64_t>::min() ? x : -x;
+}
 
-constexpr int kNumPrefixes = 250000;
+void tupleAppend(std::string &output, int64_t value) {
+  if (value == 0) {
+    output.push_back(0x14);
+    return;
+  }
+  uint32_t size = 8 - __builtin_clrsbll(value) / 8;
+  int typeCode = 0x14 + (value < 0 ? -1 : 1) * size;
+  output.push_back(typeCode);
+  if (value < 0) {
+    value = ~safeUnaryMinus(value);
+  }
+  uint64_t swap = __builtin_bswap64(value);
+  output.insert(output.end(), (uint8_t *)&swap + 8 - size,
+                (uint8_t *)&swap + 8);
+}
 
-std::string makeKey(int64_t num, int suffixLen) {
+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);
+    }
+  }
+  output.push_back('\x00');
+}
+
+template <class... Ts> std::string tupleKey(const Ts &...ts) {
   std::string result;
-  result.resize(sizeof(int64_t) + suffixLen);
+  (tupleAppend(result, ts), ...);
-  int64_t be = __builtin_bswap64(num);
-  memcpy(result.data(), &be, sizeof(int64_t));
-  memset(result.data() + sizeof(int64_t), 0, suffixLen);
   return result;
 }
 
+constexpr int kTotalKeyRange = 1'000'000'000;
+constexpr int kWindowSize = 1'000'000;
+constexpr int kNumKeys = 10;
+
 void workload(weaselab::ConflictSet *cs) {
   int64_t version = kWindowSize;
-  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)) {
-    std::vector<std::string> keys(kNumReads);
+    std::vector<int64_t> keyIndices;
-    for (auto &k : keys) {
+    for (int i = 0; i < kNumKeys; ++i) {
-      k = makeKey(rand() % kNumPrefixes, 49);
+      keyIndices.push_back(rand() % kTotalKeyRange);
     }
-    std::vector<weaselab::ConflictSet::ReadRange> reads(kNumReads);
+    std::sort(keyIndices.begin(), keyIndices.end());
-    for (int i = 0; i < reads.size(); ++i) {
+    std::vector<std::string> keys;
-      reads[i].begin.p = (const uint8_t *)(keys[i].data());
+    constexpr std::string_view fullString =
-      reads[i].begin.len = keys[i].size();
+        "this is a string, where a prefix of it is used as an element of the "
-      reads[i].end.len = 0;
+        "tuple forming the key";
-      reads[i].readVersion = version - 1;
+    for (int i = 0; i < kNumKeys; ++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());
     }
-    cs->check(reads.data(), results.data(), kNumReads);
+
+    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) {
+      writes.push_back({{(const uint8_t *)keys[i].data(), int(keys[i].size())},
+                        {nullptr, 0}});
+      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;
   }
 }
 

SkipList.cpp

@@ -767,7 +767,9 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
           false, true);
     }
 
-    sortPoints(points);
+    if (!std::is_sorted(points.begin(), points.end())) {
+      sortPoints(points);
+    }
 
     int activeWriteCount = 0;
     std::vector<std::pair<StringRef, StringRef>> combinedWriteConflictRanges;

aarch64-symbol-imports.txt

@@ -5,6 +5,7 @@ __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