Struct caminos_lib::topology::dragonfly::CanonicDragonfly

pub struct CanonicDragonfly { /* fields omitted */ }

Builds a dragonfly topology with canonic dimensions and palm-tree arrangement of global links. The canonic dimensions means

• to have as many global links as links to servers in each router,
• to have in each group the double number of routers than links to a server in a router,
• to have a unique global link joining each pair of groups,
• and to have a unique local link joining each pair of router in the same group. For the palm-tree arrangement we refer to the doctoral thesis of Marina García.

Implementations

impl CanonicDragonfly

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

Trait Implementations

impl Debug for CanonicDragonfly

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

Formats the value using the given formatter.

impl Quantifiable for CanonicDragonfly

fn total_memory(&self) -> usize

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

fn print_memory_breakdown(&self)

Prints by stdout how much memory is used per component.

fn forecast_total_memory(&self) -> usize

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

impl Topology for CanonicDragonfly

fn num_routers(&self) -> usize

fn num_servers(&self) -> usize

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

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

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

The neighbour of a server: Location+link class index

fn diameter(&self) -> usize

the greatest distance from server to server

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

Distance from a router to another.

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

Number of shortest paths from a router to another.

fn average_amount_shortest_paths(&self) -> f32

Average number of shortest paths from a router to another.

fn maximum_degree(&self) -> usize

fn minimum_degree(&self) -> usize

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

Number of ports used to other routers. This does not include non-connected ports. This should not be used as a range of valid ports. A non-connected port can be before some other valid port to a router. Use neighbour_router_iter()' or 0..ports()’ to iterate over valid ranges.

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

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

Specific for some toologies, but must be checkable for anyone

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

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.

fn up_down_distance(
    &self,
    _origin: usize,
    _destination: usize
) -> Option<(usize, usize)>

For topologies containing the so called up/down paths. Other topologies should return always None. If the return is Some((u,d)) it means there is an initial up sub-path of length u followed by a down sub-path of length d starting at origin and ending at destination. A return value of None means there is no up/down path from origin to destination. Some general guidelines, although it is not clear if they must hold always:

fn neighbour_router_iter<'a>(
    &'a self,
    router_index: usize
) -> Box<dyn Iterator<Item = NeighbourRouterIteratorItem> + 'a>

Iterate over the neighour routers, skipping non-connected ports and ports towards servers. You may want to reimplement this when implementing the trait for your type.

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.

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

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

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.

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.

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.

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.

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

Check pairs (port,vc) with

fn write_adjacencies_to_file(
    &self,
    file: &mut File,
    _format: usize
) -> Result<(), Error>

Dump the adjacencies into a file. You may use NeighboursLists::file_adj to load them.