lthread

Other C coroutines https://github.com/hnes/libaco https://github.com/baruch/libwire https://swtch.com/libtask/ https://github.com/halayli/lthread https://github.com/Tencent/libco https://byuu.org/library/libco/

the most starred co-routine C is: https://github.com/Tencent/libco It's said golang learned from libtask: https://github.com/jamwt/libtask And something else: https://github.com/baruch/libwire https://github.com/halayli/lthread (multi-core friendly)

Not directly. I think it is part of the Playstation SDK (but I'm not a game developer). There are libraries that are based on the same concept (many execution contexts per thread): * https://github.com/RichieSams/FiberTaskingLib * https://swtch.com/libtask/ * https://github.com/halayli/lthread * https://github.com/stevedekorte/coroutine RethinkDB are using something like this: http://rethinkdb.com/blog/improving-a-large-c-project-with-c... http://rethinkdb.com/blog/making-coroutines-fast/

One can use the same Go style concurrency in C with libmill [1]. Another interesting choice for concurrency would be lthread [2]. What’s special about lthread is that it allows you to make blocking calls and expensive computations, blocking IO inside a coroutine, providing you with the advantages of coroutines and pthreads. [1] http://libmill.org/ [2] https://github.com/halayli/lthread

You might want to take a look at: lthread & lthread cpp https://github.com/halayli/lthread https://github.com/halayli/lthread_cpp

here's a similar technique I use in lthread to generate functions: https://github.com/halayli/lthread/blob/master/src/lthread_s... the arguments are complete function signature

For those interested in coroutines, check out lthread & lthread cpp bindings (disclaimer: author) Code: https://github.com/halayli/lthread https://github.com/halayli/lthread_cpp Docs: http://lthread.readthedocs.org/en/latest/ http://lthread-cpp.readthedocs.org/en/latest/

Lthread (http://github.com/halayli/lthread) is basically an M:N threading model. You can run an lthread scheduler per core.

You can also write it in C and use lthread. It will be faster than what Go has to offer. https://github.com/halayli/lthread

I think lthread (http://github.com/halayli/lthread) is the only coroutine lib that allows you to block inside a coroutine and do heavy computation without affecting other coroutines. Example: void my_function(void* arg) { char buf[1024]; int ret = lthread_recv_exact(fd, buf, 1024, 0, timeout); lthread_compute_begin(); /* block as long as you wish, run heavy computation on buf, access your stack variables etc.. */ lthread_compute_end(); } Disclaimer: lthread author.

There is also https://github.com/halayli/lthread which wraps common POSIX functions.

or use lthread. http://github.com/halayli/lthread

lthread is a coroutine library that allows you to make blocking calls inside coroutines by surrounding the blocking code with lthread_compute_begin() and lthread_compute_end(). This is equivalent to async calls but without the need to capture variables. http://github.com/halayli/lthread/ Disclaimer: lthread author

Relevant: super lightweight co-routines in C, with (limited) support for blocking as well: https://github.com/halayli/lthread

For those interested, lthread now supports AIO. It's still in dev branch, but I'll be merging it soon: http://webmon.com/blog/2013/02/19/lthread-now-supports-userl... https://github.com/halayli/lthread/blob/dev/src/lthread_io.c