Account for every uncovered line in the implementation

Closes #23
Include long common prefix in fuzz test
2024-04-18 12:43:48 -07:00 · 2024-04-18 12:43:48 -07:00 · 2024-04-18 12:43:48 -07:00 · 2024-04-17 18:27:01 -07:00 · 2024-04-17 17:13:22 -07:00 · 2024-04-17 14:11:26 -07:00
627 changed files with 1430 additions and 556 deletions
--- a/.clangd
+++ b/.clangd
@@ -1,2 +1,2 @@
 CompileFlags:
-  Add: [-DENABLE_MAIN, -UNDEBUG, -DENABLE_FUZZ, -fexceptions]
+  Add: [-DENABLE_MAIN, -UNDEBUG, -DENABLE_FUZZ, -DTHREAD_TEST, -fexceptions]
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 .cache
+__pycache__
 build
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,11 +1,11 @@
 repos:
  - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: b111689e7b5cba60be3c62d5db2bd1357f4d36ca
+    rev: 6d365699efc33b1b432eab5b4ae331a19e1857de # frozen: v18.1.2
    hooks:
      - id: clang-format
        exclude: ".*third_party/.*"
  - repo: https://github.com/cheshirekow/cmake-format-precommit
-    rev: e2c2116d86a80e72e7146a06e68b7c228afc6319
+    rev: e2c2116d86a80e72e7146a06e68b7c228afc6319 # frozen: v0.6.13
    hooks:
      - id: cmake-format
  - repo: local
@@ -13,7 +13,7 @@ repos:
      - id: debug verbose check
        name: disallow checking in DEBUG_VERBOSE=1
        description: disallow checking in DEBUG_VERBOSE=1
-        entry: '^#define DEBUG_VERBOSE 1$'
+        entry: "^#define DEBUG_VERBOSE 1$"
        language: pygrep
        types: [c++]
  - repo: local
@@ -21,6 +21,14 @@ repos:
      - id: debug verbose check
        name: disallow checking in SHOW_MEMORY=1
        description: disallow checking in SHOW_MEMORY=1
-        entry: '^#define SHOW_MEMORY 1$'
+        entry: "^#define SHOW_MEMORY 1$"
        language: pygrep
        types: [c++]
+  - repo: https://github.com/shellcheck-py/shellcheck-py
+    rev: a23f6b85d0fdd5bb9d564e2579e678033debbdff # frozen: v0.10.0.1
+    hooks:
+      - id: shellcheck
+  - repo: https://github.com/psf/black
+    rev: 552baf822992936134cbd31a38f69c8cfe7c0f05 # frozen: 24.3.0
+    hooks:
+      - id: black
--- a/Bench.cpp
+++ b/Bench.cpp
@@ -34,7 +34,7 @@ ConflictSet::ReadRange singleton(Arena &arena, std::span<const uint8_t> key) {
      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())};
+  return {{key.data(), int(key.size())}, {r.data(), int(r.size())}, 0};
 }

 ConflictSet::ReadRange prefixRange(Arena &arena, std::span<const uint8_t> key) {
@@ -52,7 +52,7 @@ ConflictSet::ReadRange prefixRange(Arena &arena, std::span<const uint8_t> key) {
  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())};
+  return {{key.data(), int(key.size())}, {r.data(), int(r.size())}, 0};
 }

 void benchConflictSet() {
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,15 +1,28 @@
 cmake_minimum_required(VERSION 3.18)
 project(
-  conflict_set
-  VERSION 0.0.1
+  conflict-set
+  VERSION 0.0.4
  DESCRIPTION
    "A data structure for optimistic concurrency control on ranges of bitwise-lexicographically-ordered keys."
  HOMEPAGE_URL "https://git.weaselab.dev/weaselab/conflict-set"
  LANGUAGES C CXX)
 set(CMAKE_CXX_STANDARD 20)

+file(WRITE ${CMAKE_BINARY_DIR}/version.txt ${PROJECT_VERSION})
+
+include(CMakePushCheckState)
+include(CheckCXXCompilerFlag)
+include(CheckIncludeFileCXX)
+include(CheckCXXSourceCompiles)
+
 set(DEFAULT_BUILD_TYPE "Release")

+if(EMSCRIPTEN OR CMAKE_SYSTEM_NAME STREQUAL WASI)
+  set(WASM ON)
+else()
+  set(WASM OFF)
+endif()
+
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
  message(
    STATUS
@@ -23,16 +36,32 @@ if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
 endif()

 add_compile_options(-fdata-sections -ffunction-sections -Wswitch-enum
-                    -Werror=switch-enum)
+                    -Werror=switch-enum -fPIC)
+
+set(full_relro_flags "-pie;LINKER:-z,relro,-z,now,-z,noexecstack")
+cmake_push_check_state()
+list(APPEND CMAKE_REQUIRED_LINK_OPTIONS ${full_relro_flags})
+check_cxx_source_compiles("int main(){}" HAS_FULL_RELRO FAIL_REGEX "warning:")
+if(HAS_FULL_RELRO)
+  add_link_options(${full_relro_flags})
+endif()
+cmake_pop_check_state()
+
+set(version_script_flags LINKER:--version-script=${CMAKE_SOURCE_DIR}/linker.map)
+cmake_push_check_state()
+list(APPEND CMAKE_REQUIRED_LINK_OPTIONS ${version_script_flags})
+check_cxx_source_compiles("int main(){}" HAS_VERSION_SCRIPT FAIL_REGEX
+                          "warning:")
+cmake_pop_check_state()
+
+option(USE_SIMD_FALLBACK
+       "Use fallback implementations of functions that use SIMD" OFF)

 # This is encouraged according to
 # https://valgrind.org/docs/manual/manual-core-adv.html#manual-core-adv.clientreq
 include_directories(SYSTEM ${CMAKE_SOURCE_DIR}/third_party/valgrind)

-if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  add_compile_options(-Wno-maybe-uninitialized
-                      $<$<COMPILE_LANGUAGE:CXX>:-Wno-invalid-offsetof>)
-endif()
+add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-invalid-offsetof>)

 if(APPLE)
  add_link_options(-Wl,-dead_strip)
@@ -40,32 +69,46 @@ else()
  add_link_options(-Wl,--gc-sections)
 endif()

-include(CheckIncludeFileCXX)
-include(CMakePushCheckState)
+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()

-cmake_push_check_state()
-list(APPEND CMAKE_REQUIRED_FLAGS -mavx)
-check_include_file_cxx("immintrin.h" HAS_AVX)
-if(HAS_AVX)
+if(NOT USE_SIMD_FALLBACK)
+  cmake_push_check_state()
+  list(APPEND CMAKE_REQUIRED_FLAGS -msimd128)
+  check_include_file_cxx("wasm_simd128.h" HAS_WASM_SIMD)
+  if(HAS_WASM_SIMD)
+    add_compile_options(-msimd128)
+    add_compile_definitions(HAS_WASM_SIMD)
+  endif()
+  cmake_pop_check_state()
+
+  cmake_push_check_state()
+  list(APPEND CMAKE_REQUIRED_FLAGS -mavx)
+  check_include_file_cxx("immintrin.h" HAS_AVX)
+  if(HAS_AVX)
    add_compile_options(-mavx)
    add_compile_definitions(HAS_AVX)
-endif()
-cmake_pop_check_state()
+  endif()
+  cmake_pop_check_state()

-check_include_file_cxx("arm_neon.h" HAS_ARM_NEON)
-if(HAS_ARM_NEON)
+  check_include_file_cxx("arm_neon.h" HAS_ARM_NEON)
+  if(HAS_ARM_NEON)
    add_compile_definitions(HAS_ARM_NEON)
+  endif()
 endif()

 set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "")

