mirror of
https://github.com/python/cpython.git
synced 2025-11-02 14:41:33 +00:00
1210 lines
36 KiB
Python
1210 lines
36 KiB
Python
"""
|
|
Various tests for synchronization primitives.
|
|
"""
|
|
|
|
import gc
|
|
import sys
|
|
import time
|
|
from _thread import start_new_thread, TIMEOUT_MAX
|
|
import threading
|
|
import unittest
|
|
import weakref
|
|
|
|
from test import support
|
|
from test.support import threading_helper
|
|
|
|
|
|
requires_fork = unittest.skipUnless(support.has_fork_support,
|
|
"platform doesn't support fork "
|
|
"(no _at_fork_reinit method)")
|
|
|
|
|
|
def wait_threads_blocked(nthread):
|
|
# Arbitrary sleep to wait until N threads are blocked,
|
|
# like waiting for a lock.
|
|
time.sleep(0.010 * nthread)
|
|
|
|
|
|
class Bunch(object):
|
|
"""
|
|
A bunch of threads.
|
|
"""
|
|
def __init__(self, func, nthread, wait_before_exit=False):
|
|
"""
|
|
Construct a bunch of `nthread` threads running the same function `func`.
|
|
If `wait_before_exit` is True, the threads won't terminate until
|
|
do_finish() is called.
|
|
"""
|
|
self.func = func
|
|
self.nthread = nthread
|
|
self.started = []
|
|
self.finished = []
|
|
self.exceptions = []
|
|
self._can_exit = not wait_before_exit
|
|
self._wait_thread = None
|
|
|
|
def task(self):
|
|
tid = threading.get_ident()
|
|
self.started.append(tid)
|
|
try:
|
|
self.func()
|
|
except BaseException as exc:
|
|
self.exceptions.append(exc)
|
|
finally:
|
|
self.finished.append(tid)
|
|
for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
|
|
if self._can_exit:
|
|
break
|
|
|
|
def __enter__(self):
|
|
self._wait_thread = threading_helper.wait_threads_exit(support.SHORT_TIMEOUT)
|
|
self._wait_thread.__enter__()
|
|
|
|
try:
|
|
for _ in range(self.nthread):
|
|
start_new_thread(self.task, ())
|
|
except:
|
|
self._can_exit = True
|
|
raise
|
|
|
|
for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
|
|
if len(self.started) >= self.nthread:
|
|
break
|
|
|
|
return self
|
|
|
|
def __exit__(self, exc_type, exc_value, traceback):
|
|
for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
|
|
if len(self.finished) >= self.nthread:
|
|
break
|
|
|
|
# Wait until threads completely exit according to _thread._count()
|
|
self._wait_thread.__exit__(None, None, None)
|
|
|
|
# Break reference cycle
|
|
exceptions = self.exceptions
|
|
self.exceptions = None
|
|
if exceptions:
|
|
raise ExceptionGroup(f"{self.func} threads raised exceptions",
|
|
exceptions)
|
|
|
|
def do_finish(self):
|
|
self._can_exit = True
|
|
|
|
|
|
class BaseTestCase(unittest.TestCase):
|
|
def setUp(self):
|
|
self._threads = threading_helper.threading_setup()
|
|
|
|
def tearDown(self):
|
|
threading_helper.threading_cleanup(*self._threads)
|
|
support.reap_children()
|
|
|
|
def assertTimeout(self, actual, expected):
|
|
# The waiting and/or time.monotonic() can be imprecise, which
|
|
# is why comparing to the expected value would sometimes fail
|
|
# (especially under Windows).
|
|
self.assertGreaterEqual(actual, expected * 0.6)
|
|
# Test nothing insane happened
|
|
self.assertLess(actual, expected * 10.0)
|
|
|
|
|
|
class BaseLockTests(BaseTestCase):
|
|
"""
|
|
Tests for both recursive and non-recursive locks.
|
|
"""
|
|
|
|
def wait_phase(self, phase, expected):
|
|
for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
|
|
if len(phase) >= expected:
|
|
break
|
|
self.assertEqual(len(phase), expected)
|
|
|
|
def test_constructor(self):
|
|
lock = self.locktype()
|
|
del lock
|
|
|
|
def test_repr(self):
|
|
lock = self.locktype()
|
|
self.assertRegex(repr(lock), "<unlocked .* object (.*)?at .*>")
|
|
del lock
|
|
|
|
def test_locked_repr(self):
|
|
lock = self.locktype()
|
|
lock.acquire()
|
|
self.assertRegex(repr(lock), "<locked .* object (.*)?at .*>")
|
|
del lock
|
|
|
|
def test_acquire_destroy(self):
|
|
lock = self.locktype()
|
|
lock.acquire()
|
|
del lock
|
|
|
|
def test_acquire_release(self):
|
|
lock = self.locktype()
|
|
lock.acquire()
|
|
lock.release()
|
|
del lock
|
|
|
|
def test_try_acquire(self):
|
|
lock = self.locktype()
|
|
self.assertTrue(lock.acquire(False))
|
|
lock.release()
|
|
|
|
def test_try_acquire_contended(self):
|
|
lock = self.locktype()
|
|
lock.acquire()
|
|
result = []
|
|
def f():
|
|
result.append(lock.acquire(False))
|
|
with Bunch(f, 1):
|
|
pass
|
|
self.assertFalse(result[0])
|
|
lock.release()
|
|
|
|
def test_acquire_contended(self):
|
|
lock = self.locktype()
|
|
lock.acquire()
|
|
def f():
|
|
lock.acquire()
|
|
lock.release()
|
|
|
|
N = 5
|
|
with Bunch(f, N) as bunch:
|
|
# Threads block on lock.acquire()
|
|
wait_threads_blocked(N)
|
|
self.assertEqual(len(bunch.finished), 0)
|
|
|
|
# Threads unblocked
|
|
lock.release()
|
|
|
|
self.assertEqual(len(bunch.finished), N)
|
|
|
|
def test_with(self):
|
|
lock = self.locktype()
|
|
def f():
|
|
lock.acquire()
|
|
lock.release()
|
|
|
|
def with_lock(err=None):
|
|
with lock:
|
|
if err is not None:
|
|
raise err
|
|
|
|
# Acquire the lock, do nothing, with releases the lock
|
|
with lock:
|
|
pass
|
|
|
|
# Check that the lock is unacquired
|
|
with Bunch(f, 1):
|
|
pass
|
|
|
|
# Acquire the lock, raise an exception, with releases the lock
|
|
with self.assertRaises(TypeError):
|
|
with lock:
|
|
raise TypeError
|
|
|
|
# Check that the lock is unacquired even if after an exception
|
|
# was raised in the previous "with lock:" block
|
|
with Bunch(f, 1):
|
|
pass
|
|
|
|
def test_thread_leak(self):
|
|
# The lock shouldn't leak a Thread instance when used from a foreign
|
|
# (non-threading) thread.
|
|
lock = self.locktype()
|
|
def f():
|
|
lock.acquire()
|
|
lock.release()
|
|
|
|
# We run many threads in the hope that existing threads ids won't
|
|
# be recycled.
|
|
with Bunch(f, 15):
|
|
pass
|
|
|
|
def test_timeout(self):
|
|
lock = self.locktype()
|
|
# Can't set timeout if not blocking
|
|
self.assertRaises(ValueError, lock.acquire, False, 1)
|
|
# Invalid timeout values
|
|
self.assertRaises(ValueError, lock.acquire, timeout=-100)
|
|
self.assertRaises(OverflowError, lock.acquire, timeout=1e100)
|
|
self.assertRaises(OverflowError, lock.acquire, timeout=TIMEOUT_MAX + 1)
|
|
# TIMEOUT_MAX is ok
|
|
lock.acquire(timeout=TIMEOUT_MAX)
|
|
lock.release()
|
|
t1 = time.monotonic()
|
|
self.assertTrue(lock.acquire(timeout=5))
|
|
t2 = time.monotonic()
|
|
# Just a sanity test that it didn't actually wait for the timeout.
|
|
self.assertLess(t2 - t1, 5)
|
|
results = []
|
|
def f():
|
|
t1 = time.monotonic()
|
|
results.append(lock.acquire(timeout=0.5))
|
|
t2 = time.monotonic()
|
|
results.append(t2 - t1)
|
|
with Bunch(f, 1):
|
|
pass
|
|
self.assertFalse(results[0])
|
|
self.assertTimeout(results[1], 0.5)
|
|
|
|
def test_weakref_exists(self):
|
|
lock = self.locktype()
|
|
ref = weakref.ref(lock)
|
|
self.assertIsNotNone(ref())
|
|
|
|
def test_weakref_deleted(self):
|
|
lock = self.locktype()
|
|
ref = weakref.ref(lock)
|
|
del lock
|
|
gc.collect() # For PyPy or other GCs.
|
|
self.assertIsNone(ref())
|
|
|
|
|
|
class LockTests(BaseLockTests):
|
|
"""
|
|
Tests for non-recursive, weak locks
|
|
(which can be acquired and released from different threads).
|
|
"""
|
|
def test_reacquire(self):
|
|
# Lock needs to be released before re-acquiring.
|
|
lock = self.locktype()
|
|
phase = []
|
|
|
|
def f():
|
|
lock.acquire()
|
|
phase.append(None)
|
|
lock.acquire()
|
|
phase.append(None)
|
|
|
|
with threading_helper.wait_threads_exit():
|
|
# Thread blocked on lock.acquire()
|
|
start_new_thread(f, ())
|
|
self.wait_phase(phase, 1)
|
|
|
|
# Thread unblocked
|
|
lock.release()
|
|
self.wait_phase(phase, 2)
|
|
|
|
def test_different_thread(self):
|
|
# Lock can be released from a different thread.
|
|
lock = self.locktype()
|
|
lock.acquire()
|
|
def f():
|
|
lock.release()
|
|
with Bunch(f, 1):
|
|
pass
|
|
lock.acquire()
|
|
lock.release()
|
|
|
|
def test_state_after_timeout(self):
|
|
# Issue #11618: check that lock is in a proper state after a
|
|
# (non-zero) timeout.
|
|
lock = self.locktype()
|
|
lock.acquire()
|
|
self.assertFalse(lock.acquire(timeout=0.01))
|
|
lock.release()
|
|
self.assertFalse(lock.locked())
|
|
self.assertTrue(lock.acquire(blocking=False))
|
|
|
|
@requires_fork
|
|
def test_at_fork_reinit(self):
|
|
def use_lock(lock):
|
|
# make sure that the lock still works normally
|
|
# after _at_fork_reinit()
|
|
lock.acquire()
|
|
lock.release()
|
|
|
|
# unlocked
|
|
lock = self.locktype()
|
|
lock._at_fork_reinit()
|
|
use_lock(lock)
|
|
|
|
# locked: _at_fork_reinit() resets the lock to the unlocked state
|
|
lock2 = self.locktype()
|
|
lock2.acquire()
|
|
lock2._at_fork_reinit()
|
|
use_lock(lock2)
|
|
|
|
|
|
class RLockTests(BaseLockTests):
|
|
"""
|
|
Tests for recursive locks.
|
|
"""
|
|
def test_reacquire(self):
|
|
lock = self.locktype()
|
|
lock.acquire()
|
|
lock.acquire()
|
|
lock.release()
|
|
lock.acquire()
|
|
lock.release()
|
|
lock.release()
|
|
|
|
def test_release_unacquired(self):
|
|
# Cannot release an unacquired lock
|
|
lock = self.locktype()
|
|
self.assertRaises(RuntimeError, lock.release)
|
|
lock.acquire()
|
|
lock.acquire()
|
|
lock.release()
|
|
lock.acquire()
|
|
lock.release()
|
|
lock.release()
|
|
self.assertRaises(RuntimeError, lock.release)
|
|
|
|
def test_release_save_unacquired(self):
|
|
# Cannot _release_save an unacquired lock
|
|
lock = self.locktype()
|
|
self.assertRaises(RuntimeError, lock._release_save)
|
|
lock.acquire()
|
|
lock.acquire()
|
|
lock.release()
|
|
lock.acquire()
|
|
lock.release()
|
|
lock.release()
|
|
self.assertRaises(RuntimeError, lock._release_save)
|
|
|
|
def test_recursion_count(self):
|
|
lock = self.locktype()
|
|
self.assertEqual(0, lock._recursion_count())
|
|
lock.acquire()
|
|
self.assertEqual(1, lock._recursion_count())
|
|
lock.acquire()
|
|
lock.acquire()
|
|
self.assertEqual(3, lock._recursion_count())
|
|
lock.release()
|
|
self.assertEqual(2, lock._recursion_count())
|
|
lock.release()
|
|
lock.release()
|
|
self.assertEqual(0, lock._recursion_count())
|
|
|
|
phase = []
|
|
|
|
def f():
|
|
lock.acquire()
|
|
phase.append(None)
|
|
|
|
self.wait_phase(phase, 2)
|
|
lock.release()
|
|
phase.append(None)
|
|
|
|
with threading_helper.wait_threads_exit():
|
|
# Thread blocked on lock.acquire()
|
|
start_new_thread(f, ())
|
|
self.wait_phase(phase, 1)
|
|
self.assertEqual(0, lock._recursion_count())
|
|
|
|
# Thread unblocked
|
|
phase.append(None)
|
|
self.wait_phase(phase, 3)
|
|
self.assertEqual(0, lock._recursion_count())
|
|
|
|
def test_different_thread(self):
|
|
# Cannot release from a different thread
|
|
lock = self.locktype()
|
|
def f():
|
|
lock.acquire()
|
|
|
|
with Bunch(f, 1, True) as bunch:
|
|
try:
|
|
self.assertRaises(RuntimeError, lock.release)
|
|
finally:
|
|
bunch.do_finish()
|
|
|
|
def test__is_owned(self):
|
|
lock = self.locktype()
|
|
self.assertFalse(lock._is_owned())
|
|
lock.acquire()
|
|
self.assertTrue(lock._is_owned())
|
|
lock.acquire()
|
|
self.assertTrue(lock._is_owned())
|
|
result = []
|
|
def f():
|
|
result.append(lock._is_owned())
|
|
with Bunch(f, 1):
|
|
pass
|
|
self.assertFalse(result[0])
|
|
lock.release()
|
|
self.assertTrue(lock._is_owned())
|
|
lock.release()
|
|
self.assertFalse(lock._is_owned())
|
|
|
|
|
|
class EventTests(BaseTestCase):
|
|
"""
|
|
Tests for Event objects.
|
|
"""
|
|
|
|
def test_is_set(self):
|
|
evt = self.eventtype()
|
|
self.assertFalse(evt.is_set())
|
|
evt.set()
|
|
self.assertTrue(evt.is_set())
|
|
evt.set()
|
|
self.assertTrue(evt.is_set())
|
|
evt.clear()
|
|
self.assertFalse(evt.is_set())
|
|
evt.clear()
|
|
self.assertFalse(evt.is_set())
|
|
|
|
def _check_notify(self, evt):
|
|
# All threads get notified
|
|
N = 5
|
|
results1 = []
|
|
results2 = []
|
|
def f():
|
|
results1.append(evt.wait())
|
|
results2.append(evt.wait())
|
|
|
|
with Bunch(f, N):
|
|
# Threads blocked on first evt.wait()
|
|
wait_threads_blocked(N)
|
|
self.assertEqual(len(results1), 0)
|
|
|
|
# Threads unblocked
|
|
evt.set()
|
|
|
|
self.assertEqual(results1, [True] * N)
|
|
self.assertEqual(results2, [True] * N)
|
|
|
|
def test_notify(self):
|
|
evt = self.eventtype()
|
|
self._check_notify(evt)
|
|
# Another time, after an explicit clear()
|
|
evt.set()
|
|
evt.clear()
|
|
self._check_notify(evt)
|
|
|
|
def test_timeout(self):
|
|
evt = self.eventtype()
|
|
results1 = []
|
|
results2 = []
|
|
N = 5
|
|
def f():
|
|
results1.append(evt.wait(0.0))
|
|
t1 = time.monotonic()
|
|
r = evt.wait(0.5)
|
|
t2 = time.monotonic()
|
|
results2.append((r, t2 - t1))
|
|
|
|
with Bunch(f, N):
|
|
pass
|
|
|
|
self.assertEqual(results1, [False] * N)
|
|
for r, dt in results2:
|
|
self.assertFalse(r)
|
|
self.assertTimeout(dt, 0.5)
|
|
|
|
# The event is set
|
|
results1 = []
|
|
results2 = []
|
|
evt.set()
|
|
with Bunch(f, N):
|
|
pass
|
|
|
|
self.assertEqual(results1, [True] * N)
|
|
for r, dt in results2:
|
|
self.assertTrue(r)
|
|
|
|
def test_set_and_clear(self):
|
|
# gh-57711: check that wait() returns true even when the event is
|
|
# cleared before the waiting thread is woken up.
|
|
event = self.eventtype()
|
|
results = []
|
|
def f():
|
|
results.append(event.wait(support.LONG_TIMEOUT))
|
|
|
|
N = 5
|
|
with Bunch(f, N):
|
|
# Threads blocked on event.wait()
|
|
wait_threads_blocked(N)
|
|
|
|
# Threads unblocked
|
|
event.set()
|
|
event.clear()
|
|
|
|
self.assertEqual(results, [True] * N)
|
|
|
|
@requires_fork
|
|
def test_at_fork_reinit(self):
|
|
# ensure that condition is still using a Lock after reset
|
|
evt = self.eventtype()
|
|
with evt._cond:
|
|
self.assertFalse(evt._cond.acquire(False))
|
|
evt._at_fork_reinit()
|
|
with evt._cond:
|
|
self.assertFalse(evt._cond.acquire(False))
|
|
|
|
def test_repr(self):
|
|
evt = self.eventtype()
|
|
self.assertRegex(repr(evt), r"<\w+\.Event at .*: unset>")
|
|
evt.set()
|
|
self.assertRegex(repr(evt), r"<\w+\.Event at .*: set>")
|
|
|
|
|
|
class ConditionTests(BaseTestCase):
|
|
"""
|
|
Tests for condition variables.
|
|
"""
|
|
|
|
def test_acquire(self):
|
|
cond = self.condtype()
|
|
# Be default we have an RLock: the condition can be acquired multiple
|
|
# times.
|
|
cond.acquire()
|
|
cond.acquire()
|
|
cond.release()
|
|
cond.release()
|
|
lock = threading.Lock()
|
|
cond = self.condtype(lock)
|
|
cond.acquire()
|
|
self.assertFalse(lock.acquire(False))
|
|
cond.release()
|
|
self.assertTrue(lock.acquire(False))
|
|
self.assertFalse(cond.acquire(False))
|
|
lock.release()
|
|
with cond:
|
|
self.assertFalse(lock.acquire(False))
|
|
|
|
def test_unacquired_wait(self):
|
|
cond = self.condtype()
|
|
self.assertRaises(RuntimeError, cond.wait)
|
|
|
|
def test_unacquired_notify(self):
|
|
cond = self.condtype()
|
|
self.assertRaises(RuntimeError, cond.notify)
|
|
|
|
def _check_notify(self, cond):
|
|
# Note that this test is sensitive to timing. If the worker threads
|
|
# don't execute in a timely fashion, the main thread may think they
|
|
# are further along then they are. The main thread therefore issues
|
|
# wait_threads_blocked() statements to try to make sure that it doesn't
|
|
# race ahead of the workers.
|
|
# Secondly, this test assumes that condition variables are not subject
|
|
# to spurious wakeups. The absence of spurious wakeups is an implementation
|
|
# detail of Condition Variables in current CPython, but in general, not
|
|
# a guaranteed property of condition variables as a programming
|
|
# construct. In particular, it is possible that this can no longer
|
|
# be conveniently guaranteed should their implementation ever change.
|
|
ready = []
|
|
results1 = []
|
|
results2 = []
|
|
phase_num = 0
|
|
def f():
|
|
cond.acquire()
|
|
ready.append(phase_num)
|
|
result = cond.wait()
|
|
|
|
cond.release()
|
|
results1.append((result, phase_num))
|
|
|
|
cond.acquire()
|
|
ready.append(phase_num)
|
|
|
|
result = cond.wait()
|
|
cond.release()
|
|
results2.append((result, phase_num))
|
|
|
|
N = 5
|
|
with Bunch(f, N):
|
|
# first wait, to ensure all workers settle into cond.wait() before
|
|
# we continue. See issues #8799 and #30727.
|
|
for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
|
|
if len(ready) >= N:
|
|
break
|
|
|
|
ready.clear()
|
|
self.assertEqual(results1, [])
|
|
|
|
# Notify 3 threads at first
|
|
count1 = 3
|
|
cond.acquire()
|
|
cond.notify(count1)
|
|
wait_threads_blocked(count1)
|
|
|
|
# Phase 1
|
|
phase_num = 1
|
|
cond.release()
|
|
for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
|
|
if len(results1) >= count1:
|
|
break
|
|
|
|
self.assertEqual(results1, [(True, 1)] * count1)
|
|
self.assertEqual(results2, [])
|
|
|
|
# Wait until awaken workers are blocked on cond.wait()
|
|
for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
|
|
if len(ready) >= count1 :
|
|
break
|
|
|
|
# Notify 5 threads: they might be in their first or second wait
|
|
cond.acquire()
|
|
cond.notify(5)
|
|
wait_threads_blocked(N)
|
|
|
|
# Phase 2
|
|
phase_num = 2
|
|
cond.release()
|
|
for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
|
|
if len(results1) + len(results2) >= (N + count1):
|
|
break
|
|
|
|
count2 = N - count1
|
|
self.assertEqual(results1, [(True, 1)] * count1 + [(True, 2)] * count2)
|
|
self.assertEqual(results2, [(True, 2)] * count1)
|
|
|
|
# Make sure all workers settle into cond.wait()
|
|
for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
|
|
if len(ready) >= N:
|
|
break
|
|
|
|
# Notify all threads: they are all in their second wait
|
|
cond.acquire()
|
|
cond.notify_all()
|
|
wait_threads_blocked(N)
|
|
|
|
# Phase 3
|
|
phase_num = 3
|
|
cond.release()
|
|
for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
|
|
if len(results2) >= N:
|
|
break
|
|
self.assertEqual(results1, [(True, 1)] * count1 + [(True, 2)] * count2)
|
|
self.assertEqual(results2, [(True, 2)] * count1 + [(True, 3)] * count2)
|
|
|
|
def test_notify(self):
|
|
cond = self.condtype()
|
|
self._check_notify(cond)
|
|
# A second time, to check internal state is still ok.
|
|
self._check_notify(cond)
|
|
|
|
def test_timeout(self):
|
|
cond = self.condtype()
|
|
timeout = 0.5
|
|
results = []
|
|
def f():
|
|
cond.acquire()
|
|
t1 = time.monotonic()
|
|
result = cond.wait(timeout)
|
|
t2 = time.monotonic()
|
|
cond.release()
|
|
results.append((t2 - t1, result))
|
|
|
|
N = 5
|
|
with Bunch(f, N):
|
|
pass
|
|
self.assertEqual(len(results), N)
|
|
|
|
for dt, result in results:
|
|
self.assertTimeout(dt, timeout)
|
|
# Note that conceptually (that"s the condition variable protocol)
|
|
# a wait() may succeed even if no one notifies us and before any
|
|
# timeout occurs. Spurious wakeups can occur.
|
|
# This makes it hard to verify the result value.
|
|
# In practice, this implementation has no spurious wakeups.
|
|
self.assertFalse(result)
|
|
|
|
def test_waitfor(self):
|
|
cond = self.condtype()
|
|
state = 0
|
|
def f():
|
|
with cond:
|
|
result = cond.wait_for(lambda: state == 4)
|
|
self.assertTrue(result)
|
|
self.assertEqual(state, 4)
|
|
|
|
with Bunch(f, 1):
|
|
for i in range(4):
|
|
time.sleep(0.010)
|
|
with cond:
|
|
state += 1
|
|
cond.notify()
|
|
|
|
def test_waitfor_timeout(self):
|
|
cond = self.condtype()
|
|
state = 0
|
|
success = []
|
|
def f():
|
|
with cond:
|
|
dt = time.monotonic()
|
|
result = cond.wait_for(lambda : state==4, timeout=0.1)
|
|
dt = time.monotonic() - dt
|
|
self.assertFalse(result)
|
|
self.assertTimeout(dt, 0.1)
|
|
success.append(None)
|
|
|
|
with Bunch(f, 1):
|
|
# Only increment 3 times, so state == 4 is never reached.
|
|
for i in range(3):
|
|
time.sleep(0.010)
|
|
with cond:
|
|
state += 1
|
|
cond.notify()
|
|
|
|
self.assertEqual(len(success), 1)
|
|
|
|
|
|
class BaseSemaphoreTests(BaseTestCase):
|
|
"""
|
|
Common tests for {bounded, unbounded} semaphore objects.
|
|
"""
|
|
|
|
def test_constructor(self):
|
|
self.assertRaises(ValueError, self.semtype, value = -1)
|
|
self.assertRaises(ValueError, self.semtype, value = -sys.maxsize)
|
|
|
|
def test_acquire(self):
|
|
sem = self.semtype(1)
|
|
sem.acquire()
|
|
sem.release()
|
|
sem = self.semtype(2)
|
|
sem.acquire()
|
|
sem.acquire()
|
|
sem.release()
|
|
sem.release()
|
|
|
|
def test_acquire_destroy(self):
|
|
sem = self.semtype()
|
|
sem.acquire()
|
|
del sem
|
|
|
|
def test_acquire_contended(self):
|
|
sem_value = 7
|
|
sem = self.semtype(sem_value)
|
|
sem.acquire()
|
|
|
|
sem_results = []
|
|
results1 = []
|
|
results2 = []
|
|
phase_num = 0
|
|
|
|
def func():
|
|
sem_results.append(sem.acquire())
|
|
results1.append(phase_num)
|
|
|
|
sem_results.append(sem.acquire())
|
|
results2.append(phase_num)
|
|
|
|
def wait_count(count):
|
|
for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
|
|
if len(results1) + len(results2) >= count:
|
|
break
|
|
|
|
N = 10
|
|
with Bunch(func, N):
|
|
# Phase 0
|
|
count1 = sem_value - 1
|
|
wait_count(count1)
|
|
self.assertEqual(results1 + results2, [0] * count1)
|
|
|
|
# Phase 1
|
|
phase_num = 1
|
|
for i in range(sem_value):
|
|
sem.release()
|
|
count2 = sem_value
|
|
wait_count(count1 + count2)
|
|
self.assertEqual(sorted(results1 + results2),
|
|
[0] * count1 + [1] * count2)
|
|
|
|
# Phase 2
|
|
phase_num = 2
|
|
count3 = (sem_value - 1)
|
|
for i in range(count3):
|
|
sem.release()
|
|
wait_count(count1 + count2 + count3)
|
|
self.assertEqual(sorted(results1 + results2),
|
|
[0] * count1 + [1] * count2 + [2] * count3)
|
|
# The semaphore is still locked
|
|
self.assertFalse(sem.acquire(False))
|
|
|
|
# Final release, to let the last thread finish
|
|
count4 = 1
|
|
sem.release()
|
|
|
|
self.assertEqual(sem_results,
|
|
[True] * (count1 + count2 + count3 + count4))
|
|
|
|
def test_multirelease(self):
|
|
sem_value = 7
|
|
sem = self.semtype(sem_value)
|
|
sem.acquire()
|
|
|
|
results1 = []
|
|
results2 = []
|
|
phase_num = 0
|
|
def func():
|
|
sem.acquire()
|
|
results1.append(phase_num)
|
|
|
|
sem.acquire()
|
|
results2.append(phase_num)
|
|
|
|
def wait_count(count):
|
|
for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
|
|
if len(results1) + len(results2) >= count:
|
|
break
|
|
|
|
with Bunch(func, 10):
|
|
# Phase 0
|
|
count1 = sem_value - 1
|
|
wait_count(count1)
|
|
self.assertEqual(results1 + results2, [0] * count1)
|
|
|
|
# Phase 1
|
|
phase_num = 1
|
|
count2 = sem_value
|
|
sem.release(count2)
|
|
wait_count(count1 + count2)
|
|
self.assertEqual(sorted(results1 + results2),
|
|
[0] * count1 + [1] * count2)
|
|
|
|
# Phase 2
|
|
phase_num = 2
|
|
count3 = sem_value - 1
|
|
sem.release(count3)
|
|
wait_count(count1 + count2 + count3)
|
|
self.assertEqual(sorted(results1 + results2),
|
|
[0] * count1 + [1] * count2 + [2] * count3)
|
|
# The semaphore is still locked
|
|
self.assertFalse(sem.acquire(False))
|
|
|
|
# Final release, to let the last thread finish
|
|
sem.release()
|
|
|
|
def test_try_acquire(self):
|
|
sem = self.semtype(2)
|
|
self.assertTrue(sem.acquire(False))
|
|
self.assertTrue(sem.acquire(False))
|
|
self.assertFalse(sem.acquire(False))
|
|
sem.release()
|
|
self.assertTrue(sem.acquire(False))
|
|
|
|
def test_try_acquire_contended(self):
|
|
sem = self.semtype(4)
|
|
sem.acquire()
|
|
results = []
|
|
def f():
|
|
results.append(sem.acquire(False))
|
|
results.append(sem.acquire(False))
|
|
with Bunch(f, 5):
|
|
pass
|
|
# There can be a thread switch between acquiring the semaphore and
|
|
# appending the result, therefore results will not necessarily be
|
|
# ordered.
|
|
self.assertEqual(sorted(results), [False] * 7 + [True] * 3 )
|
|
|
|
def test_acquire_timeout(self):
|
|
sem = self.semtype(2)
|
|
self.assertRaises(ValueError, sem.acquire, False, timeout=1.0)
|
|
self.assertTrue(sem.acquire(timeout=0.005))
|
|
self.assertTrue(sem.acquire(timeout=0.005))
|
|
self.assertFalse(sem.acquire(timeout=0.005))
|
|
sem.release()
|
|
self.assertTrue(sem.acquire(timeout=0.005))
|
|
t = time.monotonic()
|
|
self.assertFalse(sem.acquire(timeout=0.5))
|
|
dt = time.monotonic() - t
|
|
self.assertTimeout(dt, 0.5)
|
|
|
|
def test_default_value(self):
|
|
# The default initial value is 1.
|
|
sem = self.semtype()
|
|
sem.acquire()
|
|
def f():
|
|
sem.acquire()
|
|
sem.release()
|
|
|
|
with Bunch(f, 1) as bunch:
|
|
# Thread blocked on sem.acquire()
|
|
wait_threads_blocked(1)
|
|
self.assertFalse(bunch.finished)
|
|
|
|
# Thread unblocked
|
|
sem.release()
|
|
|
|
def test_with(self):
|
|
sem = self.semtype(2)
|
|
def _with(err=None):
|
|
with sem:
|
|
self.assertTrue(sem.acquire(False))
|
|
sem.release()
|
|
with sem:
|
|
self.assertFalse(sem.acquire(False))
|
|
if err:
|
|
raise err
|
|
_with()
|
|
self.assertTrue(sem.acquire(False))
|
|
sem.release()
|
|
self.assertRaises(TypeError, _with, TypeError)
|
|
self.assertTrue(sem.acquire(False))
|
|
sem.release()
|
|
|
|
class SemaphoreTests(BaseSemaphoreTests):
|
|
"""
|
|
Tests for unbounded semaphores.
|
|
"""
|
|
|
|
def test_release_unacquired(self):
|
|
# Unbounded releases are allowed and increment the semaphore's value
|
|
sem = self.semtype(1)
|
|
sem.release()
|
|
sem.acquire()
|
|
sem.acquire()
|
|
sem.release()
|
|
|
|
def test_repr(self):
|
|
sem = self.semtype(3)
|
|
self.assertRegex(repr(sem), r"<\w+\.Semaphore at .*: value=3>")
|
|
sem.acquire()
|
|
self.assertRegex(repr(sem), r"<\w+\.Semaphore at .*: value=2>")
|
|
sem.release()
|
|
sem.release()
|
|
self.assertRegex(repr(sem), r"<\w+\.Semaphore at .*: value=4>")
|
|
|
|
|
|
class BoundedSemaphoreTests(BaseSemaphoreTests):
|
|
"""
|
|
Tests for bounded semaphores.
|
|
"""
|
|
|
|
def test_release_unacquired(self):
|
|
# Cannot go past the initial value
|
|
sem = self.semtype()
|
|
self.assertRaises(ValueError, sem.release)
|
|
sem.acquire()
|
|
sem.release()
|
|
self.assertRaises(ValueError, sem.release)
|
|
|
|
def test_repr(self):
|
|
sem = self.semtype(3)
|
|
self.assertRegex(repr(sem), r"<\w+\.BoundedSemaphore at .*: value=3/3>")
|
|
sem.acquire()
|
|
self.assertRegex(repr(sem), r"<\w+\.BoundedSemaphore at .*: value=2/3>")
|
|
|
|
|
|
class BarrierTests(BaseTestCase):
|
|
"""
|
|
Tests for Barrier objects.
|
|
"""
|
|
N = 5
|
|
defaultTimeout = 2.0
|
|
|
|
def setUp(self):
|
|
self.barrier = self.barriertype(self.N, timeout=self.defaultTimeout)
|
|
|
|
def tearDown(self):
|
|
self.barrier.abort()
|
|
|
|
def run_threads(self, f):
|
|
with Bunch(f, self.N):
|
|
pass
|
|
|
|
def multipass(self, results, n):
|
|
m = self.barrier.parties
|
|
self.assertEqual(m, self.N)
|
|
for i in range(n):
|
|
results[0].append(True)
|
|
self.assertEqual(len(results[1]), i * m)
|
|
self.barrier.wait()
|
|
results[1].append(True)
|
|
self.assertEqual(len(results[0]), (i + 1) * m)
|
|
self.barrier.wait()
|
|
self.assertEqual(self.barrier.n_waiting, 0)
|
|
self.assertFalse(self.barrier.broken)
|
|
|
|
def test_constructor(self):
|
|
self.assertRaises(ValueError, self.barriertype, parties=0)
|
|
self.assertRaises(ValueError, self.barriertype, parties=-1)
|
|
|
|
def test_barrier(self, passes=1):
|
|
"""
|
|
Test that a barrier is passed in lockstep
|
|
"""
|
|
results = [[],[]]
|
|
def f():
|
|
self.multipass(results, passes)
|
|
self.run_threads(f)
|
|
|
|
def test_barrier_10(self):
|
|
"""
|
|
Test that a barrier works for 10 consecutive runs
|
|
"""
|
|
return self.test_barrier(10)
|
|
|
|
def test_wait_return(self):
|
|
"""
|
|
test the return value from barrier.wait
|
|
"""
|
|
results = []
|
|
def f():
|
|
r = self.barrier.wait()
|
|
results.append(r)
|
|
|
|
self.run_threads(f)
|
|
self.assertEqual(sum(results), sum(range(self.N)))
|
|
|
|
def test_action(self):
|
|
"""
|
|
Test the 'action' callback
|
|
"""
|
|
results = []
|
|
def action():
|
|
results.append(True)
|
|
barrier = self.barriertype(self.N, action)
|
|
def f():
|
|
barrier.wait()
|
|
self.assertEqual(len(results), 1)
|
|
|
|
self.run_threads(f)
|
|
|
|
def test_abort(self):
|
|
"""
|
|
Test that an abort will put the barrier in a broken state
|
|
"""
|
|
results1 = []
|
|
results2 = []
|
|
def f():
|
|
try:
|
|
i = self.barrier.wait()
|
|
if i == self.N//2:
|
|
raise RuntimeError
|
|
self.barrier.wait()
|
|
results1.append(True)
|
|
except threading.BrokenBarrierError:
|
|
results2.append(True)
|
|
except RuntimeError:
|
|
self.barrier.abort()
|
|
pass
|
|
|
|
self.run_threads(f)
|
|
self.assertEqual(len(results1), 0)
|
|
self.assertEqual(len(results2), self.N-1)
|
|
self.assertTrue(self.barrier.broken)
|
|
|
|
def test_reset(self):
|
|
"""
|
|
Test that a 'reset' on a barrier frees the waiting threads
|
|
"""
|
|
results1 = []
|
|
results2 = []
|
|
results3 = []
|
|
def f():
|
|
i = self.barrier.wait()
|
|
if i == self.N//2:
|
|
# Wait until the other threads are all in the barrier.
|
|
for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
|
|
if self.barrier.n_waiting >= (self.N - 1):
|
|
break
|
|
self.barrier.reset()
|
|
else:
|
|
try:
|
|
self.barrier.wait()
|
|
results1.append(True)
|
|
except threading.BrokenBarrierError:
|
|
results2.append(True)
|
|
# Now, pass the barrier again
|
|
self.barrier.wait()
|
|
results3.append(True)
|
|
|
|
self.run_threads(f)
|
|
self.assertEqual(len(results1), 0)
|
|
self.assertEqual(len(results2), self.N-1)
|
|
self.assertEqual(len(results3), self.N)
|
|
|
|
|
|
def test_abort_and_reset(self):
|
|
"""
|
|
Test that a barrier can be reset after being broken.
|
|
"""
|
|
results1 = []
|
|
results2 = []
|
|
results3 = []
|
|
barrier2 = self.barriertype(self.N)
|
|
def f():
|
|
try:
|
|
i = self.barrier.wait()
|
|
if i == self.N//2:
|
|
raise RuntimeError
|
|
self.barrier.wait()
|
|
results1.append(True)
|
|
except threading.BrokenBarrierError:
|
|
results2.append(True)
|
|
except RuntimeError:
|
|
self.barrier.abort()
|
|
pass
|
|
# Synchronize and reset the barrier. Must synchronize first so
|
|
# that everyone has left it when we reset, and after so that no
|
|
# one enters it before the reset.
|
|
if barrier2.wait() == self.N//2:
|
|
self.barrier.reset()
|
|
barrier2.wait()
|
|
self.barrier.wait()
|
|
results3.append(True)
|
|
|
|
self.run_threads(f)
|
|
self.assertEqual(len(results1), 0)
|
|
self.assertEqual(len(results2), self.N-1)
|
|
self.assertEqual(len(results3), self.N)
|
|
|
|
def test_timeout(self):
|
|
"""
|
|
Test wait(timeout)
|
|
"""
|
|
def f():
|
|
i = self.barrier.wait()
|
|
if i == self.N // 2:
|
|
# One thread is late!
|
|
time.sleep(self.defaultTimeout / 2)
|
|
# Default timeout is 2.0, so this is shorter.
|
|
self.assertRaises(threading.BrokenBarrierError,
|
|
self.barrier.wait, self.defaultTimeout / 4)
|
|
self.run_threads(f)
|
|
|
|
def test_default_timeout(self):
|
|
"""
|
|
Test the barrier's default timeout
|
|
"""
|
|
timeout = 0.100
|
|
barrier = self.barriertype(2, timeout=timeout)
|
|
def f():
|
|
self.assertRaises(threading.BrokenBarrierError,
|
|
barrier.wait)
|
|
|
|
start_time = time.monotonic()
|
|
with Bunch(f, 1):
|
|
pass
|
|
dt = time.monotonic() - start_time
|
|
self.assertGreaterEqual(dt, timeout)
|
|
|
|
def test_single_thread(self):
|
|
b = self.barriertype(1)
|
|
b.wait()
|
|
b.wait()
|
|
|
|
def test_repr(self):
|
|
barrier = self.barriertype(3)
|
|
timeout = support.LONG_TIMEOUT
|
|
self.assertRegex(repr(barrier), r"<\w+\.Barrier at .*: waiters=0/3>")
|
|
def f():
|
|
barrier.wait(timeout)
|
|
|
|
N = 2
|
|
with Bunch(f, N):
|
|
# Threads blocked on barrier.wait()
|
|
for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
|
|
if barrier.n_waiting >= N:
|
|
break
|
|
self.assertRegex(repr(barrier),
|
|
r"<\w+\.Barrier at .*: waiters=2/3>")
|
|
|
|
# Threads unblocked
|
|
barrier.wait(timeout)
|
|
|
|
self.assertRegex(repr(barrier),
|
|
r"<\w+\.Barrier at .*: waiters=0/3>")
|
|
|
|
# Abort the barrier
|
|
barrier.abort()
|
|
self.assertRegex(repr(barrier),
|
|
r"<\w+\.Barrier at .*: broken>")
|