Use interleaved even if preserve_none is missing

But still run it to account for the version potentially increasing

Bench.cpp

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

CMakeLists.txt

@@ -33,6 +33,15 @@ endif()
 
 add_compile_options(-fdata-sections -ffunction-sections -Wswitch-enum
                     -Werror=switch-enum -fPIC)
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+  add_link_options("-Wno-unused-command-line-argument")
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  add_compile_options("-Wno-maybe-uninitialized")
+endif()
+
 if(NOT APPLE)
   # This causes some versions of clang to crash on macos
   add_compile_options(-g -fno-omit-frame-pointer)

Dockerfile

@@ -11,23 +11,22 @@ RUN TZ=America/Los_Angeles DEBIAN_FRONTEND=noninteractive apt-get install -y \
     binutils-aarch64-linux-gnu \
     build-essential \
     ccache \
-    clang \
     cmake \
     curl \
-    doxygen \
-    file \
     g++-aarch64-linux-gnu \
     gcovr \
     git \
-    gperf \
-    graphviz \
+    gnupg \
     libc6-dbg \
+    lsb-release \
     ninja-build \
     pre-commit \
     python3-requests \
     qemu-user \
     rpm \
+    software-properties-common \
     texlive-full \
+    wget \
     zstd
 
 # Install recent valgrind from source
@@ -43,6 +42,11 @@ RUN curl -Ls https://sourceware.org/pub/valgrind/valgrind-3.22.0.tar.bz2 -o valg
     cd .. && \
     rm -rf /tmp/*
 
+# Recent clang
+RUN wget https://apt.llvm.org/llvm.sh && chmod +x ./llvm.sh && ./llvm.sh 20
+
+RUN apt-get -y install clang llvm
+
 # Set after building valgrind, which doesn't build with clang for some reason
 ENV CC=clang
 ENV CXX=clang++

Internal.h

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

Jenkinsfile

@@ -36,18 +36,6 @@ pipeline {
                 sh 'pre-commit run --all-files --show-diff-on-failure'
             }
         }
-        stage('Clang') {
-            agent {
-                dockerfile {
-                    args '-v /home/jenkins/ccache:/ccache'
-                    reuseNode true
-                }
-            }
-            steps {
-                CleanBuildAndTest("")
-                recordIssues(tools: [clang()])
-            }
-        }
         stage('64 bit versions') {
             agent {
                 dockerfile {
@@ -141,16 +129,16 @@ pipeline {
             }
             steps {
                 script {
-                    filter_args = "-f ConflictSet.cpp -f LongestCommonPrefix.h -f Metrics.h"
+                    gcov_args = "-f ConflictSet.cpp -f LongestCommonPrefix.h -f Metrics.h --gcov-executable 'llvm-cov gcov' --exclude-noncode-lines"
                 }
-                CleanBuildAndTest("-DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_C_FLAGS=--coverage -DCMAKE_CXX_FLAGS=--coverage -DCMAKE_BUILD_TYPE=Debug -DDISABLE_TSAN=ON")
+                CleanBuildAndTest("-DCMAKE_C_FLAGS=--coverage -DCMAKE_CXX_FLAGS=--coverage -DCMAKE_BUILD_TYPE=Debug -DDISABLE_TSAN=ON")
                 sh """
-                gcovr ${filter_args} --cobertura > build/coverage.xml
+                gcovr ${gcov_args} --cobertura > build/coverage.xml
                 """
                 recordCoverage qualityGates: [[criticality: 'NOTE', metric: 'MODULE']], tools: [[parser: 'COBERTURA', pattern: 'build/coverage.xml']]
                 sh """
-                gcovr ${filter_args}
-                gcovr ${filter_args} --fail-under-line 100 > /dev/null
+                gcovr ${gcov_args}
+                gcovr ${gcov_args} --fail-under-line 100 > /dev/null
                 """
             }
         }

LongestCommonPrefix.h

@@ -129,7 +129,7 @@ longestCommonPrefix(const uint8_t *ap, const uint8_t *bp, int cl) {
   }
 
   int i = 0;
-  int end;
+  int end; // GCOVR_EXCL_LINE
 
   // kStride * kUnrollCount at a time
   end = cl & ~(kStride * kUnrollFactor - 1);

ServerBench.cpp

@@ -1,5 +1,6 @@
 #include <atomic>
 #include <cstdint>
+#include <cstdlib>
 #include <errno.h>
 #include <netdb.h>
 #include <stdio.h>
@@ -37,41 +38,20 @@ std::string makeKey(int64_t num, int suffixLen) {
 
 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);
+  constexpr int kNumWrites = 16;
   for (;; transactions.fetch_add(1, std::memory_order_relaxed)) {
-    std::vector<std::string> keys(kNumReads);
-    for (auto &k : keys) {
-      k = makeKey(rand() % kNumPrefixes, 49);
+    std::vector<std::string> keys;
+    std::vector<weaselab::ConflictSet::WriteRange> writes;
+    for (int i = 0; i < kNumWrites; ++i) {
+      keys.push_back(makeKey(rand() % kNumPrefixes, rand() % 50));
     }
-    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;
+    for (int i = 0; i < kNumWrites; ++i) {
+      writes.push_back({{(const uint8_t *)keys[i].data(), int(keys[i].size())},
+                        {nullptr, 0}});
     }
-    cs->check(reads.data(), results.data(), kNumReads);
+    cs->addWrites(writes.data(), writes.size(), version);
+    cs->setOldestVersion(version - kWindowSize);
+    ++version;
   }
 }
 

aarch64-symbol-imports.txt

@@ -5,6 +5,7 @@ __stack_chk_guard@GLIBC_2.17
 abort@GLIBC_2.17
 free@GLIBC_2.17
 malloc@GLIBC_2.17
+memcmp@GLIBC_2.17
 memcpy@GLIBC_2.17
 memmove@GLIBC_2.17
 memset@GLIBC_2.17