LibXR::AsyncBlockWait Class Reference

同步驱动操作的阻塞等待器 / Blocking waiter for synchronous driver operations. More...

#include <operation.hpp>

Public Types
enum class	State : uint32_t { IDLE = 0 , PENDING = 1 , CLAIMED = 2 , DETACHED = 3 }
	32 位等待状态，兼容 STM32 原子适配 / 32-bit wait state for STM32 atomic support. More...

Public Member Functions
void	Start (Semaphore &sem)
	绑定信号量并开始等待 / Bind a semaphore and start waiting.
void	Cancel ()
	清除等待状态，不发送通知 / Clear the wait state without posting.
ErrorCode	Wait (uint32_t timeout)
	等待完成或超时交接 / Wait for completion or a timeout handoff.
bool	TryPost (bool in_isr, ErrorCode ec)
	尝试认领完成并唤醒调用者 / Try to claim completion and wake the caller.

Detailed Description

同步驱动操作的阻塞等待器 / Blocking waiter for synchronous driver operations.

超时解除调用者的等待，迟到的完成只清退状态，不再唤醒已超时的调用者。 Timeout detaches the caller. A late completion clears the state without waking it.

Definition at line 169 of file operation.hpp.

Member Enumeration Documentation

State

enum class LibXR::AsyncBlockWait::State : uint32_t

strong

32 位等待状态，兼容 STM32 原子适配 / 32-bit wait state for STM32 atomic support.

Enumerator
IDLE	无等待 / No wait.
PENDING	等待完成 / Awaiting completion.
CLAIMED	完成方已认领通知 / Completion notification claimed.
DETACHED	调用者已超时 / Caller timed out.

Definition at line 173 of file operation.hpp.

  {
    IDLE = 0,      
    PENDING = 1,   
    CLAIMED = 2,   
    DETACHED = 3,  
  };

Member Function Documentation

Cancel()

void LibXR::AsyncBlockWait::Cancel ( )

inline

清除等待状态，不发送通知 / Clear the wait state without posting.

Definition at line 193 of file operation.hpp.

{ state_.store(State::IDLE, std::memory_order_release); }

Start()

void LibXR::AsyncBlockWait::Start ( Semaphore & sem )

inline

绑定信号量并开始等待 / Bind a semaphore and start waiting.

Parameters

sem	本次等待使用的信号量 / Semaphore for this wait.

Definition at line 185 of file operation.hpp.

  {
    sem_ = &sem;
    result_ = ErrorCode::OK;
    state_.store(State::PENDING, std::memory_order_release);
  }

TryPost()

bool LibXR::AsyncBlockWait::TryPost ( bool in_isr, ErrorCode ec )

inline

尝试认领完成并唤醒调用者 / Try to claim completion and wake the caller.

Parameters

in_isr	当前是否在中断中 / Whether called in an ISR.
ec	完成结果 / Completion result.

Returns

成功发送通知为 true，调用者已解除等待则为 false。 True when posted, false when the caller is no longer waiting.

Definition at line 250 of file operation.hpp.

  {
    DEV_ASSERT_FROM_CALLBACK(sem_ != nullptr, in_isr);
 
    State expected = State::PENDING;
    if (!state_.compare_exchange_strong(expected, State::CLAIMED,
                                        std::memory_order_acq_rel,
                                        std::memory_order_acquire))
    {
      DEV_ASSERT_FROM_CALLBACK(expected == State::DETACHED || expected == State::IDLE,
                               in_isr);
      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;
  }

Wait()

ErrorCode LibXR::AsyncBlockWait::Wait ( uint32_t timeout )

inline

等待完成或超时交接 / Wait for completion or a timeout handoff.

Parameters

timeout

传给信号量的超时值 / Timeout passed to the semaphore.

Returns

完成结果，或解除等待后的 TIMEOUT / Completion result or detached TIMEOUT.

Note

完成方已认领时，须等对应通知后才返回，可能超过指定时间。 A claimed completion must post before return, possibly exceeding the timeout.

Definition at line 202 of file operation.hpp.

  {
    DEV_ASSERT(sem_ != nullptr);
    auto wait_ans = sem_->Wait(timeout);
    if (wait_ans == ErrorCode::OK)
    {
      DEV_ASSERT(state_.load(std::memory_order_acquire) == State::CLAIMED);
      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;
    }
 
    DEV_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;
    }
 
    ErrorCode finish_wait_ans;
    do
    {
      finish_wait_ans = sem_->Wait(UINT32_MAX);
    } while (finish_wait_ans == ErrorCode::TIMEOUT);
    REQUIRE(finish_wait_ans == ErrorCode::OK);
    state_.store(State::IDLE, std::memory_order_release);
    return result_;
  }

---

The documentation for this class was generated from the following file:

• src/core/rw/operation.hpp