vorner / corona

Coroutine and async/await support for tokio-based futures

Corona

Deprecated

This library supports tokio 0.1, which is outdated. There's not much need for it any more since Rust supports native async/await syntax. Use some of the async libraries directly.

About the library

When you need to get the asynchronous out of the way.

Corona is a library providing stackful coroutines for Rust. They integrate well with futures ‒ it is possible to switch between the abstractions as needed, each coroutine is also a future and a coroutine can wait for a future to complete. Furthermore, the futures don't have to be 'static.

On the other hand, there's a runtime cost to the library. The performance does not necessarily suffer (as seen in the benchmarks). But each coroutine has its own stack, which takes memory.

You want to read the docs and examine the examples.

License

Licensed under either of

• Apache License, Version 2.0, (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

corona's Issues

larger default stack size

This issue is to figure out what size the stack should be by default - the current one is small enough that it's really easy to run into stack overflow issues.

My best guess at a sensible default is to just use the default Linux thread stack size so that we won't run into stack overflows for normal rust code, which AFAICT is 8mb.

Update benchmark results with sorted results

I just read your interesting blog post and found useful to have the benchmark results sorted.

I have done this job for you if you want: https://gist.github.com/Kerollmops/699c52da7f2cd36ab306e48976a286e5

Setting stack size causes assertion error

Minimal example:

use corona::{coroutine::*, prelude::*};
use futures::future::Future;

#[test]
fn main() {
    Coroutine::new()
        .stack_size(10_000)
        .run(|| {})
        .expect("failed")
}

Having this bug with corona = 0.4 and futures = 0.1.

Multicore scheduling

Right now the only way to have Coroutines executing on multiple threads is to manually configure the threadpool upfront and again manually handle passing work between them. This is not ideal for being able to mix and match corona and futures based code, and additionally requires users to figure out inter-thread scheduling themselves.

I'm working on a fix to this in my fork right now, any tips on how I might go about it? Seems like the obvious things to do are to replace thread-local RefCells with something from futures-locks, and replace the unsync::oneshot channels with sync::oneshot.

Also, using thread-local storage for the coroutine builder is probably the wrong approach for this use case. Is there something better we could do instead? Maybe a global futures_locks::RwLock?