| Current File : /home/mmdealscpanel/yummmdeals.com/threads.tar |
fcmp.pyc 0000644 00000003235 15037407673 0006225 0 ustar 00 �
��^c @ sz d d l Td � Z d � Z e d d d g � e d d g g g d g g � d d d d g g d d g d
g g g g Z e e � d � Z e e d � e � GHe e d
� e � GHe e e d
� � GHe e d
� e � GHe e e d
� � GHe d d g d
g g d g d g d
g � GHe d d g d
g g d g d g d
g � GHe d d g d
g g d g d g d g � GHd S( i����( t *c C sJ xC | D]; } t | � t g � k r5 t | | � q | j | � q Wd S( N( t typet fringet back( t cot listt x( ( s) /usr/lib64/python2.7/Demo/threads/fcmp.pyR s
c C sO t � } | j t | | � } y x | j | � Gq$ WWn t k
rI n XHd S( N( t Coroutinet createR t trant EarlyExit( R R t f( ( s) /usr/lib64/python2.7/Demo/threads/fcmp.pyt printinorder s
i i i i i i i c C s t � } | j t | | � } t � } | j t | | � } x� y | j | � } WnD t k
r� y | j | � } Wn t k
r� d SX| j � d SXy | j | � } Wn t k
r� | j � d SX| | k r? | j � | j � t | | � Sq? Wd S( Ni i����i ( R R R R R
t killt cmp( t l1t l2t co1t f1t co2t f2t v1t v2( ( s) /usr/lib64/python2.7/Demo/threads/fcmp.pyt fcmp s.
i i i N( R R R R R t range( ( ( s) /usr/lib64/python2.7/Demo/threads/fcmp.pyt <module> s$
-
Coroutine.py 0000644 00000012624 15037407673 0007106 0 ustar 00 # 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()
class Killed(Exception): pass
class EarlyExit(Exception): pass
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
fcmp.pyo 0000644 00000003235 15037407673 0006241 0 ustar 00 �
��^c @ sz d d l Td � Z d � Z e d d d g � e d d g g g d g g � d d d d g g d d g d
g g g g Z e e � d � Z e e d � e � GHe e d
� e � GHe e e d
� � GHe e d
� e � GHe e e d
� � GHe d d g d
g g d g d g d
g � GHe d d g d
g g d g d g d
g � GHe d d g d
g g d g d g d g � GHd S( i����( t *c C sJ xC | D]; } t | � t g � k r5 t | | � q | j | � q Wd S( N( t typet fringet back( t cot listt x( ( s) /usr/lib64/python2.7/Demo/threads/fcmp.pyR s
c C sO t � } | j t | | � } y x | j | � Gq$ WWn t k
rI n XHd S( N( t Coroutinet createR t trant EarlyExit( R R t f( ( s) /usr/lib64/python2.7/Demo/threads/fcmp.pyt printinorder s
i i i i i i i c C s t � } | j t | | � } t � } | j t | | � } x� y | j | � } WnD t k
r� y | j | � } Wn t k
r� d SX| j � d SXy | j | � } Wn t k
r� | j � d SX| | k r? | j � | j � t | | � Sq? Wd S( Ni i����i ( R R R R R
t killt cmp( t l1t l2t co1t f1t co2t f2t v1t v2( ( s) /usr/lib64/python2.7/Demo/threads/fcmp.pyt fcmp s.
i i i N( R R R R R t range( ( ( s) /usr/lib64/python2.7/Demo/threads/fcmp.pyt <module> s$
-
Coroutine.pyc 0000644 00000010227 15037407673 0007246 0 ustar 00 �
��^c @ sn d d l Z d d l Z d d
d � � YZ d e f d � � YZ d e f d � � YZ d d d � � YZ d S( i����Nt _CoEventc B s> e Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s | | _ t j � | _ d S( N( t ft synct eventt e( t selft func( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt __init__I s c C s% | j d k r d Sd | j j Sd S( Ns main coroutines coroutine for func ( R t Nonet func_name( R ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt __repr__M s c C s
t | � S( N( t id( R ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt __hash__S s c C s t t | � t | � � S( N( t cmpR ( t xt y( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt __cmp__V s c C s | j j � d S( N( R t post( R ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt resumeY s c C s | j j � | j j � d S( N( R t waitt clear( R ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR \ s
( t __name__t
__module__R R
R R R R ( ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR H s t Killedc B s e Z RS( ( R R ( ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR ` s t EarlyExitc B s e Z RS( ( R R ( ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR a s t Coroutinec B sP e Z d � Z d � Z d � Z d � Z d d � Z d d � Z d d � Z RS( c C sH t d � | _ | _ i d | j 6| _ d | _ d | _ d | _ d S( Ni ( R R t activet maint invokedbyt killedt valuet
terminated_by( R ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR d s
c G s7 t | � } d | j | <t j | j | f | � | S( N( R R R t threadt start_new_threadt _start( R R t argst me( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt createk s
c G si | j � | j se z, y t | j | � Wn t k
r= n XWd | j sa | | _ | j � n Xn d S( N( R R t applyR R R t kill( R R$ R# ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR" q s
c C sF | j r t d � n d | _ x! | j j � D] } | j � q. Wd S( Ns kill() called on dead coroutinesi ( R t TypeErrorR t keysR ( R t coroutine( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR' ~ s
c C s | j | j | j | � S( N( t tranR R ( R t data( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt back� s c C s | j | j | � S( N( R+ R ( R R, ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt detach� s c C s� | j j | � s% t d | f � n | j rA t d | f � n | | _ | j } | | j | <| | _ | j � | j � | j r� | j | k r� t � n | j
d k r� t d | j
f � q� n | j S( Ns* .tran target %r is not an active coroutines .tran target %r is killeds %r terminated early(
R t has_keyR( R R R R R R R R R R ( R t targetR, R$ ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR+ � s
N(
R R R R% R" R' R R- R. R+ ( ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR c s
( ( ( R R R t ExceptionR R R ( ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt <module>E s
telnet.py 0000644 00000006005 15037407673 0006426 0 ustar 00 # Minimal interface to the Internet telnet protocol.
#
# *** modified to use threads ***
#
# It refuses all telnet options and does not recognize any of the other
# telnet commands, but can still be used to connect in line-by-line mode.
# It's also useful to play with a number of other services,
# like time, finger, smtp and even ftp.
#
# Usage: telnet host [port]
#
# The port may be a service name or a decimal port number;
# it defaults to 'telnet'.
import sys, os, time
from socket import *
import thread
BUFSIZE = 8*1024
# Telnet protocol characters
IAC = chr(255) # Interpret as command
DONT = chr(254)
DO = chr(253)
WONT = chr(252)
WILL = chr(251)
def main():
if len(sys.argv) < 2:
sys.stderr.write('usage: telnet hostname [port]\n')
sys.exit(2)
host = sys.argv[1]
try:
hostaddr = gethostbyname(host)
except error:
sys.stderr.write(sys.argv[1] + ': bad host name\n')
sys.exit(2)
#
if len(sys.argv) > 2:
servname = sys.argv[2]
else:
servname = 'telnet'
#
if '0' <= servname[:1] <= '9':
port = eval(servname)
else:
try:
port = getservbyname(servname, 'tcp')
except error:
sys.stderr.write(servname + ': bad tcp service name\n')
sys.exit(2)
#
s = socket(AF_INET, SOCK_STREAM)
#
try:
s.connect((host, port))
except error, msg:
sys.stderr.write('connect failed: %r\n' % (msg,))
sys.exit(1)
#
thread.start_new(child, (s,))
parent(s)
def parent(s):
# read socket, write stdout
iac = 0 # Interpret next char as command
opt = '' # Interpret next char as option
while 1:
data, dummy = s.recvfrom(BUFSIZE)
if not data:
# EOF -- exit
sys.stderr.write( '(Closed by remote host)\n')
sys.exit(1)
cleandata = ''
for c in data:
if opt:
print ord(c)
## print '(replying: %r)' % (opt+c,)
s.send(opt + c)
opt = ''
elif iac:
iac = 0
if c == IAC:
cleandata = cleandata + c
elif c in (DO, DONT):
if c == DO: print '(DO)',
else: print '(DONT)',
opt = IAC + WONT
elif c in (WILL, WONT):
if c == WILL: print '(WILL)',
else: print '(WONT)',
opt = IAC + DONT
else:
print '(command)', ord(c)
elif c == IAC:
iac = 1
print '(IAC)',
else:
cleandata = cleandata + c
sys.stdout.write(cleandata)
sys.stdout.flush()
## print 'Out:', repr(cleandata)
def child(s):
# read stdin, write socket
while 1:
line = sys.stdin.readline()
## print 'Got:', repr(line)
if not line: break
s.send(line)
main()
squasher.py 0000644 00000005736 15037407673 0007000 0 ustar 00 # Coroutine example: general coroutine transfers
#
# The program is a variation of a Simula 67 program due to Dahl & Hoare,
# (Dahl/Dijkstra/Hoare, Structured Programming; Academic Press, 1972)
# who in turn credit the original example to Conway.
#
# We have a number of input lines, terminated by a 0 byte. The problem
# is to squash them together into output lines containing 72 characters
# each. A semicolon must be added between input lines. Runs of blanks
# and tabs in input lines must be squashed into single blanks.
# Occurrences of "**" in input lines must be replaced by "^".
#
# Here's a test case:
test = """\
d = sqrt(b**2 - 4*a*c)
twoa = 2*a
L = -b/twoa
R = d/twoa
A1 = L + R
A2 = L - R\0
"""
# The program should print:
# d = sqrt(b^2 - 4*a*c);twoa = 2*a; L = -b/twoa; R = d/twoa; A1 = L + R;
#A2 = L - R
#done
# getline: delivers the next input line to its invoker
# disassembler: grabs input lines from getline, and delivers them one
# character at a time to squasher, also inserting a semicolon into
# the stream between lines
# squasher: grabs characters from disassembler and passes them on to
# assembler, first replacing "**" with "^" and squashing runs of
# whitespace
# assembler: grabs characters from squasher and packs them into lines
# with 72 character each, delivering each such line to putline;
# when it sees a null byte, passes the last line to putline and
# then kills all the coroutines
# putline: grabs lines from assembler, and just prints them
from Coroutine import *
def getline(text):
for line in string.splitfields(text, '\n'):
co.tran(codisassembler, line)
def disassembler():
while 1:
card = co.tran(cogetline)
for i in range(len(card)):
co.tran(cosquasher, card[i])
co.tran(cosquasher, ';')
def squasher():
while 1:
ch = co.tran(codisassembler)
if ch == '*':
ch2 = co.tran(codisassembler)
if ch2 == '*':
ch = '^'
else:
co.tran(coassembler, ch)
ch = ch2
if ch in ' \t':
while 1:
ch2 = co.tran(codisassembler)
if ch2 not in ' \t':
break
co.tran(coassembler, ' ')
ch = ch2
co.tran(coassembler, ch)
def assembler():
line = ''
while 1:
ch = co.tran(cosquasher)
if ch == '\0':
break
if len(line) == 72:
co.tran(coputline, line)
line = ''
line = line + ch
line = line + ' ' * (72 - len(line))
co.tran(coputline, line)
co.kill()
def putline():
while 1:
line = co.tran(coassembler)
print line
import string
co = Coroutine()
cogetline = co.create(getline, test)
coputline = co.create(putline)
coassembler = co.create(assembler)
codisassembler = co.create(disassembler)
cosquasher = co.create(squasher)
co.tran(coputline)
print 'done'
# end of example
find.pyc 0000644 00000007441 15037407673 0006223 0 ustar 00 �
��^c @ s� d d l Z d d l Z d d l Z d d l Z d d l Z d d l Td d l Z d d d � � YZ d � Z d � Z d � Z
e � d S( i����N( t *t WorkQc B s> e Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C sA t j � | _ t j � | _ | j j � g | _ d | _ d S( Ni ( t threadt allocatet mutext todot acquiret workt busy( t self( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt __init__, s
c C s_ | | f } | j j � | j j | � | j j � t | j � d k r[ | j j � n d S( Ni ( R R R t appendt releaset lenR ( R t funct argst job( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt addwork3 s
c C s� | j j � | j j � | j d k r\ t | j � d k r\ | j j � | j j � d S| j d } | j d =| j d | _ | j j � t | j � d k r� | j j � n | S( Ni i ( R R R R R
R R t None( R R ( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt _getwork; s
$
c C sb | j j � | j d | _ | j d k rQ t | j � d k rQ | j j � n | j j � d S( Ni i ( R R R R
R R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt _doneworkJ s
$c C sQ t j d � x= | j � } | s& Pn | \ } } t | | � | j � q Wd S( Ng�h㈵��>( t timet sleepR t applyR ( R R R R ( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt _workerQ s
c C sV | j s
d Sx+ t | d � D] } t j | j d � q W| j � | j j � d S( Ni ( ( R t rangeR t start_newR R R ( R t nworkerst i( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt run[ s
( t __name__t
__module__R
R R R R R ( ( ( s) /usr/lib64/python2.7/Demo/threads/find.pyR # s
c C s� d } t j t j d d � \ } } x2 | D]* \ } } | d k r, t j | � } q, q, W| so t j g } n t � } x' | D] } | j t | t
| f � q Wt j � } | j | � t j � } t j
j d | | � d S( Ni i s -w:s -ws Total time %r sec.
( t getoptt syst argvt stringt atoit ost curdirR R t findt selectorR R t stderrt write( R t optsR t optt argt wqt dirt t1t t2( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt mainf s
c C s# | t d @d k o" t | t � S( Ni i ( t ST_MODEt S_ISLNK( R/ t namet fullnamet stat( ( s) /usr/lib64/python2.7/Demo/threads/find.pyR( } s c C s% y t j | � } Wn* t j k
r? } t | � Gd G| GHd SXx� | D]� } | t j t j f k rG t j j | | � } y t j | � } Wn, t j k
r� } t | � Gd G| GHqG n X| | | | | � r� | GHn t | t
� r t j j | � s| j t
| | | f � qq qG qG Wd S( Nt :( R% t listdirt errort reprR& t pardirt patht joint lstatt S_ISDIRR3 t ismountR R' ( R/ t predR. t namest msgR5 R6 R7 ( ( s) /usr/lib64/python2.7/Demo/threads/find.pyR' � s$
( ( R! R R# R R% R7 R R R2 R( R' ( ( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt <module> s
C sync.py 0000644 00000052227 15037407673 0006116 0 ustar 00 # Defines classes that provide synchronization objects. Note that use of
# this module requires that your Python support threads.
#
# condition(lock=None) # a POSIX-like condition-variable object
# barrier(n) # an n-thread barrier
# event() # an event object
# semaphore(n=1) # a semaphore object, with initial count n
# mrsw() # a multiple-reader single-writer lock
#
# CONDITIONS
#
# A condition object is created via
# import this_module
# your_condition_object = this_module.condition(lock=None)
#
# As explained below, a condition object has a lock associated with it,
# used in the protocol to protect condition data. You can specify a
# lock to use in the constructor, else the constructor will allocate
# an anonymous lock for you. Specifying a lock explicitly can be useful
# when more than one condition keys off the same set of shared data.
#
# Methods:
# .acquire()
# acquire the lock associated with the condition
# .release()
# release the lock associated with the condition
# .wait()
# block the thread until such time as some other thread does a
# .signal or .broadcast on the same condition, and release the
# lock associated with the condition. The lock associated with
# the condition MUST be in the acquired state at the time
# .wait is invoked.
# .signal()
# wake up exactly one thread (if any) that previously did a .wait
# on the condition; that thread will awaken with the lock associated
# with the condition in the acquired state. If no threads are
# .wait'ing, this is a nop. If more than one thread is .wait'ing on
# the condition, any of them may be awakened.
# .broadcast()
# wake up all threads (if any) that are .wait'ing on the condition;
# the threads are woken up serially, each with the lock in the
# acquired state, so should .release() as soon as possible. If no
# threads are .wait'ing, this is a nop.
#
# Note that if a thread does a .wait *while* a signal/broadcast is
# in progress, it's guaranteeed to block until a subsequent
# signal/broadcast.
#
# Secret feature: `broadcast' actually takes an integer argument,
# and will wake up exactly that many waiting threads (or the total
# number waiting, if that's less). Use of this is dubious, though,
# and probably won't be supported if this form of condition is
# reimplemented in C.
#
# DIFFERENCES FROM POSIX
#
# + A separate mutex is not needed to guard condition data. Instead, a
# condition object can (must) be .acquire'ed and .release'ed directly.
# This eliminates a common error in using POSIX conditions.
#
# + Because of implementation difficulties, a POSIX `signal' wakes up
# _at least_ one .wait'ing thread. Race conditions make it difficult
# to stop that. This implementation guarantees to wake up only one,
# but you probably shouldn't rely on that.
#
# PROTOCOL
#
# Condition objects are used to block threads until "some condition" is
# true. E.g., a thread may wish to wait until a producer pumps out data
# for it to consume, or a server may wish to wait until someone requests
# its services, or perhaps a whole bunch of threads want to wait until a
# preceding pass over the data is complete. Early models for conditions
# relied on some other thread figuring out when a blocked thread's
# condition was true, and made the other thread responsible both for
# waking up the blocked thread and guaranteeing that it woke up with all
# data in a correct state. This proved to be very delicate in practice,
# and gave conditions a bad name in some circles.
#
# The POSIX model addresses these problems by making a thread responsible
# for ensuring that its own state is correct when it wakes, and relies
# on a rigid protocol to make this easy; so long as you stick to the
# protocol, POSIX conditions are easy to "get right":
#
# A) The thread that's waiting for some arbitrarily-complex condition
# (ACC) to become true does:
#
# condition.acquire()
# while not (code to evaluate the ACC):
# condition.wait()
# # That blocks the thread, *and* releases the lock. When a
# # condition.signal() happens, it will wake up some thread that
# # did a .wait, *and* acquire the lock again before .wait
# # returns.
# #
# # Because the lock is acquired at this point, the state used
# # in evaluating the ACC is frozen, so it's safe to go back &
# # reevaluate the ACC.
#
# # At this point, ACC is true, and the thread has the condition
# # locked.
# # So code here can safely muck with the shared state that
# # went into evaluating the ACC -- if it wants to.
# # When done mucking with the shared state, do
# condition.release()
#
# B) Threads that are mucking with shared state that may affect the
# ACC do:
#
# condition.acquire()
# # muck with shared state
# condition.release()
# if it's possible that ACC is true now:
# condition.signal() # or .broadcast()
#
# Note: You may prefer to put the "if" clause before the release().
# That's fine, but do note that anyone waiting on the signal will
# stay blocked until the release() is done (since acquiring the
# condition is part of what .wait() does before it returns).
#
# TRICK OF THE TRADE
#
# With simpler forms of conditions, it can be impossible to know when
# a thread that's supposed to do a .wait has actually done it. But
# because this form of condition releases a lock as _part_ of doing a
# wait, the state of that lock can be used to guarantee it.
#
# E.g., suppose thread A spawns thread B and later wants to wait for B to
# complete:
#
# In A: In B:
#
# B_done = condition() ... do work ...
# B_done.acquire() B_done.acquire(); B_done.release()
# spawn B B_done.signal()
# ... some time later ... ... and B exits ...
# B_done.wait()
#
# Because B_done was in the acquire'd state at the time B was spawned,
# B's attempt to acquire B_done can't succeed until A has done its
# B_done.wait() (which releases B_done). So B's B_done.signal() is
# guaranteed to be seen by the .wait(). Without the lock trick, B
# may signal before A .waits, and then A would wait forever.
#
# BARRIERS
#
# A barrier object is created via
# import this_module
# your_barrier = this_module.barrier(num_threads)
#
# Methods:
# .enter()
# the thread blocks until num_threads threads in all have done
# .enter(). Then the num_threads threads that .enter'ed resume,
# and the barrier resets to capture the next num_threads threads
# that .enter it.
#
# EVENTS
#
# An event object is created via
# import this_module
# your_event = this_module.event()
#
# An event has two states, `posted' and `cleared'. An event is
# created in the cleared state.
#
# Methods:
#
# .post()
# Put the event in the posted state, and resume all threads
# .wait'ing on the event (if any).
#
# .clear()
# Put the event in the cleared state.
#
# .is_posted()
# Returns 0 if the event is in the cleared state, or 1 if the event
# is in the posted state.
#
# .wait()
# If the event is in the posted state, returns immediately.
# If the event is in the cleared state, blocks the calling thread
# until the event is .post'ed by another thread.
#
# Note that an event, once posted, remains posted until explicitly
# cleared. Relative to conditions, this is both the strength & weakness
# of events. It's a strength because the .post'ing thread doesn't have to
# worry about whether the threads it's trying to communicate with have
# already done a .wait (a condition .signal is seen only by threads that
# do a .wait _prior_ to the .signal; a .signal does not persist). But
# it's a weakness because .clear'ing an event is error-prone: it's easy
# to mistakenly .clear an event before all the threads you intended to
# see the event get around to .wait'ing on it. But so long as you don't
# need to .clear an event, events are easy to use safely.
#
# SEMAPHORES
#
# A semaphore object is created via
# import this_module
# your_semaphore = this_module.semaphore(count=1)
#
# A semaphore has an integer count associated with it. The initial value
# of the count is specified by the optional argument (which defaults to
# 1) passed to the semaphore constructor.
#
# Methods:
#
# .p()
# If the semaphore's count is greater than 0, decrements the count
# by 1 and returns.
# Else if the semaphore's count is 0, blocks the calling thread
# until a subsequent .v() increases the count. When that happens,
# the count will be decremented by 1 and the calling thread resumed.
#
# .v()
# Increments the semaphore's count by 1, and wakes up a thread (if
# any) blocked by a .p(). It's an (detected) error for a .v() to
# increase the semaphore's count to a value larger than the initial
# count.
#
# MULTIPLE-READER SINGLE-WRITER LOCKS
#
# A mrsw lock is created via
# import this_module
# your_mrsw_lock = this_module.mrsw()
#
# This kind of lock is often useful with complex shared data structures.
# The object lets any number of "readers" proceed, so long as no thread
# wishes to "write". When a (one or more) thread declares its intention
# to "write" (e.g., to update a shared structure), all current readers
# are allowed to finish, and then a writer gets exclusive access; all
# other readers & writers are blocked until the current writer completes.
# Finally, if some thread is waiting to write and another is waiting to
# read, the writer takes precedence.
#
# Methods:
#
# .read_in()
# If no thread is writing or waiting to write, returns immediately.
# Else blocks until no thread is writing or waiting to write. So
# long as some thread has completed a .read_in but not a .read_out,
# writers are blocked.
#
# .read_out()
# Use sometime after a .read_in to declare that the thread is done
# reading. When all threads complete reading, a writer can proceed.
#
# .write_in()
# If no thread is writing (has completed a .write_in, but hasn't yet
# done a .write_out) or reading (similarly), returns immediately.
# Else blocks the calling thread, and threads waiting to read, until
# the current writer completes writing or all the current readers
# complete reading; if then more than one thread is waiting to
# write, one of them is allowed to proceed, but which one is not
# specified.
#
# .write_out()
# Use sometime after a .write_in to declare that the thread is done
# writing. Then if some other thread is waiting to write, it's
# allowed to proceed. Else all threads (if any) waiting to read are
# allowed to proceed.
#
# .write_to_read()
# Use instead of a .write_in to declare that the thread is done
# writing but wants to continue reading without other writers
# intervening. If there are other threads waiting to write, they
# are allowed to proceed only if the current thread calls
# .read_out; threads waiting to read are only allowed to proceed
# if there are no threads waiting to write. (This is a
# weakness of the interface!)
import thread
class condition:
def __init__(self, lock=None):
# the lock actually used by .acquire() and .release()
if lock is None:
self.mutex = thread.allocate_lock()
else:
if hasattr(lock, 'acquire') and \
hasattr(lock, 'release'):
self.mutex = lock
else:
raise TypeError, 'condition constructor requires ' \
'a lock argument'
# lock used to block threads until a signal
self.checkout = thread.allocate_lock()
self.checkout.acquire()
# internal critical-section lock, & the data it protects
self.idlock = thread.allocate_lock()
self.id = 0
self.waiting = 0 # num waiters subject to current release
self.pending = 0 # num waiters awaiting next signal
self.torelease = 0 # num waiters to release
self.releasing = 0 # 1 iff release is in progress
def acquire(self):
self.mutex.acquire()
def release(self):
self.mutex.release()
def wait(self):
mutex, checkout, idlock = self.mutex, self.checkout, self.idlock
if not mutex.locked():
raise ValueError, \
"condition must be .acquire'd when .wait() invoked"
idlock.acquire()
myid = self.id
self.pending = self.pending + 1
idlock.release()
mutex.release()
while 1:
checkout.acquire(); idlock.acquire()
if myid < self.id:
break
checkout.release(); idlock.release()
self.waiting = self.waiting - 1
self.torelease = self.torelease - 1
if self.torelease:
checkout.release()
else:
self.releasing = 0
if self.waiting == self.pending == 0:
self.id = 0
idlock.release()
mutex.acquire()
def signal(self):
self.broadcast(1)
def broadcast(self, num = -1):
if num < -1:
raise ValueError, '.broadcast called with num %r' % (num,)
if num == 0:
return
self.idlock.acquire()
if self.pending:
self.waiting = self.waiting + self.pending
self.pending = 0
self.id = self.id + 1
if num == -1:
self.torelease = self.waiting
else:
self.torelease = min( self.waiting,
self.torelease + num )
if self.torelease and not self.releasing:
self.releasing = 1
self.checkout.release()
self.idlock.release()
class barrier:
def __init__(self, n):
self.n = n
self.togo = n
self.full = condition()
def enter(self):
full = self.full
full.acquire()
self.togo = self.togo - 1
if self.togo:
full.wait()
else:
self.togo = self.n
full.broadcast()
full.release()
class event:
def __init__(self):
self.state = 0
self.posted = condition()
def post(self):
self.posted.acquire()
self.state = 1
self.posted.broadcast()
self.posted.release()
def clear(self):
self.posted.acquire()
self.state = 0
self.posted.release()
def is_posted(self):
self.posted.acquire()
answer = self.state
self.posted.release()
return answer
def wait(self):
self.posted.acquire()
if not self.state:
self.posted.wait()
self.posted.release()
class semaphore:
def __init__(self, count=1):
if count <= 0:
raise ValueError, 'semaphore count %d; must be >= 1' % count
self.count = count
self.maxcount = count
self.nonzero = condition()
def p(self):
self.nonzero.acquire()
while self.count == 0:
self.nonzero.wait()
self.count = self.count - 1
self.nonzero.release()
def v(self):
self.nonzero.acquire()
if self.count == self.maxcount:
raise ValueError, '.v() tried to raise semaphore count above ' \
'initial value %r' % self.maxcount
self.count = self.count + 1
self.nonzero.signal()
self.nonzero.release()
class mrsw:
def __init__(self):
# critical-section lock & the data it protects
self.rwOK = thread.allocate_lock()
self.nr = 0 # number readers actively reading (not just waiting)
self.nw = 0 # number writers either waiting to write or writing
self.writing = 0 # 1 iff some thread is writing
# conditions
self.readOK = condition(self.rwOK) # OK to unblock readers
self.writeOK = condition(self.rwOK) # OK to unblock writers
def read_in(self):
self.rwOK.acquire()
while self.nw:
self.readOK.wait()
self.nr = self.nr + 1
self.rwOK.release()
def read_out(self):
self.rwOK.acquire()
if self.nr <= 0:
raise ValueError, \
'.read_out() invoked without an active reader'
self.nr = self.nr - 1
if self.nr == 0:
self.writeOK.signal()
self.rwOK.release()
def write_in(self):
self.rwOK.acquire()
self.nw = self.nw + 1
while self.writing or self.nr:
self.writeOK.wait()
self.writing = 1
self.rwOK.release()
def write_out(self):
self.rwOK.acquire()
if not self.writing:
raise ValueError, \
'.write_out() invoked without an active writer'
self.writing = 0
self.nw = self.nw - 1
if self.nw:
self.writeOK.signal()
else:
self.readOK.broadcast()
self.rwOK.release()
def write_to_read(self):
self.rwOK.acquire()
if not self.writing:
raise ValueError, \
'.write_to_read() invoked without an active writer'
self.writing = 0
self.nw = self.nw - 1
self.nr = self.nr + 1
if not self.nw:
self.readOK.broadcast()
self.rwOK.release()
# The rest of the file is a test case, that runs a number of parallelized
# quicksorts in parallel. If it works, you'll get about 600 lines of
# tracing output, with a line like
# test passed! 209 threads created in all
# as the last line. The content and order of preceding lines will
# vary across runs.
def _new_thread(func, *args):
global TID
tid.acquire(); id = TID = TID+1; tid.release()
io.acquire(); alive.append(id); \
print 'starting thread', id, '--', len(alive), 'alive'; \
io.release()
thread.start_new_thread( func, (id,) + args )
def _qsort(tid, a, l, r, finished):
# sort a[l:r]; post finished when done
io.acquire(); print 'thread', tid, 'qsort', l, r; io.release()
if r-l > 1:
pivot = a[l]
j = l+1 # make a[l:j] <= pivot, and a[j:r] > pivot
for i in range(j, r):
if a[i] <= pivot:
a[j], a[i] = a[i], a[j]
j = j + 1
a[l], a[j-1] = a[j-1], pivot
l_subarray_sorted = event()
r_subarray_sorted = event()
_new_thread(_qsort, a, l, j-1, l_subarray_sorted)
_new_thread(_qsort, a, j, r, r_subarray_sorted)
l_subarray_sorted.wait()
r_subarray_sorted.wait()
io.acquire(); print 'thread', tid, 'qsort done'; \
alive.remove(tid); io.release()
finished.post()
def _randarray(tid, a, finished):
io.acquire(); print 'thread', tid, 'randomizing array'; \
io.release()
for i in range(1, len(a)):
wh.acquire(); j = randint(0,i); wh.release()
a[i], a[j] = a[j], a[i]
io.acquire(); print 'thread', tid, 'randomizing done'; \
alive.remove(tid); io.release()
finished.post()
def _check_sort(a):
if a != range(len(a)):
raise ValueError, ('a not sorted', a)
def _run_one_sort(tid, a, bar, done):
# randomize a, and quicksort it
# for variety, all the threads running this enter a barrier
# at the end, and post `done' after the barrier exits
io.acquire(); print 'thread', tid, 'randomizing', a; \
io.release()
finished = event()
_new_thread(_randarray, a, finished)
finished.wait()
io.acquire(); print 'thread', tid, 'sorting', a; io.release()
finished.clear()
_new_thread(_qsort, a, 0, len(a), finished)
finished.wait()
_check_sort(a)
io.acquire(); print 'thread', tid, 'entering barrier'; \
io.release()
bar.enter()
io.acquire(); print 'thread', tid, 'leaving barrier'; \
io.release()
io.acquire(); alive.remove(tid); io.release()
bar.enter() # make sure they've all removed themselves from alive
## before 'done' is posted
bar.enter() # just to be cruel
done.post()
def test():
global TID, tid, io, wh, randint, alive
import random
randint = random.randint
TID = 0 # thread ID (1, 2, ...)
tid = thread.allocate_lock() # for changing TID
io = thread.allocate_lock() # for printing, and 'alive'
wh = thread.allocate_lock() # for calls to random
alive = [] # IDs of active threads
NSORTS = 5
arrays = []
for i in range(NSORTS):
arrays.append( range( (i+1)*10 ) )
bar = barrier(NSORTS)
finished = event()
for i in range(NSORTS):
_new_thread(_run_one_sort, arrays[i], bar, finished)
finished.wait()
print 'all threads done, and checking results ...'
if alive:
raise ValueError, ('threads still alive at end', alive)
for i in range(NSORTS):
a = arrays[i]
if len(a) != (i+1)*10:
raise ValueError, ('length of array', i, 'screwed up')
_check_sort(a)
print 'test passed!', TID, 'threads created in all'
if __name__ == '__main__':
test()
# end of module
telnet.pyo 0000644 00000004743 15037407673 0006614 0 ustar 00 �
��^c @ s� d d l Z d d l Z d d l Z d d l Td d l Z d
Z e d � Z e d � Z e d � Z e d � Z
e d � Z d
� Z d � Z
d � Z e � d S( i����N( t *i i i� i� i� i� i� c C s� t t j � d k r5 t j j d � t j d � n t j d } y t | � } Wn9 t k
r� t j j t j d d � t j d � n Xt t j � d k r� t j d } n d } d | d k o� d k n r� t | � } nH y t | d � } Wn2 t k
r/t j j | d � t j d � n Xt
t t � } y | j
| | f � Wn7 t k
r�} t j j d
| f � t j d � n Xt j t | f � t | � d S( Ni s usage: telnet hostname [port]
i s : bad host name
t telnett 0t 9t tcps : bad tcp service name
s connect failed: %r
( t lent syst argvt stderrt writet exitt
gethostbynamet errort evalt
getservbynamet sockett AF_INETt SOCK_STREAMt connectt threadt start_newt childt parent( t hostt hostaddrt servnamet portt st msg( ( s+ /usr/lib64/python2.7/Demo/threads/telnet.pyt main s6
c C sw d } d } xd| j t � \ } } | sJ t j j d � t j d � n d } x� | D]� } | r� t | � GH| j | | � d } qW | r+d } | t k r� | | } qN| t t
f k r� | t k r� d Gn d Gt t } qN| t t f k r| t k rd Gn d Gt t
} qNd Gt | � GHqW | t k rDd } d
GqW | | } qW Wt j
j | � t j
j � q Wd S( Ni t s (Closed by remote host)
i s (DO)s (DONT)s (WILL)s (WONT)s (command)s (IAC)( t recvfromt BUFSIZER R R R
t ordt sendt IACt DOt DONTt WONTt WILLt stdoutt flush( R t iact optt datat dummyt cleandatat c( ( s+ /usr/lib64/python2.7/Demo/threads/telnet.pyR B sD
c C s1 x* t j j � } | s Pn | j | � q Wd S( N( R t stdint readlineR" ( R t line( ( s+ /usr/lib64/python2.7/Demo/threads/telnet.pyR j s
i ( R t ost timeR R R t chrR# R% R$ R& R' R R R ( ( ( s+ /usr/lib64/python2.7/Demo/threads/telnet.pyt <module> s $
$ ( find.py 0000644 00000010167 15037407673 0006057 0 ustar 00 # A parallelized "find(1)" using the thread module.
# This demonstrates the use of a work queue and worker threads.
# It really does do more stats/sec when using multiple threads,
# although the improvement is only about 20-30 percent.
# (That was 8 years ago. In 2002, on Linux, I can't measure
# a speedup. :-( )
# I'm too lazy to write a command line parser for the full find(1)
# command line syntax, so the predicate it searches for is wired-in,
# see function selector() below. (It currently searches for files with
# world write permission.)
# Usage: parfind.py [-w nworkers] [directory] ...
# Default nworkers is 4
import sys
import getopt
import string
import time
import os
from stat import *
import thread
# Work queue class. Usage:
# wq = WorkQ()
# wq.addwork(func, (arg1, arg2, ...)) # one or more calls
# wq.run(nworkers)
# The work is done when wq.run() completes.
# The function calls executed by the workers may add more work.
# Don't use keyboard interrupts!
class WorkQ:
# Invariants:
# - busy and work are only modified when mutex is locked
# - len(work) is the number of jobs ready to be taken
# - busy is the number of jobs being done
# - todo is locked iff there is no work and somebody is busy
def __init__(self):
self.mutex = thread.allocate()
self.todo = thread.allocate()
self.todo.acquire()
self.work = []
self.busy = 0
def addwork(self, func, args):
job = (func, args)
self.mutex.acquire()
self.work.append(job)
self.mutex.release()
if len(self.work) == 1:
self.todo.release()
def _getwork(self):
self.todo.acquire()
self.mutex.acquire()
if self.busy == 0 and len(self.work) == 0:
self.mutex.release()
self.todo.release()
return None
job = self.work[0]
del self.work[0]
self.busy = self.busy + 1
self.mutex.release()
if len(self.work) > 0:
self.todo.release()
return job
def _donework(self):
self.mutex.acquire()
self.busy = self.busy - 1
if self.busy == 0 and len(self.work) == 0:
self.todo.release()
self.mutex.release()
def _worker(self):
time.sleep(0.00001) # Let other threads run
while 1:
job = self._getwork()
if not job:
break
func, args = job
apply(func, args)
self._donework()
def run(self, nworkers):
if not self.work:
return # Nothing to do
for i in range(nworkers-1):
thread.start_new(self._worker, ())
self._worker()
self.todo.acquire()
# Main program
def main():
nworkers = 4
opts, args = getopt.getopt(sys.argv[1:], '-w:')
for opt, arg in opts:
if opt == '-w':
nworkers = string.atoi(arg)
if not args:
args = [os.curdir]
wq = WorkQ()
for dir in args:
wq.addwork(find, (dir, selector, wq))
t1 = time.time()
wq.run(nworkers)
t2 = time.time()
sys.stderr.write('Total time %r sec.\n' % (t2-t1))
# The predicate -- defines what files we look for.
# Feel free to change this to suit your purpose
def selector(dir, name, fullname, stat):
# Look for world writable files that are not symlinks
return (stat[ST_MODE] & 0002) != 0 and not S_ISLNK(stat[ST_MODE])
# The find procedure -- calls wq.addwork() for subdirectories
def find(dir, pred, wq):
try:
names = os.listdir(dir)
except os.error, msg:
print repr(dir), ':', msg
return
for name in names:
if name not in (os.curdir, os.pardir):
fullname = os.path.join(dir, name)
try:
stat = os.lstat(fullname)
except os.error, msg:
print repr(fullname), ':', msg
continue
if pred(dir, name, fullname, stat):
print fullname
if S_ISDIR(stat[ST_MODE]):
if not os.path.ismount(fullname):
wq.addwork(find, (fullname, pred, wq))
# Call the main program
main()
README 0000644 00000000670 15037407673 0005443 0 ustar 00 This directory contains some demonstrations of the thread module.
These are mostly "proof of concept" type applications:
Generator.py Generator class implemented with threads.
sync.py Condition variables primitives by Tim Peters.
telnet.py Version of ../sockets/telnet.py using threads.
Coroutine.py Coroutines using threads, by Tim Peters (22 May 94)
fcmp.py Example of above, by Tim
squasher.py Another example of above, also by Tim
sync.pyo 0000644 00000025552 15037407673 0006276 0 ustar 00 �
��^c @ s� d d l Z d d d � � YZ d d d � � YZ d d d � � YZ d d d � � YZ d
d d � � YZ d � Z d
� Z d � Z d � Z d � Z
d � Z e d k r� e � n d S( i����Nt conditionc B sD e Z d d � Z d � Z d � Z d � Z d � Z d d � Z RS( c C s� | d k r t j � | _ n3 t | d � rH t | d � rH | | _ n t d � t j � | _ | j j � t j � | _ d | _ d | _
d | _ d | _ d | _
d S( Nt acquiret releases. condition constructor requires a lock argumenti ( t Nonet threadt
allocate_lockt mutext hasattrt TypeErrort checkoutR t idlockt idt waitingt pendingt toreleaset releasing( t selft lock( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt __init__ s
c C s | j j � d S( N( R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR * s c C s | j j � d S( N( R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR - s c C s3 | j | j | j } } } | j � s5 t d � n | j � | j } | j d | _ | j � | j � x? | j � | j � | | j k r� Pn | j � | j � qo W| j d | _ | j
d | _
| j
r� | j � n7 d | _ | j | j k o
d k n rd | _ n | j � | j � d S( Ns1 condition must be .acquire'd when .wait() invokedi i ( R R R
t lockedt
ValueErrorR R R
R R R R ( R R R R
t myid( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt wait0 s2
"
c C s | j d � d S( Ni ( t broadcast( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt signalN s i����c C s� | d k r t d | f � n | d k r/ d S| j j � | j rt | j | j | _ d | _ | j d | _ n | d k r� | j | _ n t | j | j | � | _ | j r� | j r� d | _ | j j
� n | j j
� d S( Ni����s .broadcast called with num %ri i ( R R
R R
R R R t minR R R ( R t num( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR Q s"
N( t __name__t
__module__R R R R R R R ( ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR s t barrierc B s e Z d � Z d � Z RS( c C s" | | _ | | _ t � | _ d S( N( t nt togoR t full( R R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR f s c C s] | j } | j � | j d | _ | j r9 | j � n | j | _ | j � | j � d S( Ni ( R R R R R R R ( R R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt enterk s
( R R R R! ( ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR e s t eventc B s5 e Z d � Z d � Z d � Z d � Z d � Z RS( c C s d | _ t � | _ d S( Ni ( t stateR t posted( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR w s c C s4 | j j � d | _ | j j � | j j � d S( Ni ( R$ R R# R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt post{ s
c C s' | j j � d | _ | j j � d S( Ni ( R$ R R# R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt clear� s
c C s' | j j � | j } | j j � | S( N( R$ R R# R ( R t answer( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt is_posted� s
c C s7 | j j � | j s& | j j � n | j j � d S( N( R$ R R# R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR � s
( R R R R% R& R( R ( ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR" v s
t semaphorec B s& e Z d d � Z d � Z d � Z RS( i c C s> | d k r t d | � n | | _ | | _ t � | _ d S( Ni s semaphore count %d; must be >= 1( R t countt maxcountR t nonzero( R R* ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR � s
c C sQ | j j � x | j d k r/ | j j � q W| j d | _ | j j � d S( Ni i ( R, R R* R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt p� s
c C s` | j j � | j | j k r2 t d | j � n | j d | _ | j j � | j j � d S( Ns: .v() tried to raise semaphore count above initial value %ri ( R, R R* R+ R R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt v� s
( R R R R- R. ( ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR) � s t mrswc B s> e Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C sR t j � | _ d | _ d | _ d | _ t | j � | _ t | j � | _ d S( Ni ( R R t rwOKt nrt nwt writingR t readOKt writeOK( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR � s c C sK | j j � x | j r) | j j � q W| j d | _ | j j � d S( Ni ( R0 R R2 R4 R R1 R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt read_in� s
c C sh | j j � | j d k r( t d � n | j d | _ | j d k rW | j j � n | j j � d S( Ni s, .read_out() invoked without an active readeri ( R0 R R1 R R5 R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt read_out� s
c C s] | j j � | j d | _ x# | j s2 | j rB | j j � q Wd | _ | j j � d S( Ni ( R0 R R2 R3 R1 R5 R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt write_in� s
c C sr | j j � | j s" t d � n d | _ | j d | _ | j rT | j j � n
| j j � | j j � d S( Ns- .write_out() invoked without an active writeri i (
R0 R R3 R R2 R5 R R4 R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt write_out� s
c C su | j j � | j s" t d � n d | _ | j d | _ | j d | _ | j sd | j j � n | j j � d S( Ns1 .write_to_read() invoked without an active writeri i ( R0 R R3 R R2 R1 R4 R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt
write_to_read� s
( R R R R6 R7 R8 R9 R: ( ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR/ � s
c G sy t j � t d } a t j � t j � t j | � d G| Gd Gt t � Gd GHt j � t j | | f | � d S( Ni s starting threads --t alive(
t tidR t TIDR t ioR; t appendt lenR t start_new_thread( t funct argsR ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt _new_thread� s
c
C sW t j � d G| Gd G| G| GHt j � | | d k r| | } | d } xQ t | | � D]@ } | | | k r] | | | | | | <| | <| d } q] q] W| | d | | | <| | d <t � } t � } t t | | | d | � t t | | | | � | j � | j � n t j � d G| Gd GHt j | � t j � | j
� d S( NR t qsorti s
qsort done( R> R R t rangeR" RD t _qsortR R; t removeR% (
R< t at lt rt finishedt pivott jt it l_subarray_sortedt r_subarray_sorted( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyRG � s,
!
c C s� t j � d G| Gd GHt j � x] t d t | � � D]F } t j � t d | � } t j � | | | | | | <| | <q7 Wt j � d G| Gd GHt j | � t j � | j � d S( NR s randomizing arrayi i s randomizing done(
R> R R RF R@ t wht randintR; RH R% ( R< RI RL RO RN ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt
_randarray s
!
c C s. | t t | � � k r* t d | f � n d S( Ns a not sorted( RF R@ R ( RI ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt _check_sort s c C s6 t j � d G| Gd G| GHt j � t � } t t | | � | j � t j � d G| Gd G| GHt j � | j � t t | d t | � | � | j � t
| � t j � d G| Gd GHt j � | j � t j � d G| Gd GHt j � t j � t j
| � t j � | j � | j � | j � d S( NR t randomizingt sortingi s entering barriers leaving barrier( R> R R R" RD RT R R& RG R@ RU R! R; RH R% ( R< RI t bart doneRL ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt
_run_one_sort s4
c C sX d d l } | j a d a t j � a t j � a t j � a g a d } g } x/ t | � D]! } | j
t | d d � � q^ Wt | � } t � } x+ t | � D] } t
t | | | | � q� W| j � d GHt r� t d t f � n xW t | � D]I } | | } t | � | d d k r9t d | d f � n t | � q� Wd
Gt Gd GHd S( Ni����i i i i
s* all threads done, and checking results ...s threads still alive at ends length of arrays
screwed ups test passed!s threads created in all( t randomRS R= R R R< R> RR R; RF R? R R" RD RZ R R R@ RU ( R[ t NSORTSt arraysRO RX RL RI ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt test7 s2
t __main__( ( ( ( ( (
R R R R" R) R/ RD RG RT RU RZ R^ R ( ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt <module> s T E
! fcmp.py 0000644 00000003327 15037407673 0006064 0 ustar 00 # Coroutine example: controlling multiple instances of a single function
from Coroutine import *
# fringe visits a nested list in inorder, and detaches for each non-list
# element; raises EarlyExit after the list is exhausted
def fringe(co, list):
for x in list:
if type(x) is type([]):
fringe(co, x)
else:
co.back(x)
def printinorder(list):
co = Coroutine()
f = co.create(fringe, co, list)
try:
while 1:
print co.tran(f),
except EarlyExit:
pass
print
printinorder([1,2,3]) # 1 2 3
printinorder([[[[1,[2]]],3]]) # ditto
x = [0, 1, [2, [3]], [4,5], [[[6]]] ]
printinorder(x) # 0 1 2 3 4 5 6
# fcmp lexicographically compares the fringes of two nested lists
def fcmp(l1, l2):
co1 = Coroutine(); f1 = co1.create(fringe, co1, l1)
co2 = Coroutine(); f2 = co2.create(fringe, co2, l2)
while 1:
try:
v1 = co1.tran(f1)
except EarlyExit:
try:
v2 = co2.tran(f2)
except EarlyExit:
return 0
co2.kill()
return -1
try:
v2 = co2.tran(f2)
except EarlyExit:
co1.kill()
return 1
if v1 != v2:
co1.kill(); co2.kill()
return cmp(v1,v2)
print fcmp(range(7), x) # 0; fringes are equal
print fcmp(range(6), x) # -1; 1st list ends early
print fcmp(x, range(6)) # 1; 2nd list ends early
print fcmp(range(8), x) # 1; 2nd list ends early
print fcmp(x, range(8)) # -1; 1st list ends early
print fcmp([1,[[2],8]],
[[[1],2],8]) # 0
print fcmp([1,[[3],8]],
[[[1],2],8]) # 1
print fcmp([1,[[2],8]],
[[[1],2],9]) # -1
# end of example
squasher.pyc 0000644 00000004101 15037407673 0007124 0 ustar 00 �
��^c @ s� d Z d d l Td � Z d � Z d � Z d � Z d � Z d d l Z e � Z e j e e � Z
e j e � Z e j e � Z e j e � Z
e j e � Z e j e � d GHd S(
s} d = sqrt(b**2 - 4*a*c)
twoa = 2*a
L = -b/twoa
R = d/twoa
A1 = L + R
A2 = L - R
i����( t *c C s1 x* t j | d � D] } t j t | � q Wd S( Ns
( t stringt splitfieldst cot trant codisassembler( t textt line( ( s- /usr/lib64/python2.7/Demo/threads/squasher.pyt getline- s c C s[ xT t j t � } x. t t | � � D] } t j t | | � q% Wt j t d � q Wd S( Nt ;( R R t cogetlinet ranget lent
cosquasher( t cardt i( ( s- /usr/lib64/python2.7/Demo/threads/squasher.pyt disassembler1 s
c C s� x� t j t � } | d k r[ t j t � } | d k rB d } q[ t j t | � | } n | d k r� x# t j t � } | d k rj Pqj qj Wt j t d � | } n t j t | � q Wd S( NR t ^s t ( R R R t coassembler( t cht ch2( ( s- /usr/lib64/python2.7/Demo/threads/squasher.pyt squasher8 s c C s� d } xX t j t � } | d k r( Pn t | � d k rS t j t | � d } n | | } q W| d d t | � } t j t | � t j � d S( Nt s iH R ( R R R
R t coputlinet kill( R R ( ( s- /usr/lib64/python2.7/Demo/threads/squasher.pyt assemblerK s c C s x t j t � } | GHq Wd S( N( R R R ( R ( ( s- /usr/lib64/python2.7/Demo/threads/squasher.pyt putlineY s Nt done( t testt CoroutineR R R R R R R t createR
R R R R
R ( ( ( s- /usr/lib64/python2.7/Demo/threads/squasher.pyt <module> s
sync.pyc 0000644 00000025552 15037407673 0006262 0 ustar 00 �
��^c @ s� d d l Z d d d � � YZ d d d � � YZ d d d � � YZ d d d � � YZ d
d d � � YZ d � Z d
� Z d � Z d � Z d � Z
d � Z e d k r� e � n d S( i����Nt conditionc B sD e Z d d � Z d � Z d � Z d � Z d � Z d d � Z RS( c C s� | d k r t j � | _ n3 t | d � rH t | d � rH | | _ n t d � t j � | _ | j j � t j � | _ d | _ d | _
d | _ d | _ d | _
d S( Nt acquiret releases. condition constructor requires a lock argumenti ( t Nonet threadt
allocate_lockt mutext hasattrt TypeErrort checkoutR t idlockt idt waitingt pendingt toreleaset releasing( t selft lock( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt __init__ s
c C s | j j � d S( N( R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR * s c C s | j j � d S( N( R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR - s c C s3 | j | j | j } } } | j � s5 t d � n | j � | j } | j d | _ | j � | j � x? | j � | j � | | j k r� Pn | j � | j � qo W| j d | _ | j
d | _
| j
r� | j � n7 d | _ | j | j k o
d k n rd | _ n | j � | j � d S( Ns1 condition must be .acquire'd when .wait() invokedi i ( R R R
t lockedt
ValueErrorR R R
R R R R ( R R R R
t myid( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt wait0 s2
"
c C s | j d � d S( Ni ( t broadcast( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt signalN s i����c C s� | d k r t d | f � n | d k r/ d S| j j � | j rt | j | j | _ d | _ | j d | _ n | d k r� | j | _ n t | j | j | � | _ | j r� | j r� d | _ | j j
� n | j j
� d S( Ni����s .broadcast called with num %ri i ( R R
R R
R R R t minR R R ( R t num( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR Q s"
N( t __name__t
__module__R R R R R R R ( ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR s t barrierc B s e Z d � Z d � Z RS( c C s" | | _ | | _ t � | _ d S( N( t nt togoR t full( R R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR f s c C s] | j } | j � | j d | _ | j r9 | j � n | j | _ | j � | j � d S( Ni ( R R R R R R R ( R R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt enterk s
( R R R R! ( ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR e s t eventc B s5 e Z d � Z d � Z d � Z d � Z d � Z RS( c C s d | _ t � | _ d S( Ni ( t stateR t posted( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR w s c C s4 | j j � d | _ | j j � | j j � d S( Ni ( R$ R R# R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt post{ s
c C s' | j j � d | _ | j j � d S( Ni ( R$ R R# R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt clear� s
c C s' | j j � | j } | j j � | S( N( R$ R R# R ( R t answer( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt is_posted� s
c C s7 | j j � | j s& | j j � n | j j � d S( N( R$ R R# R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR � s
( R R R R% R& R( R ( ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR" v s
t semaphorec B s& e Z d d � Z d � Z d � Z RS( i c C s> | d k r t d | � n | | _ | | _ t � | _ d S( Ni s semaphore count %d; must be >= 1( R t countt maxcountR t nonzero( R R* ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR � s
c C sQ | j j � x | j d k r/ | j j � q W| j d | _ | j j � d S( Ni i ( R, R R* R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt p� s
c C s` | j j � | j | j k r2 t d | j � n | j d | _ | j j � | j j � d S( Ns: .v() tried to raise semaphore count above initial value %ri ( R, R R* R+ R R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt v� s
( R R R R- R. ( ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR) � s t mrswc B s> e Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C sR t j � | _ d | _ d | _ d | _ t | j � | _ t | j � | _ d S( Ni ( R R t rwOKt nrt nwt writingR t readOKt writeOK( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR � s c C sK | j j � x | j r) | j j � q W| j d | _ | j j � d S( Ni ( R0 R R2 R4 R R1 R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt read_in� s
c C sh | j j � | j d k r( t d � n | j d | _ | j d k rW | j j � n | j j � d S( Ni s, .read_out() invoked without an active readeri ( R0 R R1 R R5 R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt read_out� s
c C s] | j j � | j d | _ x# | j s2 | j rB | j j � q Wd | _ | j j � d S( Ni ( R0 R R2 R3 R1 R5 R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt write_in� s
c C sr | j j � | j s" t d � n d | _ | j d | _ | j rT | j j � n
| j j � | j j � d S( Ns- .write_out() invoked without an active writeri i (
R0 R R3 R R2 R5 R R4 R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt write_out� s
c C su | j j � | j s" t d � n d | _ | j d | _ | j d | _ | j sd | j j � n | j j � d S( Ns1 .write_to_read() invoked without an active writeri i ( R0 R R3 R R2 R1 R4 R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt
write_to_read� s
( R R R R6 R7 R8 R9 R: ( ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyR/ � s
c G sy t j � t d } a t j � t j � t j | � d G| Gd Gt t � Gd GHt j � t j | | f | � d S( Ni s starting threads --t alive(
t tidR t TIDR t ioR; t appendt lenR t start_new_thread( t funct argsR ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt _new_thread� s
c
C sW t j � d G| Gd G| G| GHt j � | | d k r| | } | d } xQ t | | � D]@ } | | | k r] | | | | | | <| | <| d } q] q] W| | d | | | <| | d <t � } t � } t t | | | d | � t t | | | | � | j � | j � n t j � d G| Gd GHt j | � t j � | j
� d S( NR t qsorti s
qsort done( R> R R t rangeR" RD t _qsortR R; t removeR% (
R< t at lt rt finishedt pivott jt it l_subarray_sortedt r_subarray_sorted( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyRG � s,
!
c C s� t j � d G| Gd GHt j � x] t d t | � � D]F } t j � t d | � } t j � | | | | | | <| | <q7 Wt j � d G| Gd GHt j | � t j � | j � d S( NR s randomizing arrayi i s randomizing done(
R> R R RF R@ t wht randintR; RH R% ( R< RI RL RO RN ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt
_randarray s
!
c C s. | t t | � � k r* t d | f � n d S( Ns a not sorted( RF R@ R ( RI ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt _check_sort s c C s6 t j � d G| Gd G| GHt j � t � } t t | | � | j � t j � d G| Gd G| GHt j � | j � t t | d t | � | � | j � t
| � t j � d G| Gd GHt j � | j � t j � d G| Gd GHt j � t j � t j
| � t j � | j � | j � | j � d S( NR t randomizingt sortingi s entering barriers leaving barrier( R> R R R" RD RT R R& RG R@ RU R! R; RH R% ( R< RI t bart doneRL ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt
_run_one_sort s4
c C sX d d l } | j a d a t j � a t j � a t j � a g a d } g } x/ t | � D]! } | j
t | d d � � q^ Wt | � } t � } x+ t | � D] } t
t | | | | � q� W| j � d GHt r� t d t f � n xW t | � D]I } | | } t | � | d d k r9t d | d f � n t | � q� Wd
Gt Gd GHd S( Ni����i i i i
s* all threads done, and checking results ...s threads still alive at ends length of arrays
screwed ups test passed!s threads created in all( t randomRS R= R R R< R> RR R; RF R? R R" RD RZ R R R@ RU ( R[ t NSORTSt arraysRO RX RL RI ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt test7 s2
t __main__( ( ( ( ( (
R R R R" R) R/ RD RG RT RU RZ R^ R ( ( ( s) /usr/lib64/python2.7/Demo/threads/sync.pyt <module> s T E
! squasher.pyo 0000644 00000004101 15037407673 0007140 0 ustar 00 �
��^c @ s� d Z d d l Td � Z d � Z d � Z d � Z d � Z d d l Z e � Z e j e e � Z
e j e � Z e j e � Z e j e � Z
e j e � Z e j e � d GHd S(
s} d = sqrt(b**2 - 4*a*c)
twoa = 2*a
L = -b/twoa
R = d/twoa
A1 = L + R
A2 = L - R
i����( t *c C s1 x* t j | d � D] } t j t | � q Wd S( Ns
( t stringt splitfieldst cot trant codisassembler( t textt line( ( s- /usr/lib64/python2.7/Demo/threads/squasher.pyt getline- s c C s[ xT t j t � } x. t t | � � D] } t j t | | � q% Wt j t d � q Wd S( Nt ;( R R t cogetlinet ranget lent
cosquasher( t cardt i( ( s- /usr/lib64/python2.7/Demo/threads/squasher.pyt disassembler1 s
c C s� x� t j t � } | d k r[ t j t � } | d k rB d } q[ t j t | � | } n | d k r� x# t j t � } | d k rj Pqj qj Wt j t d � | } n t j t | � q Wd S( NR t ^s t ( R R R t coassembler( t cht ch2( ( s- /usr/lib64/python2.7/Demo/threads/squasher.pyt squasher8 s c C s� d } xX t j t � } | d k r( Pn t | � d k rS t j t | � d } n | | } q W| d d t | � } t j t | � t j � d S( Nt s iH R ( R R R
R t coputlinet kill( R R ( ( s- /usr/lib64/python2.7/Demo/threads/squasher.pyt assemblerK s c C s x t j t � } | GHq Wd S( N( R R R ( R ( ( s- /usr/lib64/python2.7/Demo/threads/squasher.pyt putlineY s Nt done( t testt CoroutineR R R R R R R t createR
R R R R
R ( ( ( s- /usr/lib64/python2.7/Demo/threads/squasher.pyt <module> s
Generator.py 0000644 00000004750 15037407673 0007066 0 ustar 00 # Generator implementation using threads
import sys
import thread
class Killed(Exception):
pass
class Generator:
# Constructor
def __init__(self, func, args):
self.getlock = thread.allocate_lock()
self.putlock = thread.allocate_lock()
self.getlock.acquire()
self.putlock.acquire()
self.func = func
self.args = args
self.done = 0
self.killed = 0
thread.start_new_thread(self._start, ())
# Internal routine
def _start(self):
try:
self.putlock.acquire()
if not self.killed:
try:
apply(self.func, (self,) + self.args)
except Killed:
pass
finally:
if not self.killed:
self.done = 1
self.getlock.release()
# Called by producer for each value; raise Killed if no more needed
def put(self, value):
if self.killed:
raise TypeError, 'put() called on killed generator'
self.value = value
self.getlock.release() # Resume consumer thread
self.putlock.acquire() # Wait for next get() call
if self.killed:
raise Killed
# Called by producer to get next value; raise EOFError if no more
def get(self):
if self.killed:
raise TypeError, 'get() called on killed generator'
self.putlock.release() # Resume producer thread
self.getlock.acquire() # Wait for value to appear
if self.done:
raise EOFError # Say there are no more values
return self.value
# Called by consumer if no more values wanted
def kill(self):
if self.killed:
raise TypeError, 'kill() called on killed generator'
self.killed = 1
self.putlock.release()
# Clone constructor
def clone(self):
return Generator(self.func, self.args)
def pi(g):
k, a, b, a1, b1 = 2L, 4L, 1L, 12L, 4L
while 1:
# Next approximation
p, q, k = k*k, 2L*k+1L, k+1L
a, b, a1, b1 = a1, b1, p*a+q*a1, p*b+q*b1
# Print common digits
d, d1 = a//b, a1//b1
while d == d1:
g.put(int(d))
a, a1 = 10L*(a%b), 10L*(a1%b1)
d, d1 = a//b, a1//b1
def test():
g = Generator(pi, ())
g.kill()
g = Generator(pi, ())
for i in range(10): print g.get(),
print
h = g.clone()
g.kill()
while 1:
print h.get(),
sys.stdout.flush()
test()
Generator.pyc 0000644 00000006367 15037407673 0007237 0 ustar 00 �
��^c @ s^ d d l Z d d l Z d e f d � � YZ d d d � � YZ d � Z d � Z e � d S( i����Nt Killedc B s e Z RS( ( t __name__t
__module__( ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyR s t Generatorc B s> e Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C ss t j � | _ t j � | _ | j j � | j j � | | _ | | _ d | _ d | _ t j | j
d � d S( Ni ( ( t threadt
allocate_lockt getlockt putlockt acquiret funct argst donet killedt start_new_threadt _start( t selfR R
( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt __init__ s
c C sy zO | j j � | j sN y t | j | f | j � WqN t k
rJ qN Xn Wd | j st d | _ | j j � n Xd S( Ni (
R R R t applyR R
R R R t release( R ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyR s
c C sN | j r t d � n | | _ | j j � | j j � | j rJ t � n d S( Ns put() called on killed generator( R t TypeErrort valueR R R R R ( R R ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt put% s
c C sH | j r t d � n | j j � | j j � | j rA t � n | j S( Ns get() called on killed generator( R R R R R R R t EOFErrorR ( R ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt get/ s
c C s/ | j r t d � n d | _ | j j � d S( Ns! kill() called on killed generatori ( R R R R ( R ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt kill9 s c C s t | j | j � S( N( R R R
( R ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt clone@ s ( R R R R R R R R ( ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyR s
c
C s� d \ } } } } } x� | | d | d | d } } } | | | | | | | | | | f \ } } } } | | | | } } xU | | k r� | j t | � � d | | d | | } } | | | | } } q� Wq Wd S( Nl l l l l
( l l l l l ( R t int(
t gt kt at bt a1t b1t pt qt dt d1( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt piC s $6 c C s� t t d � } | j � t t d � } x t d � D] } | j � Gq5 WH| j � } | j � x | j � Gt j j � qc Wd S( Ni
( ( ( R R% R t rangeR R t syst stdoutt flush( R t it h( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt testP s
( ( R' R t ExceptionR R R% R, ( ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt <module> s :
telnet.pyc 0000644 00000004743 15037407673 0006600 0 ustar 00 �
��^c @ s� d d l Z d d l Z d d l Z d d l Td d l Z d
Z e d � Z e d � Z e d � Z e d � Z
e d � Z d
� Z d � Z
d � Z e � d S( i����N( t *i i i� i� i� i� i� c C s� t t j � d k r5 t j j d � t j d � n t j d } y t | � } Wn9 t k
r� t j j t j d d � t j d � n Xt t j � d k r� t j d } n d } d | d k o� d k n r� t | � } nH y t | d � } Wn2 t k
r/t j j | d � t j d � n Xt
t t � } y | j
| | f � Wn7 t k
r�} t j j d
| f � t j d � n Xt j t | f � t | � d S( Ni s usage: telnet hostname [port]
i s : bad host name
t telnett 0t 9t tcps : bad tcp service name
s connect failed: %r
( t lent syst argvt stderrt writet exitt
gethostbynamet errort evalt
getservbynamet sockett AF_INETt SOCK_STREAMt connectt threadt start_newt childt parent( t hostt hostaddrt servnamet portt st msg( ( s+ /usr/lib64/python2.7/Demo/threads/telnet.pyt main s6
c C sw d } d } xd| j t � \ } } | sJ t j j d � t j d � n d } x� | D]� } | r� t | � GH| j | | � d } qW | r+d } | t k r� | | } qN| t t
f k r� | t k r� d Gn d Gt t } qN| t t f k r| t k rd Gn d Gt t
} qNd Gt | � GHqW | t k rDd } d
GqW | | } qW Wt j
j | � t j
j � q Wd S( Ni t s (Closed by remote host)
i s (DO)s (DONT)s (WILL)s (WONT)s (command)s (IAC)( t recvfromt BUFSIZER R R R
t ordt sendt IACt DOt DONTt WONTt WILLt stdoutt flush( R t iact optt datat dummyt cleandatat c( ( s+ /usr/lib64/python2.7/Demo/threads/telnet.pyR B sD
c C s1 x* t j j � } | s Pn | j | � q Wd S( N( R t stdint readlineR" ( R t line( ( s+ /usr/lib64/python2.7/Demo/threads/telnet.pyR j s
i ( R t ost timeR R R t chrR# R% R$ R& R' R R R ( ( ( s+ /usr/lib64/python2.7/Demo/threads/telnet.pyt <module> s $
$ ( find.pyo 0000644 00000007441 15037407673 0006237 0 ustar 00 �
��^c @ s� d d l Z d d l Z d d l Z d d l Z d d l Z d d l Td d l Z d d d � � YZ d � Z d � Z d � Z
e � d S( i����N( t *t WorkQc B s> e Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C sA t j � | _ t j � | _ | j j � g | _ d | _ d S( Ni ( t threadt allocatet mutext todot acquiret workt busy( t self( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt __init__, s
c C s_ | | f } | j j � | j j | � | j j � t | j � d k r[ | j j � n d S( Ni ( R R R t appendt releaset lenR ( R t funct argst job( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt addwork3 s
c C s� | j j � | j j � | j d k r\ t | j � d k r\ | j j � | j j � d S| j d } | j d =| j d | _ | j j � t | j � d k r� | j j � n | S( Ni i ( R R R R R
R R t None( R R ( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt _getwork; s
$
c C sb | j j � | j d | _ | j d k rQ t | j � d k rQ | j j � n | j j � d S( Ni i ( R R R R
R R R ( R ( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt _doneworkJ s
$c C sQ t j d � x= | j � } | s& Pn | \ } } t | | � | j � q Wd S( Ng�h㈵��>( t timet sleepR t applyR ( R R R R ( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt _workerQ s
c C sV | j s
d Sx+ t | d � D] } t j | j d � q W| j � | j j � d S( Ni ( ( R t rangeR t start_newR R R ( R t nworkerst i( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt run[ s
( t __name__t
__module__R
R R R R R ( ( ( s) /usr/lib64/python2.7/Demo/threads/find.pyR # s
c C s� d } t j t j d d � \ } } x2 | D]* \ } } | d k r, t j | � } q, q, W| so t j g } n t � } x' | D] } | j t | t
| f � q Wt j � } | j | � t j � } t j
j d | | � d S( Ni i s -w:s -ws Total time %r sec.
( t getoptt syst argvt stringt atoit ost curdirR R t findt selectorR R t stderrt write( R t optsR t optt argt wqt dirt t1t t2( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt mainf s
c C s# | t d @d k o" t | t � S( Ni i ( t ST_MODEt S_ISLNK( R/ t namet fullnamet stat( ( s) /usr/lib64/python2.7/Demo/threads/find.pyR( } s c C s% y t j | � } Wn* t j k
r? } t | � Gd G| GHd SXx� | D]� } | t j t j f k rG t j j | | � } y t j | � } Wn, t j k
r� } t | � Gd G| GHqG n X| | | | | � r� | GHn t | t
� r t j j | � s| j t
| | | f � qq qG qG Wd S( Nt :( R% t listdirt errort reprR& t pardirt patht joint lstatt S_ISDIRR3 t ismountR R' ( R/ t predR. t namest msgR5 R6 R7 ( ( s) /usr/lib64/python2.7/Demo/threads/find.pyR' � s$
( ( R! R R# R R% R7 R R R2 R( R' ( ( ( s) /usr/lib64/python2.7/Demo/threads/find.pyt <module> s
C Generator.pyo 0000644 00000006367 15037407673 0007253 0 ustar 00 �
��^c @ s^ d d l Z d d l Z d e f d � � YZ d d d � � YZ d � Z d � Z e � d S( i����Nt Killedc B s e Z RS( ( t __name__t
__module__( ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyR s t Generatorc B s> e Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C ss t j � | _ t j � | _ | j j � | j j � | | _ | | _ d | _ d | _ t j | j
d � d S( Ni ( ( t threadt
allocate_lockt getlockt putlockt acquiret funct argst donet killedt start_new_threadt _start( t selfR R
( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt __init__ s
c C sy zO | j j � | j sN y t | j | f | j � WqN t k
rJ qN Xn Wd | j st d | _ | j j � n Xd S( Ni (
R R R t applyR R
R R R t release( R ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyR s
c C sN | j r t d � n | | _ | j j � | j j � | j rJ t � n d S( Ns put() called on killed generator( R t TypeErrort valueR R R R R ( R R ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt put% s
c C sH | j r t d � n | j j � | j j � | j rA t � n | j S( Ns get() called on killed generator( R R R R R R R t EOFErrorR ( R ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt get/ s
c C s/ | j r t d � n d | _ | j j � d S( Ns! kill() called on killed generatori ( R R R R ( R ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt kill9 s c C s t | j | j � S( N( R R R
( R ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt clone@ s ( R R R R R R R R ( ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyR s
c
C s� d \ } } } } } x� | | d | d | d } } } | | | | | | | | | | f \ } } } } | | | | } } xU | | k r� | j t | � � d | | d | | } } | | | | } } q� Wq Wd S( Nl l l l l
( l l l l l ( R t int(
t gt kt at bt a1t b1t pt qt dt d1( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt piC s $6 c C s� t t d � } | j � t t d � } x t d � D] } | j � Gq5 WH| j � } | j � x | j � Gt j j � qc Wd S( Ni
( ( ( R R% R t rangeR R t syst stdoutt flush( R t it h( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt testP s
( ( R' R t ExceptionR R R% R, ( ( ( s. /usr/lib64/python2.7/Demo/threads/Generator.pyt <module> s :
Coroutine.pyo 0000644 00000010227 15037407673 0007262 0 ustar 00 �
��^c @ sn d d l Z d d l Z d d
d � � YZ d e f d � � YZ d e f d � � YZ d d d � � YZ d S( i����Nt _CoEventc B s> e Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C s | | _ t j � | _ d S( N( t ft synct eventt e( t selft func( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt __init__I s c C s% | j d k r d Sd | j j Sd S( Ns main coroutines coroutine for func ( R t Nonet func_name( R ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt __repr__M s c C s
t | � S( N( t id( R ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt __hash__S s c C s t t | � t | � � S( N( t cmpR ( t xt y( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt __cmp__V s c C s | j j � d S( N( R t post( R ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt resumeY s c C s | j j � | j j � d S( N( R t waitt clear( R ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR \ s
( t __name__t
__module__R R
R R R R ( ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR H s t Killedc B s e Z RS( ( R R ( ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR ` s t EarlyExitc B s e Z RS( ( R R ( ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR a s t Coroutinec B sP e Z d � Z d � Z d � Z d � Z d d � Z d d � Z d d � Z RS( c C sH t d � | _ | _ i d | j 6| _ d | _ d | _ d | _ d S( Ni ( R R t activet maint invokedbyt killedt valuet
terminated_by( R ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR d s
c G s7 t | � } d | j | <t j | j | f | � | S( N( R R R t threadt start_new_threadt _start( R R t argst me( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt createk s
c G si | j � | j se z, y t | j | � Wn t k
r= n XWd | j sa | | _ | j � n Xn d S( N( R R t applyR R R t kill( R R$ R# ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR" q s
c C sF | j r t d � n d | _ x! | j j � D] } | j � q. Wd S( Ns kill() called on dead coroutinesi ( R t TypeErrorR t keysR ( R t coroutine( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR' ~ s
c C s | j | j | j | � S( N( t tranR R ( R t data( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt back� s c C s | j | j | � S( N( R+ R ( R R, ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt detach� s c C s� | j j | � s% t d | f � n | j rA t d | f � n | | _ | j } | | j | <| | _ | j � | j � | j r� | j | k r� t � n | j
d k r� t d | j
f � q� n | j S( Ns* .tran target %r is not an active coroutines .tran target %r is killeds %r terminated early(
R t has_keyR( R R R R R R R R R R ( R t targetR, R$ ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR+ � s
N(
R R R R% R" R' R R- R. R+ ( ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyR c s
( ( ( R R R t ExceptionR R R ( ( ( s. /usr/lib64/python2.7/Demo/threads/Coroutine.pyt <module>E s