Struct AdvancedProcessor 

pub struct AdvancedProcessor { /* private fields */ }

Advanced graph-processing processor: real timing/memory instrumentation plus (optionally) adaptive candidate-operation selection.

Implementations

impl AdvancedProcessor

pub fn new(config: AdvancedConfig) -> Self

Create a new advanced processor

pub fn execute<N, E, Ix, T, F>( &mut self, graph: &Graph<N, E, Ix>, operation: F, ) -> Result<T>

where N: Node + Debug, E: EdgeWeight, Ix: IndexType, F: FnOnce(&Graph<N, E, Ix>) -> Result<T>,

Execute advanced graph processing.

Wraps operation with genuine wall-clock timing and a real (structural) memory estimate; both feed Self::get_optimization_stats. Always runs operation on the CPU – see the module docs for why there is no GPU/neuromorphic dispatch path for an opaque closure.

pub fn execute_profiled<N, E, Ix, T, F>( &mut self, graph: &Graph<N, E, Ix>, operation: F, ) -> Result<T>

where N: Node + Debug, E: EdgeWeight, Ix: IndexType, F: FnOnce(&Graph<N, E, Ix>) -> Result<T>,

Like Self::execute, but additionally measures REAL operating-system process memory (peak resident-set size) while operation runs, via background-thread sampling (crate::memory::AdvancedMemoryAnalyzer). This is strictly more accurate than the structural estimate execute uses, at the cost of spawning a monitoring thread per call – prefer execute in hot loops or over many small graphs.

pub fn execute_adaptive<N, E, Ix, T>( &mut self, graph: &Graph<N, E, Ix>, candidates: &[CandidateOp<N, E, Ix, T>], ) -> Result<T>

where N: Node + Debug, E: EdgeWeight, Ix: IndexType,

Executes the best-performing of several candidate implementations of the same operation, per this processor’s adaptive (bandit-RL) selection policy (NeuralRLAgent), and feeds the observed latency back in as a reward so future calls keep adapting. This is the genuine “RL-driven algorithm selection” the module docs describe: candidates[i] are, e.g., different algorithm implementations or parameter choices for the same task; over repeated calls the agent learns which one tends to be fastest for this workload and increasingly favors it, while still exploring the others per the configured ExplorationStrategy.

pub fn get_performance_report(&self) -> SimplePerformanceReport

Get performance report

pub fn get_optimization_stats(&self) -> AdvancedStats

Get optimization statistics, genuinely accumulated from every execute/execute_profiled/execute_adaptive call made so far (starts at AdvancedStats::default before the first call).

pub fn gpu_context(&self) -> &GPUAccelerationContext

Real GPU hardware-availability context, computed via GPUAccelerationContext::detect when this processor was constructed with enable_gpu_acceleration set (an honest GPUAccelerationContext::default otherwise).

pub fn rl_agent(&self) -> &NeuralRLAgent

The adaptive (bandit-RL) agent backing Self::execute_adaptive.

pub fn rl_agent_mut(&mut self) -> &mut NeuralRLAgent

Mutable access to the adaptive agent, e.g. to swap its ExplorationStrategy.