may 0.3.51

Rust Stackful Coroutine Library
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
90
91
92
93

use crate::coroutine_impl::{current_cancel_data, is_coroutine};
use crate::coroutine_impl::{CoroutineImpl, EventResult, EventSource, EventSubscriber};
use crate::likely::{likely, unlikely};
use crate::scheduler::get_scheduler;

use generator::{co_get_yield, co_set_para, co_yield_with};

struct Yield {}

impl EventSource for Yield {
    fn subscribe(&mut self, co: CoroutineImpl) {
        // just re-push the coroutine to the ready list
        get_scheduler().schedule(co);
    }
}

/// yield internal `EventSource` ref
/// it's ok to return a ref of object on the generator's stack
/// just like return the ref of a struct member
#[inline]
pub fn yield_with<T: EventSource>(resource: &T) {
    let cancel = current_cancel_data();
    // if cancel detected in user space
    // no need to get into kernel any more
    if unlikely(cancel.is_canceled()) {
        co_set_para(std::io::Error::other("Canceled"));
        return resource.yield_back(cancel);
    }

    let r = unsafe {
        std::mem::transmute::<*const (dyn EventSource + '_), *mut (dyn EventSource + 'static)>(
            resource as &dyn EventSource,
        )
    };
    let es = EventSubscriber::new(r);
    co_yield_with(es);

    resource.yield_back(cancel);
    cancel.clear();
}

#[inline]
pub fn yield_with_io<T: EventSource>(resource: &T, is_coroutine: bool) {
    if likely(is_coroutine) {
        #[cfg(feature = "io_cancel")]
        yield_with(resource);
        #[cfg(not(feature = "io_cancel"))]
        {
            let r = unsafe {
                std::mem::transmute::<*const (dyn EventSource + '_), *mut (dyn EventSource + 'static)>(
                    resource as &dyn EventSource,
                )
            };
            let es = EventSubscriber::new(r);
            co_yield_with(es);
        }
    } else {
        // for thread is only park the thread
        let r = unsafe {
            std::mem::transmute::<*const (dyn EventSource + '_), *mut (dyn EventSource + 'static)>(
                resource as &dyn EventSource,
            )
        };
        let es = EventSubscriber::new(r);
        crate::io::thread::PROXY_CO_SENDER.with(|tx| {
            tx.send(es).unwrap();
        });
        std::thread::park();
    }
}

/// set the coroutine para that passed into it
#[cold]
#[inline]
pub fn set_co_para(co: &mut CoroutineImpl, v: EventResult) {
    co.set_para(v);
}

/// get the coroutine para from the coroutine context
#[inline]
pub fn get_co_para() -> Option<EventResult> {
    co_get_yield::<EventResult>()
}

#[inline]
pub fn yield_now() {
    if unlikely(!is_coroutine()) {
        return std::thread::yield_now();
    }
    let y = Yield {};
    // it's safe to use the stack value here
    yield_with(&y);
}