Disable skip list tests by default

Would be great to find a way to make this all more readable

Bench.cpp

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

CMakeLists.txt

@@ -95,12 +95,23 @@ 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 $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
+add_library(${PROJECT_NAME} SHARED ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.o)
 set_target_properties(
   ${PROJECT_NAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY
                              "${CMAKE_CURRENT_BINARY_DIR}/radix_tree")
-if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
+if(CMAKE_BUILD_TYPE STREQUAL Debug)
+  set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE CXX)
+else()
   set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE C)
 endif()
 
@@ -110,19 +121,13 @@ if(HAS_VERSION_SCRIPT)
     LINKER:--version-script=${CMAKE_CURRENT_SOURCE_DIR}/linker.map)
 endif()
 
-add_library(${PROJECT_NAME}-static STATIC
-            $<TARGET_OBJECTS:${PROJECT_NAME}-object>)
-if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
+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()
   set_target_properties(${PROJECT_NAME}-static PROPERTIES LINKER_LANGUAGE C)
 endif()
-
-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()
+if(NOT APPLE)
   add_custom_command(
     TARGET ${PROJECT_NAME}-static
     POST_BUILD
@@ -177,10 +182,13 @@ 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)
 
-  foreach(TEST ${CORPUS_TESTS})
-    get_filename_component(hash ${TEST} NAME)
-    add_test(NAME skip_list_${hash} COMMAND driver_skip_list ${TEST})
-  endforeach()
+  # 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()
 
   # ad hoc testing
   add_executable(conflict_set_main ConflictSet.cpp)
@@ -248,6 +256,19 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
     add_test(NAME conflict_set_blackbox_${hash} COMMAND driver ${TEST})
   endforeach()
 
+  find_program(VALGRIND_EXE valgrind)
+  if(VALGRIND_EXE AND NOT CMAKE_CROSSCOMPILING)
+    list(LENGTH CORPUS_TESTS len)
+    math(EXPR last "${len} - 1")
+    set(partition_size 100)
+    foreach(i RANGE 0 ${last} ${partition_size})
+      list(SUBLIST CORPUS_TESTS ${i} ${partition_size} partition)
+      add_test(NAME conflict_set_blackbox_valgrind_${i}
+               COMMAND ${VALGRIND_EXE} --error-exitcode=99 --
+                       $<TARGET_FILE:driver> ${partition})
+    endforeach()
+  endif()
+
   # scripted tests. Written manually to fill in anything libfuzzer couldn't
   # find.
   if(NOT CMAKE_CROSSCOMPILING)
@@ -268,19 +289,14 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
           ${Python3_EXECUTABLE}
           ${CMAKE_CURRENT_SOURCE_DIR}/test_conflict_set.py test ${TEST}
           --build-dir ${CMAKE_CURRENT_BINARY_DIR})
-    endforeach()
-  endif()
-
-  find_program(VALGRIND_EXE valgrind)
-  if(VALGRIND_EXE AND NOT CMAKE_CROSSCOMPILING)
-    list(LENGTH CORPUS_TESTS len)
-    math(EXPR last "${len} - 1")
-    set(partition_size 100)
-    foreach(i RANGE 0 ${last} ${partition_size})
-      list(SUBLIST CORPUS_TESTS ${i} ${partition_size} partition)
-      add_test(NAME conflict_set_blackbox_valgrind_${i}
-               COMMAND ${VALGRIND_EXE} --error-exitcode=99 --
-                       $<TARGET_FILE:driver> ${partition})
+      if(VALGRIND_EXE AND NOT CMAKE_CROSSCOMPILING)
+        add_test(
+          NAME script_test_${TEST}_valgrind
+          COMMAND
+            ${VALGRIND_EXE} ${Python3_EXECUTABLE}
+            ${CMAKE_CURRENT_SOURCE_DIR}/test_conflict_set.py test ${TEST}
+            --build-dir ${CMAKE_CURRENT_BINARY_DIR})
+      endif()
     endforeach()
   endif()
 
@@ -350,6 +366,11 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
   set_target_properties(server_bench PROPERTIES SKIP_BUILD_RPATH ON)
 
   add_executable(interleaving_test InterleavingTest.cpp)
+  # work around lack of musttail for gcc
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_BUILD_TYPE STREQUAL "Debug")
+    target_compile_options(interleaving_test PRIVATE -Og
+                                                     -foptimize-sibling-calls)
+  endif()
   target_link_libraries(interleaving_test PRIVATE nanobench)
 endif()
 

