Distinguish between size and capacity

Author: Charlie Frasch

Fifo1.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cassert>
 #include <cstdlib>
 #include <memory>
 
@@ -13,10 +14,10 @@ class Fifo1 : private Alloc
     using allocator_traits = std::allocator_traits<Alloc>;
     using size_type = typename allocator_traits::size_type;
 
-    explicit Fifo1(size_type size, Alloc const& alloc = Alloc{})
+    explicit Fifo1(size_type capacity, Alloc const& alloc = Alloc{})
         : Alloc{alloc}
-        , size_{size}
-        , ring_{allocator_traits::allocate(*this, size)}
+        , capacity_{capacity}
+        , ring_{allocator_traits::allocate(*this, capacity)}
     {}
 
     // For consistency with other fifos
@@ -27,23 +28,36 @@ class Fifo1 : private Alloc
 
     ~Fifo1() {
         while(not empty()) {
-            ring_[popCursor_ % size_].~T();
+            ring_[popCursor_ % capacity_].~T();
             ++popCursor_;
         }
-        allocator_traits::deallocate(*this, ring_, size_);
+        allocator_traits::deallocate(*this, ring_, capacity_);
     }
 
-    auto size() const { return size_; }
-    auto empty() const { return popCursor_ == pushCursor_; }
-    auto full() const { return (pushCursor_ - popCursor_) == size_; }
+
+    /// Returns the number of elements in the fifo
+    auto size() const noexcept {
+        assert(popCursor_ <= pushCursor_);
+        return pushCursor_ - popCursor_;
+    }
+
+    /// Returns whether the container has no elements
+    auto empty() const noexcept { return size() == 0; }
+
+    /// Returns whether the container has capacity_() elements
+    auto full() const noexcept { return size() == capacity(); }
+
+    /// Returns the number of elements that can be held in the fifo
+    auto capacity() const noexcept { return capacity_; }
+
 
     /// 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;
         }
-        new (&ring_[pushCursor_ % size_]) T(value);
+        new (&ring_[pushCursor_ % capacity_]) T(value);
         ++pushCursor_;
         return true;
     }
@@ -54,14 +68,14 @@ class Fifo1 : private Alloc
         if (empty()) {
             return false;
         }
-        value = ring_[popCursor_ % size_];
-        ring_[popCursor_ % size_].~T();
+        value = ring_[popCursor_ % capacity_];
+        ring_[popCursor_ % capacity_].~T();
         ++popCursor_;
         return true;
     }
 
 private:
-    size_type size_;
+    size_type capacity_;
     T* ring_;
     size_type pushCursor_;
     size_type popCursor_;

Fifo2.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <atomic>
+#include <cassert>
 #include <memory>
 
 
@@ -13,31 +14,44 @@ class Fifo2 : private Alloc
     using allocator_traits = std::allocator_traits<Alloc>;
     using size_type = typename allocator_traits::size_type;
 
-    explicit Fifo2(size_type size, Alloc const& alloc = Alloc{})
+    explicit Fifo2(size_type capacity, Alloc const& alloc = Alloc{})
         : Alloc{alloc}
-        , size_{size}
-        , ring_{allocator_traits::allocate(*this, size)}
+        , capacity_{capacity}
+        , ring_{allocator_traits::allocate(*this, capacity)}
     {}
 
     ~Fifo2() {
         while(not empty()) {
-            ring_[popCursor_ % size_].~T();
+            ring_[popCursor_ % capacity_].~T();
             ++popCursor_;
         }
-        allocator_traits::deallocate(*this, ring_, size_);
+        allocator_traits::deallocate(*this, ring_, capacity_);
     }
 
-    auto size() const { return size_; }
-    auto empty() const { return popCursor_ == pushCursor_; }
-    auto full() const { return (pushCursor_ - popCursor_) == size_; }
+    /// Returns the number of elements in the fifo
+    auto size() const noexcept {
+        assert(popCursor_ <= pushCursor_);
+        return pushCursor_ - popCursor_;
+    }
+
+    /// Returns whether the container has no elements
+    auto empty() const noexcept { return size() == 0; }
+
+    /// Returns whether the container has capacity_() elements
+    auto full() const noexcept { return size() == capacity(); }
+
+    /// Returns the number of elements that can be held in the fifo
+    auto capacity() const noexcept { return capacity_; }
+
+
 
     /// 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;
         }
