Crate stuck

Multi-threading task facility building on cooperative stackful coroutine

stuck provides a multi-threading runtime to serve lightweight concurrent tasks where you can use coroutine::suspension to cooperatively resume suspending coroutines.

Usage

Construct an runtime::Runtime to runtime::Runtime::spawn initial task.

Task

• Use task::spawn to spawn new task in running task. The spawned task will run concurrent with all other tasks.
• Use task::session to create facilities to wake waiting tasks.
• Use task::JoinHandle to join task result.

Coroutine

• Use coroutine::spawn to spawn new coroutine in running task. The spawned coroutine will run cooperatively with other coroutines belonging to same task.
• Use coroutine::suspension to create facilities to resume suspending coroutines.
• Use coroutine::JoinHandle to join coroutine result.

Example

use std::time::Duration;

use stuck::channel::parallel;
use stuck::channel::prelude::*;
use stuck::{select, task, time};

#[stuck::main]
fn main() {
    let (mut request_sender, request_receiver) = parallel::bounded(1);
    let (mut response_sender, mut response_receiver) = parallel::bounded(1);

    task::spawn(move || {
        for value in request_receiver.into_iter() {
            time::sleep(Duration::from_secs(1));
            response_sender.send(value - 1).unwrap();
        }
    });

    let mut tasks = vec![6, 6, 6, 6];

    let mut sum = 0;
    loop {
        select! {
            r = <-response_receiver => if let Some(n) = r {
                sum += n;
            },
            _ = request_sender<-tasks.pop().unwrap(), if !tasks.is_empty()  => if tasks.is_empty() {
                request_sender.close();
            },
            complete => break,
        }
    }
    println!("sum: {}", sum);
    assert_eq!(sum, 20);
}

Modules

channel

Channel utilities for commnication across coroutines and tasks.

coroutine

Cooperative coroutines in task.

fs

Drop-in replacement of std::fs with no operations block scheduling thread.

net

Networking primitives for TCP/UDP communication.

runtime

Constructions to bootstrap stuck runtime.

select

Selectively read and write values to/from multiple selectables simultaneously.

task

Lightweight concurrent execution units based on coroutines.

time

Utilities to suspend running coroutines.

Macros

select

Select multiple selectables simultaneously for reading and writing

Structs

JoinError

Wraps panic as std::error::Error.

StackSize

StackSize specifies desired stack size for new task.

Attribute Macros

main

Executes marked main function in configured runtime.

test

Executes marked test function in configured runtime.