WIP

Author: Charlie Frasch

CMakeLists.txt

@@ -17,52 +17,34 @@ if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE ${buildType})
 endif()
 
+set(BOOST_ROOT /mnt/c/Users/Charles/AppData/Local/lxss/rootfs/usr/)
+find_package(Boost REQUIRED)
 
 set(CMAKE_CXX_STANDARD 23)
 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(fifo1 fifo1.cpp)
-target_link_libraries(fifo1 pthread)
-
-add_executable(fifo1.tsan fifo1.cpp)
-target_compile_options(fifo1.tsan PRIVATE -fsanitize=thread)
-target_link_libraries(fifo1.tsan PRIVATE pthread tsan)
-
-
-add_executable(fifo2 fifo2.cpp)
-target_link_libraries(fifo2 pthread)
-
-add_executable(fifo2.tsan fifo2.cpp)
-target_compile_options(fifo2.tsan PRIVATE -fsanitize=thread)
-target_link_libraries(fifo2.tsan PRIVATE pthread tsan)
-
-
-add_executable(fifo3 fifo3.cpp)
-target_link_libraries(fifo3 pthread)
-
-add_executable(fifo3.tsan fifo3.cpp)
-target_compile_options(fifo3.tsan PRIVATE -fsanitize=thread)
-target_link_libraries(fifo3.tsan PRIVATE pthread tsan)
-
-
-add_executable(fifo4 fifo4.cpp)
-target_link_libraries(fifo4 pthread)
-
-add_executable(fifo4.tsan fifo4.cpp)
-target_compile_options(fifo4.tsan PRIVATE -fsanitize=thread)
-target_link_libraries(fifo4.tsan PRIVATE pthread tsan)
-
-
-# add_executable(fifo7 fifo7.cpp)
-# target_link_libraries(fifo7 pthread)
-# 
-# add_executable(fifo7.tsan fifo7.cpp)
-# target_compile_options(fifo7.tsan PRIVATE -fsanitize=thread)
-# target_link_libraries(fifo7.tsan PRIVATE pthread tsan)
+function(add_fifo fifo)
+    add_executable(${fifo} ${CMAKE_SOURCE_DIR}/${fifo}.cpp)
+    target_link_libraries(${fifo} pthread)
+
+    add_executable(${fifo}.tsan ${CMAKE_SOURCE_DIR}/${fifo}.cpp)
+    target_compile_options(${fifo}.tsan PRIVATE -fsanitize=thread)
+    target_link_libraries(${fifo}.tsan PRIVATE pthread tsan)
+endfunction()
+
+
+add_fifo(fifo1)
+add_fifo(fifo2)
+add_fifo(fifo3)
+add_fifo(fifo4)
+add_fifo(fifo5)
+add_fifo(boost_lockfree)
+add_fifo(rigtorp)
+target_compile_options(rigtorp PRIVATE -Wno-interference-size)
+target_compile_options(rigtorp.tsan PRIVATE -Wno-interference-size)
 
 
 include(GoogleTest)

Fifo1.hpp

@@ -4,30 +4,42 @@
 #include <memory>
 
 
