HSCondition: now deriving from deque, as the AsyncQeue does, to elimitate one more level of indirection. Clearly this not good from a design standpoint, as a Condition is no Deque, but it helps speeding things up which is what this is about. Could make it a hidden class to indicate how 'special' it is

Author: Byron

lib/git/async/util.py

@@ -69,17 +69,16 @@ def empty(self):
 	put = deque.append
 
 
-class HSCondition(object):
+class HSCondition(deque):
 	"""Cleaned up code of the original condition object in order 
 	to make it run and respond faster."""
-	__slots__ = ("_lock", '_waiters')
+	__slots__ = ("_lock")
 	delay = 0.0002					# reduces wait times, but increases overhead
 
 	def __init__(self, lock=None):
 		if lock is None:
 			lock = Lock()
 		self._lock = lock
-		self._waiters = deque()
 
 	def release(self):
 		self._lock.release()
@@ -93,7 +92,7 @@ def acquire(self, block=None):
 	def wait(self, timeout=None):
 		waiter = _allocate_lock()
 		waiter.acquire()				# get it the first time, no blocking
-		self._waiters.append(waiter)
+		self.append(waiter)
 
 		# in the momemnt we release our lock, someone else might actually resume
 		self.release()
@@ -124,7 +123,7 @@ def wait(self, timeout=None):
 				# END endless loop
 				if not gotit:
 					try:
-						self._waiters.remove(waiter)
+						self.remove(waiter)
 					except ValueError:
 						pass
 				# END didn't ever get it
@@ -140,13 +139,13 @@ def notify(self, n=1):
 		In the multi-notify case, we acquire a lock just for safety, as otherwise
 		we might pop too much of someone else notifies n waiters as well, which 
 		would in the worst case lead to double-releases of locks."""
-		if not self._waiters:
+		if not self:
 			return
 		if n == 1:
 			# so here we assume this is thead-safe ! It wouldn't be in any other
 			# language, but python it is.
 			try:
-				self._waiters.popleft().release()
+				self.popleft().release()
 			except IndexError:
 				pass
 		else:
@@ -155,16 +154,16 @@ def notify(self, n=1):
 			# and waits again, but only until we are done, which is important
 			# to do that in a thread-safe fashion
 			try:
-				for i in range(min(n, len(self._waiters))):
-					self._waiters.popleft().release()
+				for i in range(min(n, len(self))):
+					self.popleft().release()
 				# END for each waiter to resume
 			finally:
 				self.release()
 			# END assure we release our lock
 		# END handle n = 1 case faster
 
 	def notify_all(self):
-		self.notify(len(self._waiters))
+		self.notify(len(self))
 
 
 class ReadOnly(Exception):

test/git/async/test_pool.py

@@ -289,8 +289,8 @@ def test_base(self):
 		self._assert_async_dependent_tasks(p)
 
 
-		# SINGLE TASK THREADED ASYNC MODE
-		################################
+		# SINGLE TASK THREADED ASYNC MODE ( 1 thread )
+		##############################################
 		# step one gear up - just one thread for now.
 		p.set_size(1)
 		assert p.size() == 1
@@ -310,8 +310,8 @@ def test_base(self):
 
 
 
-		# SINGLE TASK ASYNC MODE
-		########################
+		# SINGLE TASK ASYNC MODE ( 2 threads )
+		######################################
 		# two threads to compete for a single task
 		p.set_size(2)
 		self._assert_single_task(p, True)