hirun 0.1.1

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
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

use crate::event::{BoxedScheduler, Scheduler};
use crate::thread::{self, JoinHandle, Semaphore};
use crate::Error;
use core::marker::PhantomData;
use core::mem::ManuallyDrop;
use hipool::{Allocator, Boxed, MemPool};

pub trait Runnable {
    fn active(&mut self, ctx: &mut ThreadContext) -> Result<(), Error>;
}

impl<T: Runnable + Send, A: Allocator> Runnable for Boxed<'_, T, A> {
    fn active(&mut self, ctx: &mut ThreadContext) -> Result<(), Error> {
        Runnable::active(&mut **self, ctx)
    }
}

type Pool = &'static MemPool;

#[repr(C)]
pub struct ThreadContext {
    selector: BoxedScheduler,
}

impl ThreadContext {
    pub fn sched(&mut self) -> &mut Scheduler {
        &mut self.selector
    }
    pub fn stop(&mut self) {
        self.selector.stop();
    }
}

#[repr(C)]
pub(crate) struct Thread<T> {
    ctx: ThreadContext,
    body: T,
}

unsafe impl<T: Send> Send for Thread<T> {}

impl<T: Runnable + Send + 'static> Thread<T> {
    pub(crate) fn new_in(pool: Pool, body: T) -> Result<ThreadProxy, Error> {
        let selector = Scheduler::new_in(pool)?;
        let mut this = Boxed::new_in(
            pool,
            Self {
                ctx: ThreadContext { selector },
                body,
            },
        )?
        .into();
        let sem = Semaphore::new().unwrap();
        let sem_ref = unsafe { &*(&sem as *const Semaphore) };
        let handle = thread::spawn(move || {
            match this.active() {
                Ok(_) => {
                    sem_ref.post();
                    this.ctx.selector.run();
                }
                Err(err) => panic!("Thread Body active failed, errno = {err}"),
            }
        });
        sem_ref.wait();
        Ok(ThreadProxy {
            handle: ManuallyDrop::new(handle),
            mark: PhantomData,
        })
    }
}

impl<T: Runnable + Send> Thread<T> {
    fn active(&mut self) -> Result<(), Error> {
        self.body.active(&mut self.ctx)
    }
}

pub struct ThreadProxy {
    handle: ManuallyDrop<JoinHandle<()>>,
    mark: PhantomData<*const ()>,
}

unsafe impl Send for ThreadProxy {}

impl ThreadProxy {
    pub(crate) fn join(&mut self) {
        let _ = unsafe { ManuallyDrop::take(&mut self.handle) }.join();
    }
}