mondayio 0.2.4

A thread per core runtime based on iouring.
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

use crate::driver;

use io_uring::{opcode, IoUring};
use std::io;
use std::mem::ManuallyDrop;

/// Buffer pool shared with kernel
pub(crate) struct Pool {
    mem: *mut u8,
    num: usize,
    size: usize,
}

pub(crate) struct ProvidedBuf {
    buf: ManuallyDrop<Vec<u8>>,
    driver: driver::Handle,
}

impl Pool {
    pub(super) fn new(num: usize, size: usize) -> Pool {
        let total = num * size;
        let mut mem = ManuallyDrop::new(Vec::<u8>::with_capacity(total));

        assert_eq!(mem.capacity(), total);

        Pool {
            mem: mem.as_mut_ptr(),
            num,
            size,
        }
    }

    pub(super) fn provide_buffers(&self, uring: &mut IoUring) -> io::Result<()> {
        let op = opcode::ProvideBuffers::new(self.mem, self.size as _, self.num as _, 0, 0)
            .build()
            .user_data(0);

        // Scoped to ensure `sq` drops before trying to submit
        {
            let mut sq = uring.submission();

            if unsafe { sq.push(&op) }.is_err() {
                unimplemented!("when is this hit?");
            }
        }

        uring.submit_and_wait(1)?;

        let mut cq = uring.completion();
        for cqe in &mut cq {
            assert_eq!(cqe.user_data(), 0);
        }

        Ok(())
    }
}

impl ProvidedBuf {}

impl Drop for ProvidedBuf {
    fn drop(&mut self) {
        let mut driver = self.driver.borrow_mut();
        let pool = &driver.pool;

        let ptr = self.buf.as_mut_ptr();
        let bid = (ptr as usize - pool.mem as usize) / pool.size;

        let op = opcode::ProvideBuffers::new(ptr, pool.size as _, 1, 0, bid as _)
            .build()
            .user_data(u64::MAX);

        let mut sq = driver.uring.submission();

        if unsafe { sq.push(&op) }.is_err() {
            unimplemented!();
        }
    }
}