iox-eclipse-iceoryx#119 fixing memory sync issue in fifo

Signed-off-by: Christian Eltzschig <christian.eltzschig2@de.bosch.com>

iceoryx_utils/include/iceoryx_utils/internal/concurrent/fifo.inl

@@ -27,11 +27,14 @@ inline bool FiFo<ValueType, Capacity>::push(const ValueType& f_param_r)
     }
     else
     {
-        m_data[m_write_pos.load(std::memory_order_relaxed) % Capacity] = f_param_r;
+        auto currentWritePos = m_write_pos.load(std::memory_order_relaxed);
+        m_data[currentWritePos % Capacity] = f_param_r;
 
         // m_write_pos must be increased after writing the new value otherwise
-        // it is possible that the value is read by pop while it is written
-        m_write_pos.fetch_add(1u, std::memory_order_acq_rel);
+        // it is possible that the value is read by pop while it is written.
+        // this fifo is a single producer, single consumer fifo therefore
+        // store is allowed.
+        m_write_pos.store(currentWritePos + 1, std::memory_order_release);
         return true;
     }
 }
@@ -51,17 +54,23 @@ inline bool FiFo<ValueType, Capacity>::empty() const
 template <class ValueType, uint32_t Capacity>
 inline cxx::optional<ValueType> FiFo<ValueType, Capacity>::pop()
 {
-    if (empty())
+    bool isEmpty = (m_read_pos.load(std::memory_order_relaxed) ==
+                    // we are not allowed to use the empty method since we have to sync with
+                    // the producer pop - this is done here
+                    m_write_pos.load(std::memory_order_acquire));
+    if (isEmpty)
     {
         return cxx::nullopt_t();
     }
     else
     {
-        ValueType out = m_data[m_read_pos.load(std::memory_order_acquire) % Capacity];
+        auto currentReadPos = m_read_pos.load(std::memory_order_relaxed);
+        ValueType out = m_data[currentReadPos % Capacity];
 
         // m_read_pos must be increased after reading the pop'ed value otherwise
-        // it is possible that the pop'ed value is overwritten by push while it is read
-        m_read_pos.fetch_add(1, std::memory_order_relaxed);
+        // it is possible that the pop'ed value is overwritten by push while it is read.
+        // Implementing a single consumer fifo here allows us to use store.
+        m_read_pos.store(currentReadPos + 1, std::memory_order_relaxed);
         return out;
     }
 }