thread.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/thread.h>
#include <ove/types.hpp>
 
namespace ove {
 
template <size_t StackSize = 0>
class Thread {
public:
    template <typename F>
    Thread(F entry, void *ctx, ove_prio_t prio, const char *name)
        requires (StackSize > 0) && ThreadEntry<F>
    {
        struct ove_thread_desc desc = {};
        desc.name = name;
        desc.entry = entry;
        desc.arg = ctx;
        desc.priority = prio;
        desc.stack_size = StackSize;
#ifdef CONFIG_OVE_ZERO_HEAP
        static_assert(StackSize > 0,
                  "StackSize must be > 0 in zero-heap mode");
        desc.stack = stack_;
        int err = ove_thread_init(&handle_, &storage_, &desc);
#else
        int err = ove_thread_create_(&handle_, &desc);
#endif
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    ~Thread() {
        if (!handle_) return;
#ifdef CONFIG_OVE_ZERO_HEAP
        ove_thread_deinit(handle_);
#else
        ove_thread_destroy(handle_);
#endif
    }
 
    Thread(const Thread &) = delete;
    Thread &operator=(const Thread &) = delete;
 
#ifdef CONFIG_OVE_ZERO_HEAP
    Thread(Thread &&) = delete;
    Thread &operator=(Thread &&) = delete;
#else
    Thread(Thread &&other) noexcept : handle_(other.handle_) {
        other.handle_ = nullptr;
    }
 
    Thread &operator=(Thread &&other) noexcept {
        if (this != &other) {
            if (handle_) ove_thread_destroy(handle_);
            handle_ = other.handle_;
            other.handle_ = nullptr;
        }
        return *this;
    }
#endif
 
    void set_priority(ove_prio_t prio) {
        ove_thread_set_priority(handle_, prio);
    }
 
    void suspend() {
        ove_thread_suspend(handle_);
    }
 
    void resume() {
        ove_thread_resume(handle_);
    }
 
    ove_thread_state_t get_state() const {
        return ove_thread_get_state(handle_);
    }
 
    size_t get_stack_usage() const {
        return ove_thread_get_stack_usage(handle_);
    }
 
    int get_runtime_stats(struct ove_thread_stats *stats) const {
        return ove_thread_get_runtime_stats(handle_, stats);
    }
 
    bool valid() const { return handle_ != nullptr; }
 
    ove_thread_t handle() const { return handle_; }
 
    static void sleep_ms(uint32_t ms) {
        ove_thread_sleep_ms(ms);
    }
 
    static void yield() {
        ove_thread_yield();
    }
 
    static ove_thread_t self() {
        return ove_thread_get_self();
    }
 
private:
    ove_thread_t handle_ = nullptr;
#ifdef CONFIG_OVE_ZERO_HEAP
    ove_thread_storage_t storage_ = {};
    OVE_THREAD_STACK_MEMBER_(stack_,
                     StackSize > 0 ? StackSize : 1);
#endif
};
 
/* ── System memory statistics ──────────────────────────────────── */
 
struct MemStats {
    size_t total{};      
    size_t free{};       
    size_t used{};       
    size_t peak_used{};  
};
 
[[nodiscard]] inline int get_mem_stats(MemStats &stats) {
    struct ove_mem_stats ms{};
    int ret = ove_sys_get_mem_stats(&ms);
    if (ret == OVE_OK) {
        stats.total     = ms.total;
        stats.free      = ms.free;
        stats.used      = ms.used;
        stats.peak_used = ms.peak_used;
    }
    return ret;
}
 
/* ── Thread enumeration ───────────────────────────────────────── */
 
struct ThreadInfo {
    const char *name{};           
    ove_thread_state_t state{OVE_THREAD_STATE_UNKNOWN}; 
    int priority{};               
    size_t stack_used{};          
};
 
[[nodiscard]] inline int thread_list(ThreadInfo *out, size_t max,
                     size_t *count = nullptr) {
    struct ove_thread_info buf[16];
    size_t n = 0;
    int ret = ove_thread_list(buf, max < 16 ? max : 16, &n);
    if (ret == OVE_OK) {
        for (size_t i = 0; i < n && i < max; i++) {
            out[i].name       = buf[i].name;
            out[i].state      = buf[i].state;
            out[i].priority   = buf[i].priority;
            out[i].stack_used = buf[i].stack_used;
        }
        if (count) *count = n;
    }
    return ret;
}
 
} /* namespace ove */