Struct DataHandle 

pub struct DataHandle<Req, Rsp> {
    pub consumer: Consumer<Req>,
    pub producer: Producer<Rsp>,
    pub backpressure: Arc<BackpressureController>,
    pub req_wake: Arc<WakePair>,
    pub rsp_wake: Arc<WakePair>,
}

Handle held by the Data Plane (TPC core).

This type is Send so it can be transferred to a TPC core during setup. Call .pin() once on the target core to get a PinnedDataHandle which is !Send — enforcing at compile time that it stays on that core forever.

Fields

consumer: Consumer<Req>

Receive requests from the Control Plane.

producer: Producer<Rsp>

Send responses back to the Control Plane.

backpressure: Arc<BackpressureController>

Backpressure state for the request queue (read-only from Data Plane).

req_wake: Arc<WakePair>

Wakers for the request channel.

rsp_wake: Arc<WakePair>

Wakers for the response channel.

Implementations

impl<Req, Rsp> DataHandle<Req, Rsp>

pub fn pin(self) -> PinnedDataHandle<Req, Rsp>

Pin this handle to the current TPC core.

Returns a PinnedDataHandle which is !Send — the compiler will reject any attempt to move it to another thread.

Call this exactly once, on the target TPC core, during setup.

pub fn try_recv_request(&mut self) -> Result<Req>

Try to receive a request from the Control Plane.

pub fn drain_requests(&mut self, buf: &mut Vec<Req>, max: usize) -> usize

Drain up to max requests into the buffer.

pub fn try_send_response(&mut self, rsp: Rsp) -> Result<()>

Try to send a response back to the Control Plane.

pub fn pressure(&self) -> PressureState

Current backpressure state (read by Data Plane to decide I/O depth).

pub fn should_throttle(&self) -> bool

Whether the Data Plane should reduce read depth.

pub fn should_suspend(&self) -> bool

Whether the Data Plane should suspend new reads entirely.

pub fn request_wake_fd(&self) -> RawFd

Raw fd for the request-available signal (register with TPC event loop).

pub fn response_space_fd(&self) -> RawFd

Raw fd for the response-space-available signal.