agsim 0.2.0

A discrete event simulation library.
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

use agsim::agent::{Agent, StateType};
use agsim::simulation::Simulation;
use agsim::state::Timeline;
use chrono::{Duration, Utc};
use rand::rngs::StdRng;
use rand::{Rng, SeedableRng};
use state_macros::{State, StateDisplay};
use std::collections::HashMap;

#[derive(Debug, Clone, PartialEq, Eq, Hash, Copy)]
enum DeviceOperationalMode {
    Offline,
    Idle,
    Working,
    HeavyLoad,
}

#[derive(Debug, Clone, Default, State, StateDisplay)]
struct DeviceState {
    connected_status: bool,
    active_sessions: u32,
    memory_in_use_mb: u32,
    cpu_in_use_percent: f32,
}

fn main() {
    let mut transitions = HashMap::new();

    transitions.insert(
        DeviceOperationalMode::Offline,
        StateType::new_deterministic(
            || DeviceState {
                connected_status: false,
                active_sessions: 0,
                memory_in_use_mb: 0,
                cpu_in_use_percent: 0.0,
            },
            vec![
                (DeviceOperationalMode::Idle, 0.9),
                (DeviceOperationalMode::Working, 0.1),
            ],
            4.0 * 3600.0, // 4 hours
        ),
    );

    transitions.insert(
        DeviceOperationalMode::Idle,
        StateType::new(
            |rng| DeviceState {
                connected_status: true,
                active_sessions: 0,
                memory_in_use_mb: rng.gen_range(400..800),
                cpu_in_use_percent: rng.gen_range(0.1..5.0),
            },
            vec![
                (DeviceOperationalMode::Working, 0.4),
                (DeviceOperationalMode::Offline, 0.1),
                (DeviceOperationalMode::Idle, 0.5),
            ],
            3600.0, // 1 hour
        ),
    );

    transitions.insert(
        DeviceOperationalMode::Working,
        StateType::new(
            |rng| DeviceState {
                connected_status: true,
                active_sessions: rng.gen_range(1..4),
                memory_in_use_mb: rng.gen_range(1024..4096),
                cpu_in_use_percent: rng.gen_range(10.0..40.0),
            },
            vec![
                (DeviceOperationalMode::Idle, 0.4),
                (DeviceOperationalMode::HeavyLoad, 0.2),
                (DeviceOperationalMode::Working, 0.4),
            ],
            30.0 * 60.0, // 30 minutes
        ),
    );

    transitions.insert(
        DeviceOperationalMode::HeavyLoad,
        StateType::new(
            |rng| DeviceState {
                connected_status: true,
                active_sessions: rng.gen_range(3..10),
                memory_in_use_mb: rng.gen_range(4096..16384),
                cpu_in_use_percent: rng.gen_range(60.0..99.9),
            },
            vec![
                (DeviceOperationalMode::Working, 0.8),
                (DeviceOperationalMode::Idle, 0.2),
            ],
            10.0 * 60.0, // 10 minutes
        ),
    );

    let mut agents = Vec::new();
    let start_time = Utc::now();

    let mut rng = StdRng::seed_from_u64(42);

    for i in 0..5 {
        agents.push(Agent::new(
            format!("device_{:03}", i),
            DeviceOperationalMode::Idle,
            transitions.clone(),
            &mut rng,
        ));
    }

    let mut sim = Simulation::new(agents, start_time);
    let events = sim.run(Duration::days(7));

    println!("Generated {} events over 7 days.", events.len());

    let timelines = Timeline::generate(&events);

    let mut sorted_agents: Vec<_> = timelines.keys().collect();
    sorted_agents.sort();

    for agent_id in sorted_agents {
        println!("\n--- Timeline for {} (First 5 Entries) ---", agent_id);
        if let Some(timeline) = timelines.get(agent_id) {
            for entry in timeline.entries.iter().take(5) {
                println!("{}", entry);
            }
        }
    }
}