Dockerfile

@@ -8,6 +8,7 @@ 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 \

InterleavingTest.cpp

@@ -22,9 +22,6 @@ void *stepJob(Job *j) {
   return done ? nullptr : (void *)stepJob;
 }
 
-// So we can look at the disassembly more easily
-
-extern "C" {
 void sequential(Job **jobs, int count) {
   for (int i = 0; i < count; ++i) {
     do {
@@ -94,6 +91,87 @@ void interleaveBoundedCyclicList(Job **jobs, int count) {
   }
 }
 
+#ifndef __has_attribute
+#define __has_attribute(x) 0
+#endif
+
+#if __has_attribute(musttail)
+#define MUSTTAIL __attribute__((musttail))
+#else
+#define MUSTTAIL
+#endif
+
+struct Context {
+  constexpr static int kConcurrent = 32;
+  Job **jobs;
+  Job *inProgress[kConcurrent];
+  void (*continuation[kConcurrent])(Context *, int64_t prevJob, int64_t job,
+                                    int64_t started, int64_t count);
+  int nextJob[kConcurrent];
+};
+
+void keepGoing(Context *context, int64_t prevJob, int64_t job, int64_t started,
+               int64_t count) {
+  prevJob = job;
+  job = context->nextJob[job];
+  MUSTTAIL return context->continuation[job](context, prevJob, job, started,
+                                             count);
+}
+
+void stepJobTailCall(Context *context, int64_t prevJob, int64_t job,
+                     int64_t started, int64_t count);
+
+void complete(Context *context, int64_t prevJob, int64_t job, int64_t started,
+              int64_t count) {
+  if (started == count) {
+    if (prevJob == job) {
+      return;
+    }
+    context->nextJob[prevJob] = context->nextJob[job];
+    job = prevJob;
+  } else {
+    context->inProgress[job] = context->jobs[started++];
+    context->continuation[job] = stepJobTailCall;
+  }
+  prevJob = job;
+  job = context->nextJob[job];
+  MUSTTAIL return context->continuation[job](context, prevJob, job, started,
+                                             count);
+}
+
+void stepJobTailCall(Context *context, int64_t prevJob, int64_t job,
+                     int64_t started, int64_t count) {
+  auto *j = context->inProgress[job];
+  auto done = --(*j->input) == 0;
+#ifdef __x86_64__
+  _mm_clflush(j->input);
+#endif
+  if (done) {
+    MUSTTAIL return complete(context, prevJob, job, started, count);
+  } else {
+    context->continuation[job] = stepJobTailCall;
+    MUSTTAIL return keepGoing(context, prevJob, job, started, count);
+  }
+}
+
+void useTailCalls(Job **jobs, int count) {
+  if (count == 0) {
+    return;
+  }
+  Context context;
+  context.jobs = jobs;
+  int64_t started = std::min(Context::kConcurrent, count);
+  for (int i = 0; i < started; i++) {
+    context.inProgress[i] = jobs[i];
+    context.nextJob[i] = i + 1;
+    context.continuation[i] = stepJobTailCall;
+  }
+  context.nextJob[started - 1] = 0;
+  int prevJob = started - 1;
+  int job = 0;
+  return context.continuation[job](&context, prevJob, job, started, count);
+}
+
 void interleaveCyclicList(Job **jobs, int count) {
   auto *nextJob = (int *)alloca(sizeof(int) * count);
 
@@ -117,12 +195,11 @@ void interleaveCyclicList(Job **jobs, int count) {
     job = nextJob[job];
   }
 }
-}
 
 int main() {
   ankerl::nanobench::Bench bench;
 
-  constexpr int kNumJobs = 100;
+  constexpr int kNumJobs = 10000;
   bench.relative(true);
 
   Job jobs[kNumJobs];
@@ -140,6 +217,7 @@ int main() {
   for (auto [scheduler, name] :
        {std::make_pair(sequentialNoFuncPtr, "sequentialNoFuncPtr"),
         std::make_pair(sequential, "sequential"),
+        std::make_pair(useTailCalls, "useTailCalls"),
         std::make_pair(interleaveSwapping, "interleavingSwapping"),
         std::make_pair(interleaveBoundedCyclicList,
                        "interleaveBoundedCyclicList"),

Internal.h

@@ -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)};
 }
 

aarch64-toolchain.cmake

@@ -5,3 +5,4 @@ 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")