ReadPort class for handling read operations. More...

#include <libxr_rw.hpp>

Inheritance diagram for LibXR::ReadPort:

Collaboration diagram for LibXR::ReadPort:

Public Types
enum class	BusyState : uint32_t { Idle = 0 , Pending = 1 , Event = 2 }

Public Member Functions
	ReadPort (size_t buffer_size=128)
	Constructs a ReadPort with queue sizes.

virtual size_t	EmptySize ()
	获取队列的剩余可用空间。 Gets the remaining available space in the queue.

virtual size_t	Size ()
	获取当前队列的已使用大小。 Gets the currently used size of the queue.

bool	Readable ()
	Checks if read operations are supported.

ReadPort &	operator= (ReadFun fun)
	赋值运算符重载，用于设置读取函数。 Overloaded assignment operator to set the read function.

void	Finish (bool in_isr, ErrorCode ans, ReadInfoBlock &info, uint32_t size)
	更新读取操作的状态。 Updates the status of the read operation.

void	MarkAsRunning (ReadInfoBlock &info)
	标记读取操作为运行中。 Marks the read operation as running.

ErrorCode	operator() (RawData data, ReadOperation &op)
	读取操作符重载，用于执行读取操作。 Overloaded function call operator to perform a read operation.

virtual void	ProcessPendingReads (bool in_isr)
	Processes pending reads.

virtual void	Reset ()
	Resets the ReadPort.

Data Fields
ReadFun	read_fun_ = nullptr

LockFreeQueue< uint8_t > *	queue_data_ = nullptr

size_t	read_size_ = 0

Mutex	mutex_

ReadInfoBlock	info_

std::atomic< BusyState >	busy_ {BusyState::Idle}

Detailed Description

ReadPort class for handling read operations.

处理读取操作的ReadPort类。

Definition at line 269 of file libxr_rw.hpp.

Member Enumeration Documentation

◆ BusyState

enum class LibXR::ReadPort::BusyState : uint32_t

strong

Definition at line 272 of file libxr_rw.hpp.

  {
    Idle = 0,
    Pending = 1,
    Event = 2
  };

Constructor & Destructor Documentation

◆ ReadPort()

LibXR::ReadPort::ReadPort ( size_t buffer_size = 128 )

inline

Constructs a ReadPort with queue sizes.

以指定队列大小构造ReadPort。

Parameters

queue_size	Number of queued operations.
buffer_size	Size of each buffer.

Definition at line 292 of file libxr_rw.hpp.

      : queue_data_(buffer_size > 0 ? new(std::align_val_t(LIBXR_CACHE_LINE_SIZE))
                                          LockFreeQueue<uint8_t>(buffer_size)
                                    : nullptr)
  {
  }

Member Function Documentation

◆ EmptySize()

virtual size_t LibXR::ReadPort::EmptySize ( )

inlinevirtual

获取队列的剩余可用空间。 Gets the remaining available space in the queue.

该函数返回 queue_block_ 中当前可用的空闲空间大小。 This function returns the size of the available empty space in queue_block_.

Returns: 返回队列的空闲大小（单位：字节）。 Returns the empty size of the queue (in bytes).

Reimplemented in LibXR::ESP32UARTReadPort, and LibXR::TinyUSBUARTReadPort.

Definition at line 309 of file libxr_rw.hpp.

  {
    ASSERT(queue_data_ != nullptr);
    return queue_data_->EmptySize();
  }

◆ Finish()

void LibXR::ReadPort::Finish	(	bool	in_isr,
		ErrorCode	ans,
		ReadInfoBlock &	info,
		uint32_t	size )

inline

更新读取操作的状态。 Updates the status of the read operation.

该函数用于在读取操作过程中更新 read_size_ 并调用 UpdateStatus 方法更新 info.op_ 的状态。 This function updates read_size_ and calls UpdateStatus on info.op_ during a read operation.

Parameters

in_isr	指示是否在中断上下文中执行。 Indicates whether the operation is executed in an interrupt context.
ans	错误码，用于指示操作的结果。 Error code indicating the result of the operation.
info	需要更新状态的 `ReadInfoBlock` 引用。 Reference to the `ReadInfoBlock` whose status needs to be updated.
size	读取的数据大小。 The size of the read data.

Definition at line 371 of file libxr_rw.hpp.

  {
    read_size_ = size;
    busy_.store(BusyState::Idle, std::memory_order_release);
    info.op.UpdateStatus(in_isr, std::forward<ErrorCode>(ans));
  }

