iox-eclipse-iceoryx#615 remove blocking options from variant queue

Signed-off-by: Mathias Kraus <mathias.kraus@apex.ai>
boschglobal · May 12, 2021 · e58f79f · e58f79f
1 parent c42c47a
commit e58f79f
Show file tree

Hide file tree

Showing 3 changed files with 2 additions and 148 deletions.
diff --git a/iceoryx_utils/include/iceoryx_utils/cxx/variant_queue.hpp b/iceoryx_utils/include/iceoryx_utils/cxx/variant_queue.hpp
@@ -43,8 +43,6 @@ enum class VariantQueueTypes : uint64_t
     SoFi_SingleProducerSingleConsumer = 1,
     FiFo_MultiProducerSingleConsumer = 2,
     SoFi_MultiProducerSingleConsumer = 3,
-    BlockingFiFo_SingleProducerSingleConsumer = 4,
-    BlockingFiFo_MultiProducerSingleConsumer = 5,
 };
 
 // remark: we need to consider to support the non-resizable queue as well

diff --git a/iceoryx_utils/include/iceoryx_utils/internal/cxx/variant_queue.inl b/iceoryx_utils/include/iceoryx_utils/internal/cxx/variant_queue.inl
@@ -46,16 +46,6 @@ inline VariantQueue<ValueType, Capacity>::VariantQueue(const VariantQueueTypes t
         m_fifo.template emplace<concurrent::ResizeableLockFreeQueue<ValueType, Capacity>>();
         break;
     }
-    case VariantQueueTypes::BlockingFiFo_SingleProducerSingleConsumer:
-    {
-        m_fifo.template emplace<concurrent::TriggerQueue<ValueType, Capacity, concurrent::FiFo>>();
-        break;
-    }
-    case VariantQueueTypes::BlockingFiFo_MultiProducerSingleConsumer:
-    {
-        m_fifo.template emplace<concurrent::TriggerQueue<ValueType, Capacity, concurrent::ResizeableLockFreeQueue>>();
-        break;
-    }
     }
 }
 
@@ -95,26 +85,6 @@ optional<ValueType> VariantQueue<ValueType, Capacity>::push(const ValueType& val
             .template get_at_index<static_cast<uint64_t>(VariantQueueTypes::FiFo_MultiProducerSingleConsumer)>()
             ->push(value);
     }
-    case VariantQueueTypes::BlockingFiFo_SingleProducerSingleConsumer:
-    {
-        auto pushFailedSinceFiFoShouldBeDestroyed =
-            m_fifo
-                .template get_at_index<static_cast<uint64_t>(
-                    VariantQueueTypes::BlockingFiFo_SingleProducerSingleConsumer)>()
-                ->push(value);
-
-        return (pushFailedSinceFiFoShouldBeDestroyed) ? cxx::nullopt : cxx::make_optional<ValueType>(value);
-    }
-    case VariantQueueTypes::BlockingFiFo_MultiProducerSingleConsumer:
-    {
-        auto pushFailedSinceFiFoShouldBeDestroyed =
-            m_fifo
-                .template get_at_index<static_cast<uint64_t>(
-                    VariantQueueTypes::BlockingFiFo_MultiProducerSingleConsumer)>()
-                ->push(value);
-
-        return (pushFailedSinceFiFoShouldBeDestroyed) ? cxx::nullopt : cxx::make_optional<ValueType>(value);
-    }
     }
 
     return cxx::nullopt;
@@ -147,19 +117,6 @@ inline optional<ValueType> VariantQueue<ValueType, Capacity>::pop() noexcept
             .template get_at_index<static_cast<uint64_t>(VariantQueueTypes::FiFo_MultiProducerSingleConsumer)>()
             ->pop();
     }
-    case VariantQueueTypes::BlockingFiFo_SingleProducerSingleConsumer:
-    {
-        return m_fifo
-            .template get_at_index<static_cast<uint64_t>(
-                VariantQueueTypes::BlockingFiFo_SingleProducerSingleConsumer)>()
-            ->pop();
-    }
-    case VariantQueueTypes::BlockingFiFo_MultiProducerSingleConsumer:
-    {
-        return m_fifo
-            .template get_at_index<static_cast<uint64_t>(VariantQueueTypes::BlockingFiFo_MultiProducerSingleConsumer)>()
-            ->pop();
-    }
     }
 
     return cxx::nullopt;
@@ -189,19 +146,6 @@ inline bool VariantQueue<ValueType, Capacity>::empty() const noexcept
             .template get_at_index<static_cast<uint64_t>(VariantQueueTypes::FiFo_MultiProducerSingleConsumer)>()
             ->empty();
     }
-    case VariantQueueTypes::BlockingFiFo_SingleProducerSingleConsumer:
-    {
-        return m_fifo
-            .template get_at_index<static_cast<uint64_t>(
-                VariantQueueTypes::BlockingFiFo_SingleProducerSingleConsumer)>()
-            ->empty();
-    }
-    case VariantQueueTypes::BlockingFiFo_MultiProducerSingleConsumer:
-    {
-        return m_fifo
-            .template get_at_index<static_cast<uint64_t>(VariantQueueTypes::BlockingFiFo_MultiProducerSingleConsumer)>()
-            ->empty();
-    }
     }
 
     return true;
@@ -234,21 +178,6 @@ inline uint64_t VariantQueue<ValueType, Capacity>::size() noexcept
             ->size();
         break;
     }
