azur 0.3.1

A no_std Rust crate that implements an executor/reactor and futures using io_uring
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

//! In azur, dropping futures blocks the thread until the operation is done or cancelled.
//! This is to prevent the kernel from writing to an invalid memory location if a future is dropped
//! while the operation is still ongoing.
//!
//! This is an example of some code that could lead to undefined behavior if this safety guard was
//! not implemented.

use azur::DelayType;
use futures_util::select;

fn main() {
    let future = async {
        select! {
            _ = azur::delay(
                lx::timespec {
                    tv_sec: 2,
                    tv_nsec: 0,
                },
                DelayType::Relative,
            ) => {},

            _ = azur::delay(
                lx::timespec {
                    tv_sec: 1,
                    tv_nsec: 0,
                },
                DelayType::Relative,
            ) => {},
        }
    };
    azur::spawn(future);
    azur::run().unwrap();
}