Struct CpuKernel 

pub struct CpuKernel {

    id: KernelId,
    id_num: u64,
    state: RwLock<KernelState>,
    options: LaunchOptions,
    control: RwLock<ControlBlock>,
    telemetry: RwLock<TelemetryBuffer>,
    input_queue: Arc<BoundedQueue>,
    output_queue: Arc<BoundedQueue>,
    clock: Arc<HlcClock>,
    correlation_waiters: Mutex<HashMap<u64, Sender<MessageEnvelope>>>,
    terminate_notify: Notify,
    launched_at: Instant,
    message_counter: AtomicU64,
    k2k_endpoint: Mutex<Option<K2KEndpoint>>,
}

CPU-based kernel implementation.

Fields

id: KernelId

Kernel identifier.

id_num: u64

Numeric ID for message routing.

state: RwLock<KernelState>

Current state.

options: LaunchOptions

Launch options.

control: RwLock<ControlBlock>

Control block.

telemetry: RwLock<TelemetryBuffer>

Telemetry buffer.

input_queue: Arc<BoundedQueue>

Input queue (host -> kernel).

output_queue: Arc<BoundedQueue>

Output queue (kernel -> host).

clock: Arc<HlcClock>

HLC clock.

correlation_waiters: Mutex<HashMap<u64, Sender<MessageEnvelope>>>

Correlation waiters.

terminate_notify: Notify

Termination notifier.

launched_at: Instant

Launch time.

message_counter: AtomicU64

Message counter.

k2k_endpoint: Mutex<Option<K2KEndpoint>>

K2K endpoint for kernel-to-kernel messaging.

Implementations

impl CpuKernel

pub fn new(id: KernelId, options: LaunchOptions, node_id: u64) -> Self

Create a new CPU kernel.

pub fn new_with_k2k( id: KernelId, options: LaunchOptions, node_id: u64, k2k_endpoint: Option<K2KEndpoint>, ) -> Self

Create a new CPU kernel with optional K2K endpoint.

pub fn launch(&self)

Launch the kernel (start processing).

pub fn id(&self) -> &KernelId

Get kernel ID.

pub fn state(&self) -> KernelState

Get current state.

pub fn process_message(&self, envelope: MessageEnvelope) -> Result<()>

Process one message (for testing).

pub fn handle(self: &Arc<Self>) -> KernelHandle

Create a handle to this kernel.

pub fn is_k2k_enabled(&self) -> bool

Check if K2K messaging is enabled for this kernel.

pub async fn k2k_send( &self, destination: KernelId, envelope: MessageEnvelope, ) -> Result<DeliveryReceipt>

Send a K2K message to another kernel.

pub fn k2k_try_recv(&self) -> Option<K2KMessage>

Try to receive a K2K message (non-blocking).

pub async fn k2k_recv(&self) -> Option<K2KMessage>

Receive a K2K message (blocking).

Trait Implementations

impl KernelHandleInner for CpuKernel

fn kernel_id_num(&self) -> u64

Get numeric kernel ID.

fn current_timestamp(&self) -> HlcTimestamp

Get current timestamp.

fn activate<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Activate kernel.

fn deactivate<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Deactivate kernel.

fn terminate<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Terminate kernel.

fn send_envelope<'life0, 'async_trait>( &'life0 self, envelope: MessageEnvelope, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Send message envelope.

fn receive<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<MessageEnvelope>> + Send + 'async_trait>>

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

Receive message.

fn receive_timeout<'life0, 'async_trait>( &'life0 self, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<MessageEnvelope>> + Send + 'async_trait>>

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

Receive with timeout.

fn try_receive(&self) -> Result<MessageEnvelope>

Try receive (non-blocking).

fn receive_correlated<'life0, 'async_trait>( &'life0 self, correlation: CorrelationId, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<MessageEnvelope>> + Send + 'async_trait>>

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

Receive correlated response.

fn status(&self) -> KernelStatus

Get status.

fn metrics(&self) -> KernelMetrics

Get metrics.

fn wait<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Wait for termination.