Add files via upload

Author: CharlesFrasch

CMakeLists.txt

@@ -0,0 +1,31 @@
+cmake_minimum_required(VERSION 3.22)
+set(CMAKE_C_COMPILER /usr/bin/gcc-12)
+set(CMAKE_CXX_COMPILER /usr/bin/g++-12)
+
+project(cppcon2023)
+
+
+# TODO fix this
+set(CMAKE_BUILD_TYPE Debug)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED true)
+set(CMAKE_CXX_EXTENSIONS OFF)
+add_compile_options(-Wall -Werror -Wextra -Wconversion)
+add_compile_options(-Wno-unused-parameter)
+
+add_executable(benchmark benchmark.cpp)
+target_link_libraries(benchmark pthread)
+
+# add_executable(benchmark.tsan benchmark.cpp)
+# target_compile_options(benchmark.tsan -fsanitize=thread)
+# target_link_libraries(benchmark.tsan pthread)
+
+include(GoogleTest)
+enable_testing()
+
+add_executable(tests sanitizers.cpp Fifo1_ut.cpp)
+target_compile_options(tests PRIVATE -fsanitize=undefined -fsanitize=address)
+target_link_libraries(tests PRIVATE asan ubsan gtest gtest_main)
+target_link_options(tests PRIVATE -fsanitize=undefined -fsanitize=address)
+gtest_add_tests(TARGET tests)

Fifo1.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <cstdlib>
+#include <memory>
+
+
+/// Non-threadsafe circular FIFO
+template<typename T>
+class Fifo1
+{
+public:
+    using ValueType = T;
+
+    explicit Fifo1(std::size_t size)
+        : size_{size}
+        , ring_{
+              static_cast<ValueType*>(std::aligned_alloc(alignof(T), size * sizeof(T))),
+              &std::free}
+    {}
+
+
+    std::size_t size() const { return size_; }
+    bool empty() const { return popCursor_ == pushCursor_; }
+    bool full() const { return (pushCursor_ - popCursor_) == size_; }
+
+    bool push(T const& value) {
+        if (full()) {
+            return false;
+        }
+        new (ring_.get() + pushCursor_ % size_) T(value);
+        ++pushCursor_;
+
+        return true;
+    }
+
+    /// Pop one object from the fifo.
+    /// @return `true` if the pop operation is successful; `false` if fifo was empty.
+    bool pop(T& value) {
+        if (empty()) {
+            return false;
+        }
+        value = ring_.get()[popCursor_ % size_];
+        ring_.get()[popCursor_ % size_].~T();
+        ++popCursor_;
+
+        return true;
+    }
+
+private:
+    std::size_t size_;
+
+    using RingType = std::unique_ptr<ValueType, decltype(&std::free)>;
+    RingType ring_;
+
+    std::size_t pushCursor_{};
+    std::size_t popCursor_{};
+};

Fifo1_ut.cpp

@@ -0,0 +1,59 @@
+#include "Fifo1.hpp"
+
+#include <gtest/gtest.h>
+
+#include <type_traits>
+
+
+using TestFifo = Fifo1<int>;
+
+TEST(Fifo1, initialConditions) {
+    auto fifo = TestFifo(1234);
+
+    EXPECT_EQ(1234u, fifo.size());
+    EXPECT_TRUE(fifo.empty());
+    EXPECT_FALSE(fifo.full());
+}
+
+TEST(Fifo1, push) {
+    auto fifo = TestFifo(4);
+    ASSERT_EQ(4u, fifo.size());
+
+    EXPECT_TRUE(fifo.push(42));
+    EXPECT_FALSE(fifo.empty());
+    EXPECT_FALSE(fifo.full());
+
+    EXPECT_TRUE(fifo.push(42));
+    EXPECT_FALSE(fifo.empty());
+    EXPECT_FALSE(fifo.full());
+
+    EXPECT_TRUE(fifo.push(42));
+    EXPECT_FALSE(fifo.empty());
+    EXPECT_FALSE(fifo.full());
+
+    EXPECT_TRUE(fifo.push(42));
+    EXPECT_FALSE(fifo.empty());
+    EXPECT_TRUE(fifo.full());
+
+    EXPECT_FALSE(fifo.push(42));
+    EXPECT_FALSE(fifo.empty());
+    EXPECT_TRUE(fifo.full());
+}
+
+TEST(Fifo1, pop) {
+    auto fifo = TestFifo(4);
+
+    auto value = TestFifo::ValueType{};
+    EXPECT_FALSE(fifo.pop(value));
+
+    for (auto i = 0u; i < fifo.size(); ++i) {
+        fifo.push(42 + i);
+    }
+
+    for (auto i = 0u; i < fifo.size(); ++i) {
+        auto value = TestFifo::ValueType{};
+        EXPECT_TRUE(fifo.pop(value));
+        EXPECT_EQ(42+i, value);
+    }
+    EXPECT_FALSE(fifo.pop(value));
+}

benchmark.cpp

@@ -0,0 +1,82 @@
+#include "Fifo1.hpp"
+
+#include <array>
+#include <chrono>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <iostream>
+#include <stdexcept>
+#include <thread>
+
+#include <pthread.h>
+
+
+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);
+    }
+}
+
+template<typename T>
+void bench(char const* name, int cpu1, int cpu2) {
+    using ValueType = typename T::ValueType;
+    using AryValueType = typename ValueType::value_type;
+
+    constexpr auto queueSize = 131072;
+    constexpr auto iters = 1'000'000'000l;
+
+    T q(queueSize);
+    auto t = std::thread([&] {
+        pinThread(cpu1);
+        for (auto i = AryValueType{}; i < iters; ++i) {
+            ValueType val;
+            while (not q.pop(val)) {
+                ;
+            }
+            if (val[0] != i) {
+                std::cerr << "#### throw " << val[0] << " != " << i <<"\n";
+                throw std::runtime_error("foo");
+            }
+        }
+    });
+
+    pinThread(cpu2);
+    auto start = std::chrono::steady_clock::now();
+    for (auto i = AryValueType{}; i < iters; ++i) {
+        while (not q.push(ValueType{i})) {
+          ;
+        }
+    }
+    while (not q.empty()) {
+      ;
+    }
+    auto stop = std::chrono::steady_clock::now();
+    t.join();
+    std::cout << name << " " << iters * 1'000'000'000 /
+        std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count()
+        << " ops/s\n";
+}
+
+int main(int argc, char* argv[]) {
+    int cpu1 = -1;
+    int cpu2 = -1;
+    if (argc == 3) {
+       cpu1 = std::atoi(argv[1]);
+       cpu2 = std::atoi(argv[2]);
+    }
+
+    using TestType = std::array<long, 25>;
+    bench<Fifo1<TestType>>("Fifo1", cpu1, cpu2);
+}
+
+
+
+

sanitizers.cpp

@@ -0,0 +1,13 @@
+#include <gtest/gtest.h>
+
+extern "C" {
+    void __ubsan_on_report() {
+          FAIL() << "Encountered an undefined behavior sanitizer error";
+    }
+    void __asan_on_error() {
+          FAIL() << "Encountered an address sanitizer error";
+    }
+    void __tsan_on_report() {
+          FAIL() << "Encountered a thread sanitizer error";
+    }
+}  // extern "C"