Struct Cluster

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

A cluster represents a local subnet of connected runtimes

Implementations

impl<D> Cluster<D>

where D: Driver<Triad> + 'static,

pub fn new( local_key: &Keypair, event_tx: Sender<SubnetEvent>, cmd_rx: Receiver<SubnetCommand>, power_rx: Receiver<Power>, ) -> Result<Self>

Create a new cluster

pub fn with_runtime(self, runtime: Runtime<D>) -> Self

pub const fn learned_patterns(&self) -> &HashMap<String, Pattern>

returns an immutable reference to the learned patterns

pub fn learned_patterns_mut(&mut self) -> &mut HashMap<String, Pattern>

returns a mutable reference to the learned patterns

pub const fn runtime(&self) -> &Runtime<D>

returns an immutable reference to the local runtime

pub fn runtime_mut(&mut self) -> &mut Runtime<D>

returns a mutable reference to the runtime

pub const fn swarm(&self) -> &Swarm<SubnetBehaviour>

returns an immutable reference to the swarm

pub const fn task_peers(&self) -> &HashMap<String, Vec<PeerId>>

returns an immutable reference to the task peers

pub fn peer_id(&self) -> PeerId

returns a copy of the current peer id associated with the cluster

pub async fn get_capable_peers<T>(&self, filter: T) -> Vec<(PeerId, PeerInfo)>

where T: ToString,

returns a list of peers that are equipped with a particular capability

pub async fn get_capable_peer_ids<T>(&self, filter: T) -> Vec<PeerId>

where T: ToString,

get a list os peer ids for peers equipped with a particular capbility

pub async fn run(self) -> Result<()>

where D: TriadDriver,

the loop for the cluster

pub async fn allocate_task( &self, task_type: &str, work_units: Vec<WorkUnit>, ) -> Result<(), NetworkError>

Allocate a task across the network based on resources

pub async fn learn_network_patterns(&mut self) -> Result<(), NetworkError>

Learn patterns from the network

pub async fn distribute_surface_patterns(&self) -> Result<(), NetworkError>

Distribute surface patterns across the subnet

pub async fn form_processing_cluster( &mut self, task_type: &str, ) -> Result<Vec<PeerId>, NetworkError>

Form a dynamic cluster for processing tasks

pub async fn synchronize_memory(&self) -> Result<(), NetworkError>

Synchronize topological memory across the cluster

pub async fn dynamic_work_distribution( &mut self, operations: Vec<(EdgeId, Vec<LPR>)>, ) -> Result<(), NetworkError>

where D: TriadDriver,

Create a dynamic work distribution for a set of VNode operations

pub async fn topology_aware_learning(&self) -> Result<(), NetworkError>

Create a topology-aware work distribution for learning tasks