hirun 0.1.16

A concurrent framework for asynchronous programming based on event-driven, non-blocking I/O mechanism
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

mod traits;
pub use traits::*;

mod timer;
pub use timer::*;

#[allow(clippy::module_inception)]
mod event;
pub use event::*;

mod sched;
pub use sched::*;

mod waker;
pub(crate) use waker::*;

cfg_if::cfg_if! {
    if #[cfg(any(
            target_os = "linux",
            target_os = "android",
            target_os = "illumos",
            target_os = "redox",
    ))] {
        mod epoll;
        pub(crate) use epoll::*;
    } else if #[cfg(any(
            target_os = "ios",
            target_os = "macos",
            target_os = "freebsd",
            target_os = "openbsd",
            target_os = "netbsd",
            target_os = "dragonfly",
            target_os = "tvos",
            target_os = "watchos",
            ))] {
        mod kqueue;
        pub(crate) use kqueue::*;
    } else {
        mod select;
        pub(crate) use select::*;
    }
}

#[cfg(test)]
mod test {
    use crate::event;
    use crate::event::Poll;
    use hipool::MemPool;
    #[test]
    fn test_waker() {
        let pool = MemPool::new_boxed(0).unwrap();
        let mut poll = event::PollImpl::new_in(&pool).unwrap();
        let waker = event::Waker::new().unwrap();
        let _ = poll.add_event(waker.fd.fd(), event::POLLIN, 0_u64);
        let mut events = 0;
        let n = poll
            .wait(0, |e, _| {
                events = e;
            })
            .unwrap();
        assert_eq!(events, 0);
        assert_eq!(n, 0);
        assert!(!waker.awaken());
        waker.wake();
        let n = poll
            .wait(0, |e, _| {
                events = e;
            })
            .unwrap();
        assert_eq!(n, 1);
        assert!(waker.awaken());
    }

    #[test]
    fn test_scheduler() {
        let pool = MemPool::new_boxed(0).unwrap();
        let mut sched = event::SchedImpl::new_in(&*pool).unwrap();
        fn timer_timeout(this: &event::Timer, sched: &mut event::Scheduler) {
            static mut STOP: i32 = 0;
            if unsafe { STOP } == 0 {
                unsafe { STOP = 1 };
                unsafe { sched.set_timer(this, 1000000) };
            } else {
                sched.stop();
            }
        }
        let timer = event::Timer::new(timer_timeout);
        let now = sched.now();
        unsafe { sched.set_timer(&timer, 1 * 1000 * 1000) };
        sched.run();
        assert!(sched.stopped());
        let cur = sched.now();
        assert!((cur - now).as_micros() >= 2 * 1000 * 1000);
    }
}