Atoi demo and parallel extraction (compress) (#76)

Basic demo code submit.  Functional, passes basic testing, acts equivalently to atoi, strlen etc from libc.  Needs harder utesting to be truly shippable.

----

* Necessary introduction of binary operators to BooleanSWAR

* Fixes compile-time bug

* Implementation of compress, leading spaces, benchmarkization

* Atoi benchmarked

* Repairs parallel suffix

* Re-enables building Robin Hood tests

* Proper benchmark of parallel extraction

* Needs to #include array

* Update inc/zoo/swar/SWAR.h

* Update test/swar/BasicOperations.cpp

* fix broken test (compile error, and mislabel of SWAR<4,64t> as S16_64, causing conflict

---------

Co-authored-by: Eddie <eddie see email elsewhere>
Co-authored-by: Scottbruceheart <[email protected]>
Co-authored-by: Scott Bruceheart <[email protected]>

Author: thecppzoo

benchmark/CMakeLists.txt

@@ -56,9 +56,19 @@ add_executable(
 set_xcode_properties(zoo-google-benchmark)
 
 add_executable(
-    zoo-atoi-benchmark benchmark_main.cpp bm-swar.cpp atoi.cpp
+    zoo-atoi-benchmark benchmark_main.cpp bm-swar.cpp atoi.cpp swar/compress.cpp
 )
 set_xcode_properties(zoo-atoi-benchmark)
 
 target_link_libraries(zoo-google-benchmark benchmark::benchmark)
 target_link_libraries(zoo-atoi-benchmark benchmark::benchmark)
+
+add_library(zoo-atoi-implementations SHARED atoi.cpp)
+add_executable(
+    zoo-atoi-benchmark-from-dynamic-library benchmark_main.cpp bm-swar.cpp
+)
+target_link_libraries(
+    zoo-atoi-benchmark-from-dynamic-library
+    zoo-atoi-implementations
+    benchmark::benchmark
+)

benchmark/atoi-corpus.h

@@ -4,7 +4,9 @@
 #include <vector>
 #include <string>
 #include <cstring>
+#include <array>
 #include <random>
+#include <math.h>
 
 struct Corpus8DecimalDigits {
     std::vector<int> asNumbers_;
@@ -85,7 +87,7 @@ struct CorpusStringLength {
 
         while(count--) {
             auto length = strSize(generator);
-            sizes.push_back(length);
+            sizes.push_back(length + 1);
             for(auto i = length; i--; ) {
                 allCharacters.append(1, characters(generator));
             }
@@ -143,10 +145,171 @@ struct CorpusStringLength {
     AVX2_STRLEN_CORPUS_X_LIST \
     NEON_STRLEN_CORPUS_X_LIST
 
+struct CorpusLeadingSpaces {
+    constexpr static auto CountOfSpaceCharactersAvailable = 6;
+    constexpr static inline std::array<char, CountOfSpaceCharactersAvailable> Spaces =
+        { ' ', '\n', '\t', '\r', '\f', '\v' };
+    std::vector<int> skips_;
+    std::string characters_;
+
+    CorpusLeadingSpaces(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::geometric_distribution<>
+            spacesCount(1.0/29),
+            extraCharacters(0.5);
+            // unrepresentatively very large, but will cross the 32 boundary
+            // to test 32-byte techniques
+        std::uniform_int_distribution<>
+            spacer(0, CountOfSpaceCharactersAvailable - 1),
+            moreCharacters(0, 255);
+
+        while(count--) {
+            auto count = spacesCount(generator);
+            for(auto i = count; i--; ) {
+                allCharacters.append(1, Spaces[spacer(generator)]);
+            }
+            auto extra = moreCharacters(generator);
+            for(auto i = extra; i--; ) {
+                allCharacters.append(1, moreCharacters(generator));
+            }
+            sizes.push_back(count + extra + 1);
+            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 LEADING_SPACES_CORPUS_X_LIST X(GLIB_Spaces, spaces_glibc) X(ZooSpaces, zoo::leadingSpacesCount)
+
+void (*consumeStrPtr)(const char *, unsigned) =
+    [](const char *p, unsigned l) {
+        return;
+    };
+
+struct CorpusAtoi {
+    constexpr static auto CountOfSpaceCharactersAvailable = 6;
+    constexpr static inline std::array<char, CountOfSpaceCharactersAvailable> Spaces =
+        { ' ', '\n', '\t', '\r', '\f', '\v' };
+    std::vector<int> skips_;
+    std::string characters_;
+
+    CorpusAtoi(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::geometric_distribution
+            spacesCount(0.5),
+            insignificantZeros(0.9);
+        std::uniform_real_distribution numberLogarithmBase10(-2.0, 9.2);
+            // a maximum of 10^9.2 is ~1.6 billion, within the range.
+            // negative "logarithms" are for indicating negative numbers up to
+            // -10^2, or -100
+        std::uniform_int_distribution
+            postNumber('9' + 1, 255),
+            spacer(0, CountOfSpaceCharactersAvailable - 1);
+        char conversionBuffer[20];
+
+        while(count--) {
+            auto currentLength = allCharacters.size();
+            auto count = spacesCount(generator);
+            for(auto i = count; i--; ) {
+                allCharacters.append(1, Spaces[spacer(generator)]);
+            }
+            auto logBase10 = numberLogarithmBase10(generator);
+            int negativeSign;
+            if(0.0 <= logBase10) {
+                negativeSign = 0;
+            } else {
+                allCharacters.append(1, '-');
+                logBase10 = -logBase10;
+                negativeSign = 1;
+            }
+            auto iz = insignificantZeros(generator);
+            for(auto i = iz; i--; ) {
+                allCharacters.append(1, '0');
+            }
+            int number = exp(logBase10 * M_LN10);
+            auto n = sprintf(conversionBuffer, "%d%c", number, postNumber(generator));
+            if(n < 0) { throw 0; }
+            allCharacters.append(conversionBuffer);
+            sizes.push_back(count + negativeSign + iz + n);
+            consumeStrPtr(allCharacters.c_str() + currentLength, count + negativeSign + iz + n);
+        }
+        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 ATOI_CORPUS_X_LIST \
+    X(GLIBC_atoi, atoi) X(ZOO_ATOI, zoo::c_strToI) X(COMPARE_ATOI, zoo::compareAtoi)
+
 #define X(Typename, FunctionToCall) \
     struct Invoke##Typename { int operator()(const char *p) { return FunctionToCall(p); } };
 
 PARSE8BYTES_CORPUS_X_LIST
 STRLEN_CORPUS_X_LIST
+LEADING_SPACES_CORPUS_X_LIST
+ATOI_CORPUS_X_LIST
 
 #undef X