libxr_rw.hpp

#pragma once
 
#include <atomic>
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <utility>
 
#include "libxr_cb.hpp"
#include "libxr_def.hpp"
#include "libxr_mem.hpp"
#include "libxr_type.hpp"
#include "lockfree_queue.hpp"
#include "mutex.hpp"
#include "semaphore.hpp"
 
namespace LibXR
{
 
template <typename Args>
class Operation
{
 public:
  using Callback = LibXR::Callback<Args>;
 
  enum class OperationType : uint8_t
  {
    CALLBACK,
    BLOCK,
    POLLING,
    NONE
  };
 
  enum class OperationPollingStatus : uint8_t
  {
    READY,
    RUNNING,
    DONE,
    ERROR
  };
 
  Operation() : type(OperationType::NONE) { Memory::FastSet(&data, 0, sizeof(data)); }
 
  Operation(Semaphore& sem, uint32_t timeout = UINT32_MAX) : type(OperationType::BLOCK)
  {
    data.sem_info.sem = &sem;
    data.sem_info.timeout = timeout;
  }
 
  Operation(Callback& callback) : type(OperationType::CALLBACK)
  {
    data.callback = &callback;
  }
 
  Operation(OperationPollingStatus& status) : type(OperationType::POLLING)
  {
    data.status = &status;
  }
 
  Operation& operator=(const Operation& op)
  {
    if (this != &op)
    {
      type = op.type;
      switch (type)
      {
        case OperationType::CALLBACK:
          data.callback = op.data.callback;
          break;
        case OperationType::BLOCK:
          data.sem_info.sem = op.data.sem_info.sem;
          data.sem_info.timeout = op.data.sem_info.timeout;
          break;
        case OperationType::POLLING:
          data.status = op.data.status;
          break;
        case OperationType::NONE:
          break;
      }
    }
    return *this;
  }
 
  Operation& operator=(Operation&& op) noexcept
  {
    if (this != &op)
    {
      type = op.type;
      switch (type)
      {
        case OperationType::CALLBACK:
          data.callback = op.data.callback;
          break;
        case OperationType::BLOCK:
          data.sem_info.sem = op.data.sem_info.sem;
          data.sem_info.timeout = op.data.sem_info.timeout;
          break;
        case OperationType::POLLING:
          data.status = op.data.status;
          break;
        case OperationType::NONE:
          break;
      }
    }
    return *this;
  }
 
  template <
      typename InitOperation,
      typename = std::enable_if_t<std::is_same_v<std::decay_t<InitOperation>, Operation>>>
  Operation(InitOperation&& op)
  {
    *this = std::forward<InitOperation>(op);
  }
 
  template <typename Status>
  void UpdateStatus(bool in_isr, Status&& status)
  {
    switch (type)
    {
      case OperationType::CALLBACK:
        data.callback->Run(in_isr, std::forward<Status>(status));
        break;
      case OperationType::BLOCK:
        // BLOCK waits are signaled by semaphore only; the owning port keeps the
        // final ErrorCode in its block_result_ handoff state.
        // BLOCK 只通过信号量唤醒；最终 ErrorCode 由端口侧 block_result_ 交接。
        data.sem_info.sem->PostFromCallback(in_isr);
        break;
      case OperationType::POLLING:
        *data.status = (status == ErrorCode::OK) ? OperationPollingStatus::DONE
                                                 : OperationPollingStatus::ERROR;
        break;
      case OperationType::NONE:
        break;
    }
  }
 
  void MarkAsRunning()
  {
    if (type == OperationType::POLLING)
    {
      *data.status = OperationPollingStatus::RUNNING;
    }
  }
 
  union
  {
    Callback* callback;
    struct
    {
      Semaphore* sem;
      uint32_t timeout;
    } sem_info;
    OperationPollingStatus* status;
    // TODO: state
  } data;
 
  OperationType type;
};
 
class AsyncBlockWait
{
 public:
  // Keep the waiter state 32-bit wide so STM32 builds stay within the
  // project-wide atomic shim boundary.
  enum class State : uint32_t
  {
    IDLE = 0,
    PENDING = 1,
    CLAIMED = 2,
    DETACHED = 3,
  };
 
