desim 0.4.0

A discrete-time events simulation framework inspired by Simpy
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
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Simulate cars arriving and being served at a carwash
//!
//! Features shown in this example:
//! * Custom state
//! * Simple Resource
//! * prelude

#![feature(coroutines, coroutine_trait)]
use std::collections::HashMap;
use std::fmt::{Display, Formatter, Result};

use rand::{
    distributions::{Distribution, Uniform},
    rngs::SmallRng as Rng,
    SeedableRng,
};
use rand_distr::Exp;

use desim::prelude::*;
use desim::resources::SimpleResource;
use CarState::*;

const NUM_MACHINES: usize = 4; // A carwash with 4 machines to wash cars
const NUM_CARS: usize = 40_000; // 40'000 cars generated
const SIM_TIME: f64 = 10000.0; // New cars are spawned randomly for 10'000 minutes
const LAMBDA_DRIVE: f32 = 5.0; // Each car drives for ~5 minutes
const LAMBDA_WASH: f32 = 2.0; // It takes ~2 minutes to wash a car

#[derive(Copy, Clone, Debug)]
enum CarState {
    Drive(f32),
    WaitMachine(ResourceId),
    Wash(f32),
    Leave(ResourceId),
}

impl SimState for CarState {
    fn get_effect(&self) -> Effect {
        match self {
            Drive(t) => Effect::TimeOut(*t as f64),
            WaitMachine(r) => Effect::Request(*r),
            Wash(t) => Effect::TimeOut(*t as f64),
            Leave(r) => Effect::Release(*r),
        }
    }
    fn set_effect(&mut self, _: Effect) {
        //
    }
    fn should_log(&self) -> bool {
        true
    }
}

impl Display for CarState {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        match self {
            Drive(t) => write!(f, "Drive for {} minutes", t),
            WaitMachine(_) => write!(f, "Waiting a machine"),
            Wash(t) => write!(f, "Washing for {} minutes", t),
            Leave(_) => write!(f, "Clean! Leaving carwash"),
        }
    }
}

// Create a car process
fn car_process<'a>(
    carwash: ResourceId,
    rng: &'a mut Rng,
    distr_drive: &'a impl Distribution<f32>,
    distr_wash: &'a impl Distribution<f32>,
) -> Box<Process<CarState>> {
    // Generate random drive_time and wash_time at beginning
    let t_drive = distr_drive.sample(rng);
    let t_wash = distr_wash.sample(rng);
    Box::new(move |_| {
        // The car drives for `t_drive` time
        yield Drive(t_drive);
        // Arrives at carwash and waits for a machine to be free
        yield WaitMachine(carwash);
        // The car wash for `t_wash` time, keeping the carwash machine (resource) occupied
        yield Wash(t_wash);
        // The car leaves the carwash, freeing the resource
        yield Leave(carwash);
    })
}

fn main() {
    // Create a new simulation
    let mut sim = Simulation::new();

    // Create the carwash resource: It contains `NUM_MACHINES` machines to wash cars`
    let carwash = sim.create_resource(Box::new(SimpleResource::new(NUM_MACHINES)));

    // Create random number genrator and some distributions
    let mut rng = Rng::from_entropy();
    let unif = Uniform::new(0.0, SIM_TIME);
    let distr_drive = Exp::new(1.0 / LAMBDA_DRIVE).unwrap();
    let distr_wash = Exp::new(1.0 / LAMBDA_WASH).unwrap();

    // Create NUM_CARS car processes and schedule them at random times
    for t in unif.sample_iter(rng.clone()).take(NUM_CARS) {
        let p = sim.create_process(car_process(carwash, &mut rng, &distr_drive, &distr_wash));
        sim.schedule_event(t, p, CarState::Drive(0.0));
    }

    // Run the simulation until all cars have been washed
    sim = sim.run(EndCondition::NoEvents);

    // Print the simulation log
    for (e, state) in sim.processed_events() {
        println!("{}\t{}", e.time(), state);
    }

    // Compute average waiting time
    let mut wait_start_time = HashMap::new();

    let sum: (f64, f64) = sim
        .processed_events()
        .iter()
        .filter_map(|(e, state)| match state {
            WaitMachine(_) => {
                wait_start_time.insert(e.process(), e.time());
                None
            }
            Wash(_) => Some(e.time() - wait_start_time.remove(&e.process()).unwrap()),
            _ => None,
        })
        .fold((0.0, 0.0), |(t, c), t0| (t + t0, c + 1.0));

    println!("The average waiting time was: {}", sum.0 / sum.1);
}