Draft of strlen

Author: Eddie

benchmark/atoi-corpus.h

@@ -1,5 +1,8 @@
+#include "atoi.h"
+
 #include <vector>
 #include <string>
+#include <cstring>
 #include <random>
 
 struct Corpus8DecimalDigits {
@@ -63,8 +66,67 @@ struct Corpus8DecimalDigits {
     X(Zoo, lemire_as_zoo_swar)\
     X(LIBC, atoi)
 
+struct CorpusStringLength {
+    std::vector<int> skips_;
+    std::string characters_;
+
+    CorpusStringLength(std::vector<int> &&skips, std::string &&cs):
+        skips_{std::move(skips)}, characters_{std::move(cs)}
+    {}
+
+    template<typename G>
+    static auto makeCorpus(G &generator) {
+        auto count = 1031; // see Corpus8DecimalDigits for why 1031
+        std::vector<int> sizes;
+        std::string allCharacters;
+        std::uniform_int_distribution<> strSize(0, 101); // again a prime
+        std::uniform_int_distribution<> characters(1, 255); // notice 0 excluded
+
+        for(;;) {
+            auto length = strSize(generator);
+            sizes.push_back(length);
+            for(auto i = length; i--; ) {
+                allCharacters.append(1, characters(generator));
+            }
+            allCharacters.append(1, '\0');
+        }
+        return CorpusStringLength(std::move(sizes), std::move(allCharacters));
+    }
+
+    struct Iterator {
+        int *skips, *sentinel;
+        char *cp;
+
+        Iterator &operator++() {
+            cp += *skips++;
+            return *this;
+        }
+
+        char *operator*() {
+            return cp;
+        }
+
+        auto next() noexcept {
+            ++(*this);
+            return sentinel != skips;
+        }
+    };
+
+    Iterator commence() {
+        return {
+            skips_.data(), skips_.data() + skips_.size(), characters_.data()
+        };
+    }
+};
+
+#define STRLEN_CORPUS_X_LIST \
+    X(LIBC_STRLEN, strlen) \
+    X(ZOO_BEST_STRLEN, zoo::c_strLength) \
+    X(ZOO_NATURAL_STRLEN, zoo::c_strLength_MoreNaturalButSlightlyWorse)
+
 #define X(Typename, FunctionToCall) \
     struct Invoke##Typename { int operator()(const char *p) { return FunctionToCall(p); } };
 
 PARSE8BYTES_CORPUS_X_LIST
+STRLEN_CORPUS_X_LIST
 #undef X

benchmark/atoi.cpp

@@ -49,3 +49,45 @@ auto lemire_as_zoo_swar(const char *chars) {
     auto by10001base2to32 = byteQuads.multiply(1 + (10000ull << 32));
     return uint32_t(by10001base2to32.value() >> 32);
 }
+
+namespace zoo {
+
+std::size_t c_strLength(const char *s) {
+    std::size_t rv = 0;
+    using S = swar::SWAR<8, std::size_t>;
+    S bytes;
+    constexpr auto MSBs = S{S::MostSignificantBit};
+    for(auto base = s;; base += 8) {
+        memcpy(&bytes.m_v, base, 8);
+        // A null byte is detected in two steps:
+        // 1. it has the MSB off, and
+        // the least significant bits are also off.
+        // The swar library allows the detection of lsbs off
+        // By comparing greater equal to 0,
+        // 0 can only be greater-equal to a byte with LSBs 0
+        auto haveMSB_cleared = bytes ^ MSBs;
+        auto lsbNulls = zoo::swar::greaterEqual_MSB_off(S{0}, bytes);
+        auto nulls = swar::asBooleanSWAR(haveMSB_cleared & lsbNulls);
+        if(nulls) {
+            auto firstNullIndex = nulls.lsbIndex();
+            return firstNullIndex + (base - s);
+        }
+    }
+}
+
+std::size_t c_strLength_MoreNaturalButSlightlyWorse(const char *s) {
+    std::size_t rv = 0;
+    using S = swar::SWAR<8, std::size_t>;
+    S bytes;
+    constexpr auto MSBs = S{S::MostSignificantBit};
+    for(auto base = s;; base += 8) {
+        memcpy(&bytes.m_v, base, 8);
+        auto nulls = zoo::swar::equals(bytes, S{0});
+        if(nulls) { // there is a null!
+            auto firstNullIndex = nulls.lsbIndex();
+            return firstNullIndex + (base - s);
+        }
+    }
+}
+
+}

benchmark/atoi.h

@@ -1,4 +1,12 @@
 #include "stdint.h"
+#include <cstdlib>
 
 uint32_t parse_eight_digits_swar(const char *chars);
 uint32_t lemire_as_zoo_swar(const char *chars);
+
+namespace zoo {
+
+std::size_t c_strLength(const char *s);
+std::size_t c_strLength_MoreNaturalButSlightlyWorse(const char *s);
+
+}

benchmark/bm-swar.cpp

@@ -32,3 +32,7 @@ void runBenchmark(benchmark::State &s) {
 PARSE8BYTES_CORPUS_X_LIST
 #undef X
 
+#define X(TN, FTC) \
+    BENCHMARK(runBenchmark<CorpusStringLength, Invoke##TN>);
+STRLEN_CORPUS_X_LIST
+#undef X

inc/zoo/swar/SWAR.h

@@ -362,8 +362,16 @@ struct BooleanSWAR: SWAR<NBits, T> {
     template<int NB, typename TT>
     friend constexpr BooleanSWAR<NB, TT>
     greaterEqual_MSB_off(SWAR<NB, TT>, SWAR<NB, TT>) noexcept;
+
+    template<int NB, typename TT>
+    friend constexpr BooleanSWAR<NB, TT>
+    asBooleanSWAR(SWAR<NB, TT> arg) noexcept;
 };
 
+template<int NBits, typename T>
+constexpr BooleanSWAR<NBits, T>
+asBooleanSWAR(SWAR<NBits, T> arg) noexcept { return arg; }
+
 template<int N, int NBits, typename T>
 constexpr BooleanSWAR<NBits, T>
 constantIsGreaterEqual(SWAR<NBits, T> subtrahend) noexcept {