jay-compositor 1.15.0

The Jay compositor
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
113
114
115
116
117
118

use crate::async_engine::AsyncEngine;
use crate::async_engine::SpawnedFuture;
use crate::cpu_worker::AsyncCpuWork;
use crate::cpu_worker::CompletedWork;
use crate::cpu_worker::CpuJob;
use crate::cpu_worker::CpuWork;
use crate::cpu_worker::CpuWorker;
use crate::cpu_worker::WorkCompletion;
use crate::io_uring::IoUring;
use crate::utils::asyncevent::AsyncEvent;
use crate::wheel::Wheel;
use std::future::pending;
use std::rc::Rc;
use std::sync::Arc;
use uapi::OwnedFd;
use uapi::c::EFD_CLOEXEC;

struct Job {
    ae: Rc<AsyncEvent>,
    work: Work,
    cancel: bool,
}
struct Work(Arc<OwnedFd>);
struct AsyncWork(Arc<OwnedFd>);

impl CpuJob for Job {
    fn work(&mut self) -> &mut dyn CpuWork {
        &mut self.work
    }

    fn completed(self: Box<Self>) {
        if self.cancel {
            unreachable!();
        } else {
            self.ae.trigger();
        }
    }
}

impl Drop for Job {
    fn drop(&mut self) {
        if self.cancel {
            self.ae.trigger();
        }
    }
}

impl CpuWork for Work {
    fn run(&mut self) -> Option<Box<dyn AsyncCpuWork>> {
        Some(Box::new(AsyncWork(self.0.clone())))
    }

    fn cancel_async(&mut self, _ring: &Rc<IoUring>) {
        uapi::eventfd_write(self.0.raw(), 1).unwrap();
    }

    fn async_work_done(&mut self, work: Box<dyn AsyncCpuWork>) {
        let _ = work;
    }
}

impl AsyncCpuWork for AsyncWork {
    fn run(
        self: Box<Self>,
        eng: &Rc<AsyncEngine>,
        ring: &Rc<IoUring>,
        completion: WorkCompletion,
    ) -> SpawnedFuture<CompletedWork> {
        let ring = ring.clone();
        eng.spawn("", async move {
            let mut buf = [0; 8];
            let res = ring
                .read_no_cancel(self.0.borrow(), 0, &mut buf, |_| ())
                .await;
            res.unwrap();
            completion.complete(self)
        })
    }
}

fn run(cancel: bool) {
    let eng = AsyncEngine::new();
    let ring = IoUring::new(&eng, 32).unwrap();
    let ring2 = ring.clone();
    let wheel = Wheel::new(&eng, &ring).unwrap();
    let cpu = Rc::new(CpuWorker::new(&ring, &eng).unwrap());
    let ae = Rc::new(AsyncEvent::default());
    let eventfd = Arc::new(uapi::eventfd(0, EFD_CLOEXEC).unwrap());
    let pending_job = cpu.submit(Box::new(Job {
        ae: ae.clone(),
        work: Work(eventfd.clone()),
        cancel,
    }));
    let _fut1 = eng.spawn("", async move {
        wheel.timeout(1).await.unwrap();
        if cancel {
            drop(pending_job);
        } else {
            uapi::eventfd_write(eventfd.raw(), 1).unwrap();
            pending::<()>().await;
        }
    });
    let _fut2 = eng.spawn("", async move {
        ae.triggered().await;
        ring2.stop();
    });
    ring.run().unwrap();
}

#[test]
fn cancel() {
    run(true);
}

#[test]
fn complete() {
    run(false);
}