async.hpp

#pragma once
 
#include <atomic>
 
#include "libxr_cb.hpp"
#include "libxr_def.hpp"
#include "semaphore.hpp"
#include "thread.hpp"
 
namespace LibXR
{
 
class ASync
{
 public:
  enum class Status : uint32_t
  {
    READY = 0,         
    BUSY = 1,          
    DONE = UINT32_MAX  
  };
 
  ASync(size_t stack_depth, Thread::Priority priority);
 
  static void ThreadFun(ASync* async);
 
  std::atomic<Status> status_ = Status::READY;  
 
  [[nodiscard]] Status GetStatus()
  {
    Status cur = status_.load(std::memory_order_acquire);
    if (cur != Status::DONE)
    {
      return cur;
    }
    // 只允许一个观察者取走 DONE；迟到的观察者不能覆盖下一次提交的 BUSY。
    // Consume DONE once; a late observer must not overwrite the next submission's BUSY.
    if (status_.compare_exchange_strong(cur, Status::READY, std::memory_order_acq_rel,
                                        std::memory_order_acquire))
    {
      return Status::DONE;
    }
    return cur;
  }
 
  using Job = LibXR::Callback<ASync*>;
 
  ErrorCode AssignJob(Job job);
 
  ErrorCode AssignJobFromCallback(Job job, bool in_isr);
 
  Job job_;  
  Semaphore sem_;  
 
  Thread thread_handle_;  
 
 private:
  void RunJob();
 
#ifdef LIBXR_NOT_SUPPORT_MUTI_THREAD
  // BUSY 在写入 job_ 前置位；独立标记只在任务完整写入后发布。
  // BUSY precedes the job_ write; publish this flag only after the complete job is
  // stored.
  std::atomic<uint32_t> pending_{0U};
#endif
};
 
}  // namespace LibXR