Struct Simulation

pub struct Simulation<'a> {
    pub configuration: ConfigurationValue,
    pub seed: usize,
    pub shared: SimulationShared,
    pub mutable: SimulationMut,
    pub warmup: Time,
    pub measured: Time,
    pub server_queue_size: usize,
    pub event_queue: EventQueue,
    pub statistics: Statistics,
    pub launch_configurations: Vec<ConfigurationValue>,
    pub plugs: &'a Plugs,
    pub memory_report_period: Option<Time>,
}

The object representing the whole simulation.

Fields

configuration: ConfigurationValue

The whole parsed configuration.

seed: usize

The seed of the random number generator.

shared: SimulationShared

Encapsulated data of the simulation intended to be readable by many.

mutable: SimulationMut

Encapsulated data intended to be mutable by any.

warmup: Time

Cycles of preparation before the actual measured execution

measured: Time

Cycles of measurement

server_queue_size: usize

Maximum number of messages for generation to store in each server. Its default value is 20 messages. Attempts to generate traffic that fails because of the limit are tracked into the missed_generations statistic. Note that packets are not generated until it is the turn for the message to be sent to a router.

event_queue: EventQueue

The queue of events guiding the simulation.

statistics: Statistics

The statistics being collected.

launch_configurations: Vec<ConfigurationValue>

Information abut how to launch simulations to different systems.

plugs: &'a Plugs

Plugged functions to build traffics, routers, etc.

memory_report_period: Option<Time>

Number of cycles to wait between reports of memory usage.

Implementations

impl<'a> Simulation<'a>

pub fn new(cv: &ConfigurationValue, plugs: &'a Plugs) -> Simulation<'a>

pub fn run(&mut self)

Run the simulations until it finishes.

pub fn get_simulation_results(&self) -> ConfigurationValue

Get config value for the simulation results.

Trait Implementations

impl<'a> Quantifiable for Simulation<'a>

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.