◆ MarkAsRunning()

void LibXR::ReadPort::MarkAsRunning ( ReadInfoBlock & info )

inline

标记读取操作为运行中。 Marks the read operation as running.

该函数用于将 info.op_ 标记为运行状态，以指示当前正在进行读取操作。 This function marks info.op_ as running to indicate an ongoing read operation.

Parameters

info	需要更新状态的 `ReadInfoBlock` 引用。 Reference to the `ReadInfoBlock` whose status needs to be updated.

Definition at line 388 of file libxr_rw.hpp.

388{ info.op.MarkAsRunning(); }

◆ operator()()

ErrorCode LibXR::ReadPort::operator()	(	RawData	data,
		ReadOperation &	op )

inline

读取操作符重载，用于执行读取操作。 Overloaded function call operator to perform a read operation.

该函数检查端口是否可读，并根据 data.size_ 和 op 的类型执行不同的操作。 This function checks if the port is readable and performs different actions based on data.size_ and the type of op.

Parameters

data	包含要读取的数据。 Contains the data to be read.
op	读取操作对象，包含操作类型和同步机制。 Read operation object containing the operation type and synchronization mechanism.

Returns: 返回操作的 ErrorCode，指示操作结果。 Returns an ErrorCode indicating the result of the operation.

Definition at line 406 of file libxr_rw.hpp.

  {
    if (Readable())
    {
      mutex_.Lock();
 
      BusyState is_busy = busy_.load(std::memory_order_relaxed);
 
      if (is_busy == BusyState::Pending)
      {
        mutex_.Unlock();
        return ErrorCode::BUSY;
      }
 
      while (true)
      {
        busy_.store(BusyState::Idle, std::memory_order_release);
 
        if (queue_data_ != nullptr)
        {
          auto readable_size = queue_data_->Size();
 
          if (readable_size >= data.size_ && readable_size != 0)
          {
            auto ans = queue_data_->PopBatch(reinterpret_cast<uint8_t *>(data.addr_),
                                             data.size_);
            UNUSED(ans);
            read_size_ = data.size_;
            ASSERT(ans == ErrorCode::OK);
            if (op.type != ReadOperation::OperationType::BLOCK)
            {
              op.UpdateStatus(false, ErrorCode::OK);
            }
            mutex_.Unlock();
            return ErrorCode::OK;
          }
        }
 
        info_ = ReadInfoBlock{data, op};
 
        op.MarkAsRunning();
 
        auto ans = read_fun_(*this);
 
        if (ans != ErrorCode::OK)
        {
          BusyState expected = BusyState::Idle;
          if (busy_.compare_exchange_strong(expected, BusyState::Pending,
                                            std::memory_order_acq_rel,
                                            std::memory_order_acquire))
          {
            break;
          }
          else
          {
            expected = BusyState::Pending;
            continue;
          }
        }
        else
        {
          read_size_ = data.size_;
          if (op.type != ReadOperation::OperationType::BLOCK)
          {
            op.UpdateStatus(false, ErrorCode::OK);
          }
          mutex_.Unlock();
          return ErrorCode::OK;
        }
      }
 
      mutex_.Unlock();
 
      if (op.type == ReadOperation::OperationType::BLOCK)
      {
        return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
      }
      else
      {
        return ErrorCode::OK;
      }
    }
    else
    {
      return ErrorCode::NOT_SUPPORT;
    }
  }

◆ operator=()

ReadPort & LibXR::ReadPort::operator= ( ReadFun fun )

inline

赋值运算符重载，用于设置读取函数。 Overloaded assignment operator to set the read function.

该函数允许使用 ReadFun 类型的函数对象赋值给 ReadPort，从而设置 read_fun_。 This function allows assigning a ReadFun function object to ReadPort, setting read_fun_.

Parameters

fun	要分配的读取函数。 The read function to be assigned.

Returns: 返回自身的引用，以支持链式调用。 Returns a reference to itself for chaining.

Definition at line 348 of file libxr_rw.hpp.

  {
    read_fun_ = fun;
    return *this;
  }

◆ ProcessPendingReads()

virtual void LibXR::ReadPort::ProcessPendingReads ( bool in_isr )

inlinevirtual

Processes pending reads.

处理挂起的读取请求。

Parameters

in_isr 指示是否在中断上下文中执行。 Indicates whether the operation is executed in an interrupt context.

