context_bind 0.0.2

Simple M:N threading library. Should support Linux, MacOS, Free/OpenBSD, and Windows for x86/64, and aarch32/64

Crate context_bind [] [src]

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

StackSize

Define the size of a stack

Functions

swap

Leave Co-Routine.