iox-eclipse-iceoryx#2301 TODO

iceoryx_hoofs/posix/sync/include/iox/spin_lock_mutex.hpp

@@ -0,0 +1,120 @@
+// Copyright (c) 2024 by ekxide IO GmbH. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef IOX_HOOFS_POXIX_SYNC_SPIN_LOCK_MUTEX_HPP
+#define IOX_HOOFS_POXIX_SYNC_SPIN_LOCK_MUTEX_HPP
+
+#include "iox/atomic.hpp"
+#include "iox/detail/adaptive_wait.hpp"
+#include "iox/mutex.hpp"
+
+namespace iox
+{
+class SpinlockMutex
+{
+  public:
+    SpinlockMutex()
+        : m_flag(ATOMIC_FLAG_INIT)
+        , m_recursive{Recursive{0, 0}}
+    {
+    }
+
+    expected<void, MutexLockError> lock() noexcept
+    {
+        pid_t tid = gettid();
+
+        auto recursive = m_recursive.load();
+
+        if (recursive.tid == tid)
+        {
+            recursive.count += 1;
+            m_recursive.store(recursive);
+
+            return ok();
+        }
+
+        detail::adaptive_wait spinner;
+        spinner.wait_loop([this] { return this->m_flag.test_and_set(std::memory_order_acquire); });
+
+        m_recursive.store(Recursive{tid, 1});
+
+        return ok();
+    }
+
+    expected<void, MutexUnlockError> unlock() noexcept
+    {
+        pid_t tid = gettid();
+
+        auto recursive = m_recursive.load();
+
+        if (recursive.tid == tid)
+        {
+            recursive.count -= 1;
+
+            if (recursive.count == 0)
+            {
+                recursive.tid = 0;
+                m_recursive.store(recursive);
+                m_flag.clear(std::memory_order_release);
+            }
+            else
+            {
+                m_recursive.store(recursive);
+            }
+
+            return ok();
+        }
+
+
+        return err(MutexUnlockError::UNKNOWN_ERROR);
+    }
+
+    expected<MutexTryLock, MutexTryLockError> try_lock() noexcept
+    {
+        pid_t tid = gettid();
+
+        auto recursive = m_recursive.load();
+
+        if (recursive.tid == tid)
+        {
+            recursive.count += 1;
+            m_recursive.store(recursive);
+            return ok(MutexTryLock::LOCK_SUCCEEDED);
+        }
+
+        if (!m_flag.test_and_set(std::memory_order_acquire))
+        {
+            m_recursive.store(Recursive{tid, 1});
+
+            return ok(MutexTryLock::LOCK_SUCCEEDED);
+        }
+        return ok(MutexTryLock::FAILED_TO_ACQUIRE_LOCK);
+    }
+
+    struct Recursive
+    {
+        pid_t tid;
+        uint32_t count;
+    };
+
+  private:
+    concurrent::AtomicFlag m_flag;
+    concurrent::Atomic<Recursive> m_recursive;
+};
+
+} // namespace iox
+
+#endif // IOX_HOOFS_POXIX_SYNC_SPIN_LOCK_MUTEX_HPP

iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/condition_variable_data.hpp

@@ -18,14 +18,83 @@
 #define IOX_POSH_POPO_BUILDING_BLOCKS_CONDITION_VARIABLE_DATA_HPP
 
 #include "iceoryx_posh/iceoryx_posh_types.hpp"
+#include "iceoryx_posh/internal/popo/building_blocks/locking_policy.hpp"
 #include "iceoryx_posh/internal/posh_error_reporting.hpp"
 #include "iox/atomic.hpp"