-/// Non-threadsafe circular FIFO
-template<typename T>
-class Fifo1
+/// Non-threadsafe circular FIFO; has data races
+template<typename T, typename Alloc = std::allocator<T>>
+class Fifo1 : private Alloc
 {
 public:
-    using ValueType = T;
+    using value_type = T;
+    using allocator_traits = std::allocator_traits<Alloc>;
+    using size_type = typename allocator_traits::size_type;
 
-    explicit Fifo1(std::size_t size)
-        : size_{size}
-        , ring_{static_cast<ValueType*>(std::aligned_alloc(alignof(T), size * sizeof(T))), &std::free}
+    explicit Fifo1(size_type size, Alloc const& alloc = Alloc{})
+        : Alloc{alloc}
+        , size_{size}
+        , ring_{allocator_traits::allocate(*this, size)}
     {}
 
+    // For consistency with other fifos
+    Fifo1(Fifo1 const&) = delete;
+    Fifo1& operator=(Fifo1 const&) = delete;
+    Fifo1(Fifo1&&) = delete;
+    Fifo1& operator=(Fifo1&&) = delete;
+
     ~Fifo1() {
         while(not empty()) {
             ring_[popCursor_ % size_].~T();
             ++popCursor_;
         }
+        allocator_traits::deallocate(*this, ring_, size_);
     }
 
-    std::size_t size() const { return size_; }
-    bool empty() const { return popCursor_ == pushCursor_; }
-    bool full() const { return (pushCursor_ - popCursor_) == size_; }
+    auto size() const { return size_; }
+    auto empty() const { return popCursor_ == pushCursor_; }
+    auto full() const { return (pushCursor_ - popCursor_) == size_; }
 
-    bool push(T const& value) {
+    /// Push one object onto the fifo.
+    /// @return `true` if the operation is successful; `false` if fifo is full.
+    auto push(T const& value) {
         if (full()) {
             return false;
         }
@@ -37,8 +49,8 @@ class Fifo1
     }
 
     /// Pop one object from the fifo.
-    /// @return `true` if the pop operation is successful; `false` if fifo was empty.
-    bool pop(T& value) {
+    /// @return `true` if the pop operation is successful; `false` if fifo is empty.
+    auto pop(T& value) {
         if (empty()) {
             return false;
         }
@@ -49,11 +61,8 @@ class Fifo1
     }
 
 private:
-    std::size_t size_;
-
-    using RingType = std::unique_ptr<ValueType[], decltype(&std::free)>;
-    RingType ring_;
-
-    std::size_t pushCursor_;
-    std::size_t popCursor_;
+    size_type size_;
+    T* ring_;
+    size_type pushCursor_;
+    size_type popCursor_;
 };

Fifo2.hpp

@@ -1,28 +1,39 @@
 #pragma once
 
 #include <atomic>
-#include <cstdlib>
 #include <memory>
 
 
 /// Threadsafe but flawed circular FIFO
-template<typename T>
-class Fifo2
+template<typename T, typename Alloc = std::allocator<T>>
+class Fifo2 : private Alloc
 {
 public:
-    using ValueType = T;
+    using value_type = T;
+    using allocator_traits = std::allocator_traits<Alloc>;
+    using size_type = typename allocator_traits::size_type;
 
-    explicit Fifo2(std::size_t size)
-        : size_{size}
-        , ring_{static_cast<ValueType*>(std::aligned_alloc(alignof(T), size * sizeof(T))),
-              &std::free}
+    explicit Fifo2(size_type size, Alloc const& alloc = Alloc{})
+        : Alloc{alloc}
+        , size_{size}
+        , ring_{allocator_traits::allocate(*this, size)}
     {}
 
-    std::size_t size() const { return size_; }
-    bool empty() const { return popCursor_ == pushCursor_; }
-    bool full() const { return (pushCursor_ - popCursor_) == size_; }
+    ~Fifo2() {
+        while(not empty()) {
+            ring_[popCursor_ % size_].~T();
+            ++popCursor_;
+        }
+        allocator_traits::deallocate(*this, ring_, size_);
+    }
+
+    auto size() const { return size_; }
+    auto empty() const { return popCursor_ == pushCursor_; }
+    auto full() const { return (pushCursor_ - popCursor_) == size_; }
 
-    bool push(T const& value) {
+    /// Push one object onto the fifo.
+    /// @return `true` if the operation is successful; `false` if fifo is full.
+    auto push(T const& value) {
         if (full()) {
             return false;
         }
@@ -32,8 +43,8 @@ class Fifo2
     }
 
     /// Pop one object from the fifo.
-    /// @return `true` if the pop operation is successful; `false` if fifo was empty.
-    bool pop(T& value) {
+    /// @return `true` if the pop operation is successful; `false` if fifo is empty.
+    auto pop(T& value) {
         if (empty()) {
             return false;
         }
@@ -44,14 +55,15 @@ class Fifo2
     }
 
 private:
-    std::size_t size_;
+    size_type size_;
+    T* ring_;
 
-    using RingType = std::unique_ptr<ValueType[], decltype(&std::free)>;
-    RingType ring_;
+    using CursorType = std::atomic<size_type>;
+    static_assert(CursorType::is_always_lock_free);
 
     /// Loaded and stored by the push thread; loaded by the pop thread
-    std::atomic<std::size_t> pushCursor_;
+    CursorType pushCursor_;
 
     /// Loaded and stored by the pop thread; loaded by the push thread
-    std::atomic<std::size_t> popCursor_;
+    CursorType popCursor_;
 };

Fifo3.hpp

@@ -1,29 +1,40 @@
 #pragma once
 
 #include <atomic>
-#include <cstdlib>
 #include <memory>
 #include <new>
 
 
 /// Threadsafe, efficient circular FIFO
-template<typename T>
-class Fifo3
+template<typename T, typename Alloc = std::allocator<T>>
+class Fifo3 : private Alloc
 {
 public:
-    using ValueType = T;
+    using value_type = T;
+    using allocator_traits = std::allocator_traits<Alloc>;
+    using size_type = typename allocator_traits::size_type;
 
-    explicit Fifo3(std::size_t size)
-        : size_{size}
-        , ring_{static_cast<ValueType*>(std::aligned_alloc(alignof(T), size * sizeof(T))),
-              &std::free}
+    explicit Fifo3(size_type size, Alloc const& alloc = Alloc{})
+        : Alloc{alloc}
+        , size_{size}
+        , ring_{allocator_traits::allocate(*this, size)}
     {}
 
-    std::size_t size() const { return size_; }
-    bool empty() const { return popCursor_ == pushCursor_; }
-    bool full() const { return (pushCursor_ - popCursor_) == size_; }
+    ~Fifo3() {
+        while(not empty()) {
+            ring_[popCursor_ % size_].~T();
+            ++popCursor_;
+        }
+        allocator_traits::deallocate(*this, ring_, size_);
+    }
+
+    auto size() const { return size_; }
+    auto empty() const { return popCursor_ == pushCursor_; }
+    auto full() const { return (pushCursor_ - popCursor_) == size_; }
 
-    bool push(T const& value) {
+    /// Push one object onto the fifo.
+    /// @return `true` if the operation is successful; `false` if fifo is full.
+    auto push(T const& value) {
         auto pushCursor = pushCursor_.load(std::memory_order_relaxed);
         auto popCursor = popCursor_.load(std::memory_order_acquire);
         if (full(pushCursor, popCursor)) {
@@ -35,8 +46,8 @@ class Fifo3
     }
 
     /// Pop one object from the fifo.
-    /// @return `true` if the pop operation is successful; `false` if fifo was empty.
-    bool pop(T& value) {
+    /// @return `true` if the pop operation is successful; `false` if fifo is empty.
+    auto pop(T& value) {
         auto pushCursor = pushCursor_.load(std::memory_order_acquire);
         auto popCursor = popCursor_.load(std::memory_order_relaxed);
         if (empty(pushCursor, popCursor)) {
@@ -49,25 +60,32 @@ class Fifo3
     }
 
 private:
-    bool full(std::size_t pushCursor, std::size_t popCursor) const {
+    auto full(size_type pushCursor, size_type popCursor) const {
         return (pushCursor - popCursor) == size_;
     }
-    static bool empty(std::size_t pushCursor, std::size_t popCursor) {
+    static auto empty(size_type pushCursor, size_type popCursor) {
         return pushCursor == popCursor;
     }
 
 private:
-    std::size_t size_;
+    size_type size_;
+    T* ring_;
 
-    using RingType = std::unique_ptr<ValueType[], decltype(&std::free)>;
-    RingType ring_;
+    using CursorType = std::atomic<size_type>;
+    static_assert(CursorType::is_always_lock_free);
 
     // https://stackoverflow.com/questions/39680206/understanding-stdhardware-destructive-interference-size-and-stdhardware-cons
-    static constexpr auto hardware_destructive_interference_size = std::size_t{128};
+    // And this:
+    // error: use of ‘std::hardware_destructive_interference_size’ [-Werror=interference-size]
+    // note: its value can vary between compiler versions or with different ‘-mtune’ or ‘-mcpu’ flags
+    // note: if this use is part of a public ABI, change it to instead use a constant variable you define
+    // note: the default value for the current CPU tuning is 64 bytes
+    // note: you can stabilize this value with ‘--param hardware_destructive_interference_size=64’, or disable this warning with ‘-Wno-interference-size’
+    static constexpr auto hardware_destructive_interference_size = size_type{128};
 
     /// Loaded and stored by the push thread; loaded by the pop thread
-    alignas(hardware_destructive_interference_size) std::atomic<std::size_t> pushCursor_;
+    alignas(hardware_destructive_interference_size) CursorType pushCursor_;
 
     /// Loaded and stored by the pop thread; loaded by the push thread
-    alignas(hardware_destructive_interference_size) std::atomic<std::size_t> popCursor_;
+    alignas(hardware_destructive_interference_size) CursorType popCursor_;
 };