Include childType in ChildAndMaxVersion

Bench.cpp

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

CMakeLists.txt

@@ -95,23 +95,12 @@ target_compile_options(${PROJECT_NAME}-object PRIVATE -fno-exceptions
                                                       -fvisibility=hidden)
 target_include_directories(${PROJECT_NAME}-object
                            PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
-if(NOT LD_EXE)
-  set(LD_EXE ld)
-endif()
-add_custom_command(
-  OUTPUT ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.o
-  COMMAND ${LD_EXE} -r $<TARGET_OBJECTS:${PROJECT_NAME}-object> -o
-          ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.o
-  DEPENDS $<TARGET_OBJECTS:${PROJECT_NAME}-object>
-  COMMAND_EXPAND_LISTS)
 
-add_library(${PROJECT_NAME} SHARED ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.o)
+add_library(${PROJECT_NAME} SHARED $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
 set_target_properties(
   ${PROJECT_NAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY
                              "${CMAKE_CURRENT_BINARY_DIR}/radix_tree")
-if(CMAKE_BUILD_TYPE STREQUAL Debug)
-  set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE CXX)
-else()
+if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
   set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE C)
 endif()
 
@@ -121,13 +110,19 @@ if(HAS_VERSION_SCRIPT)
     LINKER:--version-script=${CMAKE_CURRENT_SOURCE_DIR}/linker.map)
 endif()
 
