Implementations tested & benchmarked with Catch2 too; refactoring of swar benchmarks to share between Google benchmark and Catch2

Author: thecppzoo

benchmark/CMakeLists.txt

@@ -23,7 +23,9 @@ add_subdirectory(dependencies/google_benchmark)
 
 add_executable(
   catch2Benchmark
-    catch2BenchmarkMain.cpp catch2Functions.cpp egyptian.cpp
+    catch2BenchmarkMain.cpp catch2Functions.cpp catch2swar-demo.cpp
+    atoi.cpp
+    egyptian.cpp
     RobinHood.benchmark.cpp
 )
 
@@ -32,7 +34,7 @@ add_executable(
 )
 
 add_executable(
-    zoo-atoi-benchmark benchmark_main.cpp atoi.cpp
+    zoo-atoi-benchmark benchmark_main.cpp bm-swar.cpp atoi.cpp
 )
 
 target_link_libraries(zoo-google-benchmark benchmark::benchmark)

benchmark/atoi-corpus.h

@@ -0,0 +1,70 @@
+#include <vector>
+#include <string>
+#include <random>
+
+struct Corpus8DecimalDigits {
+    std::vector<int> asNumbers_;
+    std::string characters_;
+
+    Corpus8DecimalDigits(std::vector<int> aNs, std::string cs):
+        asNumbers_(aNs),
+        characters_(cs)
+    {}
+
+    template<typename G>
+    static auto makeCorpus(G &generator) {
+        auto count = 1031; // 1031 is a prime number, this helps to disable in
+        // practice the branch predictor, the idea is to measure the performance
+        // of the code under measurement, not how the the unrealistic conditions
+        // of microbenchmarking help/hurt the code under measurement
+        std::string allCharacters;
+        allCharacters.resize(count * 9);
+        std::vector<int> inputs;
+        std::uniform_int_distribution<> range(0, 100*1000*1000 - 1);
+        char *base = allCharacters.data();
+        for(;;) {
+            auto input = range(generator);
+            snprintf(base, 9, "%08d", input);
+            inputs.push_back(input);
+            if(--count) { break; }
+            base += 9;
+        }
+        return Corpus8DecimalDigits(inputs, allCharacters);
+    }
+
+    struct Iterator {
+        Corpus8DecimalDigits *thy;
+        int *ip;
+        char *cp;
+
+        Iterator &operator++() {
+            ++ip;
+            cp += 9;
+            return *this;
+        }
+
+        char *operator*() {
+            return cp;
+        }
+
+        auto next() noexcept {
+            ++(*this);
+            return cp != thy->characters_.data() + thy->characters_.size();
+        }
+    };
+
+    Iterator commence() {
+        return { this, asNumbers_.data(), characters_.data() };
+    }
+};
+
+#define PARSE8BYTES_CORPUS_X_LIST \
+    X(Lemire, parse_eight_digits_swar)\
+    X(Zoo, lemire_as_zoo_swar)\
+    X(LIBC, atoi)
+
+#define X(Typename, FunctionToCall) \
+    struct Invoke##Typename { int operator()(const char *p) { return FunctionToCall(p); } };
+
+PARSE8BYTES_CORPUS_X_LIST
+#undef X

benchmark/atoi.cpp

@@ -1,16 +1,15 @@
 #include "zoo/swar/SWAR.h"
 #include "zoo/swar/associative_iteration.h"
 
-#include <benchmark/benchmark.h>
-
 #include <stdint.h>
 #include <string.h>
 #include <stdlib.h>
 
 // Copied from Daniel Lemire's GitHub at
+// https://lemire.me/blog/2018/10/03/quickly-parsing-eight-digits/
 // https://github.com/lemire/Code-used-on-Daniel-Lemire-s-blog/blob/ddb082981228f7256e9a4dbbf56fd4a335d78e30/2018/10/03/eightchartoi.c#L26C1-L34C2
 