+#include "iox/deadline_timer.hpp"
+#include "iox/detail/adaptive_wait.hpp"
 #include "iox/unnamed_semaphore.hpp"
 
 namespace iox
 {
 namespace popo
 {
+class SpinLockSemaphore : public detail::SemaphoreInterface<SpinLockSemaphore>
+{
+  public:
+    SpinLockSemaphore()
+        : m_count(0)
+    {
+    }
+
+    ~SpinLockSemaphore()
+    {
+        m_to_be_destroyed = true;
+    }
+
+    expected<void, SemaphoreError> post()
+    {
+        std::lock_guard<SpinlockMutex> lock(spinlock);
+        ++m_count;
+        return ok();
+    }
+
+    expected<void, SemaphoreError> wait()
+    {
+        detail::adaptive_wait spinner;
+        spinner.wait_loop([this] { return !this->tryWait(); });
+        return ok();
+    }
+
+    expected<bool, SemaphoreError> tryWait()
+    {
+        std::lock_guard<SpinlockMutex> lock(spinlock);
+        if (m_to_be_destroyed.load(std::memory_order_relaxed) == true)
+        {
+            return ok(true);
+        }
+        if (m_count.load(std::memory_order_relaxed) > 0)
+        {
+            --m_count;
+            return ok(true);
+        }
+        return ok(false);
+    }
+
+    expected<SemaphoreWaitState, SemaphoreError> timedWait(const units::Duration& timeout)
+    {
+        iox::deadline_timer deadline_timer(timeout);
+        detail::adaptive_wait spinner;
+
+        auto ret_val = SemaphoreWaitState::TIMEOUT;
+        spinner.wait_loop([this, &deadline_timer, &ret_val] {
+            if (this->tryWait())
+            {
+                ret_val = SemaphoreWaitState::NO_TIMEOUT;
+                return false;
+            }
+            return !deadline_timer.hasExpired();
+        });
+
+        return ok(ret_val);
+    }
+
+  private:
+    concurrent::Atomic<int32_t> m_count{0};
+    concurrent::Atomic<bool> m_to_be_destroyed{false};
+    SpinlockMutex spinlock;
+};
+
 struct ConditionVariableData
 {
     ConditionVariableData() noexcept;
@@ -37,7 +106,7 @@ struct ConditionVariableData
     ConditionVariableData& operator=(ConditionVariableData&& rhs) = delete;
     ~ConditionVariableData() noexcept = default;
 
-    optional<UnnamedSemaphore> m_semaphore;
+    optional<SpinLockSemaphore> m_semaphore;
     RuntimeName_t m_runtimeName;
     concurrent::Atomic<bool> m_toBeDestroyed{false};
     concurrent::Atomic<bool> m_activeNotifications[MAX_NUMBER_OF_NOTIFIERS];

iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/locking_policy.hpp

@@ -16,12 +16,106 @@
 #ifndef IOX_POSH_POPO_BUILDING_BLOCKS_LOCKING_POLICY_HPP
 #define IOX_POSH_POPO_BUILDING_BLOCKS_LOCKING_POLICY_HPP
 
+#include "iox/detail/adaptive_wait.hpp"
 #include "iox/mutex.hpp"
+#include "iox/spin_lock_mutex.hpp"
 
 namespace iox
 {
 namespace popo
 {
+class SpinlockMutex
+{
+  public:
+    SpinlockMutex()
+        : m_flag(ATOMIC_FLAG_INIT)
+        , m_recursive{Recursive{0, 0}}
+    {
+    }
+
+    expected<void, MutexLockError> lock() noexcept
+    {
+        pid_t tid = gettid();
+
+        auto recursive = m_recursive.load();
+
+        if (recursive.tid == tid)
+        {
+            recursive.count += 1;
+            m_recursive.store(recursive);
+
+            return ok();
+        }
+
+        detail::adaptive_wait spinner;
+        spinner.wait_loop([this] { return this->m_flag.test_and_set(std::memory_order_acquire); });
+
+        m_recursive.store(Recursive{tid, 1});
+
+        return ok();
+    }
+
+    expected<void, MutexUnlockError> unlock() noexcept
+    {
+        pid_t tid = gettid();
+
+        auto recursive = m_recursive.load();
+
+        if (recursive.tid == tid)
+        {
+            recursive.count -= 1;
+
+            if (recursive.count == 0)
+            {
+                recursive.tid = 0;
+                m_recursive.store(recursive);
+                m_flag.clear(std::memory_order_release);
+            }
+            else
+            {
+                m_recursive.store(recursive);
+            }
+
+            return ok();
+        }
+
+
+        return err(MutexUnlockError::UNKNOWN_ERROR);
+    }
+
+    expected<MutexTryLock, MutexTryLockError> try_lock() noexcept
+    {
+        pid_t tid = gettid();
+
+        auto recursive = m_recursive.load();
+
+        if (recursive.tid == tid)
+        {
+            recursive.count += 1;
+            m_recursive.store(recursive);
+            return ok(MutexTryLock::LOCK_SUCCEEDED);
+        }
+
+        if (!m_flag.test_and_set(std::memory_order_acquire))
+        {
+            m_recursive.store(Recursive{tid, 1});
+
+            return ok(MutexTryLock::LOCK_SUCCEEDED);
+        }
+        return ok(MutexTryLock::FAILED_TO_ACQUIRE_LOCK);
+    }
+
+    struct Recursive
+    {
+        pid_t tid;
+        uint32_t count;
+    };
+
+  private:
+    concurrent::AtomicFlag m_flag;
+    concurrent::Atomic<Recursive> m_recursive;
+};
+
 class ThreadSafePolicy
 {
   public:
@@ -33,7 +127,7 @@ class ThreadSafePolicy
     bool tryLock() const noexcept;
 
   private:
-    mutable optional<mutex> m_mutex;
+    mutable optional<SpinlockMutex> m_mutex;
 };
 
 class SingleThreadedPolicy

iceoryx_posh/source/popo/building_blocks/condition_variable_data.cpp

@@ -30,9 +30,11 @@ ConditionVariableData::ConditionVariableData() noexcept
 ConditionVariableData::ConditionVariableData(const RuntimeName_t& runtimeName) noexcept
     : m_runtimeName(runtimeName)
 {
-    UnnamedSemaphoreBuilder().initialValue(0U).isInterProcessCapable(true).create(m_semaphore).or_else([](auto) {
-        IOX_REPORT_FATAL(PoshError::POPO__CONDITION_VARIABLE_DATA_FAILED_TO_CREATE_SEMAPHORE);
-    });
+    /// @todo iox-#2301 fix this with a proper spin-lock implementation
+    // UnnamedSemaphoreBuilder().initialValue(0U).isInterProcessCapable(true).create(m_semaphore).or_else([](auto) {
+    //     IOX_REPORT_FATAL(PoshError::POPO__CONDITION_VARIABLE_DATA_FAILED_TO_CREATE_SEMAPHORE);
+    // });
+    m_semaphore.emplace();
 
     for (auto& id : m_activeNotifications)
     {

iceoryx_posh/source/popo/building_blocks/locking_policy.cpp

@@ -25,11 +25,13 @@ namespace popo
 {
 ThreadSafePolicy::ThreadSafePolicy() noexcept
 {
-    MutexBuilder()
-        .isInterProcessCapable(true)
-        .mutexType(MutexType::RECURSIVE)
-        .create(m_mutex)
-        .expect("Failed to create Mutex");
+    /// @todo iox-#2301 fix this with a proper spin-lock implementation
+    // MutexBuilder()
+    //     .isInterProcessCapable(true)
+    //     .mutexType(MutexType::RECURSIVE)
+    //     .create(m_mutex)
+    //     .expect("Failed to create Mutex");
+    m_mutex.emplace();
 }
 
 void ThreadSafePolicy::lock() const noexcept