Struct NormalizedBwConfig 

pub struct NormalizedBwConfig {
    pub mean: Option<Bandwidth>,
    pub std_dev: Option<Bandwidth>,
    pub upper_bound: Option<Bandwidth>,
    pub lower_bound: Option<Bandwidth>,
    pub duration: Option<Duration>,
    pub step: Option<Duration>,
    pub seed: Option<u64>,
}

The configuration struct for NormalizedBw.

See NormalizedBw for more details.

Fields

mean: Option<Bandwidth>

std_dev: Option<Bandwidth>

upper_bound: Option<Bandwidth>

lower_bound: Option<Bandwidth>

duration: Option<Duration>

step: Option<Duration>

seed: Option<u64>

Implementations

impl NormalizedBwConfig

pub fn new() -> Self

Creates an uninitialized config

pub fn mean(self, mean: Bandwidth) -> Self

Sets the mean

If the mean is not set, 12Mbps will be used.

pub fn std_dev(self, std_dev: Bandwidth) -> Self

Sets the standard deviation

If the standard deviation is not set, 0Mbps will be used.

pub fn upper_bound(self, upper_bound: Bandwidth) -> Self

Sets the upper bound

If the upper bound is not set, the upper bound will be the one of Bandwidth.

pub fn lower_bound(self, lower_bound: Bandwidth) -> Self

Sets the lower bound

If the lower bound is not set, the lower bound will be the one of Bandwidth.

pub fn duration(self, duration: Duration) -> Self

Sets the total duration of the trace

If the total duration is not set, 1 second will be used.

pub fn step(self, step: Duration) -> Self

Sets the duration of each value

If the step is not set, 1ms will be used.

pub fn seed(self, seed: u64) -> Self

Set the seed for a random generator

If the seed is not set, 42 will be used.

pub fn random_seed(self) -> Self

Allows to use a randomly generated seed

This is equivalent to: self.seed(rand::random())

pub fn build(self) -> NormalizedBw

Creates a new NormalizedBw corresponding to this config.

The created model will use StdRng as source of randomness (the call is equivalent to self.build_with_rng::<StdRng>()). It should be sufficient for most cases, but StdRng is not a portable random number generator, so one may want to use a portable random number generator like ChaCha, to this end one can use build_with_rng.

pub fn build_with_rng<Rng: SeedableRng + RngCore>(self) -> NormalizedBw<Rng>

Creates a new NormalizedBw corresponding to this config.

Unlike build, this method let you choose the random generator.

Example

let normal_bw = NormalizedBwConfig::new()
    .mean(Bandwidth::from_mbps(12))
    .std_dev(Bandwidth::from_mbps(1))
    .duration(Duration::from_millis(3))
    .seed(42);

let mut default_build = normal_bw.clone().build();
let mut std_build = normal_bw.clone().build_with_rng::<StdRng>();
// ChaCha is deterministic and portable, unlike StdRng
let mut chacha_build = normal_bw.clone().build_with_rng::<ChaCha20Rng>();

for cha in [12044676, 11754367, 11253775] {
    let default = default_build.next_bw();
    let std = std_build.next_bw();
    let chacha = chacha_build.next_bw();

    assert!(default.is_some());
    assert_eq!(default, std);
    assert_ne!(default, chacha);
    assert_eq!(chacha, Some((Bandwidth::from_bps(cha), Duration::from_millis(1))));
}

assert_eq!(default_build.next_bw(), None);
assert_eq!(std_build.next_bw(), None);
assert_eq!(chacha_build.next_bw(), None);

impl NormalizedBwConfig

pub fn build_truncated(self) -> NormalizedBw

This is another implementation for converting NormalizedBwConfig into NormalizedBw, where the impact of truncation (lower_bound and upper_bound field) on the mathematical expectation of the distribution is taking account by modifying the center of the distribution.

Examples

let normal_bw = NormalizedBwConfig::new()
    .mean(Bandwidth::from_mbps(12))
    .std_dev(Bandwidth::from_mbps(12))
    .duration(Duration::from_secs(100))
    .step(Duration::from_millis(1))
    .seed(42);

let mut default_build = normal_bw.clone().build();
let mut truncate_build = normal_bw.clone().build_truncated();

fn avg_mbps(mut model: impl BwTrace) -> f64{
    let mut count = 0;
    std::iter::from_fn( move ||{
        model.next_bw().map(|b| b.0.as_gbps_f64() * 1000.0)
    }).inspect(|_| count += 1).sum::<f64>() / count as f64
}

assert_eq!(avg_mbps(default_build), 12.974758080079994); // significantly higher than the expected mean
assert_eq!(avg_mbps(truncate_build), 11.97642456625989);

let normal_bw = NormalizedBwConfig::new()
    .mean(Bandwidth::from_mbps(12))
    .std_dev(Bandwidth::from_mbps(12))
    .duration(Duration::from_secs(100))
    .lower_bound(Bandwidth::from_mbps(8))
    .upper_bound(Bandwidth::from_mbps(20))
    .step(Duration::from_millis(1))
    .seed(42);

let mut default_build = normal_bw.clone().build();
let mut truncate_build = normal_bw.clone().build_truncated();

assert_eq!(avg_mbps(default_build),  13.221356471729928); // significantly higher than the expected mean
assert_eq!(avg_mbps(truncate_build), 11.978819427569897);

pub fn build_truncated_with_rng<Rng: SeedableRng + RngCore>( self, ) -> NormalizedBw<Rng>

Similar to build_truncated but let you choose the random generator.

See build for details about the reason for using another random number generator than StdRng.

Trait Implementations

impl BwTraceConfig for NormalizedBwConfig

fn into_model(self: Box<NormalizedBwConfig>) -> Box<dyn BwTrace>

impl Clone for NormalizedBwConfig

fn clone(&self) -> NormalizedBwConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NormalizedBwConfig

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

Formats the value using the given formatter.

impl Default for NormalizedBwConfig

fn default() -> NormalizedBwConfig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NormalizedBwConfig

where NormalizedBwConfig: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Forever for NormalizedBwConfig

fn forever(self) -> RepeatedBwPatternConfig

impl Serialize for NormalizedBwConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.