sync.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2026 Kamil Lulko <kamil.lulko@gmail.com>
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * This file is part of oveRTOS.
 */
 
#pragma once
 
#include <ove/sync.h>
#include <ove/types.hpp>
#include <ove/error.hpp>
#include <atomic>
 
#ifdef CONFIG_OVE_SYNC
 
namespace ove
{
 
class Mutex
{
      public:
    Mutex()
    {
#ifdef CONFIG_OVE_ZERO_HEAP
        int err = ove_mutex_init(&handle_, &storage_);
#else
        int err = ove_mutex_create(&handle_);
#endif
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    ~Mutex() noexcept
    {
        if (!handle_)
            return;
#ifdef CONFIG_OVE_ZERO_HEAP
        ove_mutex_deinit(handle_);
#else
        ove_mutex_destroy(handle_);
#endif
    }
 
    Mutex(const Mutex &) = delete;
    Mutex &operator=(const Mutex &) = delete;
 
#ifdef CONFIG_OVE_ZERO_HEAP
    Mutex(Mutex &&) = delete;
    Mutex &operator=(Mutex &&) = delete;
#else
    Mutex(Mutex &&other) noexcept : handle_(other.handle_)
    {
        other.handle_ = nullptr;
    }
 
    Mutex &operator=(Mutex &&other) noexcept
    {
        if (this != &other) {
            if (handle_)
                ove_mutex_destroy(handle_);
            handle_ = other.handle_;
            other.handle_ = nullptr;
        }
        return *this;
    }
#endif
 
    void lock()
    {
        const int err = ove_mutex_lock(handle_, OVE_WAIT_FOREVER);
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    [[nodiscard]] bool try_lock()
    {
        return ove_mutex_lock(handle_, 0) == OVE_OK;
    }
 
    template <class Rep, class Period>
    [[nodiscard]] Result<void>
    try_lock_for(const std::chrono::duration<Rep, Period> &rel) noexcept
    {
        return from_rc(ove_mutex_lock(handle_, to_timeout_ns(rel)));
    }
 
    template <class Clock, class Duration>
    [[nodiscard]] Result<void>
    try_lock_until(const std::chrono::time_point<Clock, Duration> &deadline) noexcept
    {
        const auto rel = deadline - Clock::now();
        return from_rc(ove_mutex_lock(handle_, to_timeout_ns(rel)));
    }
 
    void unlock()
    {
        ove_mutex_unlock(handle_);
    }
 
    bool valid() const
    {
        return handle_ != nullptr;
    }
 
    ove_mutex_t handle() const
    {
        return handle_;
    }
 
      private:
    ove_mutex_t handle_ = nullptr;
#ifdef CONFIG_OVE_ZERO_HEAP
    ove_mutex_storage_t storage_ = {};
#endif
};
 
/* Regression guard.  `BasicLockable` and `Lockable` are named
 * requirements (not concepts) in the C++ standard; define equivalent
 * local concepts and static_assert against them so a future change
 * that breaks std-composition (e.g. removing `try_lock`) trips the
 * build instead of failing far away in a user's `std::scoped_lock`
 * instantiation. */
namespace detail
{
 
template <class M>
concept basic_lockable = requires(M m) {
    { m.lock() };
    { m.unlock() };
};
 
template <class M>
concept lockable = basic_lockable<M> && requires(M m) {
    { m.try_lock() } -> std::convertible_to<bool>;
};
 
} /* namespace detail */
 
static_assert(detail::basic_lockable<Mutex>,
          "ove::Mutex must satisfy the BasicLockable named requirement");
static_assert(detail::lockable<Mutex>, "ove::Mutex must satisfy the Lockable named requirement");
 
class RecursiveMutex
{
      public:
    RecursiveMutex()
    {
#ifdef CONFIG_OVE_ZERO_HEAP
        int err = ove_recursive_mutex_init(&handle_, &storage_);
#else
        int err = ove_recursive_mutex_create(&handle_);
#endif
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    ~RecursiveMutex() noexcept
    {
        if (!handle_)
            return;
#ifdef CONFIG_OVE_ZERO_HEAP
        ove_mutex_deinit(handle_);
#else
        ove_recursive_mutex_destroy(handle_);
#endif
    }
 
    RecursiveMutex(const RecursiveMutex &) = delete;
    RecursiveMutex &operator=(const RecursiveMutex &) = delete;
 
#ifdef CONFIG_OVE_ZERO_HEAP
    RecursiveMutex(RecursiveMutex &&) = delete;
    RecursiveMutex &operator=(RecursiveMutex &&) = delete;
#else
    RecursiveMutex(RecursiveMutex &&other) noexcept : handle_(other.handle_)
    {
        other.handle_ = nullptr;
    }
 
    RecursiveMutex &operator=(RecursiveMutex &&other) noexcept
    {
        if (this != &other) {
            if (handle_)
                ove_recursive_mutex_destroy(handle_);
            handle_ = other.handle_;
            other.handle_ = nullptr;
        }
        return *this;
    }
#endif
 
    void lock()
    {
        const int err = ove_recursive_mutex_lock(handle_, OVE_WAIT_FOREVER);
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    [[nodiscard]] bool try_lock()
    {
        return ove_recursive_mutex_lock(handle_, 0) == OVE_OK;
    }
 
    template <class Rep, class Period>
    [[nodiscard]] Result<void>
    try_lock_for(const std::chrono::duration<Rep, Period> &rel) noexcept
    {
        return from_rc(ove_recursive_mutex_lock(handle_, to_timeout_ns(rel)));
    }
 
    template <class Clock, class Duration>
    [[nodiscard]] Result<void>
    try_lock_until(const std::chrono::time_point<Clock, Duration> &deadline) noexcept
    {
        const auto rel = deadline - Clock::now();
        return from_rc(ove_recursive_mutex_lock(handle_, to_timeout_ns(rel)));
    }
 
    void unlock()
    {
        ove_recursive_mutex_unlock(handle_);
    }
 
    bool valid() const
    {
        return handle_ != nullptr;
    }
 
    ove_mutex_t handle() const
    {
        return handle_;
    }
 
      private:
    ove_mutex_t handle_ = nullptr;
#ifdef CONFIG_OVE_ZERO_HEAP
    ove_mutex_storage_t storage_ = {};
#endif
};
 
static_assert(detail::basic_lockable<RecursiveMutex>,
          "ove::RecursiveMutex must satisfy the BasicLockable named requirement");
static_assert(detail::lockable<RecursiveMutex>,
          "ove::RecursiveMutex must satisfy the Lockable named requirement");
 
class LockGuard
{
      public:
    explicit LockGuard(Mutex &mtx) : mtx_(mtx)
    {
        mtx_.lock();
    }
 
    ~LockGuard() noexcept
    {
        mtx_.unlock();
    }
 
    LockGuard(const LockGuard &) = delete;
    LockGuard &operator=(const LockGuard &) = delete;
    LockGuard(LockGuard &&) = delete;
    LockGuard &operator=(LockGuard &&) = delete;
 
      private:
    Mutex &mtx_;
};
 
template <typename T> class StaticCell
{
      public:
    template <typename... Args> T &init(Args &&...args)
    {
        bool expected = false;
        if (!initialized_.compare_exchange_strong(expected, true))
            OVE_STATIC_INIT_ASSERT(false && "StaticCell already initialized");
        return *new (storage_) T(std::forward<Args>(args)...);
    }
 
    T &get()
    {
        OVE_STATIC_INIT_ASSERT(initialized_.load());
        return *reinterpret_cast<T *>(storage_);
    }
 
    const T &get() const
    {
        OVE_STATIC_INIT_ASSERT(initialized_.load());
        return *reinterpret_cast<const T *>(storage_);
    }
 
    bool is_initialized() const
    {
        return initialized_.load();
    }
 
    StaticCell() = default;
    ~StaticCell() = default;
    StaticCell(const StaticCell &) = delete;
    StaticCell &operator=(const StaticCell &) = delete;
    StaticCell(StaticCell &&) = delete;
    StaticCell &operator=(StaticCell &&) = delete;
 
      private:
    alignas(T) uint8_t storage_[sizeof(T)]{};
    std::atomic<bool> initialized_{false};
};
 
class Semaphore
{
      public:
    explicit Semaphore(unsigned int initial = 0, unsigned int max = 1)
    {
#ifdef CONFIG_OVE_ZERO_HEAP
        int err = ove_sem_init(&handle_, &storage_, initial, max);
#else
        int err = ove_sem_create(&handle_, initial, max);
#endif
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    ~Semaphore() noexcept
    {
        if (!handle_)
            return;
#ifdef CONFIG_OVE_ZERO_HEAP
        ove_sem_deinit(handle_);
#else
        ove_sem_destroy(handle_);
#endif
    }
 
    Semaphore(const Semaphore &) = delete;
    Semaphore &operator=(const Semaphore &) = delete;
 
#ifdef CONFIG_OVE_ZERO_HEAP
    Semaphore(Semaphore &&) = delete;
    Semaphore &operator=(Semaphore &&) = delete;
#else
    Semaphore(Semaphore &&other) noexcept : handle_(other.handle_)
    {
        other.handle_ = nullptr;
    }
 
    Semaphore &operator=(Semaphore &&other) noexcept
    {
        if (this != &other) {
            if (handle_)
                ove_sem_destroy(handle_);
            handle_ = other.handle_;
            other.handle_ = nullptr;
        }
        return *this;
    }
#endif
 
    void acquire()
    {
        const int err = ove_sem_take(handle_, OVE_WAIT_FOREVER);
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    [[nodiscard]] bool try_acquire()
    {
        return ove_sem_take(handle_, 0) == OVE_OK;
    }
 
    template <class Rep, class Period>
    [[nodiscard]] Result<void>
    try_acquire_for(const std::chrono::duration<Rep, Period> &rel) noexcept
    {
        return from_rc(ove_sem_take(handle_, to_timeout_ns(rel)));
    }
 
    template <class Clock, class Duration>
    [[nodiscard]] Result<void>
    try_acquire_until(const std::chrono::time_point<Clock, Duration> &deadline) noexcept
    {
        const auto rel = deadline - Clock::now();
        return from_rc(ove_sem_take(handle_, to_timeout_ns(rel)));
    }
 
    void release()
    {
        ove_sem_give(handle_);
    }
 
    bool valid() const
    {
        return handle_ != nullptr;
    }
 
    ove_sem_t handle() const
    {
        return handle_;
    }
 
      private:
    ove_sem_t handle_ = nullptr;
#ifdef CONFIG_OVE_ZERO_HEAP
    ove_sem_storage_t storage_ = {};
#endif
};
 
class Event
{
      public:
    Event()
    {
#ifdef CONFIG_OVE_ZERO_HEAP
        int err = ove_event_init(&handle_, &storage_);
#else
        int err = ove_event_create(&handle_);
#endif
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    ~Event() noexcept
    {
        if (!handle_)
            return;
#ifdef CONFIG_OVE_ZERO_HEAP
        ove_event_deinit(handle_);
#else
        ove_event_destroy(handle_);
#endif
    }
 
    Event(const Event &) = delete;
    Event &operator=(const Event &) = delete;
 
#ifdef CONFIG_OVE_ZERO_HEAP
    Event(Event &&) = delete;
    Event &operator=(Event &&) = delete;
#else
    Event(Event &&other) noexcept : handle_(other.handle_)
    {
        other.handle_ = nullptr;
    }
 
    Event &operator=(Event &&other) noexcept
    {
        if (this != &other) {
            if (handle_)
                ove_event_destroy(handle_);
            handle_ = other.handle_;
            other.handle_ = nullptr;
        }
        return *this;
    }
#endif
 
    void wait()
    {
        const int err = ove_event_wait(handle_, OVE_WAIT_FOREVER);
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    [[nodiscard]] bool try_wait()
    {
        return ove_event_wait(handle_, 0) == OVE_OK;
    }
 
    template <class Rep, class Period>
    [[nodiscard]] Result<void>
    try_wait_for(const std::chrono::duration<Rep, Period> &rel) noexcept
    {
        return from_rc(ove_event_wait(handle_, to_timeout_ns(rel)));
    }
 
    template <class Clock, class Duration>
    [[nodiscard]] Result<void>
    try_wait_until(const std::chrono::time_point<Clock, Duration> &deadline) noexcept
    {
        const auto rel = deadline - Clock::now();
        return from_rc(ove_event_wait(handle_, to_timeout_ns(rel)));
    }
 
    void signal()
    {
        ove_event_signal(handle_);
    }
 
    void signal_from_isr()
    {
        ove_event_signal_from_isr(handle_);
    }
 
    bool valid() const
    {
        return handle_ != nullptr;
    }
 
    ove_event_t handle() const
    {
        return handle_;
    }
 
      private:
    ove_event_t handle_ = nullptr;
#ifdef CONFIG_OVE_ZERO_HEAP
    ove_event_storage_t storage_ = {};
#endif
};
 
class CondVar
{
      public:
    CondVar()
    {
#ifdef CONFIG_OVE_ZERO_HEAP
        int err = ove_condvar_init(&handle_, &storage_);
#else
        int err = ove_condvar_create(&handle_);
#endif
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    ~CondVar() noexcept
    {
        if (!handle_)
            return;
#ifdef CONFIG_OVE_ZERO_HEAP
        ove_condvar_deinit(handle_);
#else
        ove_condvar_destroy(handle_);
#endif
    }
 
    CondVar(const CondVar &) = delete;
    CondVar &operator=(const CondVar &) = delete;
 
#ifdef CONFIG_OVE_ZERO_HEAP
    CondVar(CondVar &&) = delete;
    CondVar &operator=(CondVar &&) = delete;
#else
    CondVar(CondVar &&other) noexcept : handle_(other.handle_)
    {
        other.handle_ = nullptr;
    }
 
    CondVar &operator=(CondVar &&other) noexcept
    {
        if (this != &other) {
            if (handle_)
                ove_condvar_destroy(handle_);
            handle_ = other.handle_;
            other.handle_ = nullptr;
        }
        return *this;
    }
#endif
 
    void wait(Mutex &mtx)
    {
        const int err = ove_condvar_wait(handle_, mtx.handle(), OVE_WAIT_FOREVER);
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    template <class Rep, class Period>
    [[nodiscard]] Result<void>
    try_wait_for(Mutex &mtx, const std::chrono::duration<Rep, Period> &rel) noexcept
    {
        return from_rc(ove_condvar_wait(handle_, mtx.handle(), to_timeout_ns(rel)));
    }
 
    template <class Clock, class Duration>
    [[nodiscard]] Result<void>
    try_wait_until(Mutex &mtx,
               const std::chrono::time_point<Clock, Duration> &deadline) noexcept
    {
        const auto rel = deadline - Clock::now();
        return from_rc(ove_condvar_wait(handle_, mtx.handle(), to_timeout_ns(rel)));
    }
 
    template <typename Predicate> void wait(Mutex &mtx, Predicate pred)
    {
        while (!pred()) {
            wait(mtx);
        }
    }
 
    template <typename Rep, typename Period, typename Predicate>
    [[nodiscard]] bool try_wait_for(Mutex &mtx, std::chrono::duration<Rep, Period> rel,
                    Predicate pred)
    {
        const auto deadline = steady_clock::now() + rel;
        return try_wait_until(mtx, deadline, pred);
    }
 
    template <typename Clock, typename Duration, typename Predicate>
    [[nodiscard]] bool try_wait_until(Mutex &mtx,
                      const std::chrono::time_point<Clock, Duration> &deadline,
                      Predicate pred)
    {
        while (!pred()) {
            const auto now = Clock::now();
            if (now >= deadline)
                return pred();
            const int rc = ove_condvar_wait(handle_, mtx.handle(),
                            to_timeout_ns(deadline - now));
            (void)rc; /* spurious wake-up or timeout — re-check pred */
        }
        return true;
    }
 
    void notify_one()
    {
        ove_condvar_signal(handle_);
    }
 
    void notify_all()
    {
        ove_condvar_broadcast(handle_);
    }
 
    bool valid() const
    {
        return handle_ != nullptr;
    }
 
    ove_condvar_t handle() const
    {
        return handle_;
    }
 
      private:
    ove_condvar_t handle_ = nullptr;
#ifdef CONFIG_OVE_ZERO_HEAP
    ove_condvar_storage_t storage_ = {};
#endif
};
 
} // namespace ove
 
#endif /* CONFIG_OVE_SYNC */