  void Start(Semaphore& sem)
  {
    sem_ = &sem;
    result_ = ErrorCode::OK;
    state_.store(State::PENDING, std::memory_order_release);
  }
 
  void Cancel() { state_.store(State::IDLE, std::memory_order_release); }
 
  ErrorCode Wait(uint32_t timeout)
  {
    ASSERT(sem_ != nullptr);
    auto wait_ans = sem_->Wait(timeout);
    if (wait_ans == ErrorCode::OK)
    {
#ifdef LIBXR_DEBUG_BUILD
      ASSERT(state_.load(std::memory_order_acquire) == State::CLAIMED);
#endif
      state_.store(State::IDLE, std::memory_order_release);
      return result_;
    }
 
    State expected = State::PENDING;
    if (state_.compare_exchange_strong(expected, State::DETACHED,
                                       std::memory_order_acq_rel,
                                       std::memory_order_acquire))
    {
      return ErrorCode::TIMEOUT;
    }
 
    ASSERT(expected == State::CLAIMED || expected == State::DETACHED ||
           expected == State::IDLE);
    if (expected == State::DETACHED)
    {
      state_.store(State::IDLE, std::memory_order_release);
      return ErrorCode::TIMEOUT;
    }
    if (expected == State::IDLE)
    {
      return ErrorCode::TIMEOUT;
    }
 
    auto finish_wait_ans = sem_->Wait(UINT32_MAX);
    UNUSED(finish_wait_ans);
    ASSERT(finish_wait_ans == ErrorCode::OK);
    state_.store(State::IDLE, std::memory_order_release);
    return result_;
  }
 
  bool TryPost(bool in_isr, ErrorCode ec)
  {
    ASSERT(sem_ != nullptr);
 
    State expected = State::PENDING;
    if (!state_.compare_exchange_strong(expected, State::CLAIMED,
                                        std::memory_order_acq_rel,
                                        std::memory_order_acquire))
    {
      ASSERT(expected == State::DETACHED || expected == State::IDLE);
      if (expected == State::DETACHED)
      {
        expected = State::DETACHED;
        (void)state_.compare_exchange_strong(expected, State::IDLE,
                                             std::memory_order_acq_rel,
                                             std::memory_order_acquire);
      }
      return false;
    }
 
    result_ = ec;
    sem_->PostFromCallback(in_isr);
    return true;
  }
 
 private:
  Semaphore* sem_ = nullptr;
  std::atomic<State> state_{State::IDLE};
  ErrorCode result_ = ErrorCode::OK;
};
 
class ReadPort;
class WritePort;
 
typedef Operation<ErrorCode> ReadOperation;
 
typedef Operation<ErrorCode> WriteOperation;
 
typedef ErrorCode (*WriteFun)(WritePort& port, bool in_isr);
 
typedef ErrorCode (*ReadFun)(ReadPort& port, bool in_isr);
 
typedef struct
{
  RawData data;      
  ReadOperation op;  
} ReadInfoBlock;
 
typedef struct
{
  ConstRawData data;  
  WriteOperation op;  
} WriteInfoBlock;
 
class ReadPort
{
 public:
  // Read BLOCK states:
  // PENDING = waiting for queue-fed completion
  // BLOCK_CLAIMED = wakeup now belongs to the waiter
  // BLOCK_DETACHED = timeout/reset detached the waiter
  // The same semaphore may be reused only after the previous BLOCK call
  // returns and the port goes back to IDLE.
  // 读 BLOCK 状态：
  // PENDING = 等待队列侧完成
  // BLOCK_CLAIMED = 唤醒已经归当前 waiter 所有
  // BLOCK_DETACHED = timeout/reset 已把 waiter 分离
  // 同一个信号量只能在上一次 BLOCK 调用返回、端口回到 IDLE 后复用。
  enum class BusyState : uint32_t
  {
    IDLE = 0,     
    PENDING = 1,  
    BLOCK_CLAIMED = 2,   
    BLOCK_DETACHED = 3,  
    EVENT = UINT32_MAX   
  };
 
