[Python-checkins] cpython: Close #13550: Remove the debug machinery from the threading module: remove

Sat Mar 3 01:35:31 CET 2012

http://hg.python.org/cpython/rev/8ec51b2e57c2
changeset: 75373:8ec51b2e57c2
user: Victor Stinner <victor.stinner at gmail.com>
date: Sat Mar 03 01:32:57 2012 +0100
summary:
 Close #13550: Remove the debug machinery from the threading module: remove
verbose arguments from all threading classes and functions.
files:
 Lib/threading.py | 152 ++++------------------------------
 Misc/NEWS | 3 +
 2 files changed, 21 insertions(+), 134 deletions(-)

diff --git a/Lib/threading.py b/Lib/threading.py
--- a/Lib/threading.py
+++ b/Lib/threading.py
@@ -34,40 +34,6 @@
 del _thread
 
 
-# Debug support (adapted from ihooks.py).
-
-_VERBOSE = False
-
-if __debug__:
-
- class _Verbose(object):
-
- def __init__(self, verbose=None):
- if verbose is None:
- verbose = _VERBOSE
- self._verbose = verbose
-
- def _note(self, format, *args):
- if self._verbose:
- format = format % args
- # Issue #4188: calling current_thread() can incur an infinite
- # recursion if it has to create a DummyThread on the fly.
- ident = get_ident()
- try:
- name = _active[ident].name
- except KeyError:
- name = "<OS thread %d>" % ident
- format = "%s: %s\n" % (name, format)
- _sys.stderr.write(format)
-
-else:
- # Disable this when using "python -O"
- class _Verbose(object):
- def __init__(self, verbose=None):
- pass
- def _note(self, *args):
- pass
-
 # Support for profile and trace hooks
 
 _profile_hook = None
@@ -85,17 +51,14 @@
 
 Lock = _allocate_lock
 
-def RLock(verbose=None, *args, **kwargs):
- if verbose is None:
- verbose = _VERBOSE
- if (__debug__ and verbose) or _CRLock is None:
- return _PyRLock(verbose, *args, **kwargs)
+def RLock(*args, **kwargs):
+ if _CRLock is None:
+ return _PyRLock(*args, **kwargs)
 return _CRLock(*args, **kwargs)
 
-class _RLock(_Verbose):
+class _RLock:
 
- def __init__(self, verbose=None):
- _Verbose.__init__(self, verbose)
+ def __init__(self):
 self._block = _allocate_lock()
 self._owner = None
 self._count = 0
@@ -113,18 +76,11 @@
 me = get_ident()
 if self._owner == me:
 self._count = self._count + 1
- if __debug__:
- self._note("%s.acquire(%s): recursive success", self, blocking)
 return 1
 rc = self._block.acquire(blocking, timeout)
 if rc:
 self._owner = me
 self._count = 1
- if __debug__:
- self._note("%s.acquire(%s): initial success", self, blocking)
- else:
- if __debug__:
- self._note("%s.acquire(%s): failure", self, blocking)
 return rc
 
 __enter__ = acquire
@@ -136,11 +92,6 @@
 if not count:
 self._owner = None
 self._block.release()
- if __debug__:
- self._note("%s.release(): final release", self)
- else:
- if __debug__:
- self._note("%s.release(): non-final release", self)
 
 def __exit__(self, t, v, tb):
 self.release()
@@ -150,12 +101,8 @@
 def _acquire_restore(self, state):
 self._block.acquire()
 self._count, self._owner = state
- if __debug__:
- self._note("%s._acquire_restore()", self)
 
 def _release_save(self):
- if __debug__:
- self._note("%s._release_save()", self)
 if self._count == 0:
 raise RuntimeError("cannot release un-acquired lock")
 count = self._count
@@ -171,10 +118,9 @@
 _PyRLock = _RLock
 
 
-class Condition(_Verbose):
+class Condition:
 
- def __init__(self, lock=None, verbose=None):
- _Verbose.__init__(self, verbose)
+ def __init__(self, lock=None):
 if lock is None:
 lock = RLock()
 self._lock = lock
@@ -233,23 +179,16 @@
 if timeout is None:
 waiter.acquire()
 gotit = True
