dscale 0.5.2

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use std::cmp::Reverse;

use crate::{
    Jiffies, ProcessHandle, events::{Event, PidHandlerEvent, TimedEvent}, global::local_access::{self, setup_local_access}, process_handle::ProcessHandlePtr, random::Seed, runners::{RunStatus, SimulationRunner, common::RunnerCore, task::TaskResult}
};

pub(crate) struct SimpleRunner {
    core: RunnerCore,
    procs: Vec<ProcessHandlePtr>,
}

impl SimpleRunner {
    pub(crate) fn new(
        core: RunnerCore,
        procs: Vec<ProcessHandlePtr>,
        seed: Seed,
    ) -> Self {
        let (tx, _rx) = crossbeam_channel::unbounded::<TaskResult>();
        setup_local_access(seed, tx);
        Self { core, procs }
    }

    pub(crate) fn seed_events(&mut self, events: Vec<Reverse<TimedEvent>>) {
        self.core.seed_events(events);
    }

    fn ensure_started(&mut self) {
        if self.core.mark_started() {
            for pid in 0..self.procs.len() {
                self.core.event_queue.push(Reverse(TimedEvent {
                    invocation_time: Jiffies(0),
                    event: Event::Handler(PidHandlerEvent::Start { pid }),
                }));
            }
        }
    }

    fn run_loop(&mut self, deadline: Jiffies, max_steps: Option<usize>) -> RunStatus {
        self.ensure_started();
        let mut steps = 0;
        loop {
            if let Some(k) = max_steps {
                if steps >= k {
                    return RunStatus::Completed { steps };
                }
            }
            if self.core.clock.now() >= self.core.time_budget {
                return RunStatus::BudgetExhausted { steps };
            }
            if self.core.clock.now() >= deadline {
                return RunStatus::Completed { steps };
            }
            match self.core.event_queue.pop() {
                None => return RunStatus::NoMoreEvents { steps },
                Some(event) => {
                    steps += self.step(event.0);
                }
            }
        }
    }

    fn step(&mut self, timed_event: TimedEvent) -> usize {
        self.core.advance_time(timed_event.invocation_time);
        match timed_event.event {
            Event::Fault(event) => {
                self.core.handle_fault_event(event);
                0 // Faults does not count in steps
            }
            Event::Handler(event) => {
                if let Some(ready) = self
                    .core
                    .handle_pid_handler_event(timed_event.invocation_time, event)
                {
                    self.dispatch(ready);
                    1
                } else {
                    0
                }
            }
        }
    }

    fn dispatch(&mut self, event: PidHandlerEvent) {
        local_access::prepare(event.target_pid(), self.core.clock.now());
        match event {
            PidHandlerEvent::Start { pid } => {
                self.procs[pid].on_start();
            }
            PidHandlerEvent::Network {
                source,
                target,
                message,
                ..
            } => {
                self.procs[target].on_message(source, message);
            }
            PidHandlerEvent::Timer { pid, id } => {
                self.procs[pid].on_timer(id);
            }
        }
        self.core.resolve_events(local_access::take_events());
    }
}

impl SimulationRunner for SimpleRunner {
    fn run_full_budget(&mut self) -> RunStatus {
        self.run_loop(self.core.time_budget, None)
    }

    fn run_steps(&mut self, k: usize) -> RunStatus {
        self.run_loop(self.core.time_budget, Some(k))
    }

    fn run_sub_budget(&mut self, sub_budget: Jiffies) -> RunStatus {
        let deadline = self.core.clock.now() + sub_budget;
        self.run_loop(deadline, None)
    }
}