LibXR::AsyncBlockWait Class Reference

Shared BLOCK waiter handoff for synchronous driver operations. More...

#include <operation.hpp>

Collaboration diagram for LibXR::AsyncBlockWait:

Public Types
enum class	State : uint32_t { IDLE = 0 , PENDING = 1 , CLAIMED = 2 , DETACHED = 3 }

Public Member Functions
void	Start (Semaphore &sem)
void	Cancel ()
ErrorCode	Wait (uint32_t timeout)
bool	TryPost (bool in_isr, ErrorCode ec)

Private Attributes
Semaphore *	sem_ = nullptr
std::atomic< State >	state_ {State::IDLE}
ErrorCode	result_ = ErrorCode::OK

Detailed Description

Shared BLOCK waiter handoff for synchronous driver operations.

Timeout detaches the waiting caller. A late completion may still clear the in-flight state, but it no longer belongs to that timed-out caller.

Definition at line 234 of file operation.hpp.

Member Enumeration Documentation

State

enum class LibXR::AsyncBlockWait::State : uint32_t

strong

Definition at line 239 of file operation.hpp.

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

Member Function Documentation

Cancel()

void LibXR::AsyncBlockWait::Cancel ( )

inline

Definition at line 254 of file operation.hpp.

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

Start()

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

inline

Definition at line 247 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

Definition at line 296 of file operation.hpp.

  {
    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;
  }

Wait()

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

inline

Definition at line 256 of file operation.hpp.

  {
    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_;
  }

Field Documentation

result_

ErrorCode LibXR::AsyncBlockWait::result_ = ErrorCode::OK

private

Definition at line 323 of file operation.hpp.

sem_

Semaphore* LibXR::AsyncBlockWait::sem_ = nullptr

private

Definition at line 321 of file operation.hpp.

state_

std::atomic<State> LibXR::AsyncBlockWait::state_ {State::IDLE}

private

Definition at line 322 of file operation.hpp.

{State::IDLE};

---

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

• src/core/rw/operation.hpp