-    case VariantQueueTypes::BlockingFiFo_SingleProducerSingleConsumer:
-    {
-        return m_fifo
-            .template get_at_index<static_cast<uint64_t>(
-                VariantQueueTypes::BlockingFiFo_SingleProducerSingleConsumer)>()
-            ->size();
-        break;
-    }
-    case VariantQueueTypes::BlockingFiFo_MultiProducerSingleConsumer:
-    {
-        return m_fifo
-            .template get_at_index<static_cast<uint64_t>(VariantQueueTypes::BlockingFiFo_MultiProducerSingleConsumer)>()
-            ->size();
-        break;
-    }
     }
 
     return 0U;
@@ -280,19 +209,6 @@ inline bool VariantQueue<ValueType, Capacity>::setCapacity(const uint64_t newCap
             .template get_at_index<static_cast<uint64_t>(VariantQueueTypes::FiFo_MultiProducerSingleConsumer)>()
             ->setCapacity(newCapacity);
     }
-    case VariantQueueTypes::BlockingFiFo_SingleProducerSingleConsumer:
-    {
-        /// @todo must be implemented for FiFo
-        cxx::Expects(false);
-        return false;
-    }
-    case VariantQueueTypes::BlockingFiFo_MultiProducerSingleConsumer:
-    {
-        // we may discard elements in the queue if the size is reduced and the fifo contains too many elements
-        return m_fifo
-            .template get_at_index<static_cast<uint64_t>(VariantQueueTypes::BlockingFiFo_MultiProducerSingleConsumer)>()
-            ->setCapacity(newCapacity);
-    }
     }
     return false;
 }
@@ -324,21 +240,6 @@ inline uint64_t VariantQueue<ValueType, Capacity>::capacity() const noexcept
             ->capacity();
         break;
     }
-    case VariantQueueTypes::BlockingFiFo_SingleProducerSingleConsumer:
-    {
-        return m_fifo
-            .template get_at_index<static_cast<uint64_t>(
-                VariantQueueTypes::BlockingFiFo_SingleProducerSingleConsumer)>()
-            ->capacity();
-        break;
-    }
-    case VariantQueueTypes::BlockingFiFo_MultiProducerSingleConsumer:
-    {
-        return m_fifo
-            .template get_at_index<static_cast<uint64_t>(VariantQueueTypes::BlockingFiFo_MultiProducerSingleConsumer)>()
-            ->capacity();
-        break;
-    }
     }
 
     return 0U;

diff --git a/iceoryx_utils/test/moduletests/test_cxx_variant_queue.cpp b/iceoryx_utils/test/moduletests/test_cxx_variant_queue.cpp
@@ -17,7 +17,6 @@
 
 #include "iceoryx_utils/cxx/variant_queue.hpp"
 #include "test.hpp"
-#include "testutils/watch_dog.hpp"
 
 namespace
 {
@@ -31,7 +30,6 @@ class VariantQueue_test : public Test
   public:
     void SetUp()
     {
-        m_watchdog.watchAndActOnFailure([] { std::terminate(); });
     }
     void TearDown()
     {
@@ -44,8 +42,7 @@ class VariantQueue_test : public Test
     }
 
     // if a new fifo type is added this variable has to be adjusted
-    uint64_t numberOfQueueTypes = 6U;
-    Watchdog m_watchdog{units::Duration::fromSeconds(2U)};
+    uint64_t numberOfQueueTypes = 4U;
 };
 
 TEST_F(VariantQueue_test, isEmptyWhenCreated)
@@ -115,14 +112,7 @@ TEST_F(VariantQueue_test, pushTwoElementsAfterSecondPopIsInvalid)
 TEST_F(VariantQueue_test, handlesOverflow)
 {
     PerformTestForQueueTypes([](uint64_t typeID) {
-        VariantQueueTypes type = static_cast<VariantQueueTypes>(typeID);
-        if (type == VariantQueueTypes::BlockingFiFo_MultiProducerSingleConsumer
-            || type == VariantQueueTypes::BlockingFiFo_SingleProducerSingleConsumer)
-        {
-            return;
-        }
-
-        VariantQueue<int, 2> sut(type);
+        VariantQueue<int, 2> sut(static_cast<VariantQueueTypes>(typeID));
         // current SOFI can hold capacity +1 values, so push some more to ensure overflow
         sut.push(14123);
         sut.push(24123);
@@ -133,41 +123,6 @@ TEST_F(VariantQueue_test, handlesOverflow)
     });
 }
 
-TEST_F(VariantQueue_test, blocksOnOverflow)
-{
-    PerformTestForQueueTypes([](uint64_t typeID) {
-        VariantQueueTypes type = static_cast<VariantQueueTypes>(typeID);
-        if (!(type == VariantQueueTypes::BlockingFiFo_MultiProducerSingleConsumer
-              || type == VariantQueueTypes::BlockingFiFo_SingleProducerSingleConsumer))
-        {
-            return;
-        }
-
-        VariantQueue<int, 2> sut(type);
-
-        for (uint64_t i = 0U; i < sut.capacity(); ++i)
-        {
-            sut.push(24123 + i);
-        }
-
-        std::atomic<uint64_t> counter{0U};
-        std::thread t([&] {
-            sut.push(1231);
-            ++counter;
-        });
-
-        constexpr int64_t TIMEOUT_IN_MS = 100;
-        std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT_IN_MS));
-        EXPECT_THAT(counter.load(), Eq(0U));
-        auto result = sut.pop();
-        ASSERT_THAT(result.has_value(), Eq(true));
-        EXPECT_THAT(*result, Eq(24123));
-        std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT_IN_MS));
-        EXPECT_THAT(counter.load(), Eq(1U));
-        t.join();
-    });
-}
-
 TEST_F(VariantQueue_test, noPopWhenEmpty)
 {
     PerformTestForQueueTypes([](uint64_t typeID) {