  ReadFun read_fun_ = nullptr;
  LockFreeQueue<uint8_t>* queue_data_ = nullptr;
  ReadInfoBlock info_;
  std::atomic<BusyState> busy_{BusyState::IDLE};
  ErrorCode block_result_ = ErrorCode::OK;  
 
  ReadPort(size_t buffer_size = 128);
 
  size_t EmptySize();
 
  size_t Size();
 
  bool Readable();
 
  ReadPort& operator=(ReadFun fun);
 
  void Finish(bool in_isr, ErrorCode ans, ReadInfoBlock& info);
 
  void MarkAsRunning(ReadInfoBlock& info);
 
  ErrorCode operator()(RawData data, ReadOperation& op, bool in_isr = false);
 
  virtual void OnRxDequeue(bool) {}
 
  void ProcessPendingReads(bool in_isr);
 
  void Reset();
};
 
class WritePort
{
 public:
  // Write BLOCK states:
  // LOCKED = submit path owns queue mutation
  // BLOCK_WAITING = waiter armed, completion not claimed yet
  // BLOCK_CLAIMED = final wakeup belongs to the waiter
  // BLOCK_DETACHED = timeout/reset detached the waiter
  // The same semaphore may be reused only after the previous BLOCK call
  // returns and the port goes back to IDLE.
  // 写 BLOCK 状态：
  // LOCKED = 提交路径占有队列修改权
  // BLOCK_WAITING = waiter 已挂起，完成尚未 claim
  // BLOCK_CLAIMED = 最终唤醒已经归 waiter 所有
  // BLOCK_DETACHED = timeout/reset 已把 waiter 分离
  // 同一个信号量只能在上一次 BLOCK 调用返回、端口回到 IDLE 后复用。
  enum class BusyState : uint32_t
  {
    LOCKED =
        0,  
    BLOCK_WAITING = 1,  
    BLOCK_CLAIMED =
        2,  
    BLOCK_DETACHED = 3,  
    IDLE = UINT32_MAX    
  };
 
  WriteFun write_fun_ = nullptr;
  LockFreeQueue<WriteInfoBlock>* queue_info_;
  LockFreeQueue<uint8_t>* queue_data_;
  std::atomic<BusyState> busy_{BusyState::IDLE};
  ErrorCode block_result_ = ErrorCode::OK;  
 
  class Stream
  {
   public:
    Stream(LibXR::WritePort* port, LibXR::WriteOperation op);
 
    ~Stream();
 
    Stream& operator<<(const ConstRawData& data);
 
    ErrorCode Commit();
 
   private:
    LibXR::WritePort* port_;    
    LibXR::WriteOperation op_;  
    size_t cap_;                
    size_t size_ = 0;  
    bool locked_ = false;  
  };
 
  WritePort(size_t queue_size = 3, size_t buffer_size = 128);
 
  size_t EmptySize();
 
  size_t Size();
 
  bool Writable();
 
  WritePort& operator=(WriteFun fun);
 
  void Finish(bool in_isr, ErrorCode ans, WriteInfoBlock& info);
 
  void MarkAsRunning(WriteOperation& op);
 
  ErrorCode operator()(ConstRawData data, WriteOperation& op, bool in_isr = false);
 
  void Reset();
 
  ErrorCode CommitWrite(ConstRawData data, WriteOperation& op, bool pushed = false,
                        bool in_isr = false);
};
 
class STDIO
{
 public:
  // NOLINTBEGIN
  static inline ReadPort* read_ = nullptr;    
  static inline WritePort* write_ = nullptr;  
  static inline LibXR::Mutex* write_mutex_ =
      nullptr;  
  static inline LibXR::WritePort::Stream* write_stream_ = nullptr;
#if LIBXR_PRINTF_BUFFER_SIZE > 0
  static inline char
      printf_buff_[LIBXR_PRINTF_BUFFER_SIZE];  
#endif
  // NOLINTEND
 
  static int Printf(const char* fmt, ...);  // NOLINT
};
}  // namespace LibXR