Use version.txt instead of version.tex

latexmk seemed to have some trouble with it being a tex file

CMakeLists.txt

@@ -1,14 +1,16 @@
 cmake_minimum_required(VERSION 3.18)
 project(
   conflict-set
-  VERSION 0.0.5
+  VERSION 0.0.6
   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})
+file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/version.txt ${PROJECT_VERSION})
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/version.txt.in
+               ${CMAKE_CURRENT_SOURCE_DIR}/paper/version.txt)
 
 include(CMakePushCheckState)
 include(CheckCXXCompilerFlag)
@@ -47,7 +49,8 @@ if(HAS_FULL_RELRO)
 endif()
 cmake_pop_check_state()
 
-set(version_script_flags LINKER:--version-script=${CMAKE_SOURCE_DIR}/linker.map)
+set(version_script_flags
+    LINKER:--version-script=${CMAKE_CURRENT_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
@@ -59,7 +62,7 @@ option(USE_SIMD_FALLBACK
 
 # 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)
+include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/valgrind)
 
 add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-invalid-offsetof>)
 
@@ -106,19 +109,20 @@ 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
-                           PRIVATE ${CMAKE_SOURCE_DIR}/include)
+                           PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
 
 add_library(${PROJECT_NAME} SHARED $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
 set_target_properties(
   ${PROJECT_NAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY
-                             "${CMAKE_BINARY_DIR}/radix_tree")
+                             "${CMAKE_CURRENT_BINARY_DIR}/radix_tree")
 if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
   set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE C)
 endif()
 
 if(HAS_VERSION_SCRIPT)
