Expand description
This crate exists to be a shim between Context and a higher level library. The interface that it will present are generally not as safe as context. This is an intentional design decision to make the implementation of a co-routine library easier on myself.
Every new routine generated will allocate generally twice. Once for the
lambda (the developer will do this before calling Routine:new
) and
once internal to Routine::new
to build the stack.
Stack overflows are checked.
To integrate this crate into your project simply use
[dependencies]
context_bindings = "0.0.2"
Below is a simple example
use context_bind::{StackSize,Routine,swap};
let mut dut0 = Routine::new(StackSize::KiB8,move ||{
for i in 0usize.. {
swap(i*2);
}
}).unwrap();
let mut dut1 = Routine::new(StackSize::KiB8,move ||{
for i in 0usize.. {
swap(i*4);
}
}).unwrap();
for x in 0..10 {
let a = dut0.exec(0);
let b = dut1.exec(0);
assert_eq!(a,x*2);
assert_eq!(b,x*4);
}
The presented interface is very small. In simplest terms the value passed
to exec
will be injected, and returned by swap
. The opposite is also
true. The value give to swap
, will be injected and returned by exec
.
The exec
function will always resume within the swap call, that yielded
the co-routine context.
There is more thread safety worth discussing. A routine maybe sent another thread once contructed (this is safe). A routine can be sent between threads while it is not running. But if you move a routine while it is running (you a dark unsafe wizard), bad things may happen.
swap
will panic if it called outside of a coroutine.
What is the difference between 0.0.1 and 0.0.2? I cleaned up the docs and public interfaces.
Structs§
- Routine
- Encapsulate the state of a co-routine
Enums§
- Stack
Size - Define the size of a stack
Functions§
- swap
- Leave Co-Routine.