Fix clippy warnings and formatting issues

- Use derive(Default) with #[default] attribute for SizeBucket and QueueTier
- Remove unused std::io::Write import in persistent_fdtd.rs
- Apply cargo fmt formatting fixes across multiple files

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: mivertowski

CHANGELOG.md

@@ -11,6 +11,43 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+#### Multi-Kernel Dispatch and Persistent Message Routing
+
+- **`#[derive(PersistentMessage)]` macro** (`ringkernel-derive`)
+  - Automatic `handler_id` generation for GPU kernel dispatch
+  - Inline payload serialization with response tracking
+  - Compile-time handler registration
+
+- **`KernelDispatcher`** (`ringkernel-core/src/dispatcher.rs`) - **NEW FILE**
+  - Type-based message routing via K2K broker
+  - `DispatcherBuilder` with fluent configuration API
+  - `DispatcherConfig` for routing behavior customization
+  - `DispatcherMetrics` for observability (messages dispatched, errors, latency)
+
+- **CUDA Handler Dispatch Code Generator** (`ringkernel-cuda-codegen/src/ring_kernel.rs`)
+  - `CudaDispatchTable` for handler registration
+  - Switch-based dispatch code generation
+  - `ExtendedH2KMessage` struct generation for typed payloads
+
+- **Queue Tiering System** (`ringkernel-core/src/queue.rs`)
+  - `QueueTier` enum: Small (256), Medium (1024), Large (4096), ExtraLarge (16384)
+  - `QueueFactory` for creating appropriately-sized message queues
+  - `QueueMonitor` for queue health checking with configurable thresholds
+  - `QueueMetrics` for observability (enqueue/dequeue counts, peak depth)
+  - `for_throughput()` method for automatic tier selection based on message rate
+
+- **Persistent Message Infrastructure** (`ringkernel-core/src/persistent_message.rs`) - **NEW FILE**
+  - `PersistentMessage` trait for GPU-dispatchable messages
+  - `DispatchTable` for runtime handler registration
+  - `HandlerId` type for type-safe handler identification
+
+#### CUDA NVRTC Compilation
+
+- **`compile_ptx()` function** (`ringkernel-cuda/src/lib.rs`)
+  - Wraps `cudarc::nvrtc::compile_ptx` for downstream crates
+  - Compile CUDA source to PTX without direct cudarc dependency
+  - Returns PTX string or compilation error
+
 #### Memory Pool Management
 
 - **Size-Stratified Memory Pool** (`ringkernel-core/src/memory.rs`)

README.md

@@ -270,6 +270,54 @@ let buffer = cache.acquire::<f32>(4, ReductionOp::Sum)?;
 // Buffer automatically returned to cache on drop
 ```
 
+### Multi-Kernel Dispatch
+
+Route messages to GPU kernels based on message type:
+
+```rust
+use ringkernel_core::prelude::*;
+
+// Define a persistent message with automatic handler ID
+#[derive(PersistentMessage)]
+struct ComputeTask {
+    data: Vec<f32>,
+}
+
+// Create dispatcher with K2K broker
+let dispatcher = DispatcherBuilder::new(k2k_broker)
+    .with_default_priority(Priority::Normal)
+    .build();
+
+// Dispatch routes to appropriate kernel based on message type
+dispatcher.dispatch(kernel_id, envelope).await?;
+
+// Check metrics
+let metrics = dispatcher.metrics();
+println!("Dispatched: {}, Errors: {}", metrics.messages_dispatched, metrics.errors);
+```
+
+### Queue Tiering
+
+Select queue capacity based on expected throughput:
+
+```rust
+use ringkernel_core::queue::{QueueTier, QueueFactory, QueueMonitor};
+
+// Automatic tier selection based on message rate
+let tier = QueueTier::for_throughput(10_000, 100); // 10k msg/s, 100ms buffer
+// Returns QueueTier::Medium (1024 capacity)
+
+// Manual tier selection
+let queue = QueueFactory::create_spsc(QueueTier::Large); // 4096 capacity
+
+// Monitor queue health
+let monitor = QueueMonitor::new(queue, QueueMonitorConfig::default());
+let health = monitor.check_health();
+println!("Depth: {}, Healthy: {}", health.current_depth, health.is_healthy);
+```
+
+Available tiers: `Small` (256), `Medium` (1024), `Large` (4096), `ExtraLarge` (16384).
+
 ### Kernel-to-Kernel Messaging
 
 Direct communication between kernels:
@@ -335,6 +383,38 @@ struct Matrix4x4 {
 }
 ```
 
+### Domain System
+
+Organize messages by business domain with automatic type ID allocation:
+
+```rust
+use ringkernel::prelude::*;
+
+// 20 predefined domains with reserved type ID ranges
+#[derive(RingMessage)]
+#[message(domain = "FraudDetection")]  // Type IDs 1000-1099
+struct SuspiciousTransaction {
+    #[message(id)]
+    id: MessageId,
+    amount: f64,
+    risk_score: f32,
+}
+
+#[derive(RingMessage)]
+#[message(domain = "ProcessIntelligence")]  // Type IDs 1500-1599
+struct ActivityEvent {
+    #[message(id)]
+    id: MessageId,
+    case_id: u64,
+    activity: String,
+}
+
+// Check domain at runtime
+let domain = Domain::from_type_id(1050);  // Returns Some(Domain::FraudDetection)
+```
+
+Available domains: `GraphAnalytics`, `StatisticalML`, `Compliance`, `RiskManagement`, `OrderMatching`, `MarketData`, `Settlement`, `Accounting`, `NetworkAnalysis`, `FraudDetection`, `TimeSeries`, `Simulation`, `Banking`, `BehavioralAnalytics`, `ProcessIntelligence`, `Clearing`, `TreasuryManagement`, `PaymentProcessing`, `FinancialAudit`, `Custom`.
+
 ## Examples
 
 The repository includes 20+ working examples organized by category:
@@ -410,7 +490,7 @@ See the [Showcase Applications Guide](docs/15-showcase-applications.md) for deta
 ## Testing
 
 ```bash
-# Run all tests (775+ tests)
+# Run all tests (825+ tests)
 cargo test --workspace
 
 # CUDA backend tests (requires NVIDIA GPU)
@@ -577,7 +657,25 @@ Detailed documentation is also available in the `docs/` directory:
 
 ## GPU Code Generation
 
-Write GPU kernels in Rust and transpile them to CUDA C or WGSL. Both transpilers support three kernel types with unified API:
+Write GPU kernels in Rust and transpile them to CUDA C or WGSL. Both transpilers support three kernel types with unified API.
+
+### CUDA PTX Compilation
+
+Compile CUDA source to PTX without directly depending on cudarc:
+
+```rust
+use ringkernel_cuda::compile_ptx;
+
+let cuda_source = r#"
+    extern "C" __global__ void add(float* a, float* b, float* c, int n) {
+        int idx = blockIdx.x * blockDim.x + threadIdx.x;
+        if (idx < n) c[idx] = a[idx] + b[idx];
+    }
+"#;
+
+let ptx = compile_ptx(cuda_source)?;
+// Load PTX into CUDA module and execute
+```
 
 ### Backend Selection
 

crates/ringkernel-core/src/analytics_context.rs

@@ -178,13 +178,20 @@ impl AnalyticsContext {
     /// # Type Parameters
     ///
     /// * `T` - Element type (must be Copy and have a meaningful zero value)
-    pub fn allocate_typed<T: Copy + Default + 'static>(&mut self, count: usize) -> AllocationHandle {
+    pub fn allocate_typed<T: Copy + Default + 'static>(
+        &mut self,
+        count: usize,
+    ) -> AllocationHandle {
         let size = count * std::mem::size_of::<T>();
         let handle = self.allocate(size);
 
         // Track typed allocation
         self.stats.typed_allocations += 1;
-        *self.stats.allocations_by_type.entry(TypeId::of::<T>()).or_insert(0) += 1;
+        *self
+            .stats
+            .allocations_by_type
+            .entry(TypeId::of::<T>())
+            .or_insert(0) += 1;
 
         handle
     }
@@ -337,7 +344,9 @@ impl AnalyticsContextBuilder {
     /// Build the context.
     pub fn build(self) -> AnalyticsContext {
         let mut ctx = match self.expected_allocations {
-            Some(cap) => AnalyticsContext::with_capacity(self.name, cap.max(self.preallocations.len())),
+            Some(cap) => {
+                AnalyticsContext::with_capacity(self.name, cap.max(self.preallocations.len()))
+            }
             None => AnalyticsContext::new(self.name),
         };
 

crates/ringkernel-core/src/dispatcher.rs

@@ -247,12 +247,7 @@ impl KernelDispatcher {
         // Dispatch via K2K broker
         let receipt = self
             .broker
-            .send_priority(
-                source,
-                kernel_id,
-                envelope,
-                self.config.default_priority,
-            )
+            .send_priority(source, kernel_id, envelope, self.config.default_priority)
             .await?;
 
         // Update metrics

crates/ringkernel-core/src/lib.rs

@@ -86,16 +86,16 @@ pub mod prelude {
     };
     pub use crate::context::*;
     pub use crate::control::*;
+    pub use crate::dispatcher::{
+        DispatcherBuilder, DispatcherConfig, DispatcherMetrics, KernelDispatcher,
+    };
     pub use crate::domain::{Domain, DomainMessage, DomainParseError};
     pub use crate::error::*;
     pub use crate::health::{
         BackoffStrategy, CircuitBreaker, CircuitBreakerConfig, CircuitBreakerStats, CircuitState,
         DegradationLevel, DegradationManager, DegradationStats, HealthCheck, HealthCheckResult,
         HealthChecker, HealthStatus, KernelHealth, KernelWatchdog, LoadSheddingPolicy, RetryPolicy,
     };
-    pub use crate::dispatcher::{
-        DispatcherBuilder, DispatcherConfig, DispatcherMetrics, KernelDispatcher,
-    };
     pub use crate::hlc::*;
     pub use crate::k2k::{
         DeliveryStatus, K2KBroker, K2KBuilder, K2KConfig, K2KEndpoint, K2KMessage,

crates/ringkernel-core/src/memory.rs

@@ -324,13 +324,14 @@ pub fn create_pool(
 ///
 /// Provides predefined size classes for efficient multi-size pooling.
 /// Allocations are rounded up to the smallest bucket that fits.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
 pub enum SizeBucket {
     /// Tiny buffers (256 bytes) - metadata, small messages.
     Tiny,
     /// Small buffers (1 KB) - typical message payloads.
     Small,
     /// Medium buffers (4 KB) - page-sized allocations.
+    #[default]
     Medium,
     /// Large buffers (16 KB) - batch operations.
     Large,
@@ -399,12 +400,6 @@ impl SizeBucket {
     }
 }
 
-impl Default for SizeBucket {
-    fn default() -> Self {
-        Self::Medium
-    }
-}
-
 impl std::fmt::Display for SizeBucket {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -442,7 +437,11 @@ impl StratifiedPoolStats {
 
     /// Get hit rate for a specific bucket.
     pub fn bucket_hit_rate(&self, bucket: SizeBucket) -> f64 {
-        let allocs = self.allocations_per_bucket.get(&bucket).copied().unwrap_or(0);
+        let allocs = self
+            .allocations_per_bucket
+            .get(&bucket)
+            .copied()
+            .unwrap_or(0);
         let hits = self.hits_per_bucket.get(&bucket).copied().unwrap_or(0);
         if allocs == 0 {
             0.0
@@ -495,7 +494,10 @@ impl StratifiedMemoryPool {
 
         for bucket in SizeBucket::ALL {
             let pool_name = format!("{}_{}", name, bucket);
-            buckets.insert(bucket, MemoryPool::new(pool_name, bucket.size(), max_buffers_per_bucket));
+            buckets.insert(
+                bucket,
+                MemoryPool::new(pool_name, bucket.size(), max_buffers_per_bucket),
+            );
         }
 
         Self {
@@ -552,7 +554,10 @@ impl StratifiedMemoryPool {
 
     /// Get current size of a specific bucket pool.
     pub fn bucket_size(&self, bucket: SizeBucket) -> usize {
-        self.buckets.get(&bucket).map(|p| p.current_size()).unwrap_or(0)
+        self.buckets
+            .get(&bucket)
+            .map(|p| p.current_size())
+            .unwrap_or(0)
     }
 
     /// Get total buffers currently pooled across all buckets.
@@ -662,7 +667,10 @@ pub fn create_stratified_pool_with_capacity(
     name: impl Into<String>,
     max_buffers_per_bucket: usize,
 ) -> SharedStratifiedPool {
-    Arc::new(StratifiedMemoryPool::with_capacity(name, max_buffers_per_bucket))
+    Arc::new(StratifiedMemoryPool::with_capacity(
+        name,
+        max_buffers_per_bucket,
+    ))
 }
 
 // ============================================================================
@@ -698,7 +706,11 @@ impl std::fmt::Debug for PressureReaction {
         match self {
             Self::None => write!(f, "PressureReaction::None"),
             Self::Shrink { target_utilization } => {
-                write!(f, "PressureReaction::Shrink {{ target_utilization: {} }}", target_utilization)
+                write!(
+                    f,
+                    "PressureReaction::Shrink {{ target_utilization: {} }}",
+                    target_utilization
+                )
             }
             Self::Callback(_) => write!(f, "PressureReaction::Callback(<fn>)"),
         }
@@ -1006,9 +1018,9 @@ mod tests {
         let pool = StratifiedMemoryPool::new("test");
 
         // Allocate different sizes
-        let buf1 = pool.allocate(100);   // Tiny
-        let buf2 = pool.allocate(500);   // Small
-        let buf3 = pool.allocate(2000);  // Medium
+        let buf1 = pool.allocate(100); // Tiny
+        let buf2 = pool.allocate(500); // Small
+        let buf3 = pool.allocate(2000); // Medium
 
         assert_eq!(buf1.bucket(), SizeBucket::Tiny);
         assert_eq!(buf2.bucket(), SizeBucket::Small);
@@ -1046,14 +1058,20 @@ mod tests {
         let pool = StratifiedMemoryPool::new("test");
 
         // Allocate from different buckets
-        let _buf1 = pool.allocate(100);  // Tiny
-        let _buf2 = pool.allocate(500);  // Small
-        let _buf3 = pool.allocate(100);  // Tiny again
+        let _buf1 = pool.allocate(100); // Tiny
+        let _buf2 = pool.allocate(500); // Small
+        let _buf3 = pool.allocate(100); // Tiny again
 
         let stats = pool.stats();
         assert_eq!(stats.total_allocations, 3);
-        assert_eq!(stats.allocations_per_bucket.get(&SizeBucket::Tiny), Some(&2));
-        assert_eq!(stats.allocations_per_bucket.get(&SizeBucket::Small), Some(&1));
+        assert_eq!(
+            stats.allocations_per_bucket.get(&SizeBucket::Tiny),
+            Some(&2)
+        );
+        assert_eq!(
+            stats.allocations_per_bucket.get(&SizeBucket::Small),
+            Some(&1)
+        );
     }
 
     #[test]
@@ -1173,7 +1191,9 @@ mod tests {
         let none = PressureReaction::None;
         assert!(format!("{:?}", none).contains("None"));
 
-        let shrink = PressureReaction::Shrink { target_utilization: 0.5 };
+        let shrink = PressureReaction::Shrink {
+            target_utilization: 0.5,
+        };
         assert!(format!("{:?}", shrink).contains("0.5"));
 
         let callback = PressureReaction::Callback(Box::new(|_| {}));

crates/ringkernel-core/src/persistent_message.rs

@@ -256,9 +256,7 @@ mod tests {
 
         table.register(HandlerRegistration::new(1, "fraud_check", 1001));
         table.register(HandlerRegistration::new(2, "aggregate", 1002));
-        table.register(
-            HandlerRegistration::new(3, "pattern_detect", 1003).with_response(2003),
-        );
+        table.register(HandlerRegistration::new(3, "pattern_detect", 1003).with_response(2003));
 
         assert_eq!(table.len(), 3);
         assert_eq!(table.max_handler_id(), 3);