Struct caminos_lib::pattern::RemappedNodes

pub struct RemappedNodes { /* private fields */ }

Apply some other Pattern over a set of nodes whose indices have been remapped according to a Pattern-given permutation. A source x chooses as destination map(pattern(invmap(x))), where map is the given permutation, invmap its inverse and pattern is the underlying pattern to apply. In other words, if pattern(a)=b, then destination of map(a) is set to map(b). It can be seen as a Composition that manages building the inverse map.

Remapped nodes requires source and destination to be of the same size. The pattern creating the map is called once and must result in a permutation, as to be able to make its inverse.

For a similar operation on other types see RemappedServersTopology.

Example building a cycle in random order.

RemappedNodes{
	/// The underlying pattern to be used.
	pattern: Circulant{generators:[1]},
	/// The pattern defining the relabelling.
	map: RandomPermutation,
}

Trait Implementations

impl Debug for RemappedNodes

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

Formats the value using the given formatter.

impl Pattern for RemappedNodes

fn initialize( &mut self, source_size: usize, target_size: usize, topology: &dyn Topology, rng: &mut StdRng )

Fix the input and output size, providing the topology and random number generator. Careful with using topology in sub-patterns. For example, it may be misleading to use the dragonfly topology when building a pattern among groups or a pattern among the routers of a single group. Even just a pattern of routers instead of a pattern of servers can lead to mistakes. Read the documentation of the traffic or meta-pattern using the pattern to know what its their input and output.

fn get_destination( &self, origin: usize, topology: &dyn Topology, rng: &mut StdRng ) -> usize

Obtain a destination of a source. This will be called repeatedly as the traffic requires destination for its messages.

impl Quantifiable for RemappedNodes

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.