The open-coroutine is a simple, efficient and generic stackful-coroutine library.
Still under development, please do not use this library in the production environment !
[dependencies]
# check https://crates.io/crates/open-coroutine
open-coroutine = "x.y.z"#[open_coroutine::main]
fn main() {
//......
}Note: not supported for windows
#[open_coroutine::main]
fn main() -> std::io::Result<()> {
cfg_if::cfg_if! {
if #[cfg(all(unix, feature = "preemptive-schedule"))] {
use open_coroutine_core::scheduler::Scheduler;
use std::sync::{Arc, Condvar, Mutex};
use std::time::Duration;
static mut TEST_FLAG1: bool = true;
static mut TEST_FLAG2: bool = true;
let pair = Arc::new((Mutex::new(true), Condvar::new()));
let pair2 = Arc::clone(&pair);
let handler = std::thread::Builder::new()
.name("preemptive".to_string())
.spawn(move || {
let scheduler = Scheduler::new();
_ = scheduler.submit(
|_, _| {
println!("coroutine1 launched");
while unsafe { TEST_FLAG1 } {
println!("loop1");
_ = unsafe { libc::usleep(10_000) };
}
println!("loop1 end");
1
},
None,
);
_ = scheduler.submit(
|_, _| {
println!("coroutine2 launched");
while unsafe { TEST_FLAG2 } {
println!("loop2");
_ = unsafe { libc::usleep(10_000) };
}
println!("loop2 end");
unsafe { TEST_FLAG1 = false };
2
},
None,
);
_ = scheduler.submit(
|_, _| {
println!("coroutine3 launched");
unsafe { TEST_FLAG2 = false };
3
},
None,
);
scheduler.try_schedule();
let (lock, cvar) = &*pair2;
let mut pending = lock.lock().unwrap();
*pending = false;
// notify the condvar that the value has changed.
cvar.notify_one();
})
.expect("failed to spawn thread");
// wait for the thread to start up
let (lock, cvar) = &*pair;
let result = cvar
.wait_timeout_while(
lock.lock().unwrap(),
Duration::from_millis(3000),
|&mut pending| pending,
)
.unwrap();
if result.1.timed_out() {
Err(std::io::Error::new(
std::io::ErrorKind::Other,
"preemptive schedule failed",
))
} else {
unsafe {
handler.join().unwrap();
assert!(!TEST_FLAG1);
}
Ok(())
}
} else {
println!("please enable preemptive-schedule feature");
Ok(())
}
}
}outputs
coroutine1 launched
loop1
coroutine2 launched
loop2
coroutine3 launched
loop1
loop2 end
loop1 end
#[open_coroutine::main]
fn main() {
std::thread::sleep(std::time::Duration::from_secs(1));
}outputs
nanosleep hooked
-
support scalable stack
-
support and compatibility for AF_XDP socket
-
hook other syscall maybe interrupt by signal
syscalls
- open
- chdir
- chroot
- mkdir
- rmdir
- link
- unlink
- readlink
- stat
- dup
- dup2
- umask
- mount
- umount
- mknod
- fcntl
- truncate
- ftruncate
- setjmp
- longjmp
- chown
- lchown
- fchown
- chmod
- fchmod
- fchmodat
- semop
- ppoll
- pselect
- io_getevents
- semop
- semtimedop
- msgrcv
- msgsnd
-
support
#[open_coroutine::join]macro to wait coroutines
- refactor syscall state, distinguish between state and innerState
- Supports and is compatible with io_uring in terms of local file IO
- elegant shutdown
- use log instead of println
- enhance
#[open_coroutine::main]macro - refactor hook impl, no need to publish dylibs now
-
Monitorfollow thethread-per-coreguideline -
EventLoopfollow thethread-per-coreguideline
-
supportgenawaiteras low_level stackless coroutine (can't support it due to hook) - use
corosenseias low_level coroutine - support backtrace
- support
#[open_coroutine::co]macro - refactor
WorkStealQueue
-
use correct
epoll_eventstruct -
use
rayonfor parallel computing -
support
#[open_coroutine::main]macro -
hook almost all
readsyscallread syscalls
- recv
- readv
- pread
- preadv
- recvfrom
- recvmsg
-
hook almost all
writesyscallwrite syscalls
- send
- writev
- sendto
- sendmsg
- pwrite
- pwritev
-
hook other syscall
other syscalls
- sleep
- usleep
- nanosleep
- connect
- listen
- accept
- shutdown
- poll
- select
- basic suspend/resume supported
- use jemalloc as memory pool
- higher level coroutine abstraction supported
- preemptive scheduling supported
- work stealing supported
- sleep system call hooks supported
![dependabot[bot] avatar](https://avatars.githubusercontent.com/in/29110?v=4 "dependabot[bot]")
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent