Projects

Eventlet

Eventlet is a networking library written in Python. It achieves high scalability by using non-blocking io while at the same time retaining high programmer usability by using coroutines to make the non-blocking io operations appear blocking at the source code level.

gevent

gevent is a coroutine-based Python networking library that uses greenlet to provide a high-level synchronous API on top of libevent event loop. Features include: convenient API around greenlets familiar synchronization primitives socket module that cooperates WSGI server on top of ... [More] libevent-http DNS requests done through libevent-dns monkey patching utility to get pure Python modules to cooperate [Less]

cogen

Coroutines in python using enhanced generators from python 2.5

jyield

jyield aims to provide java continuations support similar to c# yield coroutines. The methods annotated with @Continuable are transformed in runtime or optionally in compile time.

antipaxi

In order to learn a tiny bit about the Io language and distributed consensus algorithms I'm attempting to implement a simple Paxos algorithm. While this program does run and produce behavior somewhat consistent with what I expect I cannot over emphasize enough that I don't have confidence ... [More] it is indeed correct. I was not able to conceive of a test proving its correctness. I would very much appreciate second opinions. You have been warned. [Less]

dactor

dactordactor 是使用D语言编写的轻量级线程运行框架，使用了 D2 runtime 提供的 Fiber ... [More] 作为最小的逻辑执行，编写调度器来调度大量轻量级线程的运行。调度器充分考虑高并发（无IO阻塞）、并行（多线程调度）、异步（aio/iocp、socket）和分布式（位置无关）等，非常适合编写高并发服务器程序。 dactor 使用 Coroutine + Actor 模型实现，实现高并发、并行、异步、分布式等特性时，还能够保证逻辑的连贯性，因此非常适合编写逻辑复杂的高并发分布式服务。 D语言Digital Mars 的D语言介绍： D is a systems programming language. Its focus is on combining the power and high performance of C and C++ with the programmer productivity of modern languages like Ruby and Python. Special attention is given to the needs of quality assurance, documentation, management, portability and reliability. D语言是一种系统编程语言。（待续） 相关链接Coroutine Actor Model Erlang 语言 [Less]

boba

本项目开发中，未可用。先看看代码 简介（已完成）腐朽落后的有限状态机已被本项目抛弃 （开发中）基于规则的推理引擎 （开发中）基于协程（coroutine），使用juru （规划中）自带领域特定语言（DSL） （暂时）ms-windows only ... [More] 项目名的出处http://en.wikipedia.org/wiki/Boba_Fett http://www.hudong.com/wiki/%E6%B3%A2%E9%9C%B8 参考资料Rule-based Programming Rule-based System Production System Inference Engine Expert System OPS5 Finite State Machine Fiber [Less]

febird

febird implemented a serialization framework(vs boost.serialization/google.protocolbuffer), can be used in protocol parsing, big/small data serialization, even in very small object serialize, performance is good. (such as key/data serialization in BerkeleyDB), it provide fast performance(30~80 times ... [More] faster than boost.binary_archive), and lower memory usage. febird.rpc is a C++ remote procedure call without an IDL supporting, it based on the serialization framework. febird.rpc provide convenient usage and fast performance, and an uniform coding style. most stl algorithm(sort/heap/find...) for C, provide high performance(same as stl) through C-Preprocessor Tricky. thread red-black tree implementation, kernel is written in C, and C++ interface(std::map/set interface) is supplied also, my implementation is fast(no compare function overhead) but has no code explosion, because I used a C-preprocessor tricky. febird 实现了一个序列化框架（对比boost.serializaiton/google.protocolbuffer），可以用在协议解析，大/小数据的序列化，有极高的性能（比boost.binary_archive快30~80倍），甚至对于非常小的对象，例如只有几个字节的对象，这在序列化BerkeleyDB中key/data这么小的对象（可能只是一个整数/变长整数）时非常有用。 该库提供了对BerkeleyDB的序列化封装，可以象使用std::map一样使用它。 该库也实现了一个不需要IDL的rpc，使用几个宏，很方便的自动完成函数参数的序列化，比MFC的MessageMap还要方便。 stl算法的C版本，使用了一种C预处理器技巧，提供和stl相当的性能(例如febird_sort远快于qsort，与stl::sort相当)。 线索红黑树（Threaded Red-Black Tree, C核心+C/Cpp接口，仿std::set/map）, 在提供高性能的同时，没有C++的代码膨胀问题，因为使用了一个C预处理(C-preprocessor)技巧，详见：http://blog.csdn.net/whinah/archive/2009/05/26/4218292.aspx 使用时请尽量checkout最新版 @see http://blog.csdn.net/whinah http://blog.csdn.net/whinah/archive/2008/11/07/3248730.aspx http://blog.csdn.net/whinah/archive/2008/11/07/3248770.aspx [Less]

