Clean up; add bench and bench_all apps

Author: Charlie Frasch

CMakeLists.txt

@@ -58,3 +58,12 @@ target_compile_options(unitTests PRIVATE -fsanitize=undefined -fsanitize=address
 target_link_libraries(unitTests PRIVATE asan ubsan gtest gtest_main)
 target_link_options(unitTests PRIVATE -fsanitize=undefined -fsanitize=address)
 gtest_add_tests(TARGET unitTests)
+
+
+find_package(benchmark REQUIRED)
+add_executable(bench bench.cpp)
+target_compile_options(bench PRIVATE -Wno-interference-size)
+target_link_libraries(bench PRIVATE benchmark::benchmark)
+
+add_executable(bench_all bench_all.cpp)
+target_compile_options(bench_all PRIVATE -Wno-interference-size)

Fifo3.hpp

@@ -32,7 +32,7 @@ class Fifo3 : private Alloc
 
     /// Returns the number of elements in the fifo
     auto size() const noexcept {
-        auto pushCursor = pushCursor_.load(std::memory_order_acquire);
+        auto pushCursor = pushCursor_.load(std::memory_order_relaxed);
         auto popCursor = popCursor_.load(std::memory_order_relaxed);
 
         assert(popCursor <= pushCursor);

Fifo4.hpp

@@ -31,7 +31,7 @@ class Fifo4 : private Alloc
 
     /// Returns the number of elements in the fifo
     auto size() const noexcept {
-        auto pushCursor = pushCursor_.load(std::memory_order_acquire);
+        auto pushCursor = pushCursor_.load(std::memory_order_relaxed);
         auto popCursor = popCursor_.load(std::memory_order_relaxed);
 
         assert(popCursor <= pushCursor);

Fifo4a.hpp

@@ -31,7 +31,7 @@ class Fifo4a : private Alloc
 
     /// Returns the number of elements in the fifo
     auto size() const noexcept {
-        auto pushCursor = pushCursor_.load(std::memory_order_acquire);
+        auto pushCursor = pushCursor_.load(std::memory_order_relaxed);
         auto popCursor = popCursor_.load(std::memory_order_relaxed);
 
         assert(popCursor <= pushCursor);

Fifo5.hpp

@@ -42,7 +42,7 @@ class Fifo5 : private Alloc
 
     /// Returns the number of elements in the fifo
     auto size() const noexcept {
-        auto pushCursor = pushCursor_.load(std::memory_order_acquire);
+        auto pushCursor = pushCursor_.load(std::memory_order_relaxed);
         auto popCursor = popCursor_.load(std::memory_order_relaxed);
 
         assert(popCursor <= pushCursor);

bench.cpp

@@ -0,0 +1,101 @@
+#include "Fifo4.hpp"
+#include "Fifo4a.hpp"
+#include "Fifo5.hpp"
+#include "rigtorp.hpp"
+
+#include <benchmark/benchmark.h>
+
+#include <iostream>
+#include <thread>
+
+
+static void pinThread(int cpu) {
+    if (cpu < 0) {
+        return;
+    }
+    ::cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    CPU_SET(cpu, &cpuset);
+    if (::pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset) == -1) {
+        std::perror("pthread_setaffinity_rp");
+        std::exit(EXIT_FAILURE);
+    }
+}
+
+constexpr auto cpu1 = 1;
+constexpr auto cpu2 = 2;
+
+template<typename T>
+struct isRigtorp : std::false_type {};
+
+template<typename ValueT>
+struct isRigtorp<rigtorp::SPSCQueue<ValueT>> : std::true_type {};
+
+
+template<template<typename> class FifoT>
+void BM_Fifo(benchmark::State& state) {
+    using fifo_type = FifoT<std::int_fast64_t>;
+    using value_type = typename fifo_type::value_type;
+
+    constexpr auto fifoSize = 131072;
+    fifo_type fifo(fifoSize);
+
+    auto t = std::jthread([&] {
+        pinThread(cpu1);
+        for (auto i = value_type{};; ++i) {
+            value_type val;
+            if constexpr(isRigtorp<fifo_type>::value) {
+                while (!fifo.front());
+                benchmark::DoNotOptimize(val = *fifo.front());
+                fifo.pop();
+            } else {
+                while (not fifo.pop(val)) {
+                    ;
+                }
+                benchmark::DoNotOptimize(val);
+            }
+            if (val == -1) {
+                break;
+            }
+
+            if (val != i) {
+                throw std::runtime_error("invalid value");
+            }
+        }
+    });
+
+    auto value = value_type{};
+    pinThread(cpu2);
+    for (auto _ : state) {
+        if constexpr(isRigtorp<fifo_type>::value) {
+            while (not fifo.try_push(value)) {
+                ;
+            }
+        } else {
+            while (not fifo.push(value)) {
+                ;
+            }
+        }
+        ++value;
+
+        while (not fifo.empty()) {
+          ;
+        }
+    }
+    state.counters["ops/sec"] = benchmark::Counter(double(value), benchmark::Counter::kIsRate);
+    state.PauseTiming();
+    if constexpr(isRigtorp<fifo_type>::value) {
+        while(not fifo.try_push(-1)) {}
+    } else {
+        fifo.push(-1);
+    }
+}
+
+
+BENCHMARK_TEMPLATE(BM_Fifo, Fifo4);
+BENCHMARK_TEMPLATE(BM_Fifo, Fifo4a);
+BENCHMARK_TEMPLATE(BM_Fifo, Fifo5);
+BENCHMARK_TEMPLATE(BM_Fifo, rigtorp::SPSCQueue);
+
+BENCHMARK_MAIN();
+

bench.hpp

@@ -30,12 +30,11 @@ template<typename T>
 struct isRigtorp : std::false_type {};
 
 template<typename T>
-void bench(char const* name, int cpu1, int cpu2) {
+auto bench(char const* name, long iters, int cpu1, int cpu2) {
+    using namespace std::chrono_literals;
     using value_type = typename T::value_type;
 
     constexpr auto fifoSize = 131072;
-    constexpr auto iters = 200'000'000l;
-    // constexpr auto iters = 100'000'000l;
 
     T q(fifoSize);
     auto t = std::jthread([&] {
@@ -77,21 +76,28 @@ void bench(char const* name, int cpu1, int cpu2) {
       ;
     }
     auto stop = std::chrono::steady_clock::now();
-    auto delta = std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);
-    std::cout << std::setw(7) << std::left << name << ": "
-        << std::setw(10) << std::right << iters * 1'000'000'000 / delta.count()
-        << " ops/s\n";
+    auto delta = stop - start;
+    return (iters * 1s)/delta;
 }
 
 template<template<typename> class FifoT>
 void bench(char const* name, int argc, char* argv[]) {
-    int cpu1 = -1;
-    int cpu2 = -1;
+    int cpu1 = 1;
+    int cpu2 = 2;
     if (argc == 3) {
        cpu1 = std::atoi(argv[1]);
        cpu2 = std::atoi(argv[2]);
     }
-    // using value_type = std::array<long, 25>;
+
+    constexpr auto iters = 400'000'000l;
+    // constexpr auto iters = 100'000'000l;
+
     using value_type = std::int64_t;
-    bench<FifoT<value_type>>(name, cpu1, cpu2);
+
+    // warmup
+    bench<FifoT<value_type>>(name, 1'000'000, cpu1, cpu2);
+
+    auto opsPerSec = bench<FifoT<value_type>>(name, iters, cpu1, cpu2);
+    std::cout << std::setw(7) << std::left << name << ": "
+        << std::setw(10) << std::right << opsPerSec << " ops/s\n";
 }

bench_all.cpp

@@ -0,0 +1,50 @@
+#include "Fifo3.hpp"
+#include "Fifo4.hpp"
+#include "Fifo4a.hpp"
+#include "Fifo5.hpp"
+#include "rigtorp.hpp"
+#include <boost/lockfree/spsc_queue.hpp>   // boost 1.74.0
+
+#include "bench.hpp"
+
+#include <iostream>
+
+
+template<typename ValueT>
+struct isRigtorp<rigtorp::SPSCQueue<ValueT>> : std::true_type {};
+
+
+// Configuring fixed size to match Fifo5's fixed size
+template<typename T>
+using boost_spsc_queue = boost::lockfree::spsc_queue<T, boost::lockfree::fixed_sized<true>>;
+
+
+template<typename ValueT>
+void once(long iters, int cpu1, int cpu2) {
+    std::cout <<
+        bench<Fifo3<ValueT>>("Fifo3", iters, cpu1, cpu2) << "," <<
+        bench<Fifo4<ValueT>>("Fifo4", iters, cpu1, cpu2) << "," <<
+        bench<Fifo4a<ValueT>>("Fifo4a", iters, cpu1, cpu2) << "," <<
+        bench<Fifo5<ValueT>>("Fifo5", iters, cpu1, cpu2) << "," <<
+        bench<rigtorp::SPSCQueue<ValueT>>("rigtorp", iters, cpu1, cpu2) << "," <<
+        bench<boost_spsc_queue<ValueT>>("boost::spsc_queue fixed", iters, cpu1, cpu2) <<
+        "\n";
+}
+
+int main(int argc, char* argv[]) {
+    constexpr auto cpu1 = 1;
+    constexpr auto cpu2 = 2;
+    constexpr auto iters = 400'000'000l;
+
+    auto reps = 10;
+    if (argc == 2) {
+       reps = std::atoi(argv[1]);
+    }
+
+    using value_type = std::int64_t;
+
+    std::cout << "Fifo3,Fifo4,Fifo4a,Fifo5,rigtorp,boost_spsc_queue\n";
+    for (auto rep = 0; rep < reps; ++rep) {
+        once<value_type>(iters, cpu1, cpu2);
+    }
+}