slings 0.1.4

A small async runtime based on io-uring for Rust
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

use std::future::Future;
use std::io;
use std::task::{Context, Poll};

use futures_util::future::poll_fn;

use crate::driver::Driver;
use crate::local_executor::LocalExecutor;
use crate::waker_fn::waker_fn;

pub struct Runtime {
    local_executor: LocalExecutor,
    driver: Driver,
}

impl Runtime {
    pub fn new() -> io::Result<Runtime> {
        let local_executor = LocalExecutor::new();
        let driver = Driver::new()?;

        Ok(Runtime {
            local_executor,
            driver,
        })
    }

    pub fn block_on<F>(&self, future: F) -> F::Output
    where
        F: Future,
    {
        pin_mut!(future);
        self.driver.with(|| {
            self.local_executor.with(|| {
                block_on(poll_fn(|cx| loop {
                    if let Poll::Ready(output) = future.as_mut().poll(cx) {
                        return Poll::Ready(output);
                    }
                    if self.local_executor.tick() {
                        return Poll::Pending;
                    }
                    self.driver.wait().expect("driver wait error");
                }))
            })
        })
    }
}

/// Runs a future to completion on the current thread.
fn block_on<T>(future: impl Future<Output = T>) -> T {
    pin_mut!(future);

    let waker = waker_fn(|| {});

    let cx = &mut Context::from_waker(&waker);
    loop {
        match future.as_mut().poll(cx) {
            Poll::Ready(output) => return output,
            Poll::Pending => continue,
        }
    }
}