Struct EventDrivenOptimizer 

pub struct EventDrivenOptimizer<T: Float + Debug + Send + Sync + 'static> { /* private fields */ }

Event-driven optimizer

Implementations

impl<T: Float + Debug + Send + Sync + 'static + Sum + ScalarOperand + AddAssign> EventDrivenOptimizer<T>

pub fn new( config: EventDrivenConfig<T>, stdp_config: STDPConfig<T>, membrane_config: MembraneDynamicsConfig<T>, num_neurons: usize, ) -> Self

Create a new event-driven optimizer

pub fn enqueue_event(&mut self, event: NeuromorphicEvent<T>) -> Result<()>

Add event to the processing queue.

With config.event_compression enabled the event is compressed to bytes here and only those bytes are retained (F57): the live queue really does store compressed frames instead of whole events, and the event is reconstructed lazily in Self::pop_next_event when it is about to be processed.

pub fn process_events(&mut self) -> Result<usize>

Process events from the queue

pub fn get_event_statistics(&self) -> &HashMap<EventType, EventStatistics<T>>

Get event processing statistics

pub fn get_system_state(&self) -> &SystemState<T>

Get current system state

pub fn get_metrics(&self) -> &NeuromorphicMetrics<T>

Get current metrics

pub fn clear_event_queue(&mut self)

Clear event queue, including any compressed frames still pending.

pub fn get_queue_size(&self) -> usize

Get queue size: events waiting in the in-memory priority queue plus events waiting as compressed frames.

pub fn compressed_queue_bytes(&self) -> usize

Bytes currently occupied by the compressed event queue (F57). Zero while config.event_compression is disabled, since nothing is stored in compressed form then.

pub fn compression_statistics(&self) -> (usize, usize)

Cumulative (uncompressed_bytes, compressed_bytes) measured across every event that has entered the compressed queue since construction. The uncompressed figure is the size the same event occupies under the reference (EventCompressionAlgorithm::None) codec, so the pair is a direct measurement of what compression actually achieved.

pub fn compression_ratio(&self) -> Option<f64>

Achieved compression ratio (compressed / uncompressed); None until at least one event has been compressed.

pub fn last_measured_event_rate(&self) -> Option<T>

The most recent measured event-processing rate (events per second) recorded by Self::process_events, or None if no interval long enough to be measurable has been observed yet. Always finite: the previous implementation divided the processed count by an integer millisecond count, which is zero for any batch finishing inside one clock tick, feeding inf/NaN into the adaptive handler.

pub fn current_adaptation_factor(&self) -> T

The adaptation factor currently chosen by the adaptive event handler from the measured event-processing rate history (0.5 while throughput is degrading, 1.0 while it is stable, 1.5 while it is improving).

pub fn adaptive_batch_size(&self) -> usize

Effective per-iteration batch size: the configured batch_size scaled by Self::current_adaptation_factor, so a system whose measured throughput is improving takes larger bites and one that is degrading takes smaller ones. Never zero.

pub fn event_correlation(&self, first: EventType, second: EventType) -> T

Measured temporal correlation between two event types, as accumulated by the correlation tracker over the configured correlation window.

The tracker genuinely computes and stores these strengths; before this accessor existed there was no way to read any of them back.

pub fn worker_loads(&self) -> Option<Vec<(usize, T)>>

Per-worker event counts recorded by the distributed coordinator, or None when distributed processing is disabled.

pub fn enable_distributed_processing(&mut self, num_workers: usize)

Enable distributed processing

pub fn disable_distributed_processing(&mut self)

Disable distributed processing