-add_library(${PROJECT_NAME}_object OBJECT ConflictSet.cpp)
-target_compile_options(${PROJECT_NAME}_object PRIVATE -fPIC -fno-exceptions
+add_library(${PROJECT_NAME}-object OBJECT ConflictSet.cpp)
+target_compile_options(${PROJECT_NAME}-object PRIVATE -fno-exceptions
                                                      -fvisibility=hidden)
-target_include_directories(${PROJECT_NAME}_object
+target_include_directories(${PROJECT_NAME}-object
                           PRIVATE ${CMAKE_SOURCE_DIR}/include)

-add_library(${PROJECT_NAME} SHARED $<TARGET_OBJECTS:${PROJECT_NAME}_object>)
+add_library(${PROJECT_NAME} SHARED $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
 set_target_properties(
  ${PROJECT_NAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY
                             "${CMAKE_BINARY_DIR}/radix_tree")
@@ -73,24 +116,32 @@ if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
  set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE C)
 endif()

-if(NOT APPLE)
+if(HAS_VERSION_SCRIPT)
  target_link_options(${PROJECT_NAME} PRIVATE
                      LINKER:--version-script=${CMAKE_SOURCE_DIR}/linker.map)
 endif()

-add_library(${PROJECT_NAME}_static STATIC
-            $<TARGET_OBJECTS:${PROJECT_NAME}_object>)
+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)
+  set_target_properties(${PROJECT_NAME}-static PROPERTIES LINKER_LANGUAGE C)
 endif()

-if(NOT APPLE AND CMAKE_OBJCOPY)
+if(APPLE)
  add_custom_command(
-    TARGET conflict_set_static
+    TARGET ${PROJECT_NAME}-static
+    PRE_LINK
+    COMMAND ${CMAKE_SOURCE_DIR}/privatize_symbols_macos.sh
+            $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
+else()
+  add_custom_command(
+    TARGET ${PROJECT_NAME}-static
    POST_BUILD
    COMMAND
-      ${CMAKE_OBJCOPY} --keep-global-symbols=${CMAKE_SOURCE_DIR}/symbols.txt
-      $<TARGET_FILE:${PROJECT_NAME}_static>)
+      ${CMAKE_OBJCOPY}
+      --keep-global-symbols=${CMAKE_SOURCE_DIR}/symbol-exports.txt
+      $<TARGET_FILE:${PROJECT_NAME}-static> || echo
+      "Proceeding with all symbols global in static library")
 endif()

 set(TEST_FLAGS -Wall -Wextra -Wunreachable-code -Wpedantic -UNDEBUG)
@@ -99,30 +150,51 @@ include(CTest)

 if(BUILD_TESTING)

+  # corpus tests, which are tests curated by libfuzzer. The goal is to get broad
+  # coverage with a small number of tests.
+
+  file(GLOB CORPUS_TESTS ${CMAKE_SOURCE_DIR}/corpus/*)
+
+  # extra testing that relies on shared libraries, which aren't available with
+  # wasm
+  if(NOT WASM)
    # Shared library version of FoundationDB's skip list implementation
    add_library(skip_list SHARED SkipList.cpp)
-  target_compile_options(skip_list PRIVATE -fPIC -fno-exceptions
+    target_compile_options(skip_list PRIVATE -fno-exceptions
                                             -fvisibility=hidden)
    target_include_directories(skip_list PUBLIC ${CMAKE_SOURCE_DIR}/include)
    set_target_properties(skip_list PROPERTIES LIBRARY_OUTPUT_DIRECTORY
                                               "${CMAKE_BINARY_DIR}/skip_list")
    set_target_properties(skip_list PROPERTIES OUTPUT_NAME ${PROJECT_NAME})
-  set_target_properties(skip_list PROPERTIES VERSION ${PROJECT_VERSION}
-                                             SOVERSION ${PROJECT_VERSION_MAJOR})
+    set_target_properties(
+      skip_list PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION
+                                                      ${PROJECT_VERSION_MAJOR})

    # Shared library version of a std::unordered_map-based conflict set (point
    # queries only)
    add_library(hash_table SHARED HashTable.cpp)
-  target_compile_options(hash_table PRIVATE -fPIC -fno-exceptions
+    target_compile_options(hash_table PRIVATE -fno-exceptions
                                              -fvisibility=hidden)
    target_include_directories(hash_table PUBLIC ${CMAKE_SOURCE_DIR}/include)
-  set_target_properties(hash_table PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+    set_target_properties(
+      hash_table PROPERTIES LIBRARY_OUTPUT_DIRECTORY
                            "${CMAKE_BINARY_DIR}/hash_table")
    set_target_properties(hash_table PROPERTIES OUTPUT_NAME ${PROJECT_NAME})
    set_target_properties(
      hash_table PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION
                                                       ${PROJECT_VERSION_MAJOR})

+    add_executable(driver_skip_list TestDriver.cpp)
+    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()
+  endif()
+
+  # ad hoc testing
  add_executable(conflict_set_main ConflictSet.cpp)
  target_include_directories(conflict_set_main
                             PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
@@ -149,10 +221,7 @@ if(BUILD_TESTING)
    endif()
  endif()

-  # corpus tests
-
-  file(GLOB CORPUS_TESTS ${CMAKE_SOURCE_DIR}/corpus/*)
-
+  # whitebox tests
  add_executable(fuzz_driver ConflictSet.cpp FuzzTestDriver.cpp)
  target_compile_options(fuzz_driver PRIVATE ${TEST_FLAGS})
  if(NOT CMAKE_CROSSCOMPILING)
@@ -167,13 +236,47 @@ if(BUILD_TESTING)
    add_test(NAME conflict_set_fuzz_${hash} COMMAND fuzz_driver ${TEST})
  endforeach()

+  # tsan tests
+  if(NOT CMAKE_CROSSCOMPILING AND NOT CMAKE_BUILD_TYPE STREQUAL Debug)
+    add_executable(tsan_driver ConflictSet.cpp FuzzTestDriver.cpp)
+    target_compile_options(tsan_driver PRIVATE ${TEST_FLAGS} -fsanitize=thread)
+    target_link_options(tsan_driver PRIVATE -fsanitize=thread)
+    target_compile_definitions(tsan_driver PRIVATE ENABLE_FUZZ THREAD_TEST)
+    target_include_directories(tsan_driver
+                               PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+    foreach(TEST ${CORPUS_TESTS})
+      get_filename_component(hash ${TEST} NAME)
+      add_test(NAME conflict_set_tsan_${hash} COMMAND tsan_driver ${TEST})
+    endforeach()
+  endif()
+
+  # blackbox tests
  add_executable(driver TestDriver.cpp)
  target_compile_options(driver PRIVATE ${TEST_FLAGS})
  target_link_libraries(driver PRIVATE ${PROJECT_NAME})
+  foreach(TEST ${CORPUS_TESTS})
+    get_filename_component(hash ${TEST} NAME)
+    add_test(NAME conflict_set_blackbox_${hash} COMMAND driver ${TEST})
+  endforeach()

-  add_executable(driver_skip_list TestDriver.cpp)
-  target_compile_options(driver_skip_list PRIVATE ${TEST_FLAGS})
-  target_link_libraries(driver_skip_list PRIVATE skip_list)
+  # scripted tests. Written manually to fill in anything libfuzzer couldn't
+  # find.
+  if(NOT CMAKE_CROSSCOMPILING)
+    find_package(Python3 REQUIRED COMPONENTS Interpreter)
+    set_property(
+      DIRECTORY
+      APPEND
+      PROPERTY CMAKE_CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/test_conflict_set.py)
+    execute_process(
+      COMMAND ${Python3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/test_conflict_set.py
+              list OUTPUT_VARIABLE SCRIPT_TESTS)
+    foreach(TEST ${SCRIPT_TESTS})
+      add_test(
+        NAME script_test_${TEST}
+        COMMAND ${Python3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/test_conflict_set.py
+                test ${TEST} --build-dir ${CMAKE_BINARY_DIR})
+    endforeach()
+  endif()

  find_program(VALGRIND_EXE valgrind)
  if(VALGRIND_EXE AND NOT CMAKE_CROSSCOMPILING)
@@ -182,12 +285,6 @@ if(BUILD_TESTING)
                     $<TARGET_FILE:driver> ${CORPUS_TESTS})
  endif()

-  foreach(TEST ${CORPUS_TESTS})
-    get_filename_component(hash ${TEST} NAME)
-    add_test(NAME conflict_set_blackbox_${hash} COMMAND driver ${TEST})
-    add_test(NAME skip_list_${hash} COMMAND driver_skip_list ${TEST})
-  endforeach()
-
  # api smoke tests

  # c90
@@ -208,31 +305,45 @@ if(BUILD_TESTING)
                        PROPERTIES CXX_STANDARD_REQUIRED ON)
  add_test(NAME conflict_set_cxx_api_test COMMAND conflict_set_cxx_api_test)

-  if(NOT APPLE AND NOT CMAKE_BUILD_TYPE STREQUAL Debug)
+  # symbol visibility tests
+  if(NOT WASM AND NOT CMAKE_BUILD_TYPE STREQUAL Debug)
+    if(APPLE)
+      set(symbol_exports ${CMAKE_SOURCE_DIR}/apple-symbol-exports.txt)
+      set(symbol_imports ${CMAKE_SOURCE_DIR}/apple-symbol-imports.txt)
+    else()
+      set(symbol_exports ${CMAKE_SOURCE_DIR}/symbol-exports.txt)
+      if(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64)
+        set(symbol_imports ${CMAKE_SOURCE_DIR}/aarch64-symbol-imports.txt)
+      else()
+        set(symbol_imports ${CMAKE_SOURCE_DIR}/symbol-imports.txt)
+      endif()
+    endif()
    add_test(
      NAME conflict_set_shared_symbols
-      COMMAND ${CMAKE_SOURCE_DIR}/test_symbols.sh
-              $<TARGET_FILE:${PROJECT_NAME}> ${CMAKE_SOURCE_DIR}/symbols.txt)
+      COMMAND
+        ${CMAKE_SOURCE_DIR}/test_symbols.sh $<TARGET_FILE:${PROJECT_NAME}>
+        ${symbol_exports} ${symbol_imports})
    add_test(
      NAME conflict_set_static_symbols
      COMMAND
        ${CMAKE_SOURCE_DIR}/test_symbols.sh
-        $<TARGET_FILE:${PROJECT_NAME}_static> ${CMAKE_SOURCE_DIR}/symbols.txt)
+        $<TARGET_FILE:${PROJECT_NAME}-static> ${symbol_exports}
+        ${symbol_imports})
  endif()

  # bench
-
  add_executable(conflict_set_bench Bench.cpp)
  target_link_libraries(conflict_set_bench PRIVATE ${PROJECT_NAME})
  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})
  set_target_properties(real_data_bench PROPERTIES SKIP_BUILD_RPATH ON)
 endif()
+
 # packaging

 set(CPACK_PACKAGE_CONTACT andrew@weaselab.dev)
+set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME all)

 set(CPACK_PACKAGE_VENDOR "Weaselab")
 set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
@@ -242,6 +353,30 @@ set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
 set(CPACK_RPM_PACKAGE_ARCHITECTURE ${CMAKE_SYSTEM_PROCESSOR})
 set(CPACK_RPM_SPEC_INSTALL_POST "/bin/true") # avoid stripping
 set(CPACK_RPM_PACKAGE_LICENSE "Apache 2.0")
+set(CPACK_RPM_FILE_NAME RPM-DEFAULT)
+
+# deb
+set(CPACK_DEBIAN_FILE_NAME DEB-DEFAULT)
+# see *-imports.txt - dependency versions need to be synced with symbol versions
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64)
+  set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.17)")
+else()
+  set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.14)")
+endif()
+
+# macos
+set(CMAKE_OSX_DEPLOYMENT_TARGET 11.0)
+if(APPLE)
+  find_program(PANDOC_EXE pandoc)
+  if(PANDOC_EXE)
+    execute_process(COMMAND ${PANDOC_EXE} ${CMAKE_SOURCE_DIR}/README.md -o
+                            ${CMAKE_BINARY_DIR}/README.txt)
+    set(CPACK_RESOURCE_FILE_README ${CMAKE_BINARY_DIR}/README.txt)
+  endif()
+  configure_file(${CMAKE_SOURCE_DIR}/LICENSE ${CMAKE_BINARY_DIR}/LICENSE.txt
+                 COPYONLY)
+  set(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_BINARY_DIR}/LICENSE.txt)
+endif()

 include(CPack)

@@ -253,7 +388,7 @@ target_include_directories(
         $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}>)

 target_include_directories(
-  ${PROJECT_NAME}_static
+  ${PROJECT_NAME}-static
  PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
         $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}>)

@@ -262,13 +397,16 @@ set_target_properties(
                             SOVERSION ${PROJECT_VERSION_MAJOR})

 install(
-  TARGETS ${PROJECT_NAME} ${PROJECT_NAME}_static
-  EXPORT ConflictSetConfig
+  TARGETS ${PROJECT_NAME} ${PROJECT_NAME}-static
+  EXPORT ${PROJECT_NAME}Config
  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
 install(DIRECTORY include/
        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME})

-install(EXPORT ConflictSetConfig
-        DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/ConflictSet/cmake)
+install(EXPORT ${PROJECT_NAME}Config
+        DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/cmake)
+
+cpack_add_component(all)
--- a/ConflictSet.cpp
+++ b/ConflictSet.cpp
@@ -29,6 +29,7 @@ limitations under the License.
 #include <span>
 #include <string>
 #include <string_view>
+#include <type_traits>
 #include <utility>

 #ifdef HAS_AVX
@@ -39,6 +40,8 @@ limitations under the License.

 #include <memcheck.h>

+using namespace weaselab;
+
 // Use assert for checking potentially complex properties during tests.
 // Use assume to hint simple properties to the optimizer.

@@ -216,6 +219,7 @@ struct Node {
  /* end section that's copied to the next node */

  uint8_t *partialKey();
+  size_t size() const;

  Type getType() const { return type; }
  int32_t getCapacity() const { return partialKeyCapacity; }
@@ -249,6 +253,8 @@ struct Node0 : Node {

  void copyChildrenAndKeyFrom(const Node0 &other);
  void copyChildrenAndKeyFrom(const struct Node3 &other);
+
+  size_t size() const { return sizeof(Node0) + getCapacity(); }
 };

 struct Node3 : Node {
@@ -262,6 +268,8 @@ struct Node3 : Node {
  void copyChildrenAndKeyFrom(const Node0 &other);
  void copyChildrenAndKeyFrom(const Node3 &other);
  void copyChildrenAndKeyFrom(const struct Node16 &other);
+
+  size_t size() const { return sizeof(Node3) + getCapacity(); }
 };

 struct Node16 : Node {
@@ -275,6 +283,8 @@ struct Node16 : Node {
  void copyChildrenAndKeyFrom(const Node3 &other);
  void copyChildrenAndKeyFrom(const Node16 &other);
  void copyChildrenAndKeyFrom(const struct Node48 &other);
+
+  size_t size() const { return sizeof(Node16) + getCapacity(); }
 };

 struct Node48 : Node {
@@ -290,6 +300,8 @@ struct Node48 : Node {
  void copyChildrenAndKeyFrom(const Node16 &other);
  void copyChildrenAndKeyFrom(const Node48 &other);
  void copyChildrenAndKeyFrom(const struct Node256 &other);
+
+  size_t size() const { return sizeof(Node48) + getCapacity(); }
 };

 struct Node256 : Node {
@@ -299,6 +311,8 @@ struct Node256 : Node {
  uint8_t *partialKey() { return (uint8_t *)(this + 1); }
  void copyChildrenAndKeyFrom(const Node48 &other);
  void copyChildrenAndKeyFrom(const Node256 &other);
+
+  size_t size() const { return sizeof(Node256) + getCapacity(); }
 };

 inline void Node0::copyChildrenAndKeyFrom(const Node0 &other) {
@@ -322,8 +336,8 @@ inline void Node3::copyChildrenAndKeyFrom(const Node0 &other) {
 inline void Node3::copyChildrenAndKeyFrom(const Node3 &other) {
  memcpy((char *)this + kNodeCopyBegin, (char *)&other + kNodeCopyBegin,
         kNodeCopySize);
-  memcpy(index, other.index,
-         sizeof(*this) - offsetof(Node3, index) + partialKeyLen);
+  memcpy(index, other.index, sizeof(*this) - sizeof(Node));
+  memcpy(partialKey(), &other + 1, partialKeyLen);
  for (int i = 0; i < numChildren; ++i) {
    assert(children[i].child->parent == &other);
    children[i].child->parent = this;
@@ -374,10 +388,8 @@ inline void Node16::copyChildrenAndKeyFrom(const Node48 &other) {
  other.bitSet.forEachInRange(
      [&](int c) {
        // Suppress a false positive -Waggressive-loop-optimizations warning
-        // in gcc. `assume` doesn't work for some reason.
-        if (!(i < Node16::kMaxNodes)) {
-          __builtin_unreachable(); // GCOVR_EXCL_LINE
-        }
+        // in gcc
+        assume(i < Node16::kMaxNodes);
        index[i] = c;
        children[i] = other.children[other.index[c]];
        assert(children[i].child->parent == &other);
@@ -411,7 +423,7 @@ inline void Node48::copyChildrenAndKeyFrom(const Node48 &other) {
  memcpy((char *)this + kNodeCopyBegin, (char *)&other + kNodeCopyBegin,
         kNodeCopySize);
  memcpy(&bitSet, &other.bitSet,
-         offsetof(Node48, children) - offsetof(Node48, bitSet));
+         sizeof(*this) - sizeof(Node) - sizeof(children));
  for (int i = 0; i < numChildren; ++i) {
    children[i] = other.children[i];
    assert(children[i].child->parent == &other);
@@ -430,10 +442,8 @@ inline void Node48::copyChildrenAndKeyFrom(const Node256 &other) {
  bitSet.forEachInRange(
      [&](int c) {
        // Suppress a false positive -Waggressive-loop-optimizations warning
-        // in gcc. `assume` doesn't work for some reason.
-        if (!(i < Node48::kMaxNodes)) {
-          __builtin_unreachable(); // GCOVR_EXCL_LINE
-        }
+        // in gcc.
+        assume(i < Node48::kMaxNodes);
        index[c] = i;
        children[i] = other.children[c];
        assert(children[i].child->parent == &other);
@@ -476,7 +486,8 @@ inline void Node256::copyChildrenAndKeyFrom(const Node256 &other) {

 namespace {
 std::string getSearchPathPrintable(Node *n);
-}
+std::string getSearchPath(Node *n);
+} // namespace

 // Bound memory usage following the analysis in the ART paper

@@ -538,7 +549,7 @@ template <class T> struct BoundedFreeListAllocator {
      } else {
        // The intent is to filter out too-small nodes in the freelist
        removeNode(n);
-        safe_free(n);
+        safe_free(n, sizeof(T) + n->partialKeyCapacity);
      }
    }

@@ -550,10 +561,9 @@ template <class T> struct BoundedFreeListAllocator {
  }

  void release(T *p) {
-    static_assert(std::is_trivially_destructible_v<T>);
    if (freeListBytes >= kFreeListMaxMemory) {
      removeNode(p);
-      return safe_free(p);
+      return safe_free(p, sizeof(T) + p->partialKeyCapacity);
    }
    memcpy((void *)p, &freeList, sizeof(freeList));
    freeList = p;
@@ -563,11 +573,11 @@ template <class T> struct BoundedFreeListAllocator {

  ~BoundedFreeListAllocator() {
    for (void *iter = freeList; iter != nullptr;) {
-      VALGRIND_MAKE_MEM_DEFINED(iter, sizeof(iter));
-      auto *tmp = iter;
+      VALGRIND_MAKE_MEM_DEFINED(iter, sizeof(Node));
+      auto *tmp = (T *)iter;
      memcpy(&iter, iter, sizeof(void *));
-      removeNode(((T *)tmp));
-      safe_free(tmp);
+      removeNode((tmp));
+      safe_free(tmp, sizeof(T) + tmp->partialKeyCapacity);
    }
  }

@@ -593,6 +603,23 @@ uint8_t *Node::partialKey() {
  }
 }

+size_t Node::size() const {
+  switch (type) {
+  case Type_Node0:
+    return ((Node0 *)this)->size();
+  case Type_Node3:
+    return ((Node3 *)this)->size();
+  case Type_Node16:
+    return ((Node16 *)this)->size();
+  case Type_Node48:
+    return ((Node48 *)this)->size();
+  case Type_Node256:
+    return ((Node256 *)this)->size();
+  default:                   // GCOVR_EXCL_LINE
+    __builtin_unreachable(); // GCOVR_EXCL_LINE
+  }
+}
+
 struct NodeAllocators {
  BoundedFreeListAllocator<Node0> node0;
  BoundedFreeListAllocator<Node3> node3;
@@ -603,6 +630,21 @@ struct NodeAllocators {

 template <class NodeT> int getNodeIndex(NodeT *self, uint8_t index) {
  static_assert(std::is_same_v<NodeT, Node3> || std::is_same_v<NodeT, Node16>);
+
+  // cachegrind says the plain loop is fewer instructions and more mis-predicted
+  // branches. Microbenchmark says plain loop is faster. It's written in this
+  // weird "generic" way though in case someday we can use the simd
+  // implementation easily if we want.
+  if constexpr (std::is_same_v<NodeT, Node3>) {
+    Node3 *n = (Node3 *)self;
+    for (int i = 0; i < n->numChildren; ++i) {
+      if (n->index[i] == index) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
 #ifdef HAS_AVX
  // Based on https://www.the-paper-trail.org/post/art-paper-notes/

@@ -665,7 +707,7 @@ template <class NodeT> int getNodeIndex(NodeT *self, uint8_t index) {
 // Precondition - an entry for index must exist in the node
 Node *&getChildExists(Node *self, uint8_t index) {
  switch (self->getType()) {
-  case Type_Node0:
+  case Type_Node0:           // GCOVR_EXCL_LINE
    __builtin_unreachable(); // GCOVR_EXCL_LINE
  case Type_Node3: {
    auto *self3 = static_cast<Node3 *>(self);
@@ -725,6 +767,21 @@ Node *getChild(Node *self, uint8_t index) {

 template <class NodeT> int getChildGeqSimd(NodeT *self, int child) {
  static_assert(std::is_same_v<NodeT, Node3> || std::is_same_v<NodeT, Node16>);
+
+  // cachegrind says the plain loop is fewer instructions and more mis-predicted
+  // branches. Microbenchmark says plain loop is faster. It's written in this
+  // weird "generic" way though so that someday we can use the simd
+  // implementation easily if we want.
+  if constexpr (std::is_same_v<NodeT, Node3>) {
+    Node3 *n = (Node3 *)self;
+    for (int i = 0; i < n->numChildren; ++i) {
+      if (n->index[i] >= child) {
+        return n->index[i];
+      }
+    }
+    return -1;
+  }
+
 #ifdef HAS_AVX
  __m128i key_vec = _mm_set1_epi8(child);
  __m128i indices;
@@ -898,6 +955,42 @@ Node *&getOrCreateChild(Node *&self, uint8_t index,
    assert(self->getType() == Type_Node16);

    ++self->numChildren;
+#ifdef HAS_AVX
+    __m128i key_vec = _mm_set1_epi8(index);
+    __m128i indices;
+    memcpy(&indices, self16->index, sizeof(self16->index));
+    __m128i results = _mm_cmpeq_epi8(key_vec, _mm_min_epu8(key_vec, indices));
+    int mask = (1 << (self->numChildren - 1)) - 1;
+    uint32_t bitfield = _mm_movemask_epi8(results) & mask;
+    bitfield |= uint32_t(1) << (self->numChildren - 1);
+    int i = std::countr_zero(bitfield);
+    if (i < self->numChildren - 1) {
+      memmove(self16->index + i + 1, self16->index + i,
+              self->numChildren - (i + 1));
+      memmove(self16->children + i + 1, self16->children + i,
+              (self->numChildren - (i + 1)) * sizeof(Child));
+    }
+#elif defined(HAS_ARM_NEON)
+    uint8x16_t indices;
+    memcpy(&indices, self16->index, sizeof(self16->index));
+    // 0xff for each leq
+    auto results = vcleq_u8(vdupq_n_u8(index), indices);
+    uint64_t mask = (uint64_t(1) << ((self->numChildren - 1) * 4)) - 1;
+    // 0xf for each 0xff (within mask)
+    uint64_t bitfield =
+        vget_lane_u64(
+            vreinterpret_u64_u8(vshrn_n_u16(vreinterpretq_u16_u8(results), 4)),
+            0) &
+        mask;
+    bitfield |= uint64_t(0xf) << ((self->numChildren - 1) * 4);
+    int i = std::countr_zero(bitfield) / 4;
+    if (i < self->numChildren - 1) {
+      memmove(self16->index + i + 1, self16->index + i,
+              self->numChildren - (i + 1));
+      memmove(self16->children + i + 1, self16->children + i,
+              (self->numChildren - (i + 1)) * sizeof(Child));
+    }
+#else
    int i = 0;
    for (; i < int(self->numChildren) - 1; ++i) {
      if (int(self16->index[i]) > int(index)) {
@@ -908,6 +1001,7 @@ Node *&getOrCreateChild(Node *&self, uint8_t index,
        break;
      }
    }
+#endif
    self16->index[i] = index;
    auto &result = self16->children[i].child;
    result = nullptr;
@@ -923,8 +1017,8 @@ Node *&getOrCreateChild(Node *&self, uint8_t index,
      self = newSelf;
      goto insert256;
    }
-  insert48:

+  insert48:
    auto *self48 = static_cast<Node48 *>(self);
    self48->bitSet.set(index);
    ++self->numChildren;
@@ -936,6 +1030,7 @@ Node *&getOrCreateChild(Node *&self, uint8_t index,
    return result;
  }
  case Type_Node256: {
+
  insert256:
    auto *self256 = static_cast<Node256 *>(self);
    ++self->numChildren;
@@ -971,21 +1066,21 @@ Node *nextLogical(Node *node) {

 // Invalidates `self`, replacing it with a node of at least capacity.
 // Does not return nodes to freelists when kUseFreeList is false.
-template <bool kUseFreeList>
 void freeAndMakeCapacityAtLeast(Node *&self, int capacity,
                                NodeAllocators *allocators,
-                                ConflictSet::Impl *impl) {
+                                ConflictSet::Impl *impl,
+                                const bool kUseFreeList) {
  switch (self->getType()) {
  case Type_Node0: {
    auto *self0 = (Node0 *)self;
    auto *newSelf = allocators->node0.allocate(capacity);
    newSelf->copyChildrenAndKeyFrom(*self0);
    getInTree(self, impl) = newSelf;
-    if constexpr (kUseFreeList) {
+    if (kUseFreeList) {
      allocators->node0.release(self0);
    } else {
      removeNode(self0);
-      safe_free(self0);
+      safe_free(self0, self0->size());
    }
    self = newSelf;
  } break;
@@ -994,11 +1089,11 @@ void freeAndMakeCapacityAtLeast(Node *&self, int capacity,
    auto *newSelf = allocators->node3.allocate(capacity);
    newSelf->copyChildrenAndKeyFrom(*self3);
    getInTree(self, impl) = newSelf;
-    if constexpr (kUseFreeList) {
+    if (kUseFreeList) {
      allocators->node3.release(self3);
    } else {
      removeNode(self3);
-      safe_free(self3);
+      safe_free(self3, self3->size());
    }
    self = newSelf;
  } break;
@@ -1007,11 +1102,11 @@ void freeAndMakeCapacityAtLeast(Node *&self, int capacity,
    auto *newSelf = allocators->node16.allocate(capacity);
    newSelf->copyChildrenAndKeyFrom(*self16);
    getInTree(self, impl) = newSelf;
-    if constexpr (kUseFreeList) {
+    if (kUseFreeList) {
      allocators->node16.release(self16);
    } else {
      removeNode(self16);
-      safe_free(self16);
+      safe_free(self16, self16->size());
    }
    self = newSelf;
  } break;
@@ -1020,11 +1115,11 @@ void freeAndMakeCapacityAtLeast(Node *&self, int capacity,
    auto *newSelf = allocators->node48.allocate(capacity);
    newSelf->copyChildrenAndKeyFrom(*self48);
    getInTree(self, impl) = newSelf;
-    if constexpr (kUseFreeList) {
+    if (kUseFreeList) {
      allocators->node48.release(self48);
    } else {
      removeNode(self48);
-      safe_free(self48);
+      safe_free(self48, self48->size());
    }
    self = newSelf;
  } break;
@@ -1033,11 +1128,11 @@ void freeAndMakeCapacityAtLeast(Node *&self, int capacity,
    auto *newSelf = allocators->node256.allocate(capacity);
    newSelf->copyChildrenAndKeyFrom(*self256);
    getInTree(self, impl) = newSelf;
-    if constexpr (kUseFreeList) {
+    if (kUseFreeList) {
      allocators->node256.release(self256);
    } else {
      removeNode(self256);
-      safe_free(self256);
+      safe_free(self256, self256->size());
    }
    self = newSelf;
  } break;
@@ -1051,16 +1146,20 @@ void freeAndMakeCapacityAtLeast(Node *&self, int capacity,
 // capacity.
 void maybeDecreaseCapacity(Node *&self, NodeAllocators *allocators,
                           ConflictSet::Impl *impl) {
+
  const int maxCapacity =
-      (self->numChildren + int(self->entryPresent)) * self->partialKeyLen;
+      (self->numChildren + int(self->entryPresent)) * (self->partialKeyLen + 1);
+#if DEBUG_VERBOSE && !defined(NDEBUG)
+  fprintf(stderr, "maybeDecreaseCapacity: current: %d, max: %d, key: %s\n",
+          self->getCapacity(), maxCapacity,
+          getSearchPathPrintable(self).c_str());
+#endif
  if (self->getCapacity() <= maxCapacity) {
    return;
  }
-  freeAndMakeCapacityAtLeast</*kUseFreeList*/ false>(self, maxCapacity,
-                                                     allocators, impl);
+  freeAndMakeCapacityAtLeast(self, maxCapacity, allocators, impl, false);
 }

-// TODO fuse into erase child so we don't need to repeat branches on type
 void maybeDownsize(Node *self, NodeAllocators *allocators,
                   ConflictSet::Impl *impl, Node *&dontInvalidate) {

@@ -1069,7 +1168,7 @@ void maybeDownsize(Node *self, NodeAllocators *allocators,
 #endif

  switch (self->getType()) {
-  case Type_Node0:
+  case Type_Node0:           // GCOVR_EXCL_LINE
    __builtin_unreachable(); // GCOVR_EXCL_LINE
  case Type_Node3: {
    auto *self3 = (Node3 *)self;
@@ -1084,8 +1183,7 @@ void maybeDownsize(Node *self, NodeAllocators *allocators,

      if (minCapacity > child->getCapacity()) {
        const bool update = child == dontInvalidate;
-        freeAndMakeCapacityAtLeast</*kUseFreeList*/ true>(child, minCapacity,
-                                                          allocators, impl);
+        freeAndMakeCapacityAtLeast(child, minCapacity, allocators, impl, true);
        if (update) {
          dontInvalidate = child;
        }
@@ -1179,28 +1277,11 @@ Node *erase(Node *self, NodeAllocators *allocators, ConflictSet::Impl *impl,
    return result;
  }

-  switch (self->getType()) {
-  case Type_Node0:
+  assert(self->getType() == Type_Node0);
  allocators->node0.release((Node0 *)self);
-    break;
-  case Type_Node3:
-    allocators->node3.release((Node3 *)self);
-    break;
-  case Type_Node16:
-    allocators->node16.release((Node16 *)self);
-    break;
-  case Type_Node48:
-    allocators->node48.release((Node48 *)self);
-    break;
-  case Type_Node256:
-    allocators->node256.release((Node256 *)self);
-    break;
-  default:                   // GCOVR_EXCL_LINE
-    __builtin_unreachable(); // GCOVR_EXCL_LINE
-  }

  switch (parent->getType()) {
-  case Type_Node0:
+  case Type_Node0:           // GCOVR_EXCL_LINE
    __builtin_unreachable(); // GCOVR_EXCL_LINE
  case Type_Node3: {
    auto *parent3 = static_cast<Node3 *>(parent);
@@ -1212,6 +1293,9 @@ Node *erase(Node *self, NodeAllocators *allocators, ConflictSet::Impl *impl,
    memmove(parent3->children + nodeIndex, parent3->children + nodeIndex + 1,
            sizeof(parent3->children[0]) *
                (parent->numChildren - (nodeIndex + 1)));
+
+    --parent->numChildren;
+    assert(parent->numChildren > 0 || parent->entryPresent);
  } break;
  case Type_Node16: {
    auto *parent16 = static_cast<Node16 *>(parent);
@@ -1223,6 +1307,11 @@ Node *erase(Node *self, NodeAllocators *allocators, ConflictSet::Impl *impl,
    memmove(parent16->children + nodeIndex, parent16->children + nodeIndex + 1,
            sizeof(parent16->children[0]) *
                (parent->numChildren - (nodeIndex + 1)));
+
+    --parent->numChildren;
+
+    // By kMinChildrenNode16
+    assert(parent->numChildren > 0);
  } break;
  case Type_Node48: {
    auto *parent48 = static_cast<Node48 *>(parent);
@@ -1238,27 +1327,33 @@ Node *erase(Node *self, NodeAllocators *allocators, ConflictSet::Impl *impl,
      parent48->index[parent48->children[toRemoveChildrenIndex]
                          .child->parentsIndex] = toRemoveChildrenIndex;
    }
+
+    --parent->numChildren;
+
+    // By kMinChildrenNode48
+    assert(parent->numChildren > 0);
  } break;
  case Type_Node256: {
    auto *parent256 = static_cast<Node256 *>(parent);
    parent256->bitSet.reset(parentsIndex);
    parent256->children[parentsIndex].child = nullptr;
+
+    --parent->numChildren;
+
+    // By kMinChildrenNode256
+    assert(parent->numChildren > 0);
+
  } break;
  default:                   // GCOVR_EXCL_LINE
    __builtin_unreachable(); // GCOVR_EXCL_LINE
  }

-  --parent->numChildren;
-  if (parent->numChildren == 0 && !parent->entryPresent &&
-      parent->parent != nullptr) {
-    return erase(parent, allocators, impl, dontInvalidate);
-  } else {
  const bool update = result == dontInvalidate;
  maybeDownsize(parent, allocators, impl, result);
  if (update) {
    dontInvalidate = result;
  }
-  }
+
  return result;
 }

@@ -1292,7 +1387,7 @@ constexpr int kUnrollFactor = 4;
 bool compareStride(const uint8_t *ap, const uint8_t *bp) {
 #if defined(HAS_ARM_NEON)
  static_assert(kStride == 64);
-  uint8x16_t x[4];
+  uint8x16_t x[4]; // GCOVR_EXCL_LINE
  for (int i = 0; i < 4; ++i) {
    x[i] = vceqq_u8(vld1q_u8(ap + i * 16), vld1q_u8(bp + i * 16));
  }
@@ -1302,7 +1397,7 @@ bool compareStride(const uint8_t *ap, const uint8_t *bp) {
            uint64_t(-1);
 #elif defined(HAS_AVX)
  static_assert(kStride == 64);
-  __m128i x[4];
+  __m128i x[4]; // GCOVR_EXCL_LINE
  for (int i = 0; i < 4; ++i) {
    x[i] = _mm_cmpeq_epi8(_mm_loadu_si128((__m128i *)(ap + i * 16)),
                          _mm_loadu_si128((__m128i *)(bp + i * 16)));
@@ -1321,7 +1416,7 @@ bool compareStride(const uint8_t *ap, const uint8_t *bp) {
 int firstNeqStride(const uint8_t *ap, const uint8_t *bp) {
 #if defined(HAS_AVX)
  static_assert(kStride == 64);
-  uint64_t c[kStride / 16];
+  uint64_t c[kStride / 16]; // GCOVR_EXCL_LINE
  for (int i = 0; i < kStride; i += 16) {
    const auto a = _mm_loadu_si128((__m128i *)(ap + i));
    const auto b = _mm_loadu_si128((__m128i *)(bp + i));
@@ -1363,18 +1458,6 @@ int longestCommonPrefix(const uint8_t *ap, const uint8_t *bp, int cl) {
    goto bytes;
  }

-  // Optimistic early return
-  {
-    uint64_t a;
-    uint64_t b;
-    memcpy(&a, ap, 8);
-    memcpy(&b, bp, 8);
-    const auto mismatched = a ^ b;
-    if (mismatched) {
-      return std::countr_zero(mismatched) / 8;
-    }
-  }
-
  // kStride * kUnrollCount at a time
  end = cl & ~(kStride * kUnrollFactor - 1);
  while (i < end) {
@@ -1402,8 +1485,8 @@ int longestCommonPrefix(const uint8_t *ap, const uint8_t *bp, int cl) {
  // word at a time
  end = cl & ~(sizeof(uint64_t) - 1);
  while (i < end) {
-    uint64_t a;
-    uint64_t b;
+    uint64_t a; // GCOVR_EXCL_LINE
+    uint64_t b; // GCOVR_EXCL_LINE
    memcpy(&a, ap, 8);
    memcpy(&b, bp, 8);
    const auto mismatched = a ^ b;
@@ -1492,6 +1575,9 @@ bool checkPointRead(Node *n, const std::span<const uint8_t> key,
        goto downLeftSpine;
      } else {
        n = nextSibling(n);
+        if (n == nullptr) {
+          return true;
+        }
        goto downLeftSpine;
      }
    }
@@ -1508,6 +1594,9 @@ bool checkPointRead(Node *n, const std::span<const uint8_t> key,
          goto downLeftSpine;
        } else {
          n = nextSibling(n);
+          if (n == nullptr) {
+            return true;
+          }
          goto downLeftSpine;
        }
      }
@@ -1522,9 +1611,6 @@ bool checkPointRead(Node *n, const std::span<const uint8_t> key,
    }
  }
 downLeftSpine:
-  if (n == nullptr) {
-    return true;
-  }
  for (;;) {
    if (n->entryPresent) {
      return n->entry.rangeVersion <= readVersion;
@@ -1558,7 +1644,7 @@ int64_t maxBetweenExclusive(Node *n, int begin, int end) {
    }
  }
  switch (n->getType()) {
-  case Type_Node0:
+  case Type_Node0: // GCOVR_EXCL_LINE
    // We would have returned above, after not finding a child
    __builtin_unreachable(); // GCOVR_EXCL_LINE
  case Type_Node3: {
@@ -1621,10 +1707,13 @@ Vector<uint8_t> getSearchPath(Arena &arena, Node *n) {
  }
  std::reverse(result.begin(), result.end());
  return result;
-}
+} // GCOVR_EXCL_LINE

 // Return true if the max version among all keys that start with key + [child],
-// where begin < child < end, is <= readVersion
+// where begin < child < end, is <= readVersion.
+//
+// Precondition: transitively, no child of n has a search path that's a longer
+// prefix of key than n
 bool checkRangeStartsWith(Node *n, std::span<const uint8_t> key, int begin,
                          int end, int64_t readVersion,
                          ConflictSet::Impl *impl) {
@@ -1632,10 +1721,6 @@ bool checkRangeStartsWith(Node *n, std::span<const uint8_t> key, int begin,
  fprintf(stderr, "%s(%02x,%02x)*\n", printable(key).c_str(), begin, end);
 #endif
  auto remaining = key;
-  for (;;) {
-    if (maxVersion(n, impl) <= readVersion) {
-      return true;
-    }
  if (remaining.size() == 0) {
    return maxBetweenExclusive(n, begin, end) <= readVersion;
  }
@@ -1648,6 +1733,9 @@ bool checkRangeStartsWith(Node *n, std::span<const uint8_t> key, int begin,
      goto downLeftSpine;
    } else {
      n = nextSibling(n);
+      if (n == nullptr) {
+        return true;
+      }
      goto downLeftSpine;
    }
  }
@@ -1655,7 +1743,8 @@ bool checkRangeStartsWith(Node *n, std::span<const uint8_t> key, int begin,
  n = child;
  remaining = remaining.subspan(1, remaining.size() - 1);

-    if (n->partialKeyLen > 0) {
+  assert(n->partialKeyLen > 0);
+  {
    int commonLen = std::min<int>(n->partialKeyLen, remaining.size());
    int i = longestCommonPrefix(n->partialKey(), remaining.data(), commonLen);
    if (i < commonLen) {
@@ -1664,13 +1753,13 @@ bool checkRangeStartsWith(Node *n, std::span<const uint8_t> key, int begin,
        goto downLeftSpine;
      } else {
        n = nextSibling(n);
+        if (n == nullptr) {
+          return true;
+        }
        goto downLeftSpine;
      }
    }
-      if (commonLen == n->partialKeyLen) {
-        // partial key matches
-        remaining = remaining.subspan(commonLen, remaining.size() - commonLen);
-      } else if (n->partialKeyLen > int(remaining.size())) {
+    assert(n->partialKeyLen > int(remaining.size()));
    if (begin < n->partialKey()[remaining.size()] &&
        n->partialKey()[remaining.size()] < end) {
      if (n->entryPresent && n->entry.rangeVersion > readVersion) {
@@ -1680,12 +1769,10 @@ bool checkRangeStartsWith(Node *n, std::span<const uint8_t> key, int begin,
    }
    return true;
  }
-    }
-  }
+
+  __builtin_unreachable(); // GCOVR_EXCL_LINE
+
 downLeftSpine:
-  if (n == nullptr) {
-    return true;
-  }
  for (;;) {
    if (n->entryPresent) {
      return n->entry.rangeVersion <= readVersion;
@@ -1753,6 +1840,10 @@ struct CheckRangeLeftSide {
          return true;
        } else {
          n = nextSibling(n);
+          if (n == nullptr) {
+            ok = true;
+            return true;
+          }
          return downLeftSpine();
        }
      }
@@ -1780,6 +1871,10 @@ struct CheckRangeLeftSide {
            return true;
          } else {
            n = nextSibling(n);
+            if (n == nullptr) {
+              ok = true;
+              return true;
+            }
            return downLeftSpine();
          }
        }
@@ -1788,9 +1883,7 @@ struct CheckRangeLeftSide {
          remaining =
              remaining.subspan(commonLen, remaining.size() - commonLen);
        } else if (n->partialKeyLen > int(remaining.size())) {
-          if (searchPathLen < prefixLen) {
-            return downLeftSpine();
-          }
+          assert(searchPathLen >= prefixLen);
          if (n->entryPresent && n->entry.rangeVersion > readVersion) {
            ok = false;
            return true;
@@ -1818,10 +1911,6 @@ struct CheckRangeLeftSide {

  bool downLeftSpine() {
    phase = DownLeftSpine;
-    if (n == nullptr) {
-      ok = true;
-      return true;
-    }
    return false;
  }
 };
@@ -1969,10 +2058,7 @@ struct CheckRangeRightSide {

  bool downLeftSpine() {
    phase = DownLeftSpine;
-    if (n == nullptr) {
-      ok = true;
-      return true;
-    }
+    assert(n != nullptr);
    return false;
  }
 };
@@ -2166,7 +2252,7 @@ void destroyTree(Node *root) {
      assert(c != nullptr);
      toFree.push_back(c);
    }
-    safe_free(n);
+    safe_free(n, n->size());
  }
 }

@@ -2308,6 +2394,13 @@ Iterator firstGeq(Node *n, const std::span<const uint8_t> key) {
        goto downLeftSpine;
      } else {
        n = nextSibling(n);
+        if (n == nullptr) {
+          //  This line is genuinely unreachable from any entry point of the
+          //  final library, since we can't remove a key without introducing a
+          //  key after it, and the only production caller of firstGeq is for
+          //  resuming the setOldestVersion scan.
+          return {nullptr, 1}; // GCOVR_EXCL_LINE
+        }
        goto downLeftSpine;
      }
    }
@@ -2338,9 +2431,6 @@ Iterator firstGeq(Node *n, const std::span<const uint8_t> key) {
    }
  }
 downLeftSpine:
-  if (n == nullptr) {
-    return {nullptr, 1};
-  }
  for (;;) {
    if (n->entryPresent) {
      return {n, 1};
@@ -2390,19 +2480,24 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
      return;
    }
    this->oldestVersion = oldestVersion;
+#ifdef NDEBUG
+    // This is here for performance reasons, since we want to amortize the cost
+    // of storing the search path as a string. In tests, we want to exercise the
+    // rest of the code often.
    if (keyUpdates < 100) {
      return;
    }
+#endif
    Node *n = firstGeq(root, removalKey).n;
    // There's no way to erase removalKey without introducing a key after it
    assert(n != nullptr);
    // Don't erase the root
    if (n == root) {
-      n = nextLogical(n);
+      n = nextPhysical(n);
    }
    for (; keyUpdates > 0 && n != nullptr; --keyUpdates) {
-      if (std::max(n->entry.pointVersion, n->entry.rangeVersion) <=
-          oldestVersion) {
+      if (n->entryPresent && std::max(n->entry.pointVersion,
+                                      n->entry.rangeVersion) <= oldestVersion) {
        // Any transaction n would have prevented from committing is
        // going to fail with TooOld anyway.

@@ -2413,21 +2508,22 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
        n = erase(n, &allocators, this, dummy);
      } else {
        maybeDecreaseCapacity(n, &allocators, this);
-        n = nextLogical(n);
+        n = nextPhysical(n);
      }
    }
    if (n == nullptr) {
      removalKey = {};
-      return;
-    }
-    if (keyUpdates == 0) {
-      keyUpdates = 10;
-    }
+    } else {
      removalKeyArena = Arena();
      removalKey = getSearchPath(removalKeyArena, n);
    }
+  }

  explicit Impl(int64_t oldestVersion) : oldestVersion(oldestVersion) {
+#if DEBUG_VERBOSE
+    fprintf(stderr, "radix_tree: create\n");
+#endif
+
    // Insert ""
    root = allocators.node0.allocate(0);
    root->numChildren = 0;
@@ -2442,7 +2538,12 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
    root->entry.pointVersion = oldestVersion;
    root->entry.rangeVersion = oldestVersion;
  }
-  ~Impl() { destroyTree(root); }
+  ~Impl() {
+#if DEBUG_VERBOSE
+    fprintf(stderr, "radix_tree: destroy\n");
+#endif
+    destroyTree(root);
+  }

  NodeAllocators allocators;

@@ -2453,6 +2554,7 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
  Node *root;
  int64_t rootMaxVersion;
  int64_t oldestVersion;
+  int64_t totalBytes = 0;
 };

 // Precondition - an entry for index must exist in the node
@@ -2463,7 +2565,7 @@ int64_t &maxVersion(Node *n, ConflictSet::Impl *impl) {
    return impl->rootMaxVersion;
  }
  switch (n->getType()) {
-  case Type_Node0:
+  case Type_Node0:           // GCOVR_EXCL_LINE
    __builtin_unreachable(); // GCOVR_EXCL_LINE
  case Type_Node3: {
    auto *n3 = static_cast<Node3 *>(n);
@@ -2506,20 +2608,39 @@ void ConflictSet::check(const ReadRange *reads, Result *results,

 void ConflictSet::addWrites(const WriteRange *writes, int count,
                            int64_t writeVersion) {
-  return impl->addWrites(writes, count, writeVersion);
+  mallocBytesDelta = 0;
+  impl->addWrites(writes, count, writeVersion);
+  impl->totalBytes += mallocBytesDelta;
+#if SHOW_MEMORY
+  if (impl->totalBytes != mallocBytes) {
+    abort();
+  }
+#endif
 }

 void ConflictSet::setOldestVersion(int64_t oldestVersion) {
-  return impl->setOldestVersion(oldestVersion);
+  mallocBytesDelta = 0;
+  impl->setOldestVersion(oldestVersion);
+  impl->totalBytes += mallocBytesDelta;
+#if SHOW_MEMORY
+  if (impl->totalBytes != mallocBytes) {
+    abort();
+  }
+#endif
 }

+int64_t ConflictSet::getBytes() const { return impl->totalBytes; }
+
 ConflictSet::ConflictSet(int64_t oldestVersion)
-    : impl(new (safe_malloc(sizeof(Impl))) Impl{oldestVersion}) {}
+    : impl((mallocBytesDelta = 0,
+            new(safe_malloc(sizeof(Impl))) Impl{oldestVersion})) {
+  impl->totalBytes += mallocBytesDelta;
+}

 ConflictSet::~ConflictSet() {
  if (impl) {
    impl->~Impl();
-    safe_free(impl);
+    safe_free(impl, sizeof(*impl));
  }
 }

@@ -2545,24 +2666,54 @@ ConflictSet_check(void *cs, const ConflictSet_ReadRange *reads,
 __attribute__((__visibility__("default"))) void
 ConflictSet_addWrites(void *cs, const ConflictSet_WriteRange *writes, int count,
                      int64_t writeVersion) {
-  ((ConflictSet::Impl *)cs)->addWrites(writes, count, writeVersion);
+  auto *impl = (ConflictSet::Impl *)cs;
+  mallocBytesDelta = 0;
+  impl->addWrites(writes, count, writeVersion);
+  impl->totalBytes += mallocBytesDelta;
+#if SHOW_MEMORY
+  if (impl->totalBytes != mallocBytes) {
+    abort();
+  }
+#endif
 }
 __attribute__((__visibility__("default"))) void
 ConflictSet_setOldestVersion(void *cs, int64_t oldestVersion) {
-  ((ConflictSet::Impl *)cs)->setOldestVersion(oldestVersion);
+  auto *impl = (ConflictSet::Impl *)cs;
+  mallocBytesDelta = 0;
+  impl->setOldestVersion(oldestVersion);
+  impl->totalBytes += mallocBytesDelta;
+#if SHOW_MEMORY
+  if (impl->totalBytes != mallocBytes) {
+    abort();
+  }
+#endif
 }
 __attribute__((__visibility__("default"))) void *
 ConflictSet_create(int64_t oldestVersion) {
-  return new (safe_malloc(sizeof(ConflictSet::Impl)))
+  mallocBytesDelta = 0;
+  auto *result = new (safe_malloc(sizeof(ConflictSet::Impl)))
      ConflictSet::Impl{oldestVersion};
+  result->totalBytes += mallocBytesDelta;
+  return result;
 }
 __attribute__((__visibility__("default"))) void ConflictSet_destroy(void *cs) {
  using Impl = ConflictSet::Impl;
  ((Impl *)cs)->~Impl();
-  safe_free(cs);
+  safe_free(cs, sizeof(Impl));
+}
+__attribute__((__visibility__("default"))) int64_t
+ConflictSet_getBytes(void *cs) {
+  using Impl = ConflictSet::Impl;
+  return ((Impl *)cs)->totalBytes;
 }
 }

+// Make sure abi is well-defined
+static_assert(std::is_standard_layout_v<ConflictSet::Result>);
+static_assert(std::is_standard_layout_v<ConflictSet::Key>);
+static_assert(std::is_standard_layout_v<ConflictSet::ReadRange>);
+static_assert(std::is_standard_layout_v<ConflictSet::WriteRange>);
+
 namespace {

 std::string getSearchPathPrintable(Node *n) {
@@ -2757,8 +2908,8 @@ Iterator firstGeq(Node *n, std::string_view key) {
  case Type_Node256:
    minNumChildren = kMinChildrenNode256;
    break;
-  default:                   // GCOVR_EXCL_LINE
-    __builtin_unreachable(); // GCOVR_EXCL_LINE
+  default:
+    abort();
  }
  if (node->numChildren + int(node->entryPresent) < minNumChildren) {
    fprintf(stderr,
@@ -2775,7 +2926,7 @@ Iterator firstGeq(Node *n, std::string_view key) {
  }
 }

-bool checkCorrectness(Node *node, int64_t oldestVersion,
+[[maybe_unused]] bool checkCorrectness(Node *node, int64_t oldestVersion,
                                       ConflictSet::Impl *impl) {
  bool success = true;

@@ -2816,8 +2967,8 @@ int64_t getNodeSize(struct Node *n) {
    return sizeof(Node48);
  case Type_Node256:
    return sizeof(Node256);
-  default:                   // GCOVR_EXCL_LINE
-    __builtin_unreachable(); // GCOVR_EXCL_LINE
+  default:
+    abort();
  }
 }

@@ -2873,6 +3024,7 @@ void removeKey(Node *n) {

 struct __attribute__((visibility("default"))) PeakPrinter {
  ~PeakPrinter() {
+    printf("--- radix_tree ---\n");
    printf("malloc bytes: %g\n", double(mallocBytes));
    printf("Peak malloc bytes: %g\n", double(peakMallocBytes));
    printf("Node bytes: %g\n", double(nodeBytes));
--- a/FuzzTestDriver.cpp
+++ b/FuzzTestDriver.cpp
@@ -2,10 +2,12 @@
 #include <cstdint>
 #include <fstream>
 #include <sstream>
+#include <thread>

 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);

 int main(int argc, char **argv) {
+  auto doTest = [&]() {
    for (int i = 1; i < argc; ++i) {
      std::ifstream t(argv[i], std::ios::binary);
      std::stringstream buffer;
@@ -13,4 +15,12 @@ int main(int argc, char **argv) {
      auto str = buffer.str();
      LLVMFuzzerTestOneInput((const uint8_t *)str.data(), str.size());
    }
+  };
+#ifdef THREAD_TEST
+  std::thread thread2{doTest};
+#endif
+  doTest();
+#ifdef THREAD_TEST
+  thread2.join();
+#endif
 }
--- a/HashTable.cpp
+++ b/HashTable.cpp
@@ -96,13 +96,15 @@ void ConflictSet::setOldestVersion(int64_t oldestVersion) {
  return impl->setOldestVersion(oldestVersion);
 }

+int64_t ConflictSet::getBytes() const { return -1; }
+
 ConflictSet::ConflictSet(int64_t oldestVersion)
-    : impl(new (safe_malloc(sizeof(Impl))) Impl{oldestVersion}) {}
+    : impl(new(safe_malloc(sizeof(Impl))) Impl{oldestVersion}) {}

 ConflictSet::~ConflictSet() {
  if (impl) {
    impl->~Impl();
-    safe_free(impl);
+    safe_free(impl, sizeof(Impl));
  }
 }

@@ -142,6 +144,11 @@ ConflictSet_create(int64_t oldestVersion) {
 __attribute__((__visibility__("default"))) void ConflictSet_destroy(void *cs) {
  using Impl = ConflictSet::Impl;
  ((Impl *)cs)->~Impl();
-  safe_free(cs);
+  safe_free(cs, sizeof(Impl));
+}
+__attribute__((__visibility__("default"))) int64_t
+ConflictSet_getBytes(void *cs) {
+  using Impl = ConflictSet::Impl;
+  return -1;
 }
 }
--- a/Internal.h
+++ b/Internal.h
@@ -2,6 +2,8 @@

 #include "ConflictSet.h"

+using namespace weaselab;
+
 #include <bit>
 #include <cassert>
 #include <compare>
@@ -10,10 +12,12 @@
 #include <cstdlib>
 #include <cstring>
 #include <inttypes.h>
+#include <latch>
 #include <map>
 #include <set>
 #include <span>
 #include <string>
+#include <thread>
 #include <unordered_set>
 #include <utility>
 #include <vector>
@@ -35,6 +39,17 @@ operator<=>(const std::span<const uint8_t> &lhs,
  return lhs.size() <=> rhs.size();
 }

+[[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) {
+    if (auto c = memcmp(lhs.data(), rhs.p, cl) <=> 0; c != 0) {
+      return c;
+    }
+  }
+  return lhs.size() <=> size_t(rhs.len);
+}
+
 // This header contains code that we want to reuse outside of ConflictSet.cpp or
 // want to exclude from coverage since it's only testing related.

@@ -43,43 +58,55 @@ operator<=>(const std::span<const uint8_t> &lhs,
 #if SHOW_MEMORY
 inline int64_t mallocBytes = 0;
 inline int64_t peakMallocBytes = 0;
-constexpr auto kIntMallocHeaderSize = 16;
+#endif
+
+inline thread_local int64_t mallocBytesDelta = 0;
+
+#ifndef NDEBUG
+constexpr auto kMallocHeaderSize = 16;
 #endif

 // malloc that aborts on OOM and thus always returns a non-null pointer. Must be
 // paired with `safe_free`.
 __attribute__((always_inline)) inline void *safe_malloc(size_t s) {
+  mallocBytesDelta += s;
 #if SHOW_MEMORY
  mallocBytes += s;
  if (mallocBytes > peakMallocBytes) {
    peakMallocBytes = mallocBytes;
  }
-  void *p = malloc(s + kIntMallocHeaderSize);
-  if (p == nullptr) {
-    abort();
-  }
-  memcpy(p, &s, sizeof(s));
-  return (char *)p + kIntMallocHeaderSize;
-#else
-  void *p = malloc(s);
-  if (p == nullptr) {
-    abort();
-  }
-  return p;
 #endif
+  void *p = malloc(s
+#ifndef NDEBUG
+                   + kMallocHeaderSize
+#endif
+  );
+  if (p == nullptr) {
+    abort();
+  }
+#ifndef NDEBUG
+  memcpy(p, &s, sizeof(s));
+  (char *&)p += kMallocHeaderSize;
+#endif
+  return p;
 }

 // Must be paired with `safe_malloc`.
 //
 // There's nothing safer about this than free. Only called safe_free for
 // symmetry with safe_malloc.
-__attribute__((always_inline)) inline void safe_free(void *p) {
+__attribute__((always_inline)) inline void safe_free(void *p, size_t s) {
+  mallocBytesDelta -= s;
 #if SHOW_MEMORY
-  size_t s;
-  memcpy(&s, (char *)p - kIntMallocHeaderSize, sizeof(s));
  mallocBytes -= s;
-  free((char *)p - kIntMallocHeaderSize);
+  free(p);
 #else
+#ifndef NDEBUG
+  (char *&)p -= kMallocHeaderSize;
+  size_t expected;
+  memcpy(&expected, p, sizeof(expected));
+  assert(s == expected);
+#endif
  free(p);
 #endif
 }
@@ -127,6 +154,7 @@ inline void *operator new[](size_t size, std::align_val_t align,

 /// align must be a power of two
 template <class T> T *align_up(T *t, size_t align) {
+  assert(std::popcount(align) == 1);
  auto unaligned = uintptr_t(t);
  auto aligned = (unaligned + align - 1) & ~(align - 1);
  return reinterpret_cast<T *>(reinterpret_cast<char *>(t) + aligned -
@@ -135,6 +163,7 @@ template <class T> T *align_up(T *t, size_t align) {

 /// align must be a power of two
 constexpr inline int align_up(uint32_t unaligned, uint32_t align) {
+  assert(std::popcount(align) == 1);
  return (unaligned + align - 1) & ~(align - 1);
 }

@@ -150,12 +179,10 @@ struct Arena::ArenaImpl {
  uint8_t *begin() { return reinterpret_cast<uint8_t *>(this + 1); }
 };

-static_assert(sizeof(Arena::ArenaImpl) == 16);
-static_assert(alignof(Arena::ArenaImpl) == 8);
-
 inline Arena::Arena(int initialSize) : impl(nullptr) {
  if (initialSize > 0) {
-    auto allocationSize = align_up(initialSize + sizeof(ArenaImpl), 16);
+    auto allocationSize =
+        align_up(initialSize + sizeof(ArenaImpl), alignof(ArenaImpl));
    impl = (Arena::ArenaImpl *)safe_malloc(allocationSize);
    impl->prev = nullptr;
    impl->capacity = allocationSize - sizeof(ArenaImpl);
@@ -166,7 +193,7 @@ inline Arena::Arena(int initialSize) : impl(nullptr) {
 inline void onDestroy(Arena::ArenaImpl *impl) {
  while (impl) {
    auto *prev = impl->prev;
-    safe_free(impl);
+    safe_free(impl, sizeof(Arena::ArenaImpl) + impl->capacity);
    impl = prev;
  }
 }
@@ -191,7 +218,7 @@ inline void *operator new(size_t size, std::align_val_t align, Arena &arena) {
                          (arena.impl ? std::max<int>(sizeof(Arena::ArenaImpl),
                                                      arena.impl->capacity * 2)
                                      : 0)),
-        16);
+        alignof(Arena::ArenaImpl));
    auto *impl = (Arena::ArenaImpl *)safe_malloc(allocationSize);
    impl->prev = arena.impl;
    impl->capacity = allocationSize - sizeof(Arena::ArenaImpl);
@@ -386,34 +413,6 @@ inline uint32_t Arbitrary::bounded(uint32_t s) {

 // ==================== END ARBITRARY IMPL ====================

-// ==================== BEGIN UTILITIES IMPL ====================
-
-// Call Stepwise::step for each element of remaining until it returns true.
-// Applies a permutation to `remaining` as a side effect.
-template <class Stepwise> void runInterleaved(std::span<Stepwise> remaining) {
-  while (remaining.size() > 0) {
-    for (int i = 0; i < int(remaining.size());) {
-      bool done = remaining[i].step();
-      if (done) {
-        if (i != int(remaining.size()) - 1) {
-          using std::swap;
-          swap(remaining[i], remaining.back());
-        }
-        remaining = remaining.subspan(0, remaining.size() - 1);
-      } else {
-        ++i;
-      }
-    }
-  }
-};
-
-template <class Stepwise> void runSequential(std::span<Stepwise> remaining) {
-  for (auto &r : remaining) {
-    while (!r.step()) {
-    }
-  }
-}
-
 struct ReferenceImpl {
  explicit ReferenceImpl(int64_t oldestVersion) : oldestVersion(oldestVersion) {
    writeVersionMap[""] = oldestVersion;
@@ -507,6 +506,18 @@ inline std::string printable(std::span<const uint8_t> key) {
  return printable(std::string_view((const char *)key.data(), key.size()));
 }

+inline const char *resultToStr(ConflictSet::Result r) {
+  switch (r) {
+  case ConflictSet::Commit:
+    return "commit";
+  case ConflictSet::Conflict:
+    return "conflict";
+  case ConflictSet::TooOld:
+    return "too old";
+  }
+  abort();
+}
+
 namespace {

 template <class ConflictSetImpl> struct TestDriver {
@@ -519,21 +530,12 @@ template <class ConflictSetImpl> struct TestDriver {
  ConflictSetImpl cs{oldestVersion};
  ReferenceImpl refImpl{oldestVersion};

-  constexpr static auto kMaxKeyLen = 128;
+  constexpr static auto kMaxKeySuffixLen = 8;

  bool ok = true;

-  static const char *resultToStr(ConflictSet::Result r) {
-    switch (r) {
-    case ConflictSet::Commit:
-      return "commit";
-    case ConflictSet::Conflict:
-      return "conflict";
-    case ConflictSet::TooOld:
-      return "too old";
-    }
-    abort();
-  }
+  const int prefixLen = arbitrary.bounded(512);
+  const int prefixByte = arbitrary.randT<uint8_t>();

  // Call until it returns true, for "done". Check internal invariants etc
  // between calls to next.
@@ -553,9 +555,10 @@ template <class ConflictSetImpl> struct TestDriver {
        if (!arbitrary.hasEntropy()) {
          return true;
        }
-        int keyLen = arbitrary.bounded(kMaxKeyLen);
+        int keyLen = prefixLen + arbitrary.bounded(kMaxKeySuffixLen);
        auto *begin = new (arena) uint8_t[keyLen];
-        arbitrary.randomBytes(begin, keyLen);
+        memset(begin, prefixByte, prefixLen);
+        arbitrary.randomBytes(begin + prefixLen, keyLen - prefixLen);
        keys.insert(std::string_view((const char *)begin, keyLen));
      }

@@ -620,9 +623,10 @@ template <class ConflictSetImpl> struct TestDriver {
        if (!arbitrary.hasEntropy()) {
          return true;
        }
-        int keyLen = arbitrary.bounded(kMaxKeyLen);
+        int keyLen = prefixLen + arbitrary.bounded(kMaxKeySuffixLen);
        auto *begin = new (arena) uint8_t[keyLen];
-        arbitrary.randomBytes(begin, keyLen);
+        memset(begin, prefixByte, prefixLen);
+        arbitrary.randomBytes(begin + prefixLen, keyLen - prefixLen);
        keys.insert(std::string_view((const char *)begin, keyLen));
      }

@@ -669,12 +673,26 @@ template <class ConflictSetImpl> struct TestDriver {
      auto *results2 =
          new (arena) ConflictSet::Result[numPointReads + numRangeReads];

+#ifdef THREAD_TEST
+      auto *results3 =
+          new (arena) ConflictSet::Result[numPointReads + numRangeReads];
+      std::latch ready{1};
+      std::thread thread2{[&]() {
+        ready.count_down();
+        cs.check(reads, results3, numPointReads + numRangeReads);
+      }};
+      ready.wait();
+#endif
+
      CALLGRIND_START_INSTRUMENTATION;
      cs.check(reads, results1, numPointReads + numRangeReads);
      CALLGRIND_STOP_INSTRUMENTATION;

      refImpl.check(reads, results2, numPointReads + numRangeReads);
-      for (int i = 0; i < numPointReads + numRangeReads; ++i) {
+
+      auto compareResults = [reads](ConflictSet::Result *results1,
+                                    ConflictSet::Result *results2, int count) {
+        for (int i = 0; i < count; ++i) {
          if (results1[i] != results2[i]) {
            if (reads[i].end.len == 0) {
              fprintf(stderr,
@@ -691,10 +709,24 @@ template <class ConflictSetImpl> struct TestDriver {
                  printable(reads[i].begin).c_str(),
                  printable(reads[i].end).c_str(), reads[i].readVersion);
            }
+            return false;
+          }
+        }
+        return true;
+      };
+
+      if (!compareResults(results1, results2, numPointReads + numRangeReads)) {
        ok = false;
        return true;
      }
+
+#ifdef THREAD_TEST
+      thread2.join();
+      if (!compareResults(results3, results2, numPointReads + numRangeReads)) {
+        ok = false;
+        return true;
      }
+#endif
    }
    return false;
  }
--- a/17
+++ b/17
@@ -48,6 +48,17 @@ pipeline {
                recordIssues(tools: [clang()])
            }
        }
+        stage('SIMD fallback') {
+            agent {
+                dockerfile {
+                    args '-v /home/jenkins/ccache:/ccache'
+                    reuseNode true
+                }
+            }
+            steps {
+                CleanBuildAndTest("-DUSE_SIMD_FALLBACK=ON")
+            }
+        }
        stage('Release [gcc]') {
            agent {
                dockerfile {
@@ -57,6 +68,7 @@ pipeline {
            }
            steps {
                CleanBuildAndTest("-DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_CXX_FLAGS=-DNVALGRIND")
+                recordIssues(tools: [gcc()])
                sh '''
                cd build
                cpack -G DEB
@@ -96,9 +108,12 @@ pipeline {
            steps {
                CleanBuildAndTest("-DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_C_FLAGS=--coverage -DCMAKE_CXX_FLAGS=--coverage -DCMAKE_BUILD_TYPE=Debug")
                sh '''
-                gcovr --exclude '.*third_party.*' --cobertura > build/coverage.xml
+                gcovr -f ConflictSet.cpp --cobertura > build/coverage.xml
                '''
                cobertura autoUpdateHealth: false, autoUpdateStability: false, coberturaReportFile: 'build/coverage.xml', conditionalCoverageTargets: '70, 0, 0', failUnhealthy: false, failUnstable: false, lineCoverageTargets: '80, 0, 0', maxNumberOfBuilds: 0, methodCoverageTargets: '80, 0, 0', onlyStable: false, sourceEncoding: 'ASCII', zoomCoverageChart: false
+                sh '''
+                gcovr -f ConflictSet.cpp --fail-under-line 100 > /dev/null
+                '''
            }
        }
    }
--- a/README.md
+++ b/README.md
@@ -9,76 +9,76 @@ Hardware for all benchmarks is a mac m1 2020.
 ## Skip list

 ```
-New conflict set: 1.962 sec
-                  0.637 Mtransactions/sec
-                  2.549 Mkeys/sec
-Detect only:      1.853 sec
-                  0.674 Mtransactions/sec
-                  2.698 Mkeys/sec
-Skiplist only:    1.269 sec
-                  0.985 Mtransactions/sec
-                  3.940 Mkeys/sec
+New conflict set: 1.957 sec
+                  0.639 Mtransactions/sec
+                  2.555 Mkeys/sec
+Detect only:      1.845 sec
+                  0.678 Mtransactions/sec
+                  2.710 Mkeys/sec
+Skiplist only:    1.263 sec
+                  0.990 Mtransactions/sec
+                  3.960 Mkeys/sec
 Performance counters:
-               Build: 0.0526
-                 Add: 0.054
-              Detect: 1.85
-              D.Sort: 0.413
-           D.Combine: 0.0148
-         D.CheckRead: 0.678
-   D.CheckIntraBatch: 0.00679
-        D.MergeWrite: 0.591
-      D.RemoveBefore: 0.147
+               Build: 0.0546
+                 Add: 0.0563
+              Detect: 1.84
+              D.Sort: 0.412
+           D.Combine: 0.0141
+         D.CheckRead: 0.671
+   D.CheckIntraBatch: 0.0068
+        D.MergeWrite: 0.592
+      D.RemoveBefore: 0.146
 ```

 ## Radix tree (this implementation)

 ```
-New conflict set: 1.342 sec
-                  0.931 Mtransactions/sec
-                  3.726 Mkeys/sec
-Detect only:      1.227 sec
-                  1.018 Mtransactions/sec
-                  4.074 Mkeys/sec
-Skiplist only:    0.576 sec
-                  2.169 Mtransactions/sec
-                  8.676 Mkeys/sec
+New conflict set: 1.366 sec
+                  0.915 Mtransactions/sec
+                  3.660 Mkeys/sec
+Detect only:      1.248 sec
+                  1.002 Mtransactions/sec
+                  4.007 Mkeys/sec
+Skiplist only:    0.573 sec
+                  2.182 Mtransactions/sec
+                  8.730 Mkeys/sec
 Performance counters:
-               Build: 0.0568
-                 Add: 0.0564
-              Detect: 1.23
-              D.Sort: 0.414
-           D.Combine: 0.0162
-         D.CheckRead: 0.228
-   D.CheckIntraBatch: 0.00665
-        D.MergeWrite: 0.348
-      D.RemoveBefore: 0.211
+               Build: 0.0594
+                 Add: 0.0572
+              Detect: 1.25
+              D.Sort: 0.418
+           D.Combine: 0.0149
+         D.CheckRead: 0.232
+   D.CheckIntraBatch: 0.0067
+        D.MergeWrite: 0.341
+      D.RemoveBefore: 0.232
 ```

 # Our benchmark

 ## Skip list

-|               ns/op |                op/s |    err% |     total | benchmark
-|--------------------:|--------------------:|--------:|----------:|:----------
-|              254.17 |        3,934,426.23 |    0.3% |      0.01 | `point reads`
-|              275.58 |        3,628,769.92 |    2.1% |      0.01 | `prefix reads`
-|              494.87 |        2,020,718.51 |    0.7% |      0.01 | `range reads`
-|              495.91 |        2,016,512.61 |    1.7% |      0.01 | `point writes`
-|              478.11 |        2,091,578.00 |    0.8% |      0.01 | `prefix writes`
-|              307.08 |        3,256,480.40 |    1.9% |      0.04 | `range writes`
-|              610.89 |        1,636,953.81 |    0.7% |      0.01 | `monotonic increasing point writes`
+|  ns/op |         op/s | err% | total | benchmark                           |
+| -----: | -----------: | ---: | ----: | :---------------------------------- |
+| 246.99 | 4,048,700.59 | 0.2% |  0.01 | `point reads`                       |
+| 260.16 | 3,843,784.65 | 0.1% |  0.01 | `prefix reads`                      |
+| 493.35 | 2,026,953.19 | 0.1% |  0.01 | `range reads`                       |
+| 462.05 | 2,164,289.23 | 0.6% |  0.01 | `point writes`                      |
+| 448.19 | 2,231,205.25 | 0.9% |  0.01 | `prefix writes`                     |
+| 255.83 | 3,908,845.72 | 1.5% |  0.02 | `range writes`                      |
+| 582.63 | 1,716,349.02 | 1.3% |  0.01 | `monotonic increasing point writes` |

 ## Radix tree (this implementation)

-|               ns/op |                op/s |    err% |     total | benchmark
-|--------------------:|--------------------:|--------:|----------:|:----------
-|               22.39 |       44,667,832.17 |    0.2% |      0.01 | `point reads`
-|               53.89 |       18,554,840.41 |    3.4% |      0.01 | `prefix reads`
-|              217.71 |        4,593,220.24 |    0.2% |      0.01 | `range reads`
-|               29.72 |       33,642,099.66 |    1.1% |      0.01 | `point writes`
-|               44.86 |       22,294,037.02 |    0.8% |      0.01 | `prefix writes`
-|               55.00 |       18,181,818.18 |    0.8% |      0.03 | `range writes`
-|              109.21 |        9,156,917.53 |    2.9% |      0.01 | `monotonic increasing point writes`
+|  ns/op |          op/s | err% | total | benchmark                           |
+| -----: | ------------: | ---: | ----: | :---------------------------------- |
+|  19.42 | 51,483,206.67 | 0.3% |  0.01 | `point reads`                       |
+|  58.43 | 17,115,612.57 | 0.1% |  0.01 | `prefix reads`                      |
+| 216.09 |  4,627,766.60 | 0.2% |  0.01 | `range reads`                       |
+|  28.35 | 35,267,567.72 | 0.2% |  0.01 | `point writes`                      |
+|  43.43 | 23,026,226.17 | 0.2% |  0.01 | `prefix writes`                     |
+|  50.00 | 20,000,000.00 | 0.0% |  0.01 | `range writes`                      |
+|  92.38 | 10,824,863.69 | 4.1% |  0.01 | `monotonic increasing point writes` |

 # "Real data" test

@@ -87,13 +87,13 @@ Point queries only, best of three runs. Gc ratio is the ratio of time spent doin
 ## skip list

 ```
-Check: 11.7282 seconds, 318.763 MB/s, Add: 5.76499 seconds, 121.776 MB/s, Gc ratio: 48.0772%
+Check: 11.3385 seconds, 329.718 MB/s, Add: 5.35612 seconds, 131.072 MB/s, Gc ratio: 45.7173%
 ```

 ## radix tree

 ```
-Check: 3.27475 seconds, 1141.62 MB/s, Add: 2.13594 seconds, 328.678 MB/s, Gc ratio: 50.1739%
+Check: 2.48583 seconds, 1503.93 MB/s, Add: 2.12768 seconds, 329.954 MB/s, Gc ratio: 41.7943%
 ```

 ## hash table
@@ -101,5 +101,5 @@ Check: 3.27475 seconds, 1141.62 MB/s, Add: 2.13594 seconds, 328.678 MB/s, Gc rat
 (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: 1.86291 seconds, 2006.81 MB/s, Add: 0.923653 seconds, 760.067 MB/s, Gc ratio: 54.2605%
+Check: 1.83386 seconds, 2038.6 MB/s, Add: 0.601411 seconds, 1167.32 MB/s, Gc ratio: 48.9776%
 ```
--- a/RealDataBench.cpp
+++ b/RealDataBench.cpp
@@ -1,13 +1,18 @@
 #include <ConflictSet.h>

+#include <cerrno>
 #include <chrono>
+#include <cstdio>
 #include <cstring>
 #include <fcntl.h>
+#include <string_view>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <vector>

+using namespace weaselab;
+
 double now() {
  return std::chrono::duration_cast<std::chrono::nanoseconds>(
             std::chrono::steady_clock::now().time_since_epoch())
@@ -28,7 +33,7 @@ constexpr inline size_t rightAlign(size_t offset, size_t alignment) {

 int main(int argc, const char **argv) {
  // Use with this dataset https://snap.stanford.edu/data/memetracker9.html
-  // Preprocess the files with `sed -i '' '/^Q/d'`
+  // Preprocess the files with `sed -i'' '/^Q/d'`

  double checkTime = 0;
  double addTime = 0;
@@ -40,6 +45,8 @@ int main(int argc, const char **argv) {
  int64_t version = 0;
  double timer = 0;

+  int64_t peakMemory = 0;
+
  for (int i = 1; i < argc; ++i) {
    int fd = open(argv[i], O_RDONLY);
    struct stat st;
@@ -109,6 +116,10 @@ int main(int argc, const char **argv) {
        write = {};
        reads.clear();

+        if (cs.getBytes() > peakMemory) {
+          peakMemory = cs.getBytes();
+        }
+
        timer = now();
        cs.setOldestVersion(version - 10000);
        gcTime += now() - timer;
@@ -118,8 +129,9 @@ int main(int argc, const char **argv) {
    close(fd);
  }

-  printf(
-      "Check: %g seconds, %g MB/s, Add: %g seconds, %g MB/s, Gc ratio: %g%%\n",
+  printf("Check: %g seconds, %g MB/s, Add: %g seconds, %g MB/s, Gc ratio: "
+         "%g%%, Peak idle memory: %g\n",
         checkTime, checkBytes / checkTime * 1e-6, addTime,
-      addBytes / addTime * 1e-6, gcTime / (gcTime + addTime) * 1e2);
+         addBytes / addTime * 1e-6, gcTime / (gcTime + addTime) * 1e2,
+         double(peakMemory));
 }
--- a/SkipList.cpp
+++ b/SkipList.cpp
@@ -16,6 +16,8 @@
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
+ *
+ * This source code is modified to compile outside of FoundationDB
 */

 #include "ConflictSet.h"
@@ -149,7 +151,7 @@ private:
      setMaxVersion(level, v);
    }

-    void destroy() { safe_free(this); }
+    void destroy() { safe_free(this, getNodeSize()); }

  private:
    int getNodeSize() const {
@@ -268,13 +270,21 @@ public:
  }

  explicit SkipList(Version version = 0) {
+#if DEBUG_VERBOSE
+    fprintf(stderr, "skip_list: create\n");
+#endif
    header = Node::create(StringRef(), MaxLevels - 1);
    for (int l = 0; l < MaxLevels; l++) {
      header->setNext(l, nullptr);
      header->setMaxVersion(l, version);
    }
  }
-  ~SkipList() { destroy(); }
+  ~SkipList() {
+#if DEBUG_VERBOSE
+    fprintf(stderr, "skip_list: destroy\n");
+#endif
+    destroy();
+  }
  SkipList(SkipList &&other) noexcept : header(other.header) {
    other.header = nullptr;
  }
@@ -603,6 +613,10 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
    for (int s = stripes - 1; s >= 0; s--) {
      for (int i = 0; i * 2 < ss; ++i) {
        const auto &w = writes[s * stripeSize / 2 + i];
+#if DEBUG_VERBOSE
+        printf("Write begin: %s\n", printable(w.begin).c_str());
+        fflush(stdout);
+#endif
        values[i * 2] = {w.begin.p, size_t(w.begin.len)};
        values[i * 2 + 1] = w.end.len > 0
                                ? StringRef{w.end.p, size_t(w.end.len)}
@@ -627,6 +641,8 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
        removalArena, {finger.getValue().data(), finger.getValue().size()});
  }

+  int64_t totalBytes = 0;
+
 private:
  int64_t keyUpdates = 10;
  Arena removalArena;
@@ -637,25 +653,44 @@ private:

 void ConflictSet::check(const ReadRange *reads, Result *results,
                        int count) const {
-  return impl->check(reads, results, count);
+  impl->check(reads, results, count);
 }

 void ConflictSet::addWrites(const WriteRange *writes, int count,
                            int64_t writeVersion) {
-  return impl->addWrites(writes, count, writeVersion);
+  mallocBytesDelta = 0;
+  impl->addWrites(writes, count, writeVersion);
+  impl->totalBytes += mallocBytesDelta;
+#if SHOW_MEMORY
+  if (impl->totalBytes != mallocBytes) {
+    abort();
+  }
+#endif
 }

 void ConflictSet::setOldestVersion(int64_t oldestVersion) {
-  return impl->setOldestVersion(oldestVersion);
+  mallocBytesDelta = 0;
+  impl->setOldestVersion(oldestVersion);
+  impl->totalBytes += mallocBytesDelta;
+#if SHOW_MEMORY
+  if (impl->totalBytes != mallocBytes) {
+    abort();
+  }
+#endif
 }

+int64_t ConflictSet::getBytes() const { return impl->totalBytes; }
+
 ConflictSet::ConflictSet(int64_t oldestVersion)
-    : impl(new (safe_malloc(sizeof(Impl))) Impl{oldestVersion}) {}
+    : impl((mallocBytesDelta = 0,
+            new(safe_malloc(sizeof(Impl))) Impl{oldestVersion})) {
+  impl->totalBytes += mallocBytesDelta;
+}

 ConflictSet::~ConflictSet() {
  if (impl) {
    impl->~Impl();
-    safe_free(impl);
+    safe_free(impl, sizeof(Impl));
  }
 }

@@ -681,27 +716,52 @@ ConflictSet_check(void *cs, const ConflictSet_ReadRange *reads,
 __attribute__((__visibility__("default"))) void
 ConflictSet_addWrites(void *cs, const ConflictSet_WriteRange *writes, int count,
                      int64_t writeVersion) {
-  ((ConflictSet::Impl *)cs)->addWrites(writes, count, writeVersion);
+  auto *impl = (ConflictSet::Impl *)cs;
+  mallocBytesDelta = 0;
+  impl->addWrites(writes, count, writeVersion);
+  impl->totalBytes += mallocBytesDelta;
+#if SHOW_MEMORY
+  if (impl->totalBytes != mallocBytes) {
+    abort();
+  }
+#endif
 }
 __attribute__((__visibility__("default"))) void
 ConflictSet_setOldestVersion(void *cs, int64_t oldestVersion) {
-  ((ConflictSet::Impl *)cs)->setOldestVersion(oldestVersion);
+  auto *impl = (ConflictSet::Impl *)cs;
+  mallocBytesDelta = 0;
+  impl->setOldestVersion(oldestVersion);
+  impl->totalBytes += mallocBytesDelta;
+#if SHOW_MEMORY
+  if (impl->totalBytes != mallocBytes) {
+    abort();
+  }
+#endif
 }
 __attribute__((__visibility__("default"))) void *
 ConflictSet_create(int64_t oldestVersion) {
-  return new (safe_malloc(sizeof(ConflictSet::Impl)))
+  mallocBytesDelta = 0;
+  auto *result = new (safe_malloc(sizeof(ConflictSet::Impl)))
      ConflictSet::Impl{oldestVersion};
+  result->totalBytes += mallocBytesDelta;
+  return result;
 }
 __attribute__((__visibility__("default"))) void ConflictSet_destroy(void *cs) {
  using Impl = ConflictSet::Impl;
  ((Impl *)cs)->~Impl();
-  safe_free(cs);
+  safe_free(cs, sizeof(Impl));
+}
+__attribute__((__visibility__("default"))) int64_t
+ConflictSet_getBytes(void *cs) {
+  using Impl = ConflictSet::Impl;
+  return ((Impl *)cs)->totalBytes;
 }
 }

 #if SHOW_MEMORY
 struct __attribute__((visibility("default"))) PeakPrinter {
  ~PeakPrinter() {
+    printf("--- skip_list ---\n");
    printf("malloc bytes: %g\n", double(mallocBytes));
    printf("Peak malloc bytes: %g\n", double(peakMallocBytes));
  }
--- a/aarch64-symbol-imports.txt
+++ b/aarch64-symbol-imports.txt
@@ -0,0 +1,8 @@
+__stack_chk_fail@GLIBC_2.17
+__stack_chk_guard@GLIBC_2.17
+abort@GLIBC_2.17
+free@GLIBC_2.17
+malloc@GLIBC_2.17
+memcpy@GLIBC_2.17
+memmove@GLIBC_2.17
+memset@GLIBC_2.17
--- a/apple-symbol-exports.txt
+++ b/apple-symbol-exports.txt
@@ -0,0 +1,17 @@
+_ConflictSet_addWrites
+_ConflictSet_check
+_ConflictSet_create
+_ConflictSet_destroy
+_ConflictSet_getBytes
+_ConflictSet_setOldestVersion
+__ZN8weaselab11ConflictSet16setOldestVersionEx
+__ZN8weaselab11ConflictSet9addWritesEPKNS0_10WriteRangeEix
+__ZN8weaselab11ConflictSetC1EOS0_
+__ZN8weaselab11ConflictSetC1Ex
+__ZN8weaselab11ConflictSetC2EOS0_
+__ZN8weaselab11ConflictSetC2Ex
+__ZN8weaselab11ConflictSetD1Ev
+__ZN8weaselab11ConflictSetD2Ev
+__ZN8weaselab11ConflictSetaSEOS0_
+__ZNK8weaselab11ConflictSet5checkEPKNS0_9ReadRangeEPNS0_6ResultEi
+__ZNK8weaselab11ConflictSet8getBytesEv
--- a/apple-symbol-imports.txt
+++ b/apple-symbol-imports.txt
@@ -0,0 +1,8 @@
+__tlv_bootstrap
+_abort
+_bzero
+_free
+_malloc
+_memcpy
+_memmove
+dyld_stub_binder
--- a/conflict_set.py
+++ b/conflict_set.py
@@ -0,0 +1,136 @@
+import ctypes
+import enum
+import os
+
+from typing import Optional
+
+
+class _Key(ctypes.Structure):
+    _fields_ = [("p", ctypes.POINTER(ctypes.c_ubyte)), ("len", ctypes.c_int)]
+
+
+class ReadRange(ctypes.Structure):
+    _fields_ = [
+        ("begin", _Key),
+        ("end", _Key),
+        ("readVersion", ctypes.c_int64),
+    ]
+
+
+class WriteRange(ctypes.Structure):
+    _fields_ = [("begin", _Key), ("end", _Key)]
+
+
+class Result(enum.Enum):
+    COMMIT = 0
+    CONFLICT = 1
+    TOO_OLD = 2
+
+
+def write(begin: bytes, end: Optional[bytes] = None) -> WriteRange:
+    b = (ctypes.c_ubyte * len(begin)).from_buffer(bytearray(begin))
+
+    if end is None:
+        e = (ctypes.c_ubyte * 0)()
+    else:
+        e = (ctypes.c_ubyte * len(end)).from_buffer(bytearray(end))
+    return WriteRange(_Key(b, len(b)), _Key(e, len(e)))
+
+
+def read(version: int, begin: bytes, end: Optional[bytes] = None) -> ReadRange:
+    b = (ctypes.c_ubyte * len(begin)).from_buffer(bytearray(begin))
+    if end is None:
+        e = (ctypes.c_ubyte * 0)()
+    else:
+        e = (ctypes.c_ubyte * len(end)).from_buffer(bytearray(end))
+    return ReadRange(_Key(b, len(b)), _Key(e, len(e)), version)
+
+
+class ConflictSet:
+    def __init__(
+        self,
+        version: int = 0,
+        build_dir: Optional[str] = None,
+        implementation: Optional[str] = None,
+    ) -> None:
+        self._lib = None
+        if build_dir is None:
+            build_dir = os.path.dirname(__file__) + "/build"
+        if implementation is None:
+            implementation = "radix_tree"
+        for f in (
+            build_dir + "/" + implementation + "/libconflict-set.so.0",
+            os.path.dirname(__file__)
+            + "/build/"
+            + implementation
+            + "/libconflict-set.0.dylib",
+        ):
+            try:
+                self._lib = ctypes.cdll.LoadLibrary(f)
+            except:
+                pass
+
+        if self._lib is None:
+            import sys
+
+            print(
+                "Could not find libconflict-set implementation " + implementation,
+                file=sys.stderr,
+            )
+            sys.exit(1)
+
+        self._lib.ConflictSet_create.argtypes = (ctypes.c_int64,)
+        self._lib.ConflictSet_create.restype = ctypes.c_void_p
+
+        self._lib.ConflictSet_check.argtypes = (
+            ctypes.c_void_p,
+            ctypes.POINTER(ReadRange),
+            ctypes.POINTER(ctypes.c_int),
+            ctypes.c_int,
+        )
+
+        self._lib.ConflictSet_addWrites.argtypes = (
+            ctypes.c_void_p,
+            ctypes.POINTER(WriteRange),
+            ctypes.c_int,
+            ctypes.c_int64,
+        )
+
+        self._lib.ConflictSet_setOldestVersion.argtypes = (
+            ctypes.c_void_p,
+            ctypes.c_int64,
+        )
+
+        self._lib.ConflictSet_destroy.argtypes = (ctypes.c_void_p,)
+
+        self._lib.ConflictSet_getBytes.argtypes = (ctypes.c_void_p,)
+        self._lib.ConflictSet_getBytes.restype = ctypes.c_int64
+
+        self.p = self._lib.ConflictSet_create(version)
+
+    def addWrites(self, version: int, *writes: WriteRange):
+        self._lib.ConflictSet_addWrites(
+            self.p, (WriteRange * len(writes))(*writes), len(writes), version
+        )
+
+    def check(self, *reads: ReadRange) -> list[Result]:
+        r = (ctypes.c_int * len(reads))()
+        self._lib.ConflictSet_check(self.p, *reads, r, 1)
+        return [Result(x) for x in r]
+
+    def setOldestVersion(self, version: int) -> None:
+        self._lib.ConflictSet_setOldestVersion(self.p, version)
+
+    def getBytes(self) -> int:
+        return self._lib.ConflictSet_getBytes(self.p)
+
+    def __enter__(self):
+        return self
+
+    def close(self) -> None:
+        if self.p is not None:
+            self._lib.ConflictSet_destroy(self.p)
+            self.p = None
+
+    def __exit__(self, exception_type, exception_value, exception_traceback):
+        self.close()
--- a/conflict_set_c_api_test.c
+++ b/conflict_set_c_api_test.c
@@ -7,6 +7,7 @@ int main(void) {
  ConflictSet_WriteRange w;
  ConflictSet_Result result;
  ConflictSet_ReadRange r;
+  int64_t bytes;
  w.begin.p = (const uint8_t *)"0000";
  w.begin.len = 4;
  w.end.len = 0;
@@ -17,6 +18,8 @@ int main(void) {
  r.readVersion = 0;
  ConflictSet_check(cs, &r, &result, 1);
  assert(result == ConflictSet_Conflict);
+  bytes = ConflictSet_getBytes(cs);
+  assert(bytes > 0);
  ConflictSet_destroy(cs);
  return 0;
 }
--- a/conflict_set_cxx_api_test.cpp
+++ b/conflict_set_cxx_api_test.cpp
@@ -2,6 +2,8 @@

 #include <cassert>

+using namespace weaselab;
+
 int main(void) {
  ConflictSet cs(0);
  ConflictSet::WriteRange w;
@@ -17,4 +19,6 @@ int main(void) {
  r.readVersion = 0;
  cs.check(&r, &result, 1);
  assert(result == ConflictSet::Conflict);
+  int64_t bytes = cs.getBytes();
+  assert(bytes > 0);
 }
--- a/corpus/000d72883139e535b50cc5872c57e73db3f10f97
+++ b/corpus/000d72883139e535b50cc5872c57e73db3f10f97
--- a/corpus/001a4385cfd31070dd75eaa3e1ad21d0b25687d6
+++ b/corpus/001a4385cfd31070dd75eaa3e1ad21d0b25687d6
--- a/corpus/007b28db8fbd69dba10657e88e2db37747818c02
+++ b/corpus/007b28db8fbd69dba10657e88e2db37747818c02
--- a/corpus/00879ddec809af152140691ec44ba8132a8f01d2
+++ b/corpus/00879ddec809af152140691ec44ba8132a8f01d2
--- a/corpus/00cc0f455c0dcddaac01ca4135ed12f27f5cfed2
+++ b/corpus/00cc0f455c0dcddaac01ca4135ed12f27f5cfed2
--- a/corpus/00ed163ad8fb7c9b29a13c3ea1809e989cd82ef9
+++ b/corpus/00ed163ad8fb7c9b29a13c3ea1809e989cd82ef9
--- a/corpus/017fe0001e79270892ec9a596580883273a1e4a2
+++ b/corpus/017fe0001e79270892ec9a596580883273a1e4a2
--- a/corpus/01c018a917db833f05d6c0e04e96198799953e16
+++ b/corpus/01c018a917db833f05d6c0e04e96198799953e16
--- a/corpus/02a1f402f107a5dc508b212da227d87b4ffa8904
+++ b/corpus/02a1f402f107a5dc508b212da227d87b4ffa8904
--- a/corpus/03262648f007cc440c36b2bef091dd76295074c5
+++ b/corpus/03262648f007cc440c36b2bef091dd76295074c5
--- a/corpus/0418013be6b44b43621f5c46a3487212c0f91a40
+++ b/corpus/0418013be6b44b43621f5c46a3487212c0f91a40
--- a/corpus/044269ca54d9557b8b91f3b47ec32d7afd9f6a87
+++ b/corpus/044269ca54d9557b8b91f3b47ec32d7afd9f6a87
--- a/corpus/0467f1f20c94c212ead6664b420e31e39159f437
+++ b/corpus/0467f1f20c94c212ead6664b420e31e39159f437
--- a/corpus/048484b4d6cf7bacce667023dea09dd052d74b6d
+++ b/corpus/048484b4d6cf7bacce667023dea09dd052d74b6d
--- a/corpus/05a79f06cf3f67f726dae68d18a2290f6c9a50c9
+++ b/corpus/05a79f06cf3f67f726dae68d18a2290f6c9a50c9
@@ -1 +0,0 @@
-:
--- a/corpus/06297bdca3ee519e0bc6b9992c2eb6e3e5559235
+++ b/corpus/06297bdca3ee519e0bc6b9992c2eb6e3e5559235
--- a/corpus/06934b123ae0610dd969388d5983d8689e80cfd7
+++ b/corpus/06934b123ae0610dd969388d5983d8689e80cfd7
--- a/corpus/06b10425f65b89ba3464846ea84b1f38f6332be8
+++ b/corpus/06b10425f65b89ba3464846ea84b1f38f6332be8
--- a/corpus/07e474fce6dd93493cbbce84168a8859b38e4d1e
+++ b/corpus/07e474fce6dd93493cbbce84168a8859b38e4d1e
--- a/corpus/07e675857aae0f133f253f146685f4c8e7492114
+++ b/corpus/07e675857aae0f133f253f146685f4c8e7492114
--- a/corpus/07edb657dc7dc10cdc7384beaff41811e7c2eed8
+++ b/corpus/07edb657dc7dc10cdc7384beaff41811e7c2eed8
--- a/corpus/08da5c32b915e10ad0c7ca12e5da5fbe1492c57e
+++ b/corpus/08da5c32b915e10ad0c7ca12e5da5fbe1492c57e
--- a/corpus/08e52de82e520307b0304e1e98c4b4ebac7ceab0
+++ b/corpus/08e52de82e520307b0304e1e98c4b4ebac7ceab0
--- a/corpus/09328b5c92e0e4875e2f150ee2a013e765998a13
+++ b/corpus/09328b5c92e0e4875e2f150ee2a013e765998a13
--- a/corpus/0959e4d73bfb824f1a5f90a6b7dcad46f7db2db7
+++ b/corpus/0959e4d73bfb824f1a5f90a6b7dcad46f7db2db7
--- a/corpus/098ebb4db647b726d18b4c808988b7caf976a95a
+++ b/corpus/098ebb4db647b726d18b4c808988b7caf976a95a
--- a/corpus/099cd4e9ec7dfd33064b54ab678ccf2d0724b6ae
+++ b/corpus/099cd4e9ec7dfd33064b54ab678ccf2d0724b6ae
--- a/corpus/09e702c2f99064a568d4bc7ba5d8581fdc6f2071
+++ b/corpus/09e702c2f99064a568d4bc7ba5d8581fdc6f2071
--- a/corpus/09e7f7a7e9967f1d744fca5a2e10c0e6514a3551
+++ b/corpus/09e7f7a7e9967f1d744fca5a2e10c0e6514a3551
--- a/corpus/0b4deead0afd2d2cf7bb0cd7bf56259b5f484dcb
+++ b/corpus/0b4deead0afd2d2cf7bb0cd7bf56259b5f484dcb
--- a/corpus/0bcfeb0963ee25dd38ccdc062a1cd45ecb3c1133
+++ b/corpus/0bcfeb0963ee25dd38ccdc062a1cd45ecb3c1133
--- a/corpus/0ce25b026c1c835de614a3d772e8d6b00f58c10c
+++ b/corpus/0ce25b026c1c835de614a3d772e8d6b00f58c10c
--- a/corpus/0cf423dcbda59e334384410c83cf003aaf6afca1
+++ b/corpus/0cf423dcbda59e334384410c83cf003aaf6afca1
--- a/corpus/0e21b3fc3c827043685bfb846df055c5f03aae96
+++ b/corpus/0e21b3fc3c827043685bfb846df055c5f03aae96
--- a/corpus/0e31aad966875f897220c2437c69326443675fc7
+++ b/corpus/0e31aad966875f897220c2437c69326443675fc7
--- a/corpus/0e4de14128ec7b61ae2cb2835fddd641845ee743
+++ b/corpus/0e4de14128ec7b61ae2cb2835fddd641845ee743
--- a/corpus/0e7a0b924f0f0dee763fecab2cf48aa580332206
+++ b/corpus/0e7a0b924f0f0dee763fecab2cf48aa580332206
--- a/corpus/0f2768b4a7a65be84db67f2d6cebe5fe04bce172
+++ b/corpus/0f2768b4a7a65be84db67f2d6cebe5fe04bce172
--- a/corpus/0f59a6de38d7d431261ec4fd482e99b127f04b94
+++ b/corpus/0f59a6de38d7d431261ec4fd482e99b127f04b94
--- a/corpus/0f721b035da292dd8d040551b92faa33fbf51bdc
+++ b/corpus/0f721b035da292dd8d040551b92faa33fbf51bdc
--- a/corpus/0f83749baf11d0e43cd3b215d69e36ba1477c529
+++ b/corpus/0f83749baf11d0e43cd3b215d69e36ba1477c529
--- a/corpus/0fa17661f6d468a6065a91b3cd88413952ef6000
+++ b/corpus/0fa17661f6d468a6065a91b3cd88413952ef6000
--- a/corpus/10af5fa0b33a9ed0572fc54276bd49ce8a7ee419
+++ b/corpus/10af5fa0b33a9ed0572fc54276bd49ce8a7ee419
--- a/corpus/10cc69d9013596429f0912712c0137591973c2d7
+++ b/corpus/10cc69d9013596429f0912712c0137591973c2d7
--- a/corpus/11e033caa0ce581acf472931b02588a6b2faa55d
+++ b/corpus/11e033caa0ce581acf472931b02588a6b2faa55d
--- a/corpus/11ed56158b1484931de34d38454a9ad7cff07c24
+++ b/corpus/11ed56158b1484931de34d38454a9ad7cff07c24
--- a/corpus/12128a5bddff249ab102e679bb40da952bb94b5c
+++ b/corpus/12128a5bddff249ab102e679bb40da952bb94b5c
--- a/corpus/129c09d57e97aeb7025eeff667e52582c233ce43
+++ b/corpus/129c09d57e97aeb7025eeff667e52582c233ce43
--- a/corpus/12ae1e1ff00a8c79f7a687e2aa70e94aca1dc34d
+++ b/corpus/12ae1e1ff00a8c79f7a687e2aa70e94aca1dc34d
--- a/corpus/13227d7d1bc7355aed3df9a4ea012d4a391764e7
+++ b/corpus/13227d7d1bc7355aed3df9a4ea012d4a391764e7
--- a/corpus/1450aa1eab8e8e151a8140a66f9e491f7d5b8981
+++ b/corpus/1450aa1eab8e8e151a8140a66f9e491f7d5b8981
--- a/corpus/147990fa0ada11fb7025a8534f1e4f85164869b1
+++ b/corpus/147990fa0ada11fb7025a8534f1e4f85164869b1
--- a/corpus/14a2858e77e638d88cd774b1daa0bd04314d4793
+++ b/corpus/14a2858e77e638d88cd774b1daa0bd04314d4793
--- a/corpus/14c6bc097e56e41db1047271f96028a7fee06fa6
+++ b/corpus/14c6bc097e56e41db1047271f96028a7fee06fa6
--- a/corpus/1554486d861b6dca009e47989b85bce8639b47de
+++ b/corpus/1554486d861b6dca009e47989b85bce8639b47de
--- a/corpus/156b43edfd8dc756184017bf78e382e4d129e33a
+++ b/corpus/156b43edfd8dc756184017bf78e382e4d129e33a
--- a/corpus/1607b170ded5a8458ab9b1514d34f8ed4ddd2975
+++ b/corpus/1607b170ded5a8458ab9b1514d34f8ed4ddd2975
--- a/corpus/160b10e0be9ea9eedfc99f5e3dc106bf50fc5f6d
+++ b/corpus/160b10e0be9ea9eedfc99f5e3dc106bf50fc5f6d
--- a/corpus/1632064eae678ef9865ef9eeb43c7ebeca71422d
+++ b/corpus/1632064eae678ef9865ef9eeb43c7ebeca71422d
--- a/corpus/1656832b37b5fc76132d9d50de27e6137a2a6d2c
+++ b/corpus/1656832b37b5fc76132d9d50de27e6137a2a6d2c
--- a/corpus/168fdba36e62ed56f67b6fce0a30b42943a58be4
+++ b/corpus/168fdba36e62ed56f67b6fce0a30b42943a58be4
--- a/corpus/17a4cd288c819b380f7995273ad0414dbfcaffba
+++ b/corpus/17a4cd288c819b380f7995273ad0414dbfcaffba
--- a/corpus/1841fe039040e49d98cb60458cfa98f279bec10a
+++ b/corpus/1841fe039040e49d98cb60458cfa98f279bec10a
--- a/corpus/18b6eaeb039242f729c8e3f90ea702dd2584e768
+++ b/corpus/18b6eaeb039242f729c8e3f90ea702dd2584e768
--- a/corpus/19036b267deb185071c45a9df3202b352d916fc5
+++ b/corpus/19036b267deb185071c45a9df3202b352d916fc5
--- a/corpus/19101c188a484270f33420caa342612d44681616
+++ b/corpus/19101c188a484270f33420caa342612d44681616
--- a/corpus/1922a62cd1a141321e85ea6db462719c46c13fde
+++ b/corpus/1922a62cd1a141321e85ea6db462719c46c13fde
--- a/corpus/197cb73b1a29e35935973aae7ae26b6c7ab92d07
+++ b/corpus/197cb73b1a29e35935973aae7ae26b6c7ab92d07
--- a/corpus/1a69474ab8ba1187063bd0eb5d4899a203050917
+++ b/corpus/1a69474ab8ba1187063bd0eb5d4899a203050917
--- a/corpus/1a6ec846db7894a1bf08ff44eeced3af164d3151
+++ b/corpus/1a6ec846db7894a1bf08ff44eeced3af164d3151
--- a/corpus/1a821dc4f6299984feff1ef1e7db28fe185158a4
+++ b/corpus/1a821dc4f6299984feff1ef1e7db28fe185158a4
--- a/corpus/1b088f84de15b2e015c53539b3719223134b8e73
+++ b/corpus/1b088f84de15b2e015c53539b3719223134b8e73
--- a/corpus/1b1c8e798d39b313bd793697de05fe74f7ed8a63
+++ b/corpus/1b1c8e798d39b313bd793697de05fe74f7ed8a63
--- a/corpus/1b242f22da8cf0f0507d43eff5a607dad9f7e77e
+++ b/corpus/1b242f22da8cf0f0507d43eff5a607dad9f7e77e
--- a/corpus/1b8a5ae93daf3a194087cc9747295352d7bb906b
+++ b/corpus/1b8a5ae93daf3a194087cc9747295352d7bb906b
--- a/corpus/1bd30a30823419a12d004729baa96734e410cbed
+++ b/corpus/1bd30a30823419a12d004729baa96734e410cbed
--- a/corpus/1c4b5f5582cb6551b730920695bc6874b8b81a71
+++ b/corpus/1c4b5f5582cb6551b730920695bc6874b8b81a71
--- a/corpus/1ce8fc23367508b9c141f66976e888910298d64e
+++ b/corpus/1ce8fc23367508b9c141f66976e888910298d64e
--- a/corpus/1d85043e4ef57d7d173ab3995f414fffc293f806
+++ b/corpus/1d85043e4ef57d7d173ab3995f414fffc293f806
--- a/corpus/1deefa50797a868862a42b0a5123bca56ac6dda3
+++ b/corpus/1deefa50797a868862a42b0a5123bca56ac6dda3
--- a/corpus/1e2dd92778990c50a91ba6f7cae6c88769ab5727
+++ b/corpus/1e2dd92778990c50a91ba6f7cae6c88769ab5727
--- a/Show More
+++ b/Show More