Struct RealTimeOptimizer 

pub struct RealTimeOptimizer { /* private fields */ }

Real-time performance optimizer.

Drives a single discrete knob — RTOptimizationState::optimization_level — from measured latency behaviour: it escalates while the observed deadline-miss rate is too high, relaxes while there is ample headroom, and reports the improvement it can actually attribute to its last move by comparing the current measured average against the average recorded at the moment that move was made.

Implementations

impl RealTimeOptimizer

pub fn new(config: RealTimeConfig) -> Result<Self>

pub fn observe_latency(&mut self, latency: Duration)

Record one real end-to-end processing latency.

This is what turns the optimizer from a constructed-and-forgotten object into a controller: without observations it has nothing to optimize, and Self::optimize_realtime honestly reports “nothing applied, nothing measured”.

pub fn observe_utilization( &mut self, cpu_utilization: f64, memory_pressure: f64, )

Record the real resource utilisation observed by the caller.

pub fn performance_metrics(&self) -> &RealTimeMetrics

Measured real-time metrics.

pub fn optimization_state(&self) -> &RTOptimizationState

Current optimization state.

pub fn observation_count(&self) -> usize

Number of latency observations recorded so far.

pub fn optimize_realtime( &mut self, latency_budget: Duration, ) -> Result<RTOptimizationResult>

Re-evaluate the real-time optimization level against latency_budget.

The returned figures are measurements, not estimates:

• optimization_applied is true only when this call actually changed the optimization level.
• performance_gain is baseline_avg / current_avg, where the baseline is the measured average at the moment the current level was entered — exactly 1.0 while nothing has been changed yet.
• latency_reduction_ms is the corresponding measured difference, and is negative if the last change made things worse.