Struct RdmaManagerActor

pub struct RdmaManagerActor { /* private fields */ }

Trait Implementations

impl Actor for RdmaManagerActor

type Params = IbverbsConfig

The type of initialization parameters accepted by this actor.

fn new<'async_trait>( _params: Self::Params, ) -> Pin<Box<dyn Future<Output = Result<Self, Error>> + Send + 'async_trait>>

where Self: 'async_trait,

Creates a new actor instance given its instantiation parameters.

fn handle_supervision_event<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _cx: &'life1 Instance<Self>, _event: &'life2 ActorSupervisionEvent, ) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>

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

Handle actor supervision event. Return `Ok(true)`` if the event is handled here.

fn init<'life0, 'life1, 'async_trait>( &'life0 mut self, _this: &'life1 Instance<Self>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Initialize the actor, after the runtime has been fully initialized. Init thus provides a mechanism by which an actor can reliably and always receive some initial event that can be used to kick off further (potentially delayed) processing.

fn spawn<'life0, 'async_trait>( cap: &'life0 (impl CanSpawn + 'async_trait), params: Self::Params, ) -> Pin<Box<dyn Future<Output = Result<ActorHandle<Self>, Error>> + Send + 'async_trait>>

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

Spawn a child actor, given a spawning capability (usually given by Instance). The spawned actor will be supervised by the parent (spawning) actor.

fn spawn_detached<'async_trait>( params: Self::Params, ) -> Pin<Box<dyn Future<Output = Result<ActorHandle<Self>, Error>> + Send + 'async_trait>>

where Self: 'async_trait,

Spawns this actor in a detached state, handling its messages in a background task. The returned handle is used to control the actor’s lifecycle and to interact with it.

fn spawn_server_task<F>(future: F) -> JoinHandle<<F as Future>::Output>

where F: Future + Send + 'static, <F as Future>::Output: Send + 'static,

This method is used by the runtime to spawn the actor server. It can be used by actors that require customized runtime setups (e.g., dedicated actor threads), or want to use a custom tokio runtime.

fn handle_undeliverable_message<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Instance<Self>, __arg2: Undeliverable<MessageEnvelope>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Default undeliverable message handling behavior.

impl Binds<RdmaManagerActor> for RdmaManagerActor

fn bind(ports: &Ports<Self>)

Bind ports in this actor.

impl Debug for RdmaManagerActor

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

Formats the value using the given formatter.

impl Handler<RdmaManagerMessage> for RdmaManagerActor

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, message: RdmaManagerMessage, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Handle the next M-typed message.

impl Named for RdmaManagerActor

fn typename() -> &'static str

The globally unique type name for the type. This should typically be the fully qualified Rust name of the type.

fn typehash() -> u64

A globally unique hash for this type. TODO: actually enforce perfect hashing

fn typeid() -> TypeId

The TypeId for this type. TypeIds are unique only within a binary, and should not be used for global identification.

fn port() -> u64

The globally unique port for this type. Typed ports are in the range of 1<<63..1<<64-1.

fn arm(&self) -> Option<&'static str>

If the named type is an enum, this returns the name of the arm of the value self.

unsafe fn arm_unchecked(self_: *const ()) -> Option<&'static str>

An unsafe version of ‘arm’, accepting a pointer to the value, for use in type-erased settings.

impl RdmaManagerMessageHandler for RdmaManagerActor

fn request_buffer<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, addr: usize, size: usize, ) -> Pin<Box<dyn Future<Output = Result<RdmaBuffer, Error>> + Send + 'async_trait>>

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

Requests a buffer to be registered with the RDMA domain.

This function registers a memory region with the RDMA domain and returns an RdmaBuffer that encapsulates the necessary information for RDMA operations.

Arguments

• this - The context of the actor requesting the buffer.
• addr - The starting address of the memory region to be registered.
• size - The size of the memory region to be registered.

Returns

• Result<RdmaBuffer, anyhow::Error> - On success, returns an RdmaBuffer containing the registered memory region’s details. On failure, returns an error.

fn release_buffer<'life0, 'life1, 'async_trait>( &'life0 mut self, _cx: &'life1 Context<'_, Self>, buffer: RdmaBuffer, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Deregisters a buffer from the RDMA domain.

This function removes the specified RdmaBuffer from the RDMA domain, effectively releasing the resources associated with it.

Arguments

• _this - The context of the actor releasing the buffer.
• buffer - The RdmaBuffer to be deregistered.

Returns

• Result<(), anyhow::Error> - On success, returns Ok(()). On failure, returns an error.

fn request_queue_pair<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, remote: ActorRef<RdmaManagerActor>, ) -> Pin<Box<dyn Future<Output = Result<RdmaQueuePair, Error>> + Send + 'async_trait>>

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

Requests a queue pair for communication with a remote RDMA manager actor.

This function checks if a connection already exists with the specified remote actor. If not, it initializes a new queue pair and establishes a connection with the remote actor. It then retrieves the queue pair associated with the remote actor for communication.

Arguments

• this - The context of the actor requesting the queue pair.
• remote - The ActorRef of the remote RDMA manager actor to communicate with.

Returns

• Result<RdmaQueuePair, anyhow::Error> - On success, returns the queue pair for communication. On failure, returns an error.

fn initialize_qp<'life0, 'life1, 'async_trait>( &'life0 mut self, _cx: &'life1 Context<'_, Self>, other: ActorRef<RdmaManagerActor>, ) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>

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

Convenience utility to create a new RdmaQueuePair.

This function initializes a new RDMA connection with another actor if one doesn’t already exist. It creates a new RdmaQueuePair associated with the specified actor ID and adds it to the connection map.

Arguments

• other - The ActorRef of the remote actor to connect with

fn is_connected<'life0, 'life1, 'async_trait>( &'life0 mut self, _cx: &'life1 Context<'_, Self>, other: ActorRef<RdmaManagerActor>, ) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>

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

Checks if a connection exists with another actor.

Arguments

• other - The ActorRef of the actor to check the connection with.

Returns

• bool - Returns true if connected, false otherwise.

fn connect<'life0, 'life1, 'async_trait>( &'life0 mut self, _cx: &'life1 Context<'_, Self>, other: ActorRef<RdmaManagerActor>, endpoint: RdmaQpInfo, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Establishes a connection with another actor

Arguments

• other - The ActorRef of the actor to connect to
• endpoint - Connection information needed to establish the RDMA connection

fn connection_info<'life0, 'life1, 'async_trait>( &'life0 mut self, _cx: &'life1 Context<'_, Self>, other: ActorRef<RdmaManagerActor>, ) -> Pin<Box<dyn Future<Output = Result<RdmaQpInfo, Error>> + Send + 'async_trait>>

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

Gets connection information for establishing an RDMA connection

Arguments

• other - The ActorRef to get connection info for

Returns

• RdmaQpInfo - Connection information needed for the RDMA connection

fn handle<'life0, 'life1, 'async_trait>( &'life0 mut self, cx: &'life1 Context<'_, Self>, message: RdmaManagerMessage, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Handle the next message.

impl RemoteActor for RdmaManagerActor

impl RemoteHandles<RdmaManagerMessage> for RdmaManagerActor

impl RemoteHandles<Signal> for RdmaManagerActor