C-Coroutines
asyncly
Our great sponsors
| C-Coroutines | asyncly | |
|---|---|---|
| 2 | 2 | |
| 72 | 27 | |
| - | - | |
| 0.0 | 4.6 | |
| about 7 years ago | 6 days ago | |
| C | C++ | |
| GNU Lesser General Public License v3.0 only | Apache License 2.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
C-Coroutines
-
Does anyone here actually UNDERSTAND coroutines?
A coroutine is an execution context + all necessary data for restoring the execution context. This includes a place for saving/restoring the stack and the registers. I always loved the simplicity and beauty of the coroutine_yield32: assembly implementation of this library. It's literally just swapping out stack and registers with another context in userspace. Async-await patterns are an abstraction around this to decide when to switch and when not to switch. Note that at no point a thread is started or stopped, or communicated with other threads/cores. Yielding is literally a series of unconditional moves.
-
David Mazieres' tutorial and take on C++20 coroutines
Or take advantage of the ABI of the runtime, and use assembly. [1] Yeah, not portable. But using setjmp()/longjmp() has issues as well (way too easy to mess it up because it doesn't do what you think it's doing).
[1] https://github.com/spc476/C-Coroutines
asyncly
-
Why choose async/await over threads?
One of the main benefits of async/await in Rust is that it can work in situations where you don't even have threads or dynamic memory. You can absolutely use it to write very concise code that's waiting on an interrupt on your microcontroller to have read some data coming in over I2C from some buffer. It's a higher level abstraction that allows your code to use concurrency (mostly) without having tons of interactions with the underlying runtime.
Every major piece of software that I have worked on has implemented this in one form or another (even in non-modern C++ where you don't have any coroutine concepts, Apple's grand central dispatch,). If you don't then your business logic will either be very imperformantly block on IO, have a gazillion of threads that make development/debugging a living hell, or be littered with implementation details of the underlying runtime or a combination of all 3.
If you don't use existing abstractions in the language (or through some library), you will end up building them yourselves, which is hard and probably overall inferior to widely used ones (if there are any). I have done so in the past, see https://github.com/goto-opensource/asyncly.
-
David Mazieres' tutorial and take on C++20 coroutines
Keep in mind that these is a really basic building block where you can bring your own runtime and hook coroutines into it, not something that is at all usable out of the box. This is exacerbated by the fact that the C++ standard library is still lacking support for non-blocking futures/promises.
To see how it can be used for actual asynchronous operations on a thread pool, take a look at asyncly, which I co-authored:
https://github.com/LogMeIn/asyncly/blob/master/Test/Unit/fut...
What are some alternatives?
cppcoro - A library of C++ coroutine abstractions for the coroutines TS
coro-chat - Playing with the C++17 Coroutines TS to implement a simple chat server