-  target_link_options(${PROJECT_NAME} PRIVATE
-                      LINKER:--version-script=${CMAKE_SOURCE_DIR}/linker.map)
+  target_link_options(
+    ${PROJECT_NAME} PRIVATE
+    LINKER:--version-script=${CMAKE_CURRENT_SOURCE_DIR}/linker.map)
 endif()
 
 add_library(${PROJECT_NAME}-static STATIC
@@ -131,7 +135,7 @@ if(APPLE)
   add_custom_command(
     TARGET ${PROJECT_NAME}-static
     PRE_LINK
-    COMMAND ${CMAKE_SOURCE_DIR}/privatize_symbols_macos.sh
+    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/privatize_symbols_macos.sh
             $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
 else()
   add_custom_command(
@@ -139,21 +143,22 @@ else()
     POST_BUILD
     COMMAND
       ${CMAKE_OBJCOPY}
-      --keep-global-symbols=${CMAKE_SOURCE_DIR}/symbol-exports.txt
+      --keep-global-symbols=${CMAKE_CURRENT_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)
-
 include(CTest)
 
-if(BUILD_TESTING)
+# disable tests if this is being used through e.g. FetchContent
+if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
+
+  set(TEST_FLAGS -Wall -Wextra -Wunreachable-code -Wpedantic -UNDEBUG)
 
   # 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/*)
+  file(GLOB CORPUS_TESTS ${CMAKE_CURRENT_SOURCE_DIR}/corpus/*)
 
   # extra testing that relies on shared libraries, which aren't available with
   # wasm
@@ -162,9 +167,11 @@ if(BUILD_TESTING)
     add_library(skip_list SHARED SkipList.cpp)
     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")
+    target_include_directories(skip_list
+                               PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+    set_target_properties(
+      skip_list PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+                           "${CMAKE_CURRENT_BINARY_DIR}/skip_list")
     set_target_properties(skip_list PROPERTIES OUTPUT_NAME ${PROJECT_NAME})
     set_target_properties(
       skip_list PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION
@@ -175,10 +182,11 @@ if(BUILD_TESTING)
     add_library(hash_table SHARED HashTable.cpp)
     target_compile_options(hash_table PRIVATE -fno-exceptions
                                               -fvisibility=hidden)
-    target_include_directories(hash_table PUBLIC ${CMAKE_SOURCE_DIR}/include)
+    target_include_directories(hash_table
+                               PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
     set_target_properties(
       hash_table PROPERTIES LIBRARY_OUTPUT_DIRECTORY
-                            "${CMAKE_BINARY_DIR}/hash_table")
+                            "${CMAKE_CURRENT_BINARY_DIR}/hash_table")
     set_target_properties(hash_table PROPERTIES OUTPUT_NAME ${PROJECT_NAME})
     set_target_properties(
       hash_table PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION
@@ -266,15 +274,19 @@ if(BUILD_TESTING)
     set_property(
       DIRECTORY
       APPEND
-      PROPERTY CMAKE_CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/test_conflict_set.py)
+      PROPERTY CMAKE_CONFIGURE_DEPENDS
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_conflict_set.py)
     execute_process(
-      COMMAND ${Python3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/test_conflict_set.py
-              list OUTPUT_VARIABLE SCRIPT_TESTS)
+      COMMAND ${Python3_EXECUTABLE}
+              ${CMAKE_CURRENT_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})
+        COMMAND
+          ${Python3_EXECUTABLE}
+          ${CMAKE_CURRENT_SOURCE_DIR}/test_conflict_set.py test ${TEST}
+          --build-dir ${CMAKE_CURRENT_BINARY_DIR})
     endforeach()
   endif()
 
@@ -308,25 +320,26 @@ if(BUILD_TESTING)
   # 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)
+      set(symbol_exports ${CMAKE_CURRENT_SOURCE_DIR}/apple-symbol-exports.txt)
+      set(symbol_imports ${CMAKE_CURRENT_SOURCE_DIR}/apple-symbol-imports.txt)
     else()
-      set(symbol_exports ${CMAKE_SOURCE_DIR}/symbol-exports.txt)
+      set(symbol_exports ${CMAKE_CURRENT_SOURCE_DIR}/symbol-exports.txt)
       if(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64)
-        set(symbol_imports ${CMAKE_SOURCE_DIR}/aarch64-symbol-imports.txt)
+        set(symbol_imports
+            ${CMAKE_CURRENT_SOURCE_DIR}/aarch64-symbol-imports.txt)
       else()
-        set(symbol_imports ${CMAKE_SOURCE_DIR}/symbol-imports.txt)
+        set(symbol_imports ${CMAKE_CURRENT_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}>
-        ${symbol_exports} ${symbol_imports})
+        ${CMAKE_CURRENT_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
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_symbols.sh
         $<TARGET_FILE:${PROJECT_NAME}-static> ${symbol_exports}
         ${symbol_imports})
   endif()
@@ -369,13 +382,13 @@ 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)
+    execute_process(COMMAND ${PANDOC_EXE} ${CMAKE_CURRENT_SOURCE_DIR}/README.md
+                            -o ${CMAKE_CURRENT_BINARY_DIR}/README.txt)
+    set(CPACK_RESOURCE_FILE_README ${CMAKE_CURRENT_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)
+  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/LICENSE
+                 ${CMAKE_CURRENT_BINARY_DIR}/LICENSE.txt COPYONLY)
+  set(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_CURRENT_BINARY_DIR}/LICENSE.txt)
 endif()
 
 include(CPack)

ConflictSet.cpp

@@ -2944,10 +2944,6 @@ Iterator firstGeq(Node *n, std::string_view key) {
 
 } // namespace
 
-namespace std {
-void __throw_length_error(const char *) { __builtin_unreachable(); }
-} // namespace std
-
 #if SHOW_MEMORY
 
 int64_t nodeBytes = 0;

Internal.h

@@ -255,10 +255,65 @@ template <class T> struct ArenaAlloc {
   void deallocate(T *, size_t) noexcept {}
 };
 
-template <class T> using Vector = std::vector<T, ArenaAlloc<T>>;
-template <class T> auto vector(Arena &arena) {
-  return Vector<T>(ArenaAlloc<T>(&arena));
-}
+template <class T> struct Vector {
+  static_assert(std::is_trivially_destructible_v<T>);
+  static_assert(std::is_trivially_copyable_v<T>);
+
+  explicit Vector(Arena *arena)
+      : arena(arena), t(nullptr), size_(0), capacity(0) {}
+
+  void append(std::span<const T> slice) {
+    if (size_ + int(slice.size()) > capacity) {
+      grow(std::max<int>(size_ + slice.size(), capacity * 2));
+    }
+    if (slice.size() > 0) {
+      memcpy(const_cast<std::remove_const_t<T> *>(t) + size_, slice.data(),
+             slice.size() * sizeof(T));
+    }
+    size_ += slice.size();
+  }
+
+  void push_back(const T &t) { append(std::span<const T>(&t, 1)); }
+
+  T *begin() { return t; }
+  T *end() { return t + size_; }
+  T *data() { return t; }
+  T &back() {
+    assert(size_ > 0);
+    return t[size_ - 1];
+  }
+  T &operator[](int i) {
+    assert(i >= 0 && i < size_);
+    return t[i];
+  }
+
+  void pop_back() {
+    assert(size_ > 0);
+    --size_;
+  }
+
+  int size() const { return size_; }
+
+  operator std::span<const T>() const { return std::span(t, size_); }
+
+private:
+  void grow(int newCapacity) {
+    capacity = newCapacity;
+    auto old = std::span<const T>(*this);
+    t = (T *)new (std::align_val_t(alignof(T)), *arena)
+        uint8_t[capacity * sizeof(T)];
+    size_ = 0;
+    append(old);
+  }
+
+  Arena *arena;
+  T *t;
+  int size_;
+  int capacity;
+};
+
+template <class T> auto vector(Arena &arena) { return Vector<T>(&arena); }
+
 template <class T, class C> using Set = std::set<T, C, ArenaAlloc<T>>;
 template <class T, class C = std::less<T>> auto set(Arena &arena) {
   return Set<T, C>(ArenaAlloc<T>(&arena));

paper/paper.tex

@@ -8,9 +8,11 @@
 \usepackage[edges]{forest}
 \usepackage{amsmath}
 
+\input{version.txt}
+
 \title{ARTful Concurrency Control à la FoundationDB}
 \author{Andrew Noyes \thanks{\href{mailto:andrew@weaselab.dev}{andrew@weaselab.dev}}}
-\date{}
+\date{Version \versionnumber}
 
 \usepackage{biblatex}
 \bibliography{bibliography}
@@ -33,8 +35,41 @@ This implementation is available at \url{https://git.weaselab.dev/weaselab/confl
 
 Let's begin by considering design options for \emph{lastCommit}.
 In order to manage half-open intervals we need an ordered data structure, so hash tables are out of consideration.
-For any ordered data structure we can implement \emph{lastCommit} using a representation where a logical key is mapped to the value of the last physical key less than or equal to the logical key.
-This is a standard technique used throughout FoundationDB.
+For any ordered data structure we can implement \emph{lastCommit} using a representation where a logical key range (figure \ref{fig:logicalrangemap}) is mapped so that the value of a key is the value of the last physical key (figure \ref{fig:physicalrangemap}) less than or equal to the key.
+This is a standard technique used throughout FoundationDB called a \emph{range map}.
+
+\begin{figure}
+    \caption{Physical structure of range map}
+    \label{fig:physicalrangemap}
+    \centering
+    \begin{tikzpicture}
+        \draw[-latex] (-3.5,0) -- (3.5,0);
+        \foreach \x [count=\xi from 0] in  {\epsilon, a, b}
+            {
+                \draw[shift={(\xi * 2.333 - 3.5,0)},color=black] (0pt,3pt) -- (0pt,-3pt);
+                \node[] at (\xi * 2.333 - 3.5,0.5) {$\x$};
+                \node[anchor=west] at (\xi * 2.333 - 3.5,-0.5) {$\x \mapsto \xi$};
+            };
+    \end{tikzpicture}
+\end{figure}
+
+\begin{figure}
+    \caption{Logical structure of range map}
+    \label{fig:logicalrangemap}
+    \centering
+    \begin{tikzpicture}
+        \draw[-latex] (-3.5,0) -- (3.5,0);
+        \foreach \x [count=\xi from 0] in  {\epsilon, a, b}
+            {
+                \draw[shift={(\xi * 2.333 - 3.5,0)},color=black] (0pt,3pt) -- (0pt,-3pt);
+                \node[] at (\xi * 2.333 - 3.5,0.5) {$\x$};
+            };
+        \foreach \x [count=\xi from 0] in  {{$[\epsilon, a) \mapsto \xi$}, {$[a, b) \mapsto \xi$}, {$[b, \infty) \mapsto \xi$}}
+            {
+                \node[anchor=west] at (\xi * 2.333 - 3.5,-0.5) {\x};
+            };
+    \end{tikzpicture}
+\end{figure}
 
 The problem with applying this to an off-the-shelf ordered data structure is that checking a read range is linear in the number of intersecting physical keys.
 Scanning through every recent point write intersecting a large range read would make conflict checking unacceptably slow for high-write-throughput workloads.
@@ -204,7 +239,7 @@ Libfuzzer's minimized corpus achieves 98\% line coverage on its own.
 We regenerate the corpus on an ad hoc basis by running libfuzzer for a few cpu-hours, during which it tests millions of unique inputs.
 
 In addition to asserting correct externally-visible behavior, in each of these tests we assert that internal invariants hold between operations.
-We also use address sanitizer \cite{10.5555/2342821.2342849} to detect memory errors, undefined behavior sanitizer \cite{ubsan} to detect invocations of undefined behavior, and thread sanitizer \cite{10.1145/1791194.1791203} (while exercising concurrent access as allowed by the documented contract) to detect data-race-related undefined behavior.
+We also use address sanitizer \cite{10.5555/2342821.2342849} to detect memory errors, undefined behavior sanitizer \cite{ubsan} to detect invocations of undefined behavior, and thread sanitizer \cite{10.1145/1791194.1791203} (while exercising concurrent access as allowed by the contract documented in the c++ header file) to detect data-race-related undefined behavior.
 
 Each of these sanitizers is implemented using compiler instrumentation, which means that they are not testing the final binary artifact that will be run in production.
 Therefore we also run the test inputs linking directly to the final release artifact, both standalone and under valgrind \cite{10.5555/1247360.1247362}.

paper/version.txt

@@ -0,0 +1 @@
+\providecommand{\versionnumber}{0.0.6}

version.txt.in

@@ -0,0 +1 @@
+\providecommand{\versionnumber}{@PROJECT_VERSION@}