-uint32_t parse_eight_digits_swar(const unsigned char *chars) {
+uint32_t parse_eight_digits_swar(const char *chars) {
   uint64_t val;
   memcpy(&val, chars, 8);
   val = val - 0x3030303030303030;
@@ -22,8 +21,6 @@ uint32_t parse_eight_digits_swar(const unsigned char *chars) {
 
 // Note: eight digits can represent from 0 to (10^9) - 1, the logarithm base 2
 // of 10^9 is slightly less than 30, thus, only 30 bits are needed.
-template<typename> struct Trick;
-
 auto lemire_as_zoo_swar(const char *chars) {
     uint64_t bytes;
     memcpy(&bytes, chars, 8);
@@ -40,12 +37,15 @@ auto lemire_as_zoo_swar(const char *chars) {
      * BASE256 10*B 10*C 10*D 10*E 10*F 10*G 10*H    0
      *           --------------------------------------
      * BASE256 A+10B ....................... G+10H   H
+     * See that the odd-digits (base256) contain 10*odd + even
+     * Then, we can use base(2^16) digits, and base(2^32) to
+     * calculate the conversion for the digits in 100s and 10,000s
      */
     auto by11base256 = convertedToIntegers.multiply(256*10 + 1);
     auto bytePairs = zoo::swar::doublePrecision(by11base256).odd;
     static_assert(std::is_same_v<decltype(bytePairs), zoo::swar::SWAR<16, uint64_t>>);
-    auto by101base2to16 = bytePairs.multiply(1 + 100 << 16);
+    auto by101base2to16 = bytePairs.multiply(1 + (100 << 16));
     auto byteQuads = zoo::swar::doublePrecision(by101base2to16).odd;
-    auto by10001base2to32 = zoo::swar::doublePrecision(by101base2to16).odd;
-    return uint32_t(zoo::swar::doublePrecision(by10001base2to32).odd.value());
+    auto by10001base2to32 = byteQuads.multiply(1 + (10000ull << 32));
+    return uint32_t(by10001base2to32.value() >> 32);
 }

benchmark/atoi.h

@@ -0,0 +1,4 @@
+#include "stdint.h"
+
+uint32_t parse_eight_digits_swar(const char *chars);
+uint32_t lemire_as_zoo_swar(const char *chars);

benchmark/bm-swar.cpp

@@ -0,0 +1,34 @@
+#include "atoi.h"
+#include "atoi-corpus.h"
+
+#include <benchmark/benchmark.h>
+
+int g_SideEffect = 0;
+
+template<typename Corpus, typename Callable>
+void goOverCorpus(Corpus &c, Callable &&cc) {
+    auto iterator = c.commence();
+    auto result = g_SideEffect;
+    do {
+        result ^= cc(*iterator);
+    } while(iterator.next());
+    g_SideEffect = result;
+}
+
+template<typename CorpusMaker, typename Callable>
+void runBenchmark(benchmark::State &s) {
+    std::random_device rd;
+    std::mt19937 g(rd());
+    auto corpus = CorpusMaker::makeCorpus(g);
+    Callable function;
+    for(auto _: s) {
+        goOverCorpus(corpus, function);
+    }
+}
+
+#define X(Typename, FunctionToCall) \
+    BENCHMARK(runBenchmark<Corpus8DecimalDigits, Invoke##Typename>);
+
+PARSE8BYTES_CORPUS_X_LIST
+#undef X
+

benchmark/catch2swar-demo.cpp

@@ -0,0 +1,37 @@
+#include "atoi.h"
+#include "atoi-corpus.h"
+
+#define CATCH_CONFIG_ENABLE_BENCHMARKING
+#include "catch2/catch.hpp"
+
+TEST_CASE("Atoi benchmarks", "[atoi][swar]") {
+    auto traverse =
+        [](auto &&corpus, auto &&function, auto rv) {
+            auto iterator = corpus.commence();
+            do {
+                rv ^= function(*iterator);
+            } while(iterator.next());
+            return rv;
+        };
+    std::random_device rd;
+    auto seed = rd();
+    CAPTURE(seed);
+    std::mt19937 g(seed);
+    auto corpus = Corpus8DecimalDigits::makeCorpus(g);
+    #define X(Type, Fun) \
+        auto from##Type = traverse(corpus, Invoke##Type{}, 0);
+    PARSE8BYTES_CORPUS_X_LIST
+    #undef X
+    REQUIRE(fromLemire == fromZoo);
+    REQUIRE(fromLIBC == fromZoo);
+
+    auto haveTheRoleOfMemoryBarrier = -1;
+    #define X(Type, Fun) \
+        BENCHMARK(#Type) { \
+            return \
+                traverse(corpus, Invoke##Type{}, haveTheRoleOfMemoryBarrier); \
+        };
+    PARSE8BYTES_CORPUS_X_LIST
+    #undef X
+}
+