Struct RuntimeInner 

pub struct RuntimeInner<D>
where
    D: Driver<Triad>,
{ /* private fields */ }

Implementations

impl<D> RuntimeInner<D>

where D: Driver<Triad>,

pub fn new() -> Self

Create a new runtime

pub fn fragment(&self) -> &FragTonnetz<D>

Get a reference to the fragment

pub fn fragment_mut(&mut self) -> &mut FragTonnetz<D>

Get a mutable reference to the fragment

pub fn orchestrator(&self) -> &Orchestrator

Get a reference to the orchestrator

pub fn orchestrator_mut(&mut self) -> &mut Orchestrator

returns a mutable reference to the orchestrator

pub const fn perf_tracker(&self) -> &PerformanceTracker

returns an immutable reference to the performance tracker

pub fn perf_tracker_mut(&mut self) -> &mut PerformanceTracker

returns a mutable reference to the performance tracker

pub fn performance_trend_report(&self) -> String

Get a performance trend report

pub const fn scheduler(&self) -> &Scheduler

returns a reference to the scheduler

pub fn scheduler_mut(&mut self) -> &mut Scheduler

returns a mutable reference to the scheduler

pub const fn system_info(&self) -> &SystemInfo

returns an immutable reference to the system’s info

pub fn system_info_mut(&mut self) -> &mut SystemInfo

returns a mutable reference to the system’s info

pub fn task_queue(&self) -> &[Task]

returns a reference to the tasks stored in the scheduler

pub fn task_queue_mut(&mut self) -> &mut Vec<Task>

returns a mutable reference to the task queue within the scheduler

pub fn vnodes(&self) -> &HashMap<EdgeId, VNode<D>>

returns an immutable reference to the initialized virtual node’s

pub fn vnodes_mut(&mut self) -> &mut HashMap<EdgeId, VNode<D>>

returns a mutable reference to the initialized virtual nodes

pub fn set_fragment(&mut self, fragment: FragTonnetz<D>)

set the runtimes fragment to the given value

pub fn set_orchestrator(&mut self, orchestrator: Orchestrator)

set the runtime’s orchestrator

pub fn set_scheduler(&mut self, scheduler: Scheduler)

set the runtime’s scheduler

pub fn with_fragment(self, fragment: FragTonnetz<D>) -> Self

consumes the current instance to create another with the given fragment

pub fn with_orchestrator(self, orchestrator: Orchestrator) -> Self

consumes the current instance to create another with the given orchestrator

pub fn with_scheduler(self, scheduler: Scheduler) -> Self

consumes the current instance to create another with the given scheduler

pub fn update_performance_metrics(&mut self)

Update performance tracking with current metrics

impl<D> RuntimeInner<D>

where D: Driver<Triad>,

pub fn adaptive_schedule(&mut self) -> Result<(), RuntimeError>

where D: TriadDriver,

Adaptive task scheduling based on system resources and task performance history

pub fn add_triad(&mut self, triad: Triad) -> Result<EdgeId, RuntimeError>

Add a triad to the fragment

pub fn auto_configure(&mut self) -> Result<(), RuntimeError>

Auto-configure the runtime based on available system resources

pub fn completed_tasks(&self) -> Vec<&Task>

pub fn coordinate_distributed_learning(&mut self) -> Result<usize, RuntimeError>

where D: TriadDriver,

Coordinate distributed learning with gradient sharing

pub fn coordinate_knowledge_transfer(&mut self) -> Result<(), RuntimeError>

where D: TriadDriver,

Coordinate knowledge sharing between surface networks

pub fn coordinate_learning(&mut self) -> Result<(), RuntimeError>

where D: TriadDriver,

coordinate learning between nodes

pub fn execute_task(&mut self, task_id: usize) -> Result<(), RuntimeError>

where D: TriadDriver,

executes the task associated with the given identitifier

pub fn execute_tasks(&mut self) -> Result<(), RuntimeError>

where D: TriadDriver,

Execute tasks in the queue

pub fn get_vnode(&self, id: &EdgeId) -> Option<&VNode<D>>

returns an immutable reference to the node with the given identifier; if any

pub fn get_vnode_mut(&mut self, id: &EdgeId) -> Option<&mut VNode<D>>

returns a mutable reference to the partition with the given identifier; if any

pub fn init_complete_layer(&mut self) -> Result<(), RuntimeError>

Initialize the runtime with major and minor triads

pub fn init_node_surfaces(&mut self) -> Result<(), RuntimeError>

where D: TriadDriver,

Initialize surface networks for all nodes in the fragment

pub fn init_specialized_surfaces(&mut self) -> Result<(), RuntimeError>

where D: TriadDriver,

Initialize surface networks with class-specific tuning

pub fn optimize_memory_allocation(&mut self) -> Result<(), RuntimeError>

where D: TriadDriver,

Optimize memory allocation across nodes

pub fn optimize_surface_networks(&mut self) -> Result<(), RuntimeError>

where D: TriadDriver,

Optimize the surface networks across all nodes

pub fn predict_task_resources(&self, task_type: &TaskType) -> (f32, f32)

Get predicted resource requirements for a task

pub fn predictive_schedule( &mut self, look_ahead_ms: u64, ) -> Result<(), RuntimeError>

where D: TriadDriver,

Schedule tasks using predictive resource management

pub fn prioritize_tonnetz_tasks(&mut self) -> Result<(), RuntimeError>

where D: TriadDriver,

Prioritize tasks based on observer position in Tonnetz space

pub fn process_messages(&mut self) -> Result<(), RuntimeError>

where D: TriadDriver,

Process messages between nodes

pub fn run_maintenance(&mut self) -> Result<Vec<usize>, RuntimeError>

where D: TriadDriver,

Run maintenance including knowledge coordination

pub fn runtime_metrics(&self) -> ResourceMetrics

Get detailed resource metrics

pub fn schedule_knowledge_transfer(&mut self, priority: usize) -> usize

Schedule a knowledge transfer task with the given priority

pub fn schedule_memory_optimization(&mut self) -> Result<usize, RuntimeError>

Schedule memory optimization based on current memory usage

pub fn schedule_task(&mut self, task_type: TaskType, priority: usize) -> usize

Schedule a task for execution

pub fn system_health_report(&self) -> String

Generate a comprehensive system health report with performance insights

pub fn tune_surface_networks(&mut self) -> Result<(), RuntimeError>

where D: TriadDriver,

Tune surface network parameters based on node performance

pub fn voice_leading_distance( &self, from: &EdgeId, to: &EdgeId, ) -> Option<usize>

compute the vocal leading distance between two facets; see voice_leading_distance for more information

Trait Implementations

impl<D> Clone for RuntimeInner<D>

where D: Driver<Triad> + Clone,

fn clone(&self) -> RuntimeInner<D>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<D> Debug for RuntimeInner<D>

where D: Driver<Triad> + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<D> Default for RuntimeInner<D>

where D: Driver<Triad>,

fn default() -> Self

Returns the “default value” for a type.

impl<D> Execute<usize> for RuntimeInner<D>

where D: TriadDriver,

type Output = Result<(), RuntimeError>

fn execute(self, rhs: usize) -> Self::Output

impl<D> ExecuteMut<usize> for RuntimeInner<D>

where D: TriadDriver,

type Output = Result<(), RuntimeError>

fn execute_mut(&mut self, rhs: usize) -> Self::Output