- if __debug__:
- self._note("%s.wait(): got it", self)
 else:
 if timeout > 0:
 gotit = waiter.acquire(True, timeout)
 else:
 gotit = waiter.acquire(False)
 if not gotit:
- if __debug__:
- self._note("%s.wait(%s): timed out", self, timeout)
 try:
 self._waiters.remove(waiter)
 except ValueError:
 pass
- else:
- if __debug__:
- self._note("%s.wait(%s): got it", self, timeout)
 return gotit
 finally:
 self._acquire_restore(saved_state)
@@ -265,19 +204,9 @@
 else:
 waittime = endtime - _time()
 if waittime <= 0:
- if __debug__:
- self._note("%s.wait_for(%r, %r): Timed out.",
- self, predicate, timeout)
 break
- if __debug__:
- self._note("%s.wait_for(%r, %r): Waiting with timeout=%s.",
- self, predicate, timeout, waittime)
 self.wait(waittime)
 result = predicate()
- else:
- if __debug__:
- self._note("%s.wait_for(%r, %r): Success.",
- self, predicate, timeout)
 return result
 
 def notify(self, n=1):
@@ -286,11 +215,7 @@
 __waiters = self._waiters
 waiters = __waiters[:n]
 if not waiters:
- if __debug__:
- self._note("%s.notify(): no waiters", self)
 return
- self._note("%s.notify(): notifying %d waiter%s", self, n,
- n!=1 and "s" or "")
 for waiter in waiters:
 waiter.release()
 try:
@@ -304,14 +229,13 @@
 notifyAll = notify_all
 
 
-class Semaphore(_Verbose):
+class Semaphore:
 
 # After Tim Peters' semaphore class, but not quite the same (no maximum)
 
- def __init__(self, value=1, verbose=None):
+ def __init__(self, value=1):
 if value < 0:
 raise ValueError("semaphore initial value must be >= 0")
- _Verbose.__init__(self, verbose)
 self._cond = Condition(Lock())
 self._value = value
 
@@ -324,9 +248,6 @@
 while self._value == 0:
 if not blocking:
 break
- if __debug__:
- self._note("%s.acquire(%s): blocked waiting, value=%s",
- self, blocking, self._value)
 if timeout is not None:
 if endtime is None:
 endtime = _time() + timeout
@@ -337,9 +258,6 @@
 self._cond.wait(timeout)
 else:
 self._value = self._value - 1
- if __debug__:
- self._note("%s.acquire: success, value=%s",
- self, self._value)
 rc = True
 self._cond.release()
 return rc
@@ -349,9 +267,6 @@
 def release(self):
 self._cond.acquire()
 self._value = self._value + 1
- if __debug__:
- self._note("%s.release: success, value=%s",
- self, self._value)
 self._cond.notify()
 self._cond.release()
 
@@ -361,8 +276,8 @@
 
 class BoundedSemaphore(Semaphore):
 """Semaphore that checks that # releases is <= # acquires"""
- def __init__(self, value=1, verbose=None):
- Semaphore.__init__(self, value, verbose)
+ def __init__(self, value=1):
+ Semaphore.__init__(self, value)
 self._initial_value = value
 
 def release(self):
@@ -371,12 +286,11 @@
 return Semaphore.release(self)
 
 
-class Event(_Verbose):
+class Event:
 
 # After Tim Peters' event class (without is_posted())
 
- def __init__(self, verbose=None):
- _Verbose.__init__(self, verbose)
+ def __init__(self):
 self._cond = Condition(Lock())
 self._flag = False
 
@@ -426,13 +340,13 @@
 # since the previous cycle. In addition, a 'resetting' state exists which is
 # similar to 'draining' except that threads leave with a BrokenBarrierError,
 # and a 'broken' state in which all threads get the exception.
-class Barrier(_Verbose):
+class Barrier:
 """
 Barrier. Useful for synchronizing a fixed number of threads
 at known synchronization points. Threads block on 'wait()' and are
 simultaneously once they have all made that call.
 """
