home *** CD-ROM | disk | FTP | other *** search
/ com!online 2005 April / com_0405_1.iso / opensource / BTpp-0.5.4-bin.exe / $INSTDIR / BT++.exe / threading.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-04-19  |  23.3 KB  |  655 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.2)
  3.  
  4. import sys
  5. import time
  6. import thread
  7. import traceback
  8. import StringIO
  9. _sys = sys
  10. del sys
  11. _time = time.time
  12. _sleep = time.sleep
  13. del time
  14. _start_new_thread = thread.start_new_thread
  15. _allocate_lock = thread.allocate_lock
  16. _get_ident = thread.get_ident
  17. ThreadError = thread.error
  18. del thread
  19. _print_exc = traceback.print_exc
  20. del traceback
  21. _StringIO = StringIO.StringIO
  22. del StringIO
  23. _VERBOSE = 0
  24.  
  25. class _Verbose:
  26.     
  27.     def __init__(self, verbose = None):
  28.         pass
  29.  
  30.     
  31.     def _note(self, *args):
  32.         pass
  33.  
  34.  
  35. Lock = _allocate_lock
  36.  
  37. def RLock(*args, **kwargs):
  38.     return apply(_RLock, args, kwargs)
  39.  
  40.  
  41. class _RLock(_Verbose):
  42.     
  43.     def __init__(self, verbose = None):
  44.         _Verbose.__init__(self, verbose)
  45.         self._RLock__block = _allocate_lock()
  46.         self._RLock__owner = None
  47.         self._RLock__count = 0
  48.  
  49.     
  50.     def __repr__(self):
  51.         if self._RLock__owner:
  52.             pass
  53.         return '<%s(%s, %d)>' % (self.__class__.__name__, self._RLock__owner.getName(), self._RLock__count)
  54.  
  55.     
  56.     def acquire(self, blocking = 1):
  57.         me = currentThread()
  58.         if self._RLock__owner is me:
  59.             self._RLock__count = self._RLock__count + 1
  60.             return 1
  61.         
  62.         rc = self._RLock__block.acquire(blocking)
  63.         if rc:
  64.             self._RLock__owner = me
  65.             self._RLock__count = 1
  66.         
  67.         return rc
  68.  
  69.     
  70.     def release(self):
  71.         me = currentThread()
  72.         self._RLock__count = count = self._RLock__count - 1
  73.         if not count:
  74.             self._RLock__owner = None
  75.             self._RLock__block.release()
  76.         
  77.  
  78.     
  79.     def _acquire_restore(self, .2):
  80.         (count, owner) = .2
  81.         self._RLock__block.acquire()
  82.         self._RLock__count = count
  83.         self._RLock__owner = owner
  84.  
  85.     
  86.     def _release_save(self):
  87.         count = self._RLock__count
  88.         self._RLock__count = 0
  89.         owner = self._RLock__owner
  90.         self._RLock__owner = None
  91.         self._RLock__block.release()
  92.         return (count, owner)
  93.  
  94.     
  95.     def _is_owned(self):
  96.         return self._RLock__owner is currentThread()
  97.  
  98.  
  99.  
  100. def Condition(*args, **kwargs):
  101.     return apply(_Condition, args, kwargs)
  102.  
  103.  
  104. class _Condition(_Verbose):
  105.     
  106.     def __init__(self, lock = None, verbose = None):
  107.         _Verbose.__init__(self, verbose)
  108.         if lock is None:
  109.             lock = RLock()
  110.         
  111.         self._Condition__lock = lock
  112.         self.acquire = lock.acquire
  113.         self.release = lock.release
  114.         
  115.         try:
  116.             self._release_save = lock._release_save
  117.         except AttributeError:
  118.             pass
  119.  
  120.         
  121.         try:
  122.             self._acquire_restore = lock._acquire_restore
  123.         except AttributeError:
  124.             pass
  125.  
  126.         
  127.         try:
  128.             self._is_owned = lock._is_owned
  129.         except AttributeError:
  130.             pass
  131.  
  132.         self._Condition__waiters = []
  133.  
  134.     
  135.     def __repr__(self):
  136.         return '<Condition(%s, %d)>' % (self._Condition__lock, len(self._Condition__waiters))
  137.  
  138.     
  139.     def _release_save(self):
  140.         self._Condition__lock.release()
  141.  
  142.     
  143.     def _acquire_restore(self, x):
  144.         self._Condition__lock.acquire()
  145.  
  146.     
  147.     def _is_owned(self):
  148.         if self._Condition__lock.acquire(0):
  149.             self._Condition__lock.release()
  150.             return 0
  151.         else:
  152.             return 1
  153.  
  154.     
  155.     def wait(self, timeout = None):
  156.         me = currentThread()
  157.         waiter = _allocate_lock()
  158.         waiter.acquire()
  159.         self._Condition__waiters.append(waiter)
  160.         saved_state = self._release_save()
  161.         
  162.         try:
  163.             if timeout is None:
  164.                 waiter.acquire()
  165.             else:
  166.                 endtime = _time() + timeout
  167.                 delay = 0.00050000000000000001
  168.                 while 1:
  169.                     gotit = waiter.acquire(0)
  170.                     if gotit:
  171.                         break
  172.                     
  173.                     remaining = endtime - _time()
  174.                     if remaining <= 0:
  175.                         break
  176.                     
  177.                     delay = min(delay * 2, remaining, 0.050000000000000003)
  178.                     _sleep(delay)
  179.                 if not gotit:
  180.                     
  181.                     try:
  182.                         self._Condition__waiters.remove(waiter)
  183.                     except ValueError:
  184.                         pass
  185.  
  186.                 self._acquire_restore(saved_state)
  187.                 return None
  188.  
  189.  
  190.     
  191.     def notify(self, n = 1):
  192.         me = currentThread()
  193.         _Condition__waiters = self._Condition__waiters
  194.         waiters = _Condition__waiters[:n]
  195.         if not waiters:
  196.             return None
  197.         
  198.         if not n != 1 and 's':
  199.             pass
  200.         self._note('%s.notify(): notifying %d waiter%s', self, n, '')
  201.         for waiter in waiters:
  202.             waiter.release()
  203.             
  204.             try:
  205.                 _Condition__waiters.remove(waiter)
  206.             except ValueError:
  207.                 pass
  208.  
  209.         
  210.  
  211.     
  212.     def notifyAll(self):
  213.         self.notify(len(self._Condition__waiters))
  214.  
  215.  
  216.  
  217. def Semaphore(*args, **kwargs):
  218.     return apply(_Semaphore, args, kwargs)
  219.  
  220.  
  221. class _Semaphore(_Verbose):
  222.     
  223.     def __init__(self, value = 1, verbose = None):
  224.         _Verbose.__init__(self, verbose)
  225.         self._Semaphore__cond = Condition(Lock())
  226.         self._Semaphore__value = value
  227.  
  228.     
  229.     def acquire(self, blocking = 1):
  230.         rc = 0
  231.         self._Semaphore__cond.acquire()
  232.         while self._Semaphore__value == 0:
  233.             if not blocking:
  234.                 break
  235.             
  236.             self._Semaphore__cond.wait()
  237.         self._Semaphore__value = self._Semaphore__value - 1
  238.         rc = 1
  239.         self._Semaphore__cond.release()
  240.         return rc
  241.  
  242.     
  243.     def release(self):
  244.         self._Semaphore__cond.acquire()
  245.         self._Semaphore__value = self._Semaphore__value + 1
  246.         self._Semaphore__cond.notify()
  247.         self._Semaphore__cond.release()
  248.  
  249.  
  250.  
  251. def BoundedSemaphore(*args, **kwargs):
  252.     return apply(_BoundedSemaphore, args, kwargs)
  253.  
  254.  
  255. class _BoundedSemaphore(_Semaphore):
  256.     
  257.     def __init__(self, value = 1, verbose = None):
  258.         _Semaphore.__init__(self, value, verbose)
  259.         self._initial_value = value
  260.  
  261.     
  262.     def release(self):
  263.         if self._Semaphore__value >= self._initial_value:
  264.             raise ValueError, 'Semaphore released too many times'
  265.         
  266.         return _Semaphore.release(self)
  267.  
  268.  
  269.  
  270. def Event(*args, **kwargs):
  271.     return apply(_Event, args, kwargs)
  272.  
  273.  
  274. class _Event(_Verbose):
  275.     
  276.     def __init__(self, verbose = None):
  277.         _Verbose.__init__(self, verbose)
  278.         self._Event__cond = Condition(Lock())
  279.         self._Event__flag = 0
  280.  
  281.     
  282.     def isSet(self):
  283.         return self._Event__flag
  284.  
  285.     
  286.     def set(self):
  287.         self._Event__cond.acquire()
  288.         self._Event__flag = 1
  289.         self._Event__cond.notifyAll()
  290.         self._Event__cond.release()
  291.  
  292.     
  293.     def clear(self):
  294.         self._Event__cond.acquire()
  295.         self._Event__flag = 0
  296.         self._Event__cond.release()
  297.  
  298.     
  299.     def wait(self, timeout = None):
  300.         self._Event__cond.acquire()
  301.         if not (self._Event__flag):
  302.             self._Event__cond.wait(timeout)
  303.         
  304.         self._Event__cond.release()
  305.  
  306.  
  307. _counter = 0
  308.  
  309. def _newname(template = 'Thread-%d'):
  310.     global _counter
  311.     _counter = _counter + 1
  312.     return template % _counter
  313.  
  314. _active_limbo_lock = _allocate_lock()
  315. _active = { }
  316. _limbo = { }
  317.  
  318. class Thread(_Verbose):
  319.     __initialized = 0
  320.     
  321.     def __init__(self, group = None, target = None, name = None, args = (), kwargs = { }, verbose = None):
  322.         _Verbose.__init__(self, verbose)
  323.         self._Thread__target = target
  324.         if not name:
  325.             pass
  326.         self._Thread__name = str(_newname())
  327.         self._Thread__args = args
  328.         self._Thread__kwargs = kwargs
  329.         self._Thread__daemonic = self._set_daemon()
  330.         self._Thread__started = 0
  331.         self._Thread__stopped = 0
  332.         self._Thread__block = Condition(Lock())
  333.         self._Thread__initialized = 1
  334.  
  335.     
  336.     def _set_daemon(self):
  337.         return currentThread().isDaemon()
  338.  
  339.     
  340.     def __repr__(self):
  341.         status = 'initial'
  342.         if self._Thread__started:
  343.             status = 'started'
  344.         
  345.         if self._Thread__stopped:
  346.             status = 'stopped'
  347.         
  348.         if self._Thread__daemonic:
  349.             status = status + ' daemon'
  350.         
  351.         return '<%s(%s, %s)>' % (self.__class__.__name__, self._Thread__name, status)
  352.  
  353.     
  354.     def start(self):
  355.         _active_limbo_lock.acquire()
  356.         _limbo[self] = self
  357.         _active_limbo_lock.release()
  358.         _start_new_thread(self._Thread__bootstrap, ())
  359.         self._Thread__started = 1
  360.         _sleep(9.9999999999999995e-007)
  361.  
  362.     
  363.     def run(self):
  364.         if self._Thread__target:
  365.             apply(self._Thread__target, self._Thread__args, self._Thread__kwargs)
  366.         
  367.  
  368.     
  369.     def __bootstrap(self):
  370.         
  371.         try:
  372.             self._Thread__started = 1
  373.             _active_limbo_lock.acquire()
  374.             _active[_get_ident()] = self
  375.             del _limbo[self]
  376.             _active_limbo_lock.release()
  377.             
  378.             try:
  379.                 self.run()
  380.             except SystemExit:
  381.                 pass
  382.             except:
  383.                 s = _StringIO()
  384.                 _print_exc(file = s)
  385.                 _sys.stderr.write('Exception in thread %s:\n%s\n' % (self.getName(), s.getvalue()))
  386.  
  387.         finally:
  388.             self._Thread__stop()
  389.             
  390.             try:
  391.                 self._Thread__delete()
  392.             except:
  393.                 pass
  394.  
  395.  
  396.  
  397.     
  398.     def __stop(self):
  399.         self._Thread__block.acquire()
  400.         self._Thread__stopped = 1
  401.         self._Thread__block.notifyAll()
  402.         self._Thread__block.release()
  403.  
  404.     
  405.     def __delete(self):
  406.         _active_limbo_lock.acquire()
  407.         del _active[_get_ident()]
  408.         _active_limbo_lock.release()
  409.  
  410.     
  411.     def join(self, timeout = None):
  412.         self._Thread__block.acquire()
  413.         if timeout is None:
  414.             while not (self._Thread__stopped):
  415.                 self._Thread__block.wait()
  416.         else:
  417.             deadline = _time() + timeout
  418.             while not (self._Thread__stopped):
  419.                 delay = deadline - _time()
  420.                 if delay <= 0:
  421.                     break
  422.                 
  423.                 self._Thread__block.wait(delay)
  424.         self._Thread__block.release()
  425.  
  426.     
  427.     def getName(self):
  428.         return self._Thread__name
  429.  
  430.     
  431.     def setName(self, name):
  432.         self._Thread__name = str(name)
  433.  
  434.     
  435.     def isAlive(self):
  436.         if self._Thread__started:
  437.             pass
  438.         return not (self._Thread__stopped)
  439.  
  440.     
  441.     def isDaemon(self):
  442.         return self._Thread__daemonic
  443.  
  444.     
  445.     def setDaemon(self, daemonic):
  446.         self._Thread__daemonic = daemonic
  447.  
  448.  
  449.  
  450. def Timer(*args, **kwargs):
  451.     return _Timer(*args, **kwargs)
  452.  
  453.  
  454. class _Timer(Thread):
  455.     
  456.     def __init__(self, interval, function, args = [], kwargs = { }):
  457.         Thread.__init__(self)
  458.         self.interval = interval
  459.         self.function = function
  460.         self.args = args
  461.         self.kwargs = kwargs
  462.         self.finished = Event()
  463.  
  464.     
  465.     def cancel(self):
  466.         self.finished.set()
  467.  
  468.     
  469.     def run(self):
  470.         self.finished.wait(self.interval)
  471.         if not self.finished.isSet():
  472.             self.function(*self.args, **self.kwargs)
  473.         
  474.         self.finished.set()
  475.  
  476.  
  477.  
  478. class _MainThread(Thread):
  479.     
  480.     def __init__(self):
  481.         Thread.__init__(self, name = 'MainThread')
  482.         self._Thread__started = 1
  483.         _active_limbo_lock.acquire()
  484.         _active[_get_ident()] = self
  485.         _active_limbo_lock.release()
  486.         import atexit
  487.         atexit.register(self._MainThread__exitfunc)
  488.  
  489.     
  490.     def _set_daemon(self):
  491.         return 0
  492.  
  493.     
  494.     def _MainThread__exitfunc(self):
  495.         self._Thread__stop()
  496.         t = _pickSomeNonDaemonThread()
  497.         if t:
  498.             pass
  499.         
  500.         while t:
  501.             t.join()
  502.             t = _pickSomeNonDaemonThread()
  503.         self._Thread__delete()
  504.  
  505.  
  506.  
  507. def _pickSomeNonDaemonThread():
  508.     for t in enumerate():
  509.         if not t.isDaemon() and t.isAlive():
  510.             return t
  511.         
  512.     
  513.     return None
  514.  
  515.  
  516. class _DummyThread(Thread):
  517.     
  518.     def __init__(self):
  519.         Thread.__init__(self, name = _newname('Dummy-%d'))
  520.         self._Thread__started = 1
  521.         _active_limbo_lock.acquire()
  522.         _active[_get_ident()] = self
  523.         _active_limbo_lock.release()
  524.  
  525.     
  526.     def _set_daemon(self):
  527.         return 1
  528.  
  529.     
  530.     def join(self, timeout = None):
  531.         pass
  532.  
  533.  
  534.  
  535. def currentThread():
  536.     
  537.     try:
  538.         return _active[_get_ident()]
  539.     except KeyError:
  540.         return _DummyThread()
  541.  
  542.  
  543.  
  544. def activeCount():
  545.     _active_limbo_lock.acquire()
  546.     count = len(_active) + len(_limbo)
  547.     _active_limbo_lock.release()
  548.     return count
  549.  
  550.  
  551. def enumerate():
  552.     _active_limbo_lock.acquire()
  553.     active = _active.values() + _limbo.values()
  554.     _active_limbo_lock.release()
  555.     return active
  556.  
  557. _MainThread()
  558.  
  559. def _test():
  560.     
  561.     class BoundedQueue(_Verbose):
  562.         
  563.         def __init__(self, limit):
  564.             _Verbose.__init__(self)
  565.             self.mon = RLock()
  566.             self.rc = Condition(self.mon)
  567.             self.wc = Condition(self.mon)
  568.             self.limit = limit
  569.             self.queue = []
  570.  
  571.         
  572.         def put(self, item):
  573.             self.mon.acquire()
  574.             while len(self.queue) >= self.limit:
  575.                 self._note('put(%s): queue full', item)
  576.                 self.wc.wait()
  577.             self.queue.append(item)
  578.             self._note('put(%s): appended, length now %d', item, len(self.queue))
  579.             self.rc.notify()
  580.             self.mon.release()
  581.  
  582.         
  583.         def get(self):
  584.             self.mon.acquire()
  585.             while not (self.queue):
  586.                 self._note('get(): queue empty')
  587.                 self.rc.wait()
  588.             item = self.queue[0]
  589.             del self.queue[0]
  590.             self._note('get(): got %s, %d left', item, len(self.queue))
  591.             self.wc.notify()
  592.             self.mon.release()
  593.             return item
  594.  
  595.  
  596.     
  597.     class ProducerThread(Thread):
  598.         
  599.         def __init__(self, queue, quota):
  600.             Thread.__init__(self, name = 'Producer')
  601.             self.queue = queue
  602.             self.quota = quota
  603.  
  604.         
  605.         def run(self):
  606.             random = random
  607.             import random
  608.             counter = 0
  609.             while counter < self.quota:
  610.                 counter = counter + 1
  611.                 self.queue.put('%s.%d' % (self.getName(), counter))
  612.                 _sleep(random() * 1.0000000000000001e-005)
  613.  
  614.  
  615.     
  616.     class ConsumerThread(Thread):
  617.         
  618.         def __init__(self, queue, count):
  619.             Thread.__init__(self, name = 'Consumer')
  620.             self.queue = queue
  621.             self.count = count
  622.  
  623.         
  624.         def run(self):
  625.             while self.count > 0:
  626.                 item = self.queue.get()
  627.                 print item
  628.                 self.count = self.count - 1
  629.  
  630.  
  631.     NP = 3
  632.     QL = 4
  633.     NI = 5
  634.     Q = BoundedQueue(QL)
  635.     P = []
  636.     for i in range(NP):
  637.         t = ProducerThread(Q, NI)
  638.         t.setName('Producer-%d' % (i + 1))
  639.         P.append(t)
  640.     
  641.     C = ConsumerThread(Q, NI * NP)
  642.     for t in P:
  643.         t.start()
  644.         _sleep(9.9999999999999995e-007)
  645.     
  646.     C.start()
  647.     for t in P:
  648.         t.join()
  649.     
  650.     C.join()
  651.  
  652. if __name__ == '__main__':
  653.     _test()
  654.  
  655.