-add_library(${PROJECT_NAME}-static STATIC ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.o)
-if(CMAKE_BUILD_TYPE STREQUAL Debug)
-  set_target_properties(${PROJECT_NAME}-static PROPERTIES LINKER_LANGUAGE CXX)
-else()
+add_library(${PROJECT_NAME}-static STATIC
+            $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
+if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
   set_target_properties(${PROJECT_NAME}-static PROPERTIES LINKER_LANGUAGE C)
 endif()
-if(NOT APPLE)
+
+if(APPLE)
+  add_custom_command(
+    TARGET ${PROJECT_NAME}-static
+    PRE_LINK
+    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/privatize_symbols_macos.sh
+            $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
+else()
   add_custom_command(
     TARGET ${PROJECT_NAME}-static
     POST_BUILD
@@ -182,13 +177,10 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
   target_compile_options(driver_skip_list PRIVATE ${TEST_FLAGS})
   target_link_libraries(driver_skip_list PRIVATE skip_list)
 
-  # enable to test skip list
-  if(0)
-    foreach(TEST ${CORPUS_TESTS})
-      get_filename_component(hash ${TEST} NAME)
-      add_test(NAME skip_list_${hash} COMMAND driver_skip_list ${TEST})
-    endforeach()
-  endif()
+  foreach(TEST ${CORPUS_TESTS})
+    get_filename_component(hash ${TEST} NAME)
+    add_test(NAME skip_list_${hash} COMMAND driver_skip_list ${TEST})
+  endforeach()
 
   # ad hoc testing
   add_executable(conflict_set_main ConflictSet.cpp)

Dockerfile

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

Internal.h

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

Jenkinsfile

@@ -81,7 +81,7 @@ pipeline {
                 CleanBuildAndTest("-DUSE_SIMD_FALLBACK=ON")
             }
         }
-        stage('Release [clang]') {
+        stage('Release [gcc]') {
             agent {
                 dockerfile {
                     args '-v /home/jenkins/ccache:/ccache'
@@ -89,8 +89,8 @@ pipeline {
                 }
             }
             steps {
-                CleanBuildAndTest("-DCMAKE_CXX_FLAGS=-DNVALGRIND")
-                recordIssues(tools: [clang()])
+                CleanBuildAndTest("-DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_CXX_FLAGS=-DNVALGRIND")
+                recordIssues(tools: [gcc()])
                 sh '''
                 cd build
                 cpack -G DEB
@@ -103,19 +103,7 @@ pipeline {
                 minio bucket: 'jenkins', credentialsId: 'jenkins-minio', excludes: '', host: 'minio.weaselab.dev', includes: 'build/*.deb,build/*.rpm,paper/*.pdf', targetFolder: '${JOB_NAME}/${BUILD_NUMBER}/${STAGE_NAME}/'
             }
         }
-        stage('Release [gcc]') {
-            agent {
-                dockerfile {
-                    args '-v /home/jenkins/ccache:/ccache'
-                    reuseNode true
-                }
-            }
-            steps {
-                CleanBuildAndTest("-DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_CXX_FLAGS=-DNVALGRIND")
-                recordIssues(tools: [gcc()])
-            }
-        }
-        stage('Release [clang,aarch64]') {
+        stage('Release [gcc,aarch64]') {
             agent {
                 dockerfile {
                     args '-v /home/jenkins/ccache:/ccache'

ServerBench.cpp

@@ -1,5 +1,4 @@
 #include <atomic>
-#include <cstdint>
 #include <errno.h>
 #include <netdb.h>
 #include <stdio.h>
@@ -22,56 +21,78 @@
 
 std::atomic<int64_t> transactions;
 
+constexpr int kBaseSearchDepth = 115;
 constexpr int kWindowSize = 10000000;
 
-constexpr int kNumPrefixes = 250000;
-
-std::string makeKey(int64_t num, int suffixLen) {
+std::string numToKey(int64_t num) {
   std::string result;
-  result.resize(sizeof(int64_t) + suffixLen);
+  result.resize(kBaseSearchDepth + sizeof(int64_t));
+  memset(result.data(), 0, kBaseSearchDepth);
   int64_t be = __builtin_bswap64(num);
-  memcpy(result.data(), &be, sizeof(int64_t));
-  memset(result.data() + sizeof(int64_t), 0, suffixLen);
+  memcpy(result.data() + kBaseSearchDepth, &be, sizeof(int64_t));
   return result;
 }
 
 void workload(weaselab::ConflictSet *cs) {
   int64_t version = kWindowSize;
-  for (int i = 0; i < kNumPrefixes; ++i) {
-    for (int j = 0; j < 50; ++j) {
-      weaselab::ConflictSet::WriteRange wr;
-      auto k = makeKey(i, j);
-      wr.begin.p = (const uint8_t *)k.data();
-      wr.begin.len = k.size();
-      wr.end.len = 0;
-      cs->addWrites(&wr, 1, version);
-    }
-  }
-  ++version;
-  for (int i = 0; i < kNumPrefixes; ++i) {
-    weaselab::ConflictSet::WriteRange wr;
-    auto k = makeKey(i, 50);
-    wr.begin.p = (const uint8_t *)k.data();
-    wr.begin.len = k.size();
-    wr.end.len = 0;
-    cs->addWrites(&wr, 1, version);
-  }
-
-  constexpr int kNumReads = 1;
-  std::vector<weaselab::ConflictSet::Result> results(kNumReads);
+  cs->addWrites(nullptr, 0, version);
   for (;; transactions.fetch_add(1, std::memory_order_relaxed)) {
-    std::vector<std::string> keys(kNumReads);
-    for (auto &k : keys) {
-      k = makeKey(rand() % kNumPrefixes, 49);
+    // Reads
+    {
+      auto beginK = numToKey(version - kWindowSize);
+      auto endK = numToKey(version - 1);
+      auto pointRv = version - kWindowSize + rand() % kWindowSize + 1;
+      auto pointK = numToKey(pointRv);
+      weaselab::ConflictSet::ReadRange reads[] = {
+          {
+              {(const uint8_t *)pointK.data(), int(pointK.size())},
+              {nullptr, 0},
+              pointRv,
+          },
+          {
+              {(const uint8_t *)beginK.data(), int(beginK.size())},
+              {(const uint8_t *)endK.data(), int(endK.size())},
+              version - 2,
+          },
+      };
+      weaselab::ConflictSet::Result result[sizeof(reads) / sizeof(reads[0])];
+      cs->check(reads, result, sizeof(reads) / sizeof(reads[0]));
+      // for (int i = 0; i < sizeof(reads) / sizeof(reads[0]); ++i) {
+      //   if (result[i] != weaselab::ConflictSet::Commit) {
+      //     fprintf(stderr, "Unexpected conflict: [%s, %s) @ %" PRId64 "\n",
+      //             printable(reads[i].begin).c_str(),
+      //             printable(reads[i].end).c_str(), reads[i].readVersion);
+      //     abort();
+      //   }
+      // }
     }
-    std::vector<weaselab::ConflictSet::ReadRange> reads(kNumReads);
-    for (int i = 0; i < reads.size(); ++i) {
-      reads[i].begin.p = (const uint8_t *)(keys[i].data());
-      reads[i].begin.len = keys[i].size();
-      reads[i].end.len = 0;
-      reads[i].readVersion = version - 1;
+    // Writes
+    {
+      weaselab::ConflictSet::WriteRange w;
+      auto k = numToKey(version);
+      w.begin.p = (const uint8_t *)k.data();
+      w.end.len = 0;
+      if (version % (kWindowSize / 2) == 0) {
+        for (int l = 0; l <= k.size(); ++l) {
+          w.begin.len = l;
+          cs->addWrites(&w, 1, version);
+        }
+      } else {
+        w.begin.len = k.size();
+        cs->addWrites(&w, 1, version);
+        int64_t beginN = version - kWindowSize + rand() % kWindowSize;
+        auto b = numToKey(beginN);
+        auto e = numToKey(beginN + 1000);
+        w.begin.p = (const uint8_t *)b.data();
+        w.begin.len = b.size();
+        w.end.p = (const uint8_t *)e.data();
+        w.end.len = e.size();
+        cs->addWrites(&w, 1, version);
+      }
     }
-    cs->check(reads.data(), results.data(), kNumReads);
+    // GC
+    cs->setOldestVersion(version - kWindowSize);
+    ++version;
   }
 }
 

aarch64-toolchain.cmake

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