-        new (&ring_[pushCursor_ % size_]) T(value);
+        new (&ring_[pushCursor_ % capacity_]) T(value);
         ++pushCursor_;
         return true;
     }
@@ -48,14 +62,14 @@ class Fifo2 : private Alloc
         if (empty()) {
             return false;
         }
-        value = ring_[popCursor_ % size_];
-        ring_[popCursor_ % size_].~T();
+        value = ring_[popCursor_ % capacity_];
+        ring_[popCursor_ % capacity_].~T();
         ++popCursor_;
         return true;
     }
 
 private:
-    size_type size_;
+    size_type capacity_;
     T* ring_;
 
     using CursorType = std::atomic<size_type>;

Fifo3.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <atomic>
+#include <cassert>
 #include <memory>
 #include <new>
 
@@ -14,23 +15,39 @@ class Fifo3 : private Alloc
     using allocator_traits = std::allocator_traits<Alloc>;
     using size_type = typename allocator_traits::size_type;
 
-    explicit Fifo3(size_type size, Alloc const& alloc = Alloc{})
+    explicit Fifo3(size_type capacity, Alloc const& alloc = Alloc{})
         : Alloc{alloc}
-        , size_{size}
-        , ring_{allocator_traits::allocate(*this, size)}
+        , capacity_{capacity}
+        , ring_{allocator_traits::allocate(*this, capacity)}
     {}
 
     ~Fifo3() {
         while(not empty()) {
-            ring_[popCursor_ % size_].~T();
+            ring_[popCursor_ % capacity_].~T();
             ++popCursor_;
         }
-        allocator_traits::deallocate(*this, ring_, size_);
+        allocator_traits::deallocate(*this, ring_, capacity_);
     }
 
-    auto size() const { return size_; }
-    auto empty() const { return popCursor_ == pushCursor_; }
-    auto full() const { return (pushCursor_ - popCursor_) == size_; }
+
+    /// Returns the number of elements in the fifo
+    auto size() const noexcept {
+        auto pushCursor = pushCursor_.load(std::memory_order_acquire);
+        auto popCursor = popCursor_.load(std::memory_order_relaxed);
+
+        assert(popCursor <= pushCursor);
+        return pushCursor - popCursor;
+    }
+
+    /// Returns whether the container has no elements
+    auto empty() const noexcept { return size() == 0; }
+
+    /// Returns whether the container has capacity_() elements
+    auto full() const noexcept { return size() == capacity(); }
+
+    /// Returns the number of elements that can be held in the fifo
+    auto capacity() const noexcept { return capacity_; }
+
 
     /// Push one object onto the fifo.
     /// @return `true` if the operation is successful; `false` if fifo is full.
@@ -40,7 +57,7 @@ class Fifo3 : private Alloc
         if (full(pushCursor, popCursor)) {
             return false;
         }
-        new (&ring_[pushCursor % size_]) T(value);
+        new (&ring_[pushCursor % capacity_]) T(value);
         pushCursor_.store(pushCursor + 1, std::memory_order_release);
         return true;
     }
@@ -53,39 +70,41 @@ class Fifo3 : private Alloc
         if (empty(pushCursor, popCursor)) {
             return false;
         }
-        value = ring_[popCursor % size_];
-        ring_[popCursor % size_].~T();
+        value = ring_[popCursor % capacity_];
+        ring_[popCursor % capacity_].~T();
         popCursor_.store(popCursor + 1, std::memory_order_release);
         return true;
     }
 
 private:
