apecs 0.8.4

An asyncronous and parallel entity-component system
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

//! Tests for bugs we've encountered.
use apecs::{graph, ok, Facade, Graph, GraphError, View, ViewMut, World};

struct Channel {
    tx: async_broadcast::Sender<()>,
    rx: async_broadcast::Receiver<()>,
    ok_to_drop: bool,
}

impl Default for Channel {
    fn default() -> Self {
        let (tx, rx) = async_broadcast::broadcast(3);
        Channel {
            tx,
            rx,
            ok_to_drop: false,
        }
    }
}

#[test]
fn system_batch_drops_resources_after_racing_asyncs() {
    // ensures that resources are dropped after being sent to
    // an async that is awaiting Facade::visit, but then gets
    // cancelled

    let _ = env_logger::builder()
        .is_test(true)
        .filter_level(log::LevelFilter::Trace)
        .try_init();

    // * each tick this increments a counter by 1
    // * when the counter reaches 3 it fires an event
    fn ticker((chan, mut tick): (ViewMut<Channel>, ViewMut<usize>)) -> Result<(), GraphError> {
        *tick += 1;
        log::info!("ticked {}", *tick);
        if *tick == 3 {
            chan.tx.try_broadcast(()).unwrap();
        } else if *tick > 100 {
            panic!("really shouldn't have taken this long");
        }
        ok()
    }

    // This function infinitely loops, acquiring a unit resource and reading it
    async fn loser(facade: &mut Facade) {
        log::info!("running loser");
        loop {
            log::info!("loser awaiting View<()>");
            facade
                .visit(|unit: View<()>| {
                    log::info!("loser got View<()>");
                    let () = *unit;
                })
                .await
                .unwrap();
        }
    }

    // * races the losing async against awaiting an event from ticker
    // * after ticker wins the race, we should be able to access the unit
    //   resource, because the async executor has dropped the future which
    //   required it
    async fn race(mut facade: Facade) {
        log::info!("starting the race, awaiting View<Channel<()>>");
        let mut rx = facade
            .visit(|chan: View<Channel>| chan.rx.clone())
            .await
            .unwrap();
        log::info!("race got View<Channel<()>> and is done with it");
        {
            futures_lite::future::or(
                async {
                    rx.recv().await.expect("tx was dropped");
                },
                async {
                    loser(&mut facade).await;
                    panic!("this was supposed to lose the race");
                },
            )
            .await;
        }

        log::info!("race is over");

        facade
            .visit(|(unit, mut channel): (View<()>, ViewMut<Channel>)| {
                let () = *unit;
                channel.ok_to_drop = true;
            })
            .await
            .unwrap();

        log::info!("async exiting");
    }

    let mut world = World::default();
    let facade = world.facade();
    let task = smol::spawn(race(facade));
    world.add_subgraph(graph!(ticker));

    while !task.is_finished() {
        println!("tick");
        world.tick().unwrap();
        println!("tock");
        world.get_facade_schedule().unwrap().run().unwrap();
    }
    log::info!("executor is empty, ending the test");
}

#[test]
fn readme() {}