- def __init__(self, parties, action=None, timeout=None, verbose=None):
+ def __init__(self, parties, action=None, timeout=None):
 """
 Create a barrier, initialised to 'parties' threads.
 'action' is a callable which, when supplied, will be called
@@ -441,7 +355,6 @@
 If a 'timeout' is provided, it is uses as the default for
 all subsequent 'wait()' calls.
 """
- _Verbose.__init__(self, verbose)
 self._cond = Condition(Lock())
 self._action = action
 self._timeout = timeout
@@ -602,7 +515,7 @@
 
 # Main class for threads
 
-class Thread(_Verbose):
+class Thread:
 
 __initialized = False
 # Need to store a reference to sys.exc_info for printing
@@ -615,9 +528,8 @@
 #XXX __exc_clear = _sys.exc_clear
 
 def __init__(self, group=None, target=None, name=None,
- args=(), kwargs=None, verbose=None, *, daemon=None):
+ args=(), kwargs=None, *, daemon=None):
 assert group is None, "group argument must be None for now"
- _Verbose.__init__(self, verbose)
 if kwargs is None:
 kwargs = {}
 self._target = target
@@ -664,8 +576,6 @@
 
 if self._started.is_set():
 raise RuntimeError("threads can only be started once")
- if __debug__:
- self._note("%s.start(): starting thread", self)
 with _active_limbo_lock:
 _limbo[self] = self
 try:
@@ -715,24 +625,17 @@
 with _active_limbo_lock:
 _active[self._ident] = self
 del _limbo[self]
- if __debug__:
- self._note("%s._bootstrap(): thread started", self)
 
 if _trace_hook:
- self._note("%s._bootstrap(): registering trace hook", self)
 _sys.settrace(_trace_hook)
 if _profile_hook:
- self._note("%s._bootstrap(): registering profile hook", self)
 _sys.setprofile(_profile_hook)
 
 try:
 self.run()
 except SystemExit:
- if __debug__:
- self._note("%s._bootstrap(): raised SystemExit", self)
+ pass
 except:
- if __debug__:
- self._note("%s._bootstrap(): unhandled exception", self)
 # If sys.stderr is no more (most likely from interpreter
 # shutdown) use self._stderr. Otherwise still use sys (as in
 # _sys) in case sys.stderr was redefined since the creation of
@@ -763,9 +666,6 @@
 # hog; deleting everything else is just for thoroughness
 finally:
 del exc_type, exc_value, exc_tb
- else:
- if __debug__:
- self._note("%s._bootstrap(): normal return", self)
 finally:
 # Prevent a race in
 # test_threading.test_no_refcycle_through_target when
@@ -832,29 +732,18 @@
 if self is current_thread():
 raise RuntimeError("cannot join current thread")
 
- if __debug__:
- if not self._stopped:
- self._note("%s.join(): waiting until thread stops", self)
-
 self._block.acquire()
 try:
 if timeout is None:
 while not self._stopped:
 self._block.wait()
- if __debug__:
- self._note("%s.join(): thread stopped", self)
 else:
 deadline = _time() + timeout
 while not self._stopped:
 delay = deadline - _time()
 if delay <= 0:
- if __debug__:
- self._note("%s.join(): timed out", self)
 break
 self._block.wait(delay)
- else:
- if __debug__:
- self._note("%s.join(): thread stopped", self)
 finally:
 self._block.release()
 
@@ -947,14 +836,9 @@
 def _exitfunc(self):
 self._stop()
 t = _pickSomeNonDaemonThread()
- if t:
- if __debug__:
- self._note("%s: waiting for other threads", self)
 while t:
 t.join()
 t = _pickSomeNonDaemonThread()
- if __debug__:
- self._note("%s: exiting", self)
 self._delete()
 
 def _pickSomeNonDaemonThread():
diff --git a/Misc/NEWS b/Misc/NEWS
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -511,6 +511,9 @@
 Library
 -------
 
+- Issue #13550: Remove the debug machinery from the threading module: remove
+ verbose arguments from all threading classes and functions.
+
 - Issue #14159: Fix the len() of weak containers (WeakSet, WeakKeyDictionary,
 WeakValueDictionary) to return a better approximation when some objects
 are dead or dying. Moreover, the implementation is now O(1) rather than
-- 
Repository URL: http://hg.python.org/cpython
