Struct caminos_lib::topology::neighbourslists::NeighboursLists

pub struct NeighboursLists { /* fields omitted */ }

A topology based on having sotred the list of neighbours to each router. It is used

• to load a topology from a file (topology=File)
• and to create a topology with random links (topology=RandomRegularGraph).

Implementations

impl NeighboursLists

pub fn new(
    list: Vec<Vec<(usize, usize)>>,
    servers: Vec<usize>
) -> NeighboursLists

Build a topology with the given list of adjacency for routers and servers. list[i][j] = (r,p) with r the j-th neighbour router of the i-th router, where i is the p-th neighbour of r. servers[i] = amount of servers connected to the i-th router.

pub fn new_cfg(
    cv: &ConfigurationValue,
    rng: &RefCell<StdRng>
) -> NeighboursLists

Trait Implementations

impl Debug for NeighboursLists

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

Formats the value using the given formatter.

impl Quantifiable for NeighboursLists

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 NeighboursLists

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