threading.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <thread>
#include <mutex>
#include <shared_mutex>
#include <condition_variable>
#include <atomic>
#include <functional>
#include <string>
#include <cstdint>
 
// For future realtime support
#include <pthread.h>
#include <sched.h>
 
namespace commrat {
 
enum class ThreadPriority {
    IDLE = 0,       
    LOW = 10,       
    NORMAL = 50,    
    HIGH = 75,      
    REALTIME = 99   
};
 
enum class SchedulingPolicy {
    NORMAL,         
    FIFO,           
    ROUND_ROBIN,    
    DEADLINE        
};
 
struct ThreadConfig {
    std::string name{"unnamed"};
    ThreadPriority priority = ThreadPriority::NORMAL;
    SchedulingPolicy policy = SchedulingPolicy::NORMAL;
    int cpu_affinity = -1;  
    size_t stack_size = 0;  
};
 
class Thread {
public:
    Thread() = default;
    
    template<typename Func>
    Thread(const ThreadConfig& config, Func&& func)
        : config_(config), 
          thread_([this, f = std::forward<Func>(func)]() mutable {
              this->thread_function(std::move(f));
          }) {
    }
    
    explicit Thread(const ThreadConfig& config) 
        : config_(config) {
    }
    
    ~Thread() {
        if (thread_.joinable()) {
            thread_.join();
        }
    }
    
    // Non-copyable, movable
    Thread(const Thread&) = delete;
    Thread& operator=(const Thread&) = delete;
    Thread(Thread&&) = default;
    Thread& operator=(Thread&&) = default;
    
    template<typename Func>
    void start(Func&& func) {
        if (thread_.joinable()) {
            return;  // Already running
        }
        thread_ = std::thread([this, f = std::forward<Func>(func)]() mutable {
            this->thread_function(std::move(f));
        });
    }
    
    void join() {
        if (thread_.joinable()) {
            thread_.join();
        }
    }
    
    void detach() {
        if (thread_.joinable()) {
            thread_.detach();
        }
    }
    
    bool joinable() const noexcept {
        return thread_.joinable();
    }
    
    std::thread::native_handle_type native_handle() {
        return thread_.native_handle();
    }
    
    std::thread::id get_id() const noexcept {
        return thread_.get_id();
    }
    
    const ThreadConfig& config() const noexcept {
        return config_;
    }
 
private:
    template<typename Func>
    void thread_function(Func&& func) {
        // Set thread name (Linux-specific)
#ifdef __linux__
        if (!config_.name.empty()) {
            pthread_setname_np(pthread_self(), config_.name.c_str());
        }
#endif
        
        // Set priority and scheduling policy
        apply_thread_config();
        
        // Run user function
        func();
    }
    
    void apply_thread_config() {
        pthread_t thread_handle = pthread_self();
        
        // Set scheduling policy and priority
        if (config_.policy != SchedulingPolicy::NORMAL || 
            config_.priority != ThreadPriority::NORMAL) {
            
            int policy = SCHED_OTHER;
            switch (config_.policy) {
                case SchedulingPolicy::FIFO:
                    policy = SCHED_FIFO;
                    break;
                case SchedulingPolicy::ROUND_ROBIN:
                    policy = SCHED_RR;
                    break;
                default:
                    policy = SCHED_OTHER;
            }
            
            struct sched_param param;
            param.sched_priority = static_cast<int>(config_.priority);
            
            // Note: Requires CAP_SYS_NICE capability or root for SCHED_FIFO/RR
            pthread_setschedparam(thread_handle, policy, &param);
        }
        
        // Set CPU affinity
        if (config_.cpu_affinity >= 0) {
            cpu_set_t cpuset;
            CPU_ZERO(&cpuset);
            CPU_SET(config_.cpu_affinity, &cpuset);
            pthread_setaffinity_np(thread_handle, sizeof(cpu_set_t), &cpuset);
        }
    }
    
    ThreadConfig config_;
    std::thread thread_;
};
 
class Mutex {
public:
    Mutex() = default;
    ~Mutex() = default;
    
    // Non-copyable, non-movable
    Mutex(const Mutex&) = delete;
    Mutex& operator=(const Mutex&) = delete;
    
    void lock() { mutex_.lock(); }
    bool try_lock() { return mutex_.try_lock(); }
    void unlock() { mutex_.unlock(); }
    
    std::mutex& native() { return mutex_; }
    
private:
    std::mutex mutex_;
};
 
class SharedMutex {
public:
    SharedMutex() = default;
    ~SharedMutex() = default;
    
    // Non-copyable, non-movable
    SharedMutex(const SharedMutex&) = delete;
    SharedMutex& operator=(const SharedMutex&) = delete;
    
    void lock() { mutex_.lock(); }               // Exclusive (write) lock
    void lock_shared() { mutex_.lock_shared(); } // Shared (read) lock
    bool try_lock() { return mutex_.try_lock(); }
    bool try_lock_shared() { return mutex_.try_lock_shared(); }
    void unlock() { mutex_.unlock(); }
    void unlock_shared() { mutex_.unlock_shared(); }
    
    std::shared_mutex& native() { return mutex_; }
    
private:
    std::shared_mutex mutex_;
};
 
using Lock = std::lock_guard<Mutex>;
using UniqueLock = std::unique_lock<Mutex>;
 
using SharedLock = std::shared_lock<SharedMutex>;
 
using UniqueLockShared = std::unique_lock<SharedMutex>;
 
class ConditionVariable {
public:
    ConditionVariable() = default;
    ~ConditionVariable() = default;
    
    // Non-copyable, non-movable
    ConditionVariable(const ConditionVariable&) = delete;
    ConditionVariable& operator=(const ConditionVariable&) = delete;
    
    void notify_one() noexcept { cv_.notify_one(); }
    void notify_all() noexcept { cv_.notify_all(); }
    
    // Accept std::unique_lock<std::mutex> directly for condition variable compatibility
    void wait(std::unique_lock<std::mutex>& lock) { cv_.wait(lock); }
    
    template<typename Predicate>
    void wait(std::unique_lock<std::mutex>& lock, Predicate pred) {
        cv_.wait(lock, pred);
    }
    
    template<typename Rep, typename Period>
    std::cv_status wait_for(std::unique_lock<std::mutex>& lock, 
                           const std::chrono::duration<Rep, Period>& rel_time) {
        return cv_.wait_for(lock, rel_time);
    }
    
private:
    std::condition_variable cv_;
};
 
#define Synchronized(mutex) \
    if (commrat::Lock _lock_##__LINE__{mutex}; true)
 
#define ReadLocked(mutex) \
    if (commrat::SharedLock _lock_##__LINE__{mutex}; true)
 
#define WriteLocked(mutex) \
    if (commrat::UniqueLockShared _lock_##__LINE__{mutex}; true)
 
} // namespace commrat