thread.hpp

#pragma once
 
#include <climits>
 
#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);
 
    // 线程栈大小设定，至少满足 PTHREAD_STACK_MIN
    size_t stack_size = LibXR::max(static_cast<size_t>(PTHREAD_STACK_MIN), stack_depth);
    pthread_attr_setstacksize(&attr, stack_size);
 
    class ThreadBlock
    {
     public:
      ThreadBlock(decltype(function) fun, ArgType arg, const char *name)
          : fun_(fun),
            arg_(arg),
            name_(reinterpret_cast<char *>(malloc(strlen(name) + 1)))
      {
        strcpy(name_, name);
      }
 
      ~ThreadBlock() { free(name_); }
 
      static void *Port(void *arg)
      {
        ThreadBlock *block = static_cast<ThreadBlock *>(arg);
 
        if (block->name_ && block->name_[0] != '\0')
        {
          char name_buf[16];
          std::strncpy(name_buf, block->name_, sizeof(name_buf) - 1);
          name_buf[sizeof(name_buf) - 1] = '\0';
          pthread_setname_np(pthread_self(), name_buf);
        }
 
        volatile const char *thread_name = block->name_;
        block->fun_(block->arg_);
 
        UNUSED(thread_name);
        delete block;
        return static_cast<void *>(nullptr);
      }
 
      decltype(function) fun_;  
      ArgType arg_;  
      char *name_;   
    };
 
    auto block = new ThreadBlock(function, arg, name);
 
    // 优先尝试设置 SCHED_FIFO 和线程优先级
    int min_priority = sched_get_priority_min(SCHED_FIFO);
    int max_priority = sched_get_priority_max(SCHED_FIFO);
    bool scheduling_set = false;
 
    UNUSED(scheduling_set);
 
    if (max_priority - min_priority >= static_cast<int>(Priority::REALTIME))
    {
      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)
      {
        scheduling_set = true;
      }
      else
      {
        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);
      }
    }
    else
    {
      XR_LOG_WARN(
          "SCHED_FIFO not supported or insufficient range. Using default policy.");
      pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);
    }
 
    // 创建线程
    int ans = pthread_create(&this->thread_handle_, &attr, ThreadBlock::Port, block);
 
    pthread_attr_destroy(&attr);
 
    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();
 
  operator libxr_thread_handle() { return thread_handle_; }
 
 private:
  libxr_thread_handle thread_handle_;  
};
 
}  // namespace LibXR