-    auto full(size_type pushCursor, size_type popCursor) const {
-        return (pushCursor - popCursor) == size_;
+    auto full(size_type pushCursor, size_type popCursor) const noexcept {
+        return (pushCursor - popCursor) == capacity_;
     }
-    static auto empty(size_type pushCursor, size_type popCursor) {
+    static auto empty(size_type pushCursor, size_type popCursor) noexcept {
         return pushCursor == popCursor;
     }
 
 private:
-    size_type size_;
+    size_type capacity_;
     T* 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
-    // And this:
+    // N.B. std::hardware_destructive_interference_size is not used directly
     // 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};
+    static constexpr auto hardware_destructive_interference_size = size_type{64};
 
     /// Loaded and stored by the push thread; loaded by the pop thread
     alignas(hardware_destructive_interference_size) CursorType pushCursor_;
 
     /// Loaded and stored by the pop thread; loaded by the push thread
     alignas(hardware_destructive_interference_size) CursorType popCursor_;
+
+    // Padding to avoid false sharing with adjacent objects
+    char padding_[hardware_destructive_interference_size - sizeof(size_type)];
 };

Fifo4.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <atomic>
+#include <cassert>
 #include <memory>
 #include <new>
 
@@ -14,23 +15,38 @@ class Fifo4 : private Alloc
     using allocator_traits = std::allocator_traits<Alloc>;
     using size_type = typename allocator_traits::size_type;
 
-    explicit Fifo4(size_type size, Alloc const& alloc = Alloc{})
+    explicit Fifo4(size_type capacity, Alloc const& alloc = Alloc{})
         : Alloc{alloc}
-        , size_{size}
-        , ring_{allocator_traits::allocate(*this, size_)}
+        , capacity_{capacity}
+        , ring_{allocator_traits::allocate(*this, capacity)}
     {}
 
     ~Fifo4() {
         while(not empty()) {
-            ring_[popCursor_ % size_].~T();
+            ring_[popCursor_ % capacity_].~T();
             ++popCursor_;
         }
-        allocator_traits::deallocate(*this, ring_, size_);
+        allocator_traits::deallocate(*this, ring_, capacity_);
     }
 
-    auto size() const { return size_; }
-    auto empty() const { return popCursor_ == pushCursor_; }
-    auto full() const { return (pushCursor_ - popCursor_) == size_; }
+    /// Returns the number of elements in the fifo
+    auto size() const noexcept {
+        auto pushCursor = pushCursor_.load(std::memory_order_acquire);
+        auto popCursor = popCursor_.load(std::memory_order_relaxed);
+
+        assert(popCursor <= pushCursor);
+        return pushCursor - popCursor;
+    }
+
+    /// Returns whether the container has no elements
+    auto empty() const noexcept { return size() == 0; }
+
+    /// Returns whether the container has capacity_() elements
+    auto full() const noexcept { return size() == capacity(); }
+
+    /// Returns the number of elements that can be held in the fifo
+    auto capacity() const noexcept { return capacity_; }
+
 
     /// Push one object onto the fifo.
     /// @return `true` if the operation is successful; `false` if fifo is full.
@@ -43,7 +59,7 @@ class Fifo4 : private Alloc
             return false;
         }
 
-        new (&ring_[pushCursor % size_]) T(value);
+        new (&ring_[pushCursor % capacity_]) T(value);
         pushCursor_.store(pushCursor + 1, std::memory_order_release);
         return true;
     }
@@ -59,29 +75,29 @@ class Fifo4 : private Alloc
             return false;
         }
 
-        value = ring_[popCursor % size_];
-        ring_[popCursor % size_].~T();
+        value = ring_[popCursor % capacity_];
+        ring_[popCursor % capacity_].~T();
         popCursor_.store(popCursor + 1, std::memory_order_release);
         return true;
     }
 
 private:
-    auto full(size_type pushCursor, size_type popCursor) const {
-        return (pushCursor - popCursor) == size_;
+    auto full(size_type pushCursor, size_type popCursor) const noexcept {
+        return (pushCursor - popCursor) == capacity_;
     }
-    static auto empty(size_type pushCursor, size_type popCursor) {
+    static auto empty(size_type pushCursor, size_type popCursor) noexcept {
         return pushCursor == popCursor;
     }
 
 private:
-    size_type size_;
+    size_type capacity_;
     T* 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 = size_type{128};
+    // See Fifo3 for reason std::hardware_destructive_interference_size is not used directly
+    static constexpr auto hardware_destructive_interference_size = size_type{64};
 
     /// Loaded and stored by the push thread; loaded by the pop thread
     alignas(hardware_destructive_interference_size) CursorType pushCursor_;
@@ -94,4 +110,7 @@ class Fifo4 : private Alloc
 
     /// Exclusive to the pop thread
     alignas(hardware_destructive_interference_size) size_type pushCursorCached_{};
+
+    // Padding to avoid false sharing with adjacent objects
+    char padding_[hardware_destructive_interference_size - sizeof(size_type)];
 };