Skip to main content

bounded_queues/
bounded_queues.rs

1//! Demonstrates bounded command-radio queues without advancing beyond a game tick.
2use c3mesh::{
3    ChannelConfig, ChannelOptions, ChannelState, DeviceConfig, DeviceKind, DropReason,
4    NetworkConfig, NetworkEvent, PacketMetadata, QueueConfig, QueueDiscipline, SimTime, Simulator,
5    SimulatorOptions,
6};
7use std::collections::BTreeMap;
8
9fn main() -> Result<(), Box<dyn std::error::Error>> {
10    let network = NetworkConfig {
11        devices: vec![
12            DeviceConfig {
13                id: "sender".into(),
14                kind: DeviceKind::Source {
15                    egress: "radio".into(),
16                },
17                mobility: Default::default(),
18                interference: vec![],
19            },
20            DeviceConfig {
21                id: "receiver".into(),
22                kind: DeviceKind::Sink,
23                mobility: Default::default(),
24                interference: vec![],
25            },
26        ],
27        channels: vec![ChannelConfig {
28            id: "radio".into(),
29            endpoints: ["sender".into(), "receiver".into()],
30            bit_rate_bps: 8_000,
31            propagation_delay_ns: 1_000_000,
32            state: ChannelState::Operational,
33            distance: None,
34            radio: None,
35        }],
36    };
37    let mut simulator = Simulator::new_with_options(
38        network,
39        SimulatorOptions {
40            seed: 42,
41            channels: BTreeMap::from([(
42                "radio".into(),
43                ChannelOptions {
44                    mtu_bytes: Some(128),
45                    wire_overhead_bytes: 20,
46                    queue: QueueConfig {
47                        max_packets: Some(2),
48                        max_bytes: Some(256),
49                        discipline: QueueDiscipline::StrictPriority,
50                    },
51                    ..Default::default()
52                },
53            )]),
54        },
55    )?;
56    simulator.send("sender", "receiver", vec![0; 100])?;
57    simulator.schedule_send_with_metadata(
58        SimTime::from_nanos(1),
59        "sender",
60        "receiver",
61        b"old contact".to_vec(),
62        PacketMetadata {
63            priority: 1,
64            expires_at: Some(SimTime::from_nanos(50_000_000)),
65            ..Default::default()
66        },
67    )?;
68    simulator.schedule_send_with_metadata(
69        SimTime::from_nanos(2),
70        "sender",
71        "receiver",
72        b"background".to_vec(),
73        PacketMetadata {
74            priority: 1,
75            ..Default::default()
76        },
77    )?;
78    let urgent = simulator.schedule_send_with_metadata(
79        SimTime::from_nanos(3),
80        "sender",
81        "receiver",
82        b"move".to_vec(),
83        PacketMetadata {
84            priority: 230,
85            ..Default::default()
86        },
87    )?;
88    let mut events = simulator.advance_to(SimTime::from_nanos(10_000_000))?;
89    let metrics = simulator.channel_queue_metrics("radio")?;
90    assert_eq!(metrics.packets_0_to_1, 2);
91    println!(
92        "At 10 ms: {} waiting packets, {} wire bytes",
93        metrics.packets_0_to_1, metrics.bytes_0_to_1
94    );
95    events.extend(simulator.run()?);
96    assert!(events.iter().any(|event| matches!(
97        event,
98        NetworkEvent::PacketDropped {
99            reason: DropReason::Expired,
100            ..
101        }
102    )));
103    assert!(events.iter().any(|event| matches!(event,
104        NetworkEvent::PacketDelivered { packet, .. } if packet.id() == urgent
105    )));
106    for event in events {
107        println!("{event:?}");
108    }
109    Ok(())
110}