From 6929dd87c24c2ac2d2a11941a24d0eb7fa9b3d62 Mon Sep 17 00:00:00 2001 From: Mathias Kraus Date: Thu, 19 Sep 2024 21:30:48 +0200 Subject: [PATCH] iox-#2301 Squash me --- iceoryx_hoofs/CMakeLists.txt | 2 +- .../sync/include/iox/spin_semaphore.hpp | 18 ++++--- .../concurrent/sync/source/spin_semaphore.cpp | 8 +-- .../include/iox}/semaphore_interface.hpp | 30 +++++++---- .../include/iox/detail/semaphore_helper.hpp | 54 +++++++++++++++++++ .../sync/include/iox/named_semaphore.hpp | 9 +++- .../sync/include/iox/unnamed_semaphore.hpp | 9 +++- .../posix/sync/source/named_semaphore.cpp | 16 +++++- ...ore_interface.cpp => semaphore_helper.cpp} | 43 +++++---------- .../posix/sync/source/unnamed_semaphore.cpp | 23 ++++++-- 10 files changed, 151 insertions(+), 61 deletions(-) rename iceoryx_hoofs/{posix/sync/include/iox/detail => design/include/iox}/semaphore_interface.hpp (79%) create mode 100644 iceoryx_hoofs/posix/sync/include/iox/detail/semaphore_helper.hpp rename iceoryx_hoofs/posix/sync/source/{semaphore_interface.cpp => semaphore_helper.cpp} (57%) diff --git a/iceoryx_hoofs/CMakeLists.txt b/iceoryx_hoofs/CMakeLists.txt index 4ad1670b87..7aa4487598 100644 --- a/iceoryx_hoofs/CMakeLists.txt +++ b/iceoryx_hoofs/CMakeLists.txt @@ -136,7 +136,7 @@ iox_add_library( posix/sync/source/named_semaphore.cpp posix/sync/source/signal_handler.cpp posix/sync/source/signal_watcher.cpp - posix/sync/source/semaphore_interface.cpp + posix/sync/source/semaphore_helper.cpp posix/sync/source/thread.cpp posix/sync/source/unnamed_semaphore.cpp posix/time/source/adaptive_wait.cpp diff --git a/iceoryx_hoofs/concurrent/sync/include/iox/spin_semaphore.hpp b/iceoryx_hoofs/concurrent/sync/include/iox/spin_semaphore.hpp index 406eef9bc7..8a8666bb33 100644 --- a/iceoryx_hoofs/concurrent/sync/include/iox/spin_semaphore.hpp +++ b/iceoryx_hoofs/concurrent/sync/include/iox/spin_semaphore.hpp @@ -21,8 +21,9 @@ #include "iox/atomic.hpp" #include "iox/deadline_timer.hpp" #include "iox/detail/adaptive_wait.hpp" -#include "iox/detail/semaphore_interface.hpp" +#include "iox/detail/semaphore_helper.hpp" #include "iox/optional.hpp" +#include "iox/semaphore_interface.hpp" #include "iox/spin_lock.hpp" namespace iox @@ -43,18 +44,19 @@ class SpinSemaphore : public detail::SemaphoreInterface ~SpinSemaphore() noexcept; - expected post() noexcept; + private: + friend class optional; + friend class detail::SemaphoreInterface; - expected wait() noexcept; + explicit SpinSemaphore(int32_t initial_value) noexcept; - expected tryWait() noexcept; + expected post_impl() noexcept; - expected timedWait(const units::Duration& timeout) noexcept; + expected wait_impl() noexcept; - private: - friend class optional; + expected try_wait_impl() noexcept; - explicit SpinSemaphore(int32_t initial_value) noexcept; + expected timed_wait_impl(const units::Duration& timeout) noexcept; private: concurrent::Atomic m_count{0}; diff --git a/iceoryx_hoofs/concurrent/sync/source/spin_semaphore.cpp b/iceoryx_hoofs/concurrent/sync/source/spin_semaphore.cpp index 2b17ae0749..48e17c44ea 100644 --- a/iceoryx_hoofs/concurrent/sync/source/spin_semaphore.cpp +++ b/iceoryx_hoofs/concurrent/sync/source/spin_semaphore.cpp @@ -43,21 +43,21 @@ SpinSemaphore::~SpinSemaphore() noexcept m_to_be_destroyed = true; } -expected SpinSemaphore::post() noexcept +expected SpinSemaphore::post_impl() noexcept { std::lock_guard lock(*m_spinlock); ++m_count; return ok(); } -expected SpinSemaphore::wait() noexcept +expected SpinSemaphore::wait_impl() noexcept { detail::adaptive_wait spinner; spinner.wait_loop([this] { return !this->tryWait(); }); return ok(); } -expected SpinSemaphore::tryWait() noexcept +expected SpinSemaphore::try_wait_impl() noexcept { std::lock_guard lock(*m_spinlock); if (m_to_be_destroyed.load(std::memory_order_relaxed)) @@ -72,7 +72,7 @@ expected SpinSemaphore::tryWait() noexcept return ok(false); } -expected SpinSemaphore::timedWait(const units::Duration& timeout) noexcept +expected SpinSemaphore::timed_wait_impl(const units::Duration& timeout) noexcept { iox::deadline_timer deadline_timer(timeout); detail::adaptive_wait spinner; diff --git a/iceoryx_hoofs/posix/sync/include/iox/detail/semaphore_interface.hpp b/iceoryx_hoofs/design/include/iox/semaphore_interface.hpp similarity index 79% rename from iceoryx_hoofs/posix/sync/include/iox/detail/semaphore_interface.hpp rename to iceoryx_hoofs/design/include/iox/semaphore_interface.hpp index 355d7fce08..aa634a7646 100644 --- a/iceoryx_hoofs/posix/sync/include/iox/detail/semaphore_interface.hpp +++ b/iceoryx_hoofs/design/include/iox/semaphore_interface.hpp @@ -1,4 +1,5 @@ // Copyright (c) 2022 by Apex.AI Inc. All rights reserved. +// 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. @@ -14,8 +15,8 @@ // // SPDX-License-Identifier: Apache-2.0 -#ifndef IOX_HOOFS_POSIX_SYNC_SEMAPHORE_INTERFACE_HPP -#define IOX_HOOFS_POSIX_SYNC_SEMAPHORE_INTERFACE_HPP +#ifndef IOX_HOOFS_DESIGN_SEMAPHORE_INTERFACE_HPP +#define IOX_HOOFS_DESIGN_SEMAPHORE_INTERFACE_HPP #include "iceoryx_platform/semaphore.hpp" #include "iox/duration.hpp" @@ -59,32 +60,41 @@ class SemaphoreInterface /// @brief Increments the semaphore by one /// @return Fails when the value of the semaphore overflows or when the /// semaphore was removed from outside the process - expected post() noexcept; + expected post() noexcept + { + return static_cast(this)->post_impl(); + } /// @brief Decrements the semaphore by one. When the semaphore value is zero /// it blocks until the semaphore value is greater zero /// @return Fails when semaphore was removed from outside the process - expected wait() noexcept; + expected wait() noexcept + { + return static_cast(this)->wait_impl(); + } /// @brief Tries to decrement the semaphore by one. When the semaphore value is zero /// it returns false otherwise it returns true and decrement the value by one. /// @return Fails when semaphore was removed from outside the process - expected tryWait() noexcept; + expected tryWait() noexcept + { + return static_cast(this)->try_wait_impl(); + } /// @brief Tries to decrement the semaphore by one. When the semaphore value is zero /// it waits until the timeout has passed. /// @return If during the timeout time the semaphore value increases to non zero /// it returns SemaphoreWaitState::NO_TIMEOUT and decreases the semaphore by one /// otherwise returns SemaphoreWaitState::TIMEOUT - expected timedWait(const units::Duration& timeout) noexcept; + expected timedWait(const units::Duration& timeout) noexcept + { + return static_cast(this)->timed_wait_impl(timeout); + } protected: SemaphoreInterface() noexcept = default; - - private: - iox_sem_t* getHandle() noexcept; }; } // namespace detail } // namespace iox -#endif // IOX_HOOFS_POSIX_SYNC_SEMAPHORE_INTERFACE_HPP +#endif // IOX_HOOFS_DESIGN_SEMAPHORE_INTERFACE_HPP diff --git a/iceoryx_hoofs/posix/sync/include/iox/detail/semaphore_helper.hpp b/iceoryx_hoofs/posix/sync/include/iox/detail/semaphore_helper.hpp new file mode 100644 index 0000000000..4bd1381f0b --- /dev/null +++ b/iceoryx_hoofs/posix/sync/include/iox/detail/semaphore_helper.hpp @@ -0,0 +1,54 @@ +// Copyright (c) 2022 by Apex.AI Inc. 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_POSIX_SYNC_SEMAPHORE_HELPER_HPP +#define IOX_HOOFS_POSIX_SYNC_SEMAPHORE_HELPER_HPP + +#include "iceoryx_platform/semaphore.hpp" +#include "iox/duration.hpp" +#include "iox/expected.hpp" +#include "iox/semaphore_interface.hpp" + +namespace iox +{ +namespace detail +{ +/// @brief Increments the semaphore by one +/// @return Fails when the value of the semaphore overflows or when the +/// semaphore was removed from outside the process +expected sem_post(iox_sem_t* handle) noexcept; + +/// @brief Decrements the semaphore by one. When the semaphore value is zero +/// it blocks until the semaphore value is greater zero +/// @return Fails when semaphore was removed from outside the process +expected sem_wait(iox_sem_t* handle) noexcept; + +/// @brief Tries to decrement the semaphore by one. When the semaphore value is zero +/// it returns false otherwise it returns true and decrement the value by one. +/// @return Fails when semaphore was removed from outside the process +expected sem_try_wait(iox_sem_t* handle) noexcept; + +/// @brief Tries to decrement the semaphore by one. When the semaphore value is zero +/// it waits until the timeout has passed. +/// @return If during the timeout time the semaphore value increases to non zero +/// it returns SemaphoreWaitState::NO_TIMEOUT and decreases the semaphore by one +/// otherwise returns SemaphoreWaitState::TIMEOUT +expected sem_timed_wait(iox_sem_t* handle, const units::Duration& timeout) noexcept; + +} // namespace detail +} // namespace iox + +#endif // IOX_HOOFS_POSIX_SYNC_SEMAPHORE_HELPER_HPP diff --git a/iceoryx_hoofs/posix/sync/include/iox/named_semaphore.hpp b/iceoryx_hoofs/posix/sync/include/iox/named_semaphore.hpp index fffd38f8e1..687222a502 100644 --- a/iceoryx_hoofs/posix/sync/include/iox/named_semaphore.hpp +++ b/iceoryx_hoofs/posix/sync/include/iox/named_semaphore.hpp @@ -19,10 +19,11 @@ #include "iceoryx_platform/platform_settings.hpp" #include "iox/builder.hpp" -#include "iox/detail/semaphore_interface.hpp" +#include "iox/detail/semaphore_helper.hpp" #include "iox/expected.hpp" #include "iox/filesystem.hpp" #include "iox/optional.hpp" +#include "iox/semaphore_interface.hpp" #include "iox/string.hpp" namespace iox @@ -50,7 +51,11 @@ class NamedSemaphore final : public detail::SemaphoreInterface friend class detail::SemaphoreInterface; NamedSemaphore(iox_sem_t* handle, const Name_t& name, const bool hasOwnership) noexcept; - iox_sem_t* getHandle() noexcept; + + expected post_impl() noexcept; + expected wait_impl() noexcept; + expected try_wait_impl() noexcept; + expected timed_wait_impl(const units::Duration& timeout) noexcept; iox_sem_t* m_handle = nullptr; Name_t m_name; diff --git a/iceoryx_hoofs/posix/sync/include/iox/unnamed_semaphore.hpp b/iceoryx_hoofs/posix/sync/include/iox/unnamed_semaphore.hpp index 2649f3afc0..a27891e17a 100644 --- a/iceoryx_hoofs/posix/sync/include/iox/unnamed_semaphore.hpp +++ b/iceoryx_hoofs/posix/sync/include/iox/unnamed_semaphore.hpp @@ -18,9 +18,10 @@ #define IOX_HOOFS_POSIX_SYNC_UNNAMED_SEMAPHORE_HPP #include "iox/builder.hpp" -#include "iox/detail/semaphore_interface.hpp" +#include "iox/detail/semaphore_helper.hpp" #include "iox/expected.hpp" #include "iox/optional.hpp" +#include "iox/semaphore_interface.hpp" namespace iox { @@ -48,7 +49,11 @@ class UnnamedSemaphore final : public detail::SemaphoreInterface; UnnamedSemaphore() noexcept = default; - iox_sem_t* getHandle() noexcept; + + expected post_impl() noexcept; + expected wait_impl() noexcept; + expected try_wait_impl() noexcept; + expected timed_wait_impl(const units::Duration& timeout) noexcept; iox_sem_t m_handle; bool m_destroyHandle = true; diff --git a/iceoryx_hoofs/posix/sync/source/named_semaphore.cpp b/iceoryx_hoofs/posix/sync/source/named_semaphore.cpp index 01eb583db0..86a840a658 100644 --- a/iceoryx_hoofs/posix/sync/source/named_semaphore.cpp +++ b/iceoryx_hoofs/posix/sync/source/named_semaphore.cpp @@ -239,8 +239,20 @@ NamedSemaphore::~NamedSemaphore() noexcept } } -iox_sem_t* NamedSemaphore::getHandle() noexcept +expected NamedSemaphore::post_impl() noexcept { - return m_handle; + return detail::sem_post(m_handle); +} +expected NamedSemaphore::wait_impl() noexcept +{ + return detail::sem_wait(m_handle); +} +expected NamedSemaphore::try_wait_impl() noexcept +{ + return detail::sem_try_wait(m_handle); +} +expected NamedSemaphore::timed_wait_impl(const units::Duration& timeout) noexcept +{ + return detail::sem_timed_wait(m_handle, timeout); } } // namespace iox diff --git a/iceoryx_hoofs/posix/sync/source/semaphore_interface.cpp b/iceoryx_hoofs/posix/sync/source/semaphore_helper.cpp similarity index 57% rename from iceoryx_hoofs/posix/sync/source/semaphore_interface.cpp rename to iceoryx_hoofs/posix/sync/source/semaphore_helper.cpp index 3d84d9ad78..05653fa27e 100644 --- a/iceoryx_hoofs/posix/sync/source/semaphore_interface.cpp +++ b/iceoryx_hoofs/posix/sync/source/semaphore_helper.cpp @@ -14,17 +14,15 @@ // // SPDX-License-Identifier: Apache-2.0 -#include "iox/detail/semaphore_interface.hpp" +#include "iox/detail/semaphore_helper.hpp" #include "iox/logging.hpp" -#include "iox/named_semaphore.hpp" #include "iox/posix_call.hpp" -#include "iox/unnamed_semaphore.hpp" namespace iox { namespace detail { -SemaphoreError errnoToEnum(const int32_t errnum) noexcept +SemaphoreError sem_errno_to_enum(const int32_t errnum) noexcept { switch (errnum) { @@ -44,70 +42,57 @@ SemaphoreError errnoToEnum(const int32_t errnum) noexcept return SemaphoreError::UNDEFINED; } -template -iox_sem_t* SemaphoreInterface::getHandle() noexcept +expected sem_post(iox_sem_t* handle) noexcept { - return static_cast(this)->getHandle(); -} - -template -expected SemaphoreInterface::post() noexcept -{ - auto result = IOX_POSIX_CALL(iox_sem_post)(getHandle()).failureReturnValue(-1).evaluate(); + auto result = IOX_POSIX_CALL(iox_sem_post)(handle).failureReturnValue(-1).evaluate(); if (result.has_error()) { - return err(errnoToEnum(result.error().errnum)); + return err(sem_errno_to_enum(result.error().errnum)); } return ok(); } -template -expected -SemaphoreInterface::timedWait(const units::Duration& timeout) noexcept +expected sem_timed_wait(iox_sem_t* handle, const units::Duration& timeout) noexcept { const timespec timeoutAsTimespec = timeout.timespec(units::TimeSpecReference::Epoch); - auto result = IOX_POSIX_CALL(iox_sem_timedwait)(getHandle(), &timeoutAsTimespec) + auto result = IOX_POSIX_CALL(iox_sem_timedwait)(handle, &timeoutAsTimespec) .failureReturnValue(-1) .ignoreErrnos(ETIMEDOUT) .evaluate(); if (result.has_error()) { - return err(errnoToEnum(result.error().errnum)); + return err(sem_errno_to_enum(result.error().errnum)); } return ok((result.value().errnum == ETIMEDOUT) ? SemaphoreWaitState::TIMEOUT : SemaphoreWaitState::NO_TIMEOUT); } -template -expected SemaphoreInterface::tryWait() noexcept +expected sem_try_wait(iox_sem_t* handle) noexcept { - auto result = IOX_POSIX_CALL(iox_sem_trywait)(getHandle()).failureReturnValue(-1).ignoreErrnos(EAGAIN).evaluate(); + auto result = IOX_POSIX_CALL(iox_sem_trywait)(handle).failureReturnValue(-1).ignoreErrnos(EAGAIN).evaluate(); if (result.has_error()) { - return err(errnoToEnum(result.error().errnum)); + return err(sem_errno_to_enum(result.error().errnum)); } return ok(result.value().errnum != EAGAIN); } -template -expected SemaphoreInterface::wait() noexcept +expected sem_wait(iox_sem_t* handle) noexcept { - auto result = IOX_POSIX_CALL(iox_sem_wait)(getHandle()).failureReturnValue(-1).evaluate(); + auto result = IOX_POSIX_CALL(iox_sem_wait)(handle).failureReturnValue(-1).evaluate(); if (result.has_error()) { - return err(errnoToEnum(result.error().errnum)); + return err(sem_errno_to_enum(result.error().errnum)); } return ok(); } -template class SemaphoreInterface; -template class SemaphoreInterface; } // namespace detail } // namespace iox diff --git a/iceoryx_hoofs/posix/sync/source/unnamed_semaphore.cpp b/iceoryx_hoofs/posix/sync/source/unnamed_semaphore.cpp index 058ded3670..df5fbc08ec 100644 --- a/iceoryx_hoofs/posix/sync/source/unnamed_semaphore.cpp +++ b/iceoryx_hoofs/posix/sync/source/unnamed_semaphore.cpp @@ -65,7 +65,7 @@ UnnamedSemaphore::~UnnamedSemaphore() noexcept { if (m_destroyHandle) { - auto result = IOX_POSIX_CALL(iox_sem_destroy)(getHandle()).failureReturnValue(-1).evaluate(); + auto result = IOX_POSIX_CALL(iox_sem_destroy)(&m_handle).failureReturnValue(-1).evaluate(); if (result.has_error()) { switch (result.error().errnum) @@ -81,8 +81,25 @@ UnnamedSemaphore::~UnnamedSemaphore() noexcept } } -iox_sem_t* UnnamedSemaphore::getHandle() noexcept + +expected UnnamedSemaphore::post_impl() noexcept +{ + return detail::sem_post(&m_handle); +} + +expected UnnamedSemaphore::wait_impl() noexcept { - return &m_handle; + return detail::sem_wait(&m_handle); } + +expected UnnamedSemaphore::try_wait_impl() noexcept +{ + return detail::sem_try_wait(&m_handle); +} + +expected UnnamedSemaphore::timed_wait_impl(const units::Duration& timeout) noexcept +{ + return detail::sem_timed_wait(&m_handle, timeout); +} + } // namespace iox