Struct ControlHandle 

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

Handle held by the Control Plane (Tokio).

Fields

producer: Producer<Req>

Send requests to the Data Plane.

consumer: Consumer<Rsp>

Receive responses from the Data Plane.

backpressure: Arc<BackpressureController>

Backpressure state for the request queue.

req_wake: Arc<WakePair>

Wakers for the request channel.

rsp_wake: Arc<WakePair>

Wakers for the response channel.

Implementations

impl<Req, Rsp> ControlHandle<Req, Rsp>

pub fn try_send_request(&mut self, req: Req) -> Result<()>

Try to send a request to the Data Plane.

On success, signals the consumer wake eventfd so the TPC core wakes up. Updates backpressure state based on queue utilization.

pub fn try_recv_response(&mut self) -> Result<Rsp>

Try to receive a response from the Data Plane.

On success, signals the producer wake eventfd so the TPC core knows there’s space for more responses.

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

Drain up to max responses into the buffer.

pub fn pressure(&self) -> PressureState

Current backpressure state.

pub fn response_wake_fd(&self) -> RawFd

Raw fd for the response-available signal (register with Tokio’s AsyncFd).

pub fn request_space_fd(&self) -> RawFd

Raw fd for the request-space-available signal.