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 <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() {
        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
 
    [[nodiscard]] int lock(uint32_t timeout_ms = OVE_WAIT_FOREVER) {
        return ove_mutex_lock(handle_, timeout_ms);
    }
 
    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
};
 
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() {
        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
 
    [[nodiscard]] int lock(uint32_t timeout_ms = OVE_WAIT_FOREVER) {
        return ove_recursive_mutex_lock(handle_, timeout_ms);
    }
 
    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
};
 
class LockGuard {
public:
    explicit LockGuard(Mutex &mtx)
        : mtx_(mtx) {
        (void)mtx_.lock(); /* wait forever — failure is fatal */
    }
 
    ~LockGuard() {
        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() {
        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
 
    [[nodiscard]] int take(uint32_t timeout_ms = OVE_WAIT_FOREVER) {
        return ove_sem_take(handle_, timeout_ms);
    }
 
    void give() {
        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() {
        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
 
    [[nodiscard]] int wait(uint32_t timeout_ms = OVE_WAIT_FOREVER) {
        return ove_event_wait(handle_, timeout_ms);
    }
 
    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() {
        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
 
    [[nodiscard]] int wait(Mutex &mtx,
                   uint32_t timeout_ms = OVE_WAIT_FOREVER) {
        return ove_condvar_wait(handle_, mtx.handle(), timeout_ms);
    }
 
    void signal() {
        ove_condvar_signal(handle_);
    }
 
    void broadcast() {
        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 */