160 lines
5.4 KiB
Python
160 lines
5.4 KiB
Python
# Coroutine implementation using Python threads.
|
|
#
|
|
# Combines ideas from Guido's Generator module, and from the coroutine
|
|
# features of Icon and Simula 67.
|
|
#
|
|
# To run a collection of functions as coroutines, you need to create
|
|
# a Coroutine object to control them:
|
|
# co = Coroutine()
|
|
# and then 'create' a subsidiary object for each function in the
|
|
# collection:
|
|
# cof1 = co.create(f1 [, arg1, arg2, ...]) # [] means optional,
|
|
# cof2 = co.create(f2 [, arg1, arg2, ...]) #... not list
|
|
# cof3 = co.create(f3 [, arg1, arg2, ...])
|
|
# etc. The functions need not be distinct; 'create'ing the same
|
|
# function multiple times gives you independent instances of the
|
|
# function.
|
|
#
|
|
# To start the coroutines running, use co.tran on one of the create'd
|
|
# functions; e.g., co.tran(cof2). The routine that first executes
|
|
# co.tran is called the "main coroutine". It's special in several
|
|
# respects: it existed before you created the Coroutine object; if any of
|
|
# the create'd coroutines exits (does a return, or suffers an unhandled
|
|
# exception), EarlyExit error is raised in the main coroutine; and the
|
|
# co.detach() method transfers control directly to the main coroutine
|
|
# (you can't use co.tran() for this because the main coroutine doesn't
|
|
# have a name ...).
|
|
#
|
|
# Coroutine objects support these methods:
|
|
#
|
|
# handle = .create(func [, arg1, arg2, ...])
|
|
# Creates a coroutine for an invocation of func(arg1, arg2, ...),
|
|
# and returns a handle ("name") for the coroutine so created. The
|
|
# handle can be used as the target in a subsequent .tran().
|
|
#
|
|
# .tran(target, data=None)
|
|
# Transfer control to the create'd coroutine "target", optionally
|
|
# passing it an arbitrary piece of data. To the coroutine A that does
|
|
# the .tran, .tran acts like an ordinary function call: another
|
|
# coroutine B can .tran back to it later, and if it does A's .tran
|
|
# returns the 'data' argument passed to B's tran. E.g.,
|
|
#
|
|
# in coroutine coA in coroutine coC in coroutine coB
|
|
# x = co.tran(coC) co.tran(coB) co.tran(coA,12)
|
|
# print x # 12
|
|
#
|
|
# The data-passing feature is taken from Icon, and greatly cuts
|
|
# the need to use global variables for inter-coroutine communication.
|
|
#
|
|
# .back( data=None )
|
|
# The same as .tran(invoker, data=None), where 'invoker' is the
|
|
# coroutine that most recently .tran'ed control to the coroutine
|
|
# doing the .back. This is akin to Icon's "&source".
|
|
#
|
|
# .detach( data=None )
|
|
# The same as .tran(main, data=None), where 'main' is the
|
|
# (unnameable!) coroutine that started it all. 'main' has all the
|
|
# rights of any other coroutine: upon receiving control, it can
|
|
# .tran to an arbitrary coroutine of its choosing, go .back to
|
|
# the .detach'er, or .kill the whole thing.
|
|
#
|
|
# .kill()
|
|
# Destroy all the coroutines, and return control to the main
|
|
# coroutine. None of the create'ed coroutines can be resumed after a
|
|
# .kill(). An EarlyExit exception does a .kill() automatically. It's
|
|
# a good idea to .kill() coroutines you're done with, since the
|
|
# current implementation consumes a thread for each coroutine that
|
|
# may be resumed.
|
|
|
|
import thread
|
|
import sync
|
|
|
|
class _CoEvent:
|
|
def __init__(self, func):
|
|
self.f = func
|
|
self.e = sync.event()
|
|
|
|
def __repr__(self):
|
|
if self.f is None:
|
|
return 'main coroutine'
|
|
else:
|
|
return 'coroutine for func ' + self.f.func_name
|
|
|
|
def __hash__(self):
|
|
return id(self)
|
|
|
|
def __cmp__(x,y):
|
|
return cmp(id(x), id(y))
|
|
|
|
def resume(self):
|
|
self.e.post()
|
|
|
|
def wait(self):
|
|
self.e.wait()
|
|
self.e.clear()
|
|
|
|
Killed = 'Coroutine.Killed'
|
|
EarlyExit = 'Coroutine.EarlyExit'
|
|
|
|
class Coroutine:
|
|
def __init__(self):
|
|
self.active = self.main = _CoEvent(None)
|
|
self.invokedby = {self.main: None}
|
|
self.killed = 0
|
|
self.value = None
|
|
self.terminated_by = None
|
|
|
|
def create(self, func, *args):
|
|
me = _CoEvent(func)
|
|
self.invokedby[me] = None
|
|
thread.start_new_thread(self._start, (me,) + args)
|
|
return me
|
|
|
|
def _start(self, me, *args):
|
|
me.wait()
|
|
if not self.killed:
|
|
try:
|
|
try:
|
|
apply(me.f, args)
|
|
except Killed:
|
|
pass
|
|
finally:
|
|
if not self.killed:
|
|
self.terminated_by = me
|
|
self.kill()
|
|
|
|
def kill(self):
|
|
if self.killed:
|
|
raise TypeError, 'kill() called on dead coroutines'
|
|
self.killed = 1
|
|
for coroutine in self.invokedby.keys():
|
|
coroutine.resume()
|
|
|
|
def back(self, data=None):
|
|
return self.tran( self.invokedby[self.active], data )
|
|
|
|
def detach(self, data=None):
|
|
return self.tran( self.main, data )
|
|
|
|
def tran(self, target, data=None):
|
|
if not self.invokedby.has_key(target):
|
|
raise TypeError, '.tran target %r is not an active coroutine' % (target,)
|
|
if self.killed:
|
|
raise TypeError, '.tran target %r is killed' % (target,)
|
|
self.value = data
|
|
me = self.active
|
|
self.invokedby[target] = me
|
|
self.active = target
|
|
target.resume()
|
|
|
|
me.wait()
|
|
if self.killed:
|
|
if self.main is not me:
|
|
raise Killed
|
|
if self.terminated_by is not None:
|
|
raise EarlyExit, '%r terminated early' % (self.terminated_by,)
|
|
|
|
return self.value
|
|
|
|
# end of module
|