Struct caminos_lib::topology::cartesian::Hamming

pub struct Hamming { /* fields omitted */ }

The Hamming graph, the Cartesian product of complete graphs. Networks based on Hamming graphs have been called flattened butterflies and Hyper X.

Implementations

impl Hamming

pub fn new(cv: &ConfigurationValue) -> Hamming

Trait Implementations

impl Debug for Hamming

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

Formats the value using the given formatter.

impl Quantifiable for Hamming

pub fn total_memory(&self) -> usize

Get the total memory currently being employed by the implementing type. Both stack and heap.

pub fn print_memory_breakdown(&self)

Prints by stdout how much memory is used per component.

pub fn forecast_total_memory(&self) -> usize

Get an estimation on how much memory the type could reach during the simulation.

impl Topology for Hamming

pub fn num_routers(&self) -> usize

pub fn num_servers(&self) -> usize

pub fn num_arcs(&self) -> usize

pub fn neighbour(&self, router_index: usize, port: usize) -> (Location, usize)

Neighbours of a router: Location+link class index Routers should be before servers

pub fn server_neighbour(&self, server_index: usize) -> (Location, usize)

The neighbour of a server: Location+link class index

pub fn diameter(&self) -> usize

the greatest distance from server to server

pub fn average_distance(&self) -> f32

from servers to different servers

pub fn distance(&self, origin: usize, destination: usize) -> usize

Distance from a router to another.

pub fn amount_shortest_paths(
    &self,
    _origin: usize,
    _destination: usize
) -> usize

Number of shortest paths from a router to another.

pub fn average_amount_shortest_paths(&self) -> f32

Average number of shortest paths from a router to another.

pub fn distance_distribution(&self, _origin: usize) -> Vec<usize>

pub fn maximum_degree(&self) -> usize

pub fn minimum_degree(&self) -> usize

pub fn degree(&self, _router_index: usize) -> usize

Number of ports used to other routers. FIXME: Should iclude NULL ports?

pub fn ports(&self, _router_index: usize) -> usize

pub fn cartesian_data(&self) -> Option<&CartesianData>

Specific for some toologies, but must be checkable for anyone

pub fn coordinated_routing_record(
    &self,
    coordinates_a: &Vec<usize>,
    coordinates_b: &Vec<usize>,
    _rng: Option<&RefCell<StdRng>>
) -> Vec<i32>

Specific for some toologies, but must be checkable for anyone

pub fn is_direction_change(
    &self,
    _router_index: usize,
    _input_port: usize,
    _output_port: usize
) -> bool

Specific for some toologies, but must be checkable for anyone Indicates if going from input_port to output_port implies a direction change. Used for the bubble routing.

pub fn bfs(&self, origin: usize, class_weight: Option<&[usize]>) -> Vec<usize>

Breadth First Search to compute distances from a router to all others. It may use weights, but it there are multiple paths with different distances it may give a non-minimal distance, since it is not Dijkstra.

pub fn compute_distance_matrix(
    &self,
    class_weight: Option<&[usize]>
) -> Matrix<usize>

pub fn floyd(&self) -> Matrix<usize>

pub fn compute_amount_shortest_paths(&self) -> (Matrix<usize>, Matrix<usize>)

Return a pair of matrices (D,A) with D[i,j] being the distance from i to j and A[i,j] being the number of paths of length D[i,j] from i to j.

pub fn components(&self, allowed_classes: &[bool]) -> Vec<Vec<usize>>

Find the coponents of the subtopology induced via the allowed links. Returns vector ret with ret[k] containing the vertices in the k-th component.

pub fn compute_near_far_matrices(&self) -> (Matrix<usize>, Matrix<usize>)

returns a cople matrices (N,F) with N[u,v] = number of neighbours w of v with D(u,v)>D(u,w). F[u,v] = number of neighbours w of v with D(u,v)<D(u,w). A router v with F[u,v]=0 is called a boundary vertex of u.

pub fn eccentricity(&self, router_index: usize) -> usize

Computes the eccentricy of a router. That is, the greatest possible length of a shortest path from that router to any other.

pub fn check_adjacency_consistency(&self, amount_link_classes: Option<usize>)

Check pairs (port,vc) with