dscale 0.5.1

A fast & deterministic simulation framework for benchmarking and testing distributed systems
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

mod bandwidth;
mod latency;

use std::sync::Arc;

pub use bandwidth::BandwidthConfig;

use crate::GLOBAL_POOL;
use crate::Jiffies;
use crate::Rank;
use crate::events::Event;
use crate::events::NetworkFsm;
use crate::events::RankHandlerEvent;
use crate::events::TimedEvent;
use crate::network::bandwidth::Bandwidth;
use crate::network::latency::Latency;
use crate::random::Randomizer;
use crate::random::Seed;
use crate::topology::Topology;

pub(crate) enum NetworkDecision {
    Keep(TimedEvent),
    Ready(RankHandlerEvent),
}

pub(crate) struct Network {
    bandwidth: Bandwidth,
    latency: Latency,
}

impl Network {
    pub(crate) fn new(
        seed: Seed,
        bandwidth_type: BandwidthConfig,
        topology: Arc<Topology>,
    ) -> Self {
        Self {
            latency: Latency::new(Randomizer::new(seed), topology.clone()),
            bandwidth: Bandwidth::new(bandwidth_type, topology.list_pool(GLOBAL_POOL).len()),
        }
    }
}

impl Network {
    pub(crate) fn compute_latency(&mut self, source: Rank, target: Rank) -> Jiffies {
        self.latency.random_latency(source, target)
    }
}

impl Network {
    pub(crate) fn decide(
        &mut self,
        invocation_time: Jiffies,
        mut event: RankHandlerEvent,
    ) -> NetworkDecision {
        match &mut event {
            RankHandlerEvent::Network {
                target,
                message,
                fsm,
                ..
            } => match fsm {
                NetworkFsm::KeepLatency => {
                    match self
                        .bandwidth
                        .try_pass(message.virtual_size(), *target, invocation_time)
                    {
                        None => NetworkDecision::Ready(event),
                        Some(additional_latency) => {
                            *fsm = NetworkFsm::KeepBandwidth;
                            NetworkDecision::Keep(TimedEvent {
                                invocation_time: invocation_time + additional_latency,
                                event: Event::Handler(event),
                            })
                        }
                    }
                }
                NetworkFsm::KeepBandwidth => {
                    self.bandwidth.add_passed(message.virtual_size(), *target);
                    NetworkDecision::Ready(event)
                }
            },
            _ => unreachable!(),
        }
    }
}