Lightweight, portable C++ fibers, MIT license

问题:

I would like to get ahold of a lightweight, portable fiber lib with MIT license (or looser). Boost.Coroutine does not qualify (not lightweight), neither do Portable Coroutine Library nor Kent C++CSP (both GPL).

Edit: could you help me find one? :)

回答1:

1. Libtask: MIT License
2. Libconcurrency: LGPL (a little tighter than MIT, but it's a functional library!)

Both are written for C.

回答2:

I actually blogged about this in the past. Have a look! I hope it answers your questions. In it, I cover a number of libraries, and I was particularly interested in ones that were useful for systems programming (asynchronous IO).

Conspicuously absent from that coverage is Boost.Coroutine, which I'll discuss here. Boost.Coroutine may be considered "heavyweight" conceptually (in terms of its family of types), but the implementation is quite efficient. The real problem is that Boost.Coroutine is incomplete, and (last I checked) far from complete. I had spent some time trying to work with the author through its non-starter issues, as I was really looking forward to using it in conjunction with Boost.Asio (this was one of Boost.Coroutine's primary objectives), but the author has not had the time to take his work to the Boost formal review stage.

回答3:

list of implementations for C

for ultra lightweight "threads" take a look at Protothreads at the bottom of the wikipedia article.

回答4:

Now you have two better options with Boost license:

• Boost.Fiber
• Boost.Coroutine2

回答5:

There is a blazing fast and lightweight C asymmetric coroutine library - libaco.

It is really small, very fast and extremely memory efficient:

Along with the implementation of a production-ready C coroutine library, here is a detailed documentation about how to implement a fastest and correct coroutine library and also with a strict mathematical proof;

It has no more than 700 LOC but has the full function you may want from a coroutine library;

The benchmark part shows that one time of the context switching between coroutines only takes about 10 ns (for the case of standalone stack) on the AWS c5d.large machine;

User could choose to create a new coroutine with a standalone stack or with a share stack (could be shared with others);

It is extremely memory efficient: 10,000,000 amount of co simultaneously to run only cost 2.8 GB physical memory (run with tcmalloc, each co has a 120B copy-stack size configuration).

It also has a very detailed documentation.

PS:

It is under the Apache License, Version 2.0.