Tags : Browse Projects

Select a tag to browse associated projects and drill deeper into the tag cloud.

Eventlet

Compare

  Analyzed about 21 hours ago

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.

31.8K lines of code

15 current contributors

3 months since last commit

11 users on Open Hub

Low Activity
4.8
   
I Use This

gevent

Compare

  Analyzed 7 months ago

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]

229K lines of code

13 current contributors

7 months since last commit

9 users on Open Hub

Activity Not Available
5.0
 
I Use This

cogen

Compare

  Analyzed about 1 year ago

Coroutines in python using enhanced generators from python 2.5

4.49K lines of code

0 current contributors

about 7 years since last commit

5 users on Open Hub

Activity Not Available
5.0
 
I Use This

python-asyncio

Compare

  Analyzed about 1 year ago

This Python module provides infrastructure for writing single-threaded concurrent code using coroutines, multiplexing I/O access over sockets and other resources, running network clients and servers, and other related primitives.

21.3K lines of code

0 current contributors

about 2 years since last commit

1 users on Open Hub

Activity Not Available
0.0
 
I Use This

jyield

Compare

  Analyzed about 1 year ago

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.

2.58K lines of code

0 current contributors

almost 7 years since last commit

1 users on Open Hub

Activity Not Available
0.0
 
I Use This

python-pulsar

Compare

  Analyzed about 21 hours ago

Concurrent python

27.3K lines of code

5 current contributors

4 months since last commit

1 users on Open Hub

Moderate Activity
0.0
 
I Use This
Licenses: No declared licenses

febird

Compare

  Analyzed about 3 years ago

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]

206K lines of code

1 current contributors

about 3 years since last commit

0 users on Open Hub

Activity Not Available
0.0
 
I Use This

libconcurrency

Compare

  Analyzed about 1 year ago

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]

564 lines of code

0 current contributors

almost 9 years since last commit

0 users on Open Hub

Activity Not Available
0.0
 
I Use This

Fiberized.IO

Compare

  Analyzed about 23 hours ago

Fiber and async I/O based network library

28.6K lines of code

2 current contributors

4 months since last commit

0 users on Open Hub

Very Low Activity
0.0
 
I Use This
Licenses: BSL-1.0, BSD-2-Clause, MIT

trollius

Compare

  Analyzed about 15 hours ago

Portage of the Tulip project (asyncio module, PEP 3156) on Python 2.7.

22.4K lines of code

0 current contributors

almost 2 years since last commit

0 users on Open Hub

Very Low Activity
0.0
 
I Use This