Struct KernelDispatcher 

pub struct KernelDispatcher {
    routes: RwLock<RawRwLock, HashMap<u64, KernelId>>,
    handler_tables: RwLock<RawRwLock, HashMap<KernelId, DispatchTable>>,
    broker: Arc<K2KBroker>,
    config: DispatcherConfig,
    metrics: RwLock<RawRwLock, DispatcherMetrics>,
}

Routes messages by type_id to registered handler kernels.

The dispatcher maintains a routing table mapping message type IDs to kernel IDs. When a message envelope is dispatched, the dispatcher looks up the type_id in the routing table and forwards the message to the appropriate kernel via the K2K broker.

Fields

routes: RwLock<RawRwLock, HashMap<u64, KernelId>>

handler_tables: RwLock<RawRwLock, HashMap<KernelId, DispatchTable>>

broker: Arc<K2KBroker>

config: DispatcherConfig

metrics: RwLock<RawRwLock, DispatcherMetrics>

Implementations

impl KernelDispatcher

pub fn builder() -> DispatcherBuilder

Create a new dispatcher builder.

pub fn new(broker: Arc<K2KBroker>) -> KernelDispatcher

Create a new dispatcher with the given broker.

pub fn with_config( broker: Arc<K2KBroker>, config: DispatcherConfig, ) -> KernelDispatcher

Create a new dispatcher with custom configuration.

pub fn register<M>(&self, kernel_id: KernelId) -> Result<(), RingKernelError>

where M: PersistentMessage,

Register a message type to route to a specific kernel.

Type Parameters

• M: A message type implementing PersistentMessage

Arguments

• kernel_id: The kernel that will handle messages of this type

pub fn register_with_name<M>( &self, kernel_id: KernelId, handler_name: &str, ) -> Result<(), RingKernelError>

where M: PersistentMessage,

Register a message type with a custom handler name.

pub fn register_route(&self, type_id: u64, kernel_id: KernelId)

Register a route with explicit type_id (for dynamic registration).

pub fn unregister(&self, type_id: u64)

Unregister a message type.

pub fn get_route(&self, type_id: u64) -> Option<KernelId>

Get the kernel ID for a message type.

pub fn has_route(&self, type_id: u64) -> bool

Check if a route exists for a type.

pub fn routes(&self) -> Vec<(u64, KernelId)>

Get all registered routes.

pub fn get_dispatch_table(&self, kernel_id: &KernelId) -> Option<DispatchTable>

Get the dispatch table for a kernel (for CUDA codegen).

pub async fn dispatch( &self, envelope: MessageEnvelope, ) -> Result<DeliveryReceipt, RingKernelError>

Dispatch a message envelope to the appropriate kernel.

The type_id from the envelope header is used to look up the destination kernel. If no route exists for the type_id, returns an error.

Returns

• Ok(DeliveryReceipt) with delivery status
• Err(RingKernelError::UnknownMessageType) if no route exists

pub async fn dispatch_from( &self, source: KernelId, envelope: MessageEnvelope, ) -> Result<DeliveryReceipt, RingKernelError>

Dispatch a message from a specific source kernel.

pub async fn dispatch_message<M>( &self, message: &M, timestamp: HlcTimestamp, ) -> Result<DeliveryReceipt, RingKernelError>

where M: PersistentMessage,

Dispatch a typed message.

Creates an envelope from the message and dispatches it.

pub fn metrics(&self) -> DispatcherMetrics

Get current metrics.

pub fn reset_metrics(&self)

Reset metrics.

pub fn broker(&self) -> &Arc<K2KBroker>

Get a reference to the underlying K2K broker.