Struct IbvBackend 

pub struct IbvBackend<I: IbvDeviceImpl>(pub ActorHandle<IbvManagerActor<I>>);

Wrapper around ActorHandle<IbvManagerActor<I>> that moves the RDMA data-plane (post send/recv, poll CQ) off the actor loop while keeping state-mutating operations (MR registration/deregistration, QP management) serialized through actor messages.

Tuple Fields

0: ActorHandle<IbvManagerActor<I>>

Methods from Deref<Target = ActorHandle<IbvManagerActor<I>>>

pub fn actor_addr(&self) -> &ActorAddr

The ActorAddr of the actor represented by this handle.

pub fn drain_and_stop(&self, reason: &str) -> Result<(), ActorError>

Signal the actor to drain its current messages and then stop.

pub fn stop(&self, reason: &str) -> Result<(), ActorError>

Signal the actor to stop without draining ordinary queued work first.

pub fn kill(&self, reason: &str) -> Result<(), ActorError>

Signal the actor to terminate immediately.

pub fn status(&self) -> Receiver<ActorStatus>

A watch that observes the lifecycle state of the actor.

pub fn port<M>(&self) -> PortHandle<M>

where M: Message, A: Handler<M>,

Return a port for the provided message type handled by the actor.

pub fn try_post<C, M>( &self, cx: &C, message: M, ) -> Result<(), MailboxSenderError>

where C: Actor, M: Message, A: Handler<M>,

Post message to this actor’s handler port for M, returning an error if delivery fails (the actor has stopped, its mailbox is closed, or the underlying channel is disconnected). Unlike Endpoint::post, the caller observes the failure instead of having it reported through the actor’s lost-message channel.

pub fn bind<R>(&self) -> ActorRef<R>

where R: Binds<A>,

TEMPORARY: bind… TODO: we shoudl also have a default binding(?)

Trait Implementations

impl<I: IbvDeviceImpl> Clone for IbvBackend<I>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I: Debug + IbvDeviceImpl> Debug for IbvBackend<I>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I: IbvDeviceImpl> Deref for IbvBackend<I>

type Target = ActorHandle<IbvManagerActor<I>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<I: IbvDeviceImpl> RdmaBackend for IbvBackend<I>

where RdmaRemoteBuffer: ResolveRemoteBackendContext<IbvBackend<I>>,

fn submit<'life0, 'life1, 'async_trait>( &'life0 self, cx: &'life1 (impl 'async_trait + Actor + Send + Sync), ops: Vec<RdmaOp>, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Submit a batch of RDMA operations.

Translates each op to an IbvOp, then ships the whole batch to IbvManagerActor via [SubmitOps]. The manager interleaves local-MR resolution with per-op dispatch: each op is sent to its [QueuePairActor] as a one-item [ProcessOps] the moment its MR is ready, so QP work on op i overlaps MR registration for op i+1.

Always waits for exactly ops.len() per-op replies before returning. Per-op failures are collected and formatted into a single multi-line Err listing each op_idx and its error message.

type RemoteBackendContext = IbvRemoteBackendContext<I>

Serializable per-buffer context carried on the wire.

type TransportInfo = ()

Backend-specific transport details (e.g. a cffi struct with raw ibverbs handles for GPU-initiated RDMA).

fn available() -> bool

Whether this backend is available on this host in the current proc. Returns false if the backend is supported on the host but is disabled by a config.

fn transport_level(&self) -> RdmaTransportLevel

The transport level this backend provides.

fn transport_info(&self) -> Option<Self::TransportInfo>

Low-level transport details for direct control over RDMA operations (e.g. from a GPU kernel).

fn spawn<'life0, 'life1, 'async_trait>( cx: &'life0 (impl 'async_trait + Actor + Send + Sync), config: &'life1 RdmaConfig, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Spawn the backend’s actor(s) as children of cx and return its handle.

fn register_remote_buffer<'life0, 'life1, 'async_trait>( &'life0 self, cx: &'life1 (impl 'async_trait + Actor + Send + Sync), remote_buf_id: usize, local: KeepaliveLocalMemory, ) -> Pin<Box<dyn Future<Output = Result<IbvRemoteBackendContext<I>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Register local for remote access and return its wire context.

fn release_buffer<'life0, 'life1, 'async_trait>( &'life0 self, cx: &'life1 (impl 'async_trait + Actor + Send + Sync), remote_buf_id: usize, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Release a buffer registration by id.