Reimplemented in LibXR::ESP32UARTReadPort, and LibXR::TinyUSBUARTReadPort.

Definition at line 501 of file libxr_rw.hpp.

  {
    ASSERT(queue_data_ != nullptr);
 
    if (in_isr)
    {
      auto is_busy = busy_.load(std::memory_order_relaxed);
 
      if (is_busy == BusyState::Pending)
      {
        if (queue_data_->Size() >= info_.data.size_)
        {
          if (info_.data.size_ > 0)
          {
            auto ans = queue_data_->PopBatch(
                reinterpret_cast<uint8_t *>(info_.data.addr_), info_.data.size_);
            UNUSED(ans);
            ASSERT(ans == ErrorCode::OK);
          }
          Finish(in_isr, ErrorCode::OK, info_, info_.data.size_);
        }
      }
      else if (is_busy == BusyState::Idle)
      {
        busy_.store(BusyState::Event, std::memory_order_release);
      }
    }
    else
    {
      LibXR::Mutex::LockGuard lock_guard(mutex_);
      if (busy_.load(std::memory_order_relaxed) == BusyState::Pending)
      {
        if (queue_data_->Size() >= info_.data.size_)
        {
          if (info_.data.size_ > 0)
          {
            auto ans = queue_data_->PopBatch(
                reinterpret_cast<uint8_t *>(info_.data.addr_), info_.data.size_);
            UNUSED(ans);
            ASSERT(ans == ErrorCode::OK);
          }
          Finish(in_isr, ErrorCode::OK, info_, info_.data.size_);
        }
      }
    }
  }

◆ Readable()

bool LibXR::ReadPort::Readable ( )

inline

Checks if read operations are supported.

检查是否支持读取操作。

Definition at line 333 of file libxr_rw.hpp.

333{ return read_fun_ != nullptr; }

◆ Reset()

virtual void LibXR::ReadPort::Reset ( )

inlinevirtual

Resets the ReadPort.

重置ReadPort。

Reimplemented in LibXR::ESP32UARTReadPort, and LibXR::TinyUSBUARTReadPort.

Definition at line 550 of file libxr_rw.hpp.

  {
    ASSERT(queue_data_ != nullptr);
    Mutex::LockGuard lock_guard(mutex_);
    queue_data_->Reset();
    read_size_ = 0;
  }

◆ Size()

virtual size_t LibXR::ReadPort::Size ( )

inlinevirtual

获取当前队列的已使用大小。 Gets the currently used size of the queue.

该函数返回 queue_block_ 当前已占用的空间大小。 This function returns the size of the space currently used in queue_block_.

Returns: 返回队列的已使用大小（单位：字节）。 Returns the used size of the queue (in bytes).

Reimplemented in LibXR::ESP32UARTReadPort, and LibXR::TinyUSBUARTReadPort.

Definition at line 325 of file libxr_rw.hpp.

  {
    ASSERT(queue_data_ != nullptr);
    return queue_data_->Size();
  }

Field Documentation

◆ busy_

std::atomic<BusyState> LibXR::ReadPort::busy_ {BusyState::Idle}

Definition at line 284 of file libxr_rw.hpp.

284{BusyState::Idle};

◆ info_

ReadInfoBlock LibXR::ReadPort::info_

Definition at line 283 of file libxr_rw.hpp.

◆ mutex_

Mutex LibXR::ReadPort::mutex_

Definition at line 282 of file libxr_rw.hpp.

◆ queue_data_

LockFreeQueue<uint8_t>* LibXR::ReadPort::queue_data_ = nullptr

Definition at line 280 of file libxr_rw.hpp.

◆ read_fun_

ReadFun LibXR::ReadPort::read_fun_ = nullptr

Definition at line 279 of file libxr_rw.hpp.

◆ read_size_

size_t LibXR::ReadPort::read_size_ = 0

Definition at line 281 of file libxr_rw.hpp.

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

src/core/libxr_rw.hpp

Public Types

Public Member Functions

Data Fields

Detailed Description

Member Enumeration Documentation

◆ BusyState

Constructor & Destructor Documentation

◆ ReadPort()

Member Function Documentation

◆ EmptySize()

◆ Finish()

◆ MarkAsRunning()

◆ operator()()

◆ operator=()

◆ ProcessPendingReads()

◆ Readable()

◆ Reset()

◆ Size()

Field Documentation

◆ busy_

◆ info_

◆ mutex_

◆ queue_data_

◆ read_fun_

◆ read_size_