Module dispatcher 

Multi-Kernel Message Dispatcher

This module provides a KernelDispatcher that routes messages by type_id to appropriate handler kernels. It builds on the K2K broker infrastructure to enable type-based message routing across multiple GPU kernels.

Architecture

Host Application
      │
      ▼
┌─────────────────────────────────────────────────┐
│            KernelDispatcher                      │
│  ┌─────────────────────────────────────────┐   │
│  │ Route Table (type_id → kernel_id)       │   │
│  │  1001 → fraud_processor                 │   │
│  │  1002 → aggregator                      │   │
│  │  1003 → pattern_detector                │   │
│  └─────────────────────────────────────────┘   │
│                     │                           │
│                     ▼                           │
│  ┌─────────────────────────────────────────┐   │
│  │            K2K Broker                   │   │
│  └─────────────────────────────────────────┘   │
└─────────────────────────────────────────────────┘
                      │
      ┌───────────────┼───────────────┐
      ▼               ▼               ▼
┌──────────┐   ┌──────────┐   ┌──────────┐
│ Kernel A │   │ Kernel B │   │ Kernel C │
└──────────┘   └──────────┘   └──────────┘

Example

use ringkernel_core::dispatcher::{KernelDispatcher, DispatcherBuilder};
use ringkernel_core::k2k::K2KBroker;

// Create dispatcher with routes
let broker = K2KBroker::new(K2KConfig::default());
let dispatcher = DispatcherBuilder::new()
    .route::<FraudCheckRequest>(KernelId::new("fraud_processor"))
    .route::<AggregateRequest>(KernelId::new("aggregator"))
    .build(broker);

// Dispatch a message (routing determined by type_id)
let envelope = MessageEnvelope::from_message(&fraud_check, clock.now());
let receipt = dispatcher.dispatch(envelope).await?;

Structs

DispatcherBuilder

Builder for creating a KernelDispatcher.

DispatcherConfig

Configuration for the kernel dispatcher.

DispatcherMetrics

Metrics for dispatcher operations.

KernelDispatcher

Routes messages by type_id to registered handler kernels.