libconcurrency

Concurrency in CA lightweight concurrency library for C, featuring symmetric coroutines as the main control flow abstraction. The library is similar to State Threads, but using coroutines instead of green threads. This simplifies inter-procedural calls and largely eliminates the need for mutexes and ... [More] semaphores for signaling. Eventually, coroutine calls will also be able to safely migrate between kernel threads, so the achievable scalability is consequently much higher than State Threads, which is purposely single-threaded. This library was inspired by Douglas W. Jones' "minimal user-level thread package". The pseudo-platform-neutral probing algorithm on the svn trunk is derived from his code. There is also a safer, more portable coroutine implementation based on stack copying, which was inspired by sigfpe's page on portable continuations in C. Copying is more portable and flexible than stack switching, and making copying competitive with switching is being researched. CoroutinesCoroutine calls consist of only one operation: coro_call. This operation suspends the currently executing coroutine, and resumes the target coroutine passing it a given value. Passing a value in the other direction is exactly the same. Coroutines which use only one operation like this are called symmetric coroutines. Asymmetric coroutines use two different operations, like call and yield, implying that one caller is subordinate to another. Lua supports asymmetric coroutines. In many ways, such coroutines closely resemble the Inter-Process Communication (IPC) facilities of microkernel operating systems like EROS, and they are also closely related to actors. Revisiting Coroutines is a detailed paper explaining the advantages of coroutines as a control flow abstraction. While the authors prefer asymmetric coroutines, and use a coroutine label to avoid capture problems, I think it's simpler to simply use the coroutine reference itself in place of a label. Comparison to Existing AlternativesFeatures libconcurrency provides that are not found in libcoro, libCoroutine, libpcl, coro: Cloning a coroutine: this enables a straightforward implementation of multishot continuations. Without the ability to clone, only one-shot continuations can be implemented in terms of coroutines. Note, cloning is not available on Windows since Windows uses the Fibers API. This was necessary to handle some unfortunate problems. The more portable stack copying implementation does support cloning. Portable Speed: libconcurrency is based on a portable technique that modifies jmp_buf and uses setjmp/longjmp to save and restore contexts. This is fast because setjmp/longjmp do not save and restore signals, whereas most other libraries are based on ucontext, which is very portable but inefficient, or assembler which is efficient but not portable. The library consists of entirely C99 compliant C and no exotic platform or OS features are used. Actual coroutine API: most of the listed libraries implement green threads, not coroutines. You'll note that no values are passed between coroutines in these libraries. Passing values between coroutines is one of the primary reasons why they are more general than threads. Simpler API: the API consists of only 6 orthogonal functions: coro_init, coro_call, coro_clone, coro_poll, coro_free. Works on Windows: libconcurrency is primarily developed on Windows, and uses Windows Fibers for coroutines. Resources are managed: the coro_poll function must be called periodically to ensure a coroutine has enough resources to continue executing. This function can shrink or grow the stack using a hysteresis algorithm inspired by the description of one-shot continuations in Representing Control in the Presence of One-Shot Continuations. ExampleHere's a basic reader/writer that simply echoes characters read to the screen: #include #include coro cr; coro cw; void reader(cvalue r) { while (1) { printf("> "); r.c = getchar(); if (r.c != '\n') { coro_call(cw, r); } } } void writer(cvalue w) { while(1) { printf(" echo: %c\n", w.c); w = coro_call(cr, cnone); } } int main(int argc, char **argv) { coro _main = coro_init(); printf("Simple reader/writer echo...\n"); cr = coro_new(reader); cw = coro_new(writer); coro_call(cw, cnone); return 0; } [Less]