thread.hpp

#pragma once
 
#include <climits>
#include <cstring>
 
#include "libxr_mem.hpp"
#include "libxr_system.hpp"
#include "libxr_time.hpp"
#include "logger.hpp"
 
namespace LibXR
{
class Thread
{
 public:
  enum class Priority : uint8_t
  {
    IDLE,      
    LOW,       
    MEDIUM,    
    HIGH,      
    REALTIME,  
    NUMBER,    
  };
 
  Thread() {};
 
  Thread(libxr_thread_handle handle) : thread_handle_(handle) {};
 
  template <typename ArgType>
  void Create(ArgType arg, void (*function)(ArgType arg), const char* name,
              size_t stack_depth, Thread::Priority priority)
  {
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    ConfigureAttributes(attr, stack_depth, priority);
 
    class ThreadBlock
    {
     public:
      ThreadBlock(decltype(function) fun, ArgType arg, const char* name)
          : fun_(fun), arg_(arg)
      {
        std::memset(name_, 0, sizeof(name_));
        if (name != nullptr)
        {
          std::strncpy(name_, name, sizeof(name_) - 1);
        }
      }
 
      static void* Port(void* arg)
      {
        ThreadBlock* block = static_cast<ThreadBlock*>(arg);
 
        if (block->name_[0] != '\0')
        {
          pthread_setname_np(pthread_self(), block->name_);
        }
 
        block->fun_(block->arg_);
        delete block;
        return static_cast<void*>(nullptr);
      }
 
      decltype(function) fun_;  
      ArgType arg_;             
      char name_[16];           
    };
 
    auto block = new ThreadBlock(function, arg, name);
 
    // 创建线程
    int ans = pthread_create(&this->thread_handle_, &attr, ThreadBlock::Port, block);
 
    if (ans != 0)
    {
      XR_LOG_WARN("Failed to create thread: %s (%s), retrying with default attributes.",
                  name, strerror(ans));
 
      // 完全使用系统默认属性（attr = nullptr）
      ans = pthread_create(&this->thread_handle_, nullptr, ThreadBlock::Port, block);
 
      if (ans != 0)
      {
        XR_LOG_ERROR("Failed to create thread: %s (%s)", name, strerror(ans));
        delete block;
      }
    }
 
    pthread_attr_destroy(&attr);
  }
 
  static Thread Current(void);
 
  static uint32_t GetTime();
 
  static void Sleep(uint32_t milliseconds);
 
  static void SleepUntil(MillisecondTimestamp& last_waskup_time, uint32_t time_to_sleep);
 
  static void Yield();
 
  ErrorCode Join();
 
  operator libxr_thread_handle() { return thread_handle_; }
 
 private:
  static void ConfigureAttributes(pthread_attr_t& attr, size_t stack_depth,
                                  Thread::Priority priority)
  {
    const size_t stack_size =
        LibXR::max(static_cast<size_t>(PTHREAD_STACK_MIN), stack_depth);
    pthread_attr_setstacksize(&attr, stack_size);
    ConfigureScheduling(attr, priority);
  }
 
  static void ConfigureScheduling(pthread_attr_t& attr, Thread::Priority priority)
  {
    const int min_priority = sched_get_priority_min(SCHED_FIFO);
    const int max_priority = sched_get_priority_max(SCHED_FIFO);
    if (max_priority - min_priority < static_cast<int>(Priority::REALTIME))
    {
      XR_LOG_WARN(
          "SCHED_FIFO not supported or insufficient range. Using default policy.");
      pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);
      return;
    }
 
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
    pthread_attr_setschedpolicy(&attr, SCHED_FIFO);
 
    struct sched_param sp;
    Memory::FastSet(&sp, 0, sizeof(sp));
    sp.sched_priority = min_priority + static_cast<int>(priority);
 
    if (pthread_attr_setschedparam(&attr, &sp) == 0)
    {
      return;
    }
 
    XR_LOG_WARN("Failed to set thread priority. Falling back to default policy.");
    pthread_attr_setschedpolicy(&attr, SCHED_OTHER);
    pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);
  }
 
  libxr_thread_handle thread_handle_;  
};
 
}  // namespace LibXR