What is a coroutine?

coroutine = continuation:
- a static snapshot of execution position
- list of stack frames of nested function calls, including the instruction pointer and the registers
thread: an execution unit scheduled by the operating system which is or will be running a coroutine
process: a bunch of threads which share the same virtual address space, filehandles, signal handlers, permissions etc.

Most threads are waiting

AcceptConnections()

nbsocket.accept()

waiting for fd 3 becoming readable

HandleHttpProxyConnection()

ReadHttpRequest()

nbfile.readline()

nbsocket.recv()

waiting for fd 4 becoming readable

HandleHttpProxyConnection()

WriteHttpResponseHeader()

nbfile.write()

nbsocket.send()

waiting for fd 5 becoming writable

CleanCachePeriodically()

sleep()

sleeping until timestamp 123456789.01 is reached

Coroutine implementations in Python

Stackless tasklet
- Syncless, Concurrence, (Eventlet)
greenlet
- gevent, Eventlet, Syncless, (Concurrence)
PyPy coroutine
(generator)
- monocle, Chiral, DieselWeb, MultiTask, FriendlyFlow, Weightless, Fibra, Cogen
(thread)

... and the corresponding I/O libraries

Stackless tasklet
- Syncless, Concurrence, (Eventlet)
greenlet
- gevent, Eventlet, Syncless, (Concurrence)
PyPy coroutine
(generator)
- monocle, Chiral, DieselWeb, MultiTask, FriendlyFlow, Weightless, Fibra, Cogen
(thread)

Why emulate?

Why emulate coroutine implementations with each other?

to be able to run Syncless, Concurrence etc. with greenlet
to be able to run gevent etc. with Stackless
to understand them better

Coroutine emulators in Python

emulate greenlet using Stackless
- Eventlet 0.9.16: eventlet/support/stacklesss.py
- Syncless 0.23: syncless/greenlet_using_stackless.py
  - test: test/greenlet_test.py
emulate Stackless using greenlet
- PyPy 1.5.0: lib_pypy/stackless.py
  - supports coroutine and greenlet natively
  - emulates Stackless using PyPy coroutine
  - as a fallback, emulates Stackless using greenlet
- Concurrence 0.3.1: lib/concurrence/_stackless.py
- Syncless 0.23: syncless/greenstackless.py
  - test: test/stackless_test.py

greenlet emulation correctness

14: number of tests in test/greenlet_test.py
14: native CPython greenlet
14: Syncless
09: native PyPy stackless.greenlet (no sys.getrefcount; fail: del)
00: Eventlet (no throw, incomplete emulation, missing class members)

These numbers useless as metrics, thus they are not fair.

Stackless emulation correctness

20: number of tests in test/stackless_test.py
20: native Stackless Python
18: Syncless (fails: del refcount, del gc)
00: Concurrence (missing main, getmain, is_main, prev, next, current)
00: PyPy (missing main, current, next, prev, TaskletExit)

These numbers useless as metrics, thus they are not fair.

Who needs 13371 concurrent connections?

server with long-living, low volume connections
- for chat rooms
- for web–IRC gateways
- for publish/subscribe messaging
- for online multiplayer games (e.g. MUDs, second life)
low-traffic custom sites or services on low-memory servers
peer-to-peer clients (e.g. the bittorrent reference impl.)
session-aware proxies

Coroutines are also useful for just a dozen connections:

file transfer and backup clients
automated stock and forex trading

Memory leak in greenlet

import gc
import sys
from greenlet import greenlet
def F(other_ref, x):
  greenlet.getcurrent().parent.switch(42)
x = []
xr = sys.getrefcount(x)
g = [greenlet(F), greenlet(F)]
assert 42 == g[0].switch(g[1], x)
assert 42 == g[1].switch(g[0], x)  # Comment this line to fix.
del g[:]
gc.collect()
print sys.getrefcount(x) - xr  #: 4, greenlets still not deleted.

Should emulators emulate this memory leak?
May emulators postpone deletion or to have memory leaks?
Should emulators emulate __del__ timing?

No memory leak in Stackless

import gc
import sys
import stackless
def F(other_ref, x):
  stackless.schedule_remove()
x = []
xr = sys.getrefcount(x)
g = [stackless.tasklet(F), stackless.tasklet(F)]
g[0](g[1], x)
g[1](g[0], x)
print sys.getrefcount(x) - xr  #: 2
g[0].run()
g[1].run()
del g[:]
print sys.getrefcount(x) - xr  #: 1, tasklets not deleted yet.
gc.collect()
print sys.getrefcount(x) - xr  #: 0, tasklets deleted.

Differences between greenlet, Stackless and coroutine

Stackless runnables list
Stackless channel
Stackless channel waiting list
Stackless pickling (not emulated)
Stackless main tasklet
greenlet parent
coroutine (no extras)

Emulation challenges

Pedantic:

all classes, methods, functions and globals present
correct default values for all functions
correct argument names and default values for all functions
raise the same exceptions on invalid operations

Tricky:

which coroutine continues upon a fatal exception
which coroutine continues upon __del__
what is the default of the passed value
stackless.current without calling a function