blob: 7ae693ca40b7e63ea9900420bcf42a71af958e73 [file]
# Test cases for librt.threading (compile and run)
[case testConcurrentNativeAttributeGetSet]
from typing import Any
import threading
import sys
class Item:
def __init__(self, value: int) -> None:
self.value = value
class Box:
def __init__(self) -> None:
self.item = Item(0)
def native_writer(box: Box, count: int) -> None:
for i in range(count):
box.item = Item(i)
def native_reader(box: Box, count: int) -> None:
for _ in range(count):
item = box.item
assert item.value >= 0
def dynamic_writer(box: Any, count: int) -> None:
for i in range(count):
box.item = Item(i)
def dynamic_reader(box: Any, count: int) -> None:
for _ in range(count):
item = box.item
assert item.value >= 0
def test_attribute_set_decrefs_old_value_immediately() -> None:
box = Box()
dynamic_sys: Any = sys
old = box.item
before = dynamic_sys.getrefcount(old)
box.item = Item(1)
assert dynamic_sys.getrefcount(old) == before - 1
dynamic: Any = box
old = box.item
before = dynamic_sys.getrefcount(old)
dynamic.item = Item(2)
assert dynamic_sys.getrefcount(old) == before - 1
def test_concurrent_native_attribute_get_set() -> None:
# Native access exercises the direct generated calls. Access through Any uses
# the generated getset descriptor. On a free-threaded build all four workers
# race, repeatedly dropping the field's last reference to the previous Item.
box = Box()
count = 10_000
threads = [
threading.Thread(target=native_writer, args=(box, count)),
threading.Thread(target=native_reader, args=(box, count)),
threading.Thread(target=dynamic_writer, args=(box, count)),
threading.Thread(target=dynamic_reader, args=(box, count)),
]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
assert box.item.value >= 0
[case testConcurrentNativeAttributeDelete]
from typing import Any
import threading
class Item:
def __init__(self, value: int) -> None:
self.value = value
class DelBox:
__deletable__ = ["item"]
def __init__(self) -> None:
self.item = Item(0)
def native_setter(box: DelBox, count: int) -> None:
for i in range(count):
box.item = Item(i)
def native_deleter(box: DelBox, count: int) -> None:
for _ in range(count):
try:
del box.item
except AttributeError:
pass
def native_reader(box: DelBox, count: int) -> None:
for _ in range(count):
try:
item = box.item
except AttributeError:
continue
assert item.value >= 0
def dynamic_deleter(box: Any, count: int) -> None:
for _ in range(count):
try:
del box.item
except AttributeError:
pass
def dynamic_reader(box: Any, count: int) -> None:
for _ in range(count):
try:
item = box.item
except AttributeError:
continue
assert item.value >= 0
def test_concurrent_native_attribute_delete() -> None:
# A deleted attribute is the only way a read that already observed a live value
# can still fail: the optimistic incref can miss and the locked reload then sees
# NULL, so the read raises AttributeError (see CPy_GetAttrRefSlow). Readers here
# must therefore tolerate AttributeError, but never see a freed or torn value.
box = DelBox()
count = 10_000
threads = [
threading.Thread(target=native_setter, args=(box, count)),
threading.Thread(target=native_deleter, args=(box, count)),
threading.Thread(target=native_reader, args=(box, count)),
threading.Thread(target=dynamic_deleter, args=(box, count)),
threading.Thread(target=dynamic_reader, args=(box, count)),
]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
[case testConcurrentNativeIntAttribute]
from typing import Any
import threading
BIG = 2**80
COUNT = 10_000
class Box:
__deletable__ = ["n"]
def __init__(self) -> None:
self.n = 0
class Lazy:
def set_n(self, n: int) -> None:
self.n = n
def check(v: int) -> None:
assert 0 <= v < COUNT or BIG <= v < BIG + COUNT, v
def long_writer(box: Box, count: int) -> None:
for i in range(count):
box.n = BIG + i
def short_writer(box: Box, count: int) -> None:
for i in range(count):
box.n = i
def native_reader(box: Box, count: int) -> None:
for _ in range(count):
try:
v = box.n
except AttributeError:
continue
check(v)
def native_deleter(box: Box, count: int) -> None:
for _ in range(count):
try:
del box.n
except AttributeError:
pass
def dynamic_writer(box: Any, count: int) -> None:
for i in range(count):
box.n = BIG + i if i % 2 else i
def dynamic_reader(box: Any, count: int) -> None:
for _ in range(count):
try:
v = box.n
except AttributeError:
continue
check(v)
def run(*targets: Any) -> None:
box = Box()
threads = [threading.Thread(target=t, args=(box, COUNT)) for t in targets]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
try:
check(box.n)
except AttributeError:
pass
def test_concurrent_int_attribute_read_write() -> None:
# Long values own a reference to a PyLong, so readers race with writers that
# release the old value (see CPyTagged_GetAttr).
run(long_writer, native_reader, dynamic_reader)
run(long_writer, long_writer, native_reader, dynamic_writer)
run(long_writer, short_writer, native_deleter, native_reader, dynamic_reader)
def lazy_writer(boxes: list[Lazy], i: int) -> None:
for j, box in enumerate(boxes):
box.set_n(BIG + j if (i + j) % 2 else j)
def test_concurrent_first_assignment() -> None:
boxes = [Lazy() for _ in range(COUNT)]
threads = [threading.Thread(target=lazy_writer, args=(boxes, i)) for i in range(4)]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
for box in boxes:
check(box.n)
[case testLockBasics_librt]
from typing import Any
from testutil import assertRaises
from librt.threading import Lock
class BadBool:
def __bool__(self) -> bool:
raise RuntimeError("bad bool")
class MutableLockHolder:
def __init__(self) -> None:
self.lock = Lock()
def test_lock_basic() -> None:
lock = Lock()
assert not lock.locked()
assert lock.acquire()
assert lock.locked()
lock.release()
assert not lock.locked()
def test_lock_context_manager() -> None:
lock = Lock()
with lock as acquired:
assert acquired is True
assert lock.locked()
assert not lock.locked()
def test_mutable_lock_attribute() -> None:
mutable_holder = MutableLockHolder()
assert not mutable_holder.lock.locked()
with mutable_holder.lock:
assert mutable_holder.lock.locked()
assert not mutable_holder.lock.locked()
dynamic_holder: Any = mutable_holder
replacement = Lock()
dynamic_holder.lock = replacement
assert mutable_holder.lock is replacement
with mutable_holder.lock:
assert replacement.locked()
with assertRaises(TypeError):
dynamic_holder.lock = object()
def test_lock_non_blocking() -> None:
lock = Lock()
assert lock.acquire()
assert not lock.acquire(False)
lock.release()
assert lock.acquire(False)
lock.release()
def test_contention() -> None:
import threading
lock = Lock()
counter = [0]
n_threads = 4
n_increments = 10000
def worker() -> None:
for _ in range(n_increments):
lock.acquire()
counter[0] += 1
lock.release()
threads = [threading.Thread(target=worker) for _ in range(n_threads)]
for t in threads:
t.start()
for t in threads:
t.join()
assert counter[0] == n_threads * n_increments
def test_cross_thread_release() -> None:
# threading.Lock is unowned: a lock acquired on one thread may be
# released from another, after which another thread can acquire it.
import threading
lock = Lock()
assert lock.acquire()
started = threading.Event()
released = threading.Event()
def releaser() -> None:
started.set()
# Hand the lock off from a different thread than the acquirer.
lock.release()
released.set()
t = threading.Thread(target=releaser)
t.start()
started.wait()
# This may block until releaser releases the lock on the other thread.
assert lock.acquire()
t.join()
assert released.is_set()
lock.release()
assert not lock.locked()
def test_context_manager_exception() -> None:
lock = Lock()
try:
with lock:
assert lock.locked()
raise ValueError("test")
except ValueError:
pass
assert not lock.locked()
def test_acquire_blocking_true() -> None:
lock = Lock()
assert lock.acquire(True)
assert lock.locked()
lock.release()
def test_lock_constructor_errors() -> None:
lock_type: Any = Lock
make_type: Any = type
with assertRaises(TypeError):
lock_type(1)
with assertRaises(TypeError):
lock_type(foo=1)
with assertRaises(TypeError):
make_type("LockSubclass", (lock_type,), {})
def test_lock_acquire_argument_errors() -> None:
lock: Any = Lock()
with assertRaises(TypeError):
lock.acquire(True, False)
with assertRaises(TypeError):
lock.acquire(foo=True)
def test_lock_acquire_blocking_truthiness() -> None:
lock: Any = Lock()
assert lock.acquire(blocking=True)
assert lock.locked()
assert not lock.acquire(blocking=False)
lock.release()
assert lock.acquire(None)
assert lock.locked()
assert not lock.acquire(None)
lock.release()
assert lock.acquire(1)
lock.release()
assert lock.acquire(0)
lock.release()
def test_lock_acquire_blocking_bool_error() -> None:
lock: Any = Lock()
with assertRaises(RuntimeError, "bad bool"):
lock.acquire(BadBool())
with assertRaises(RuntimeError, "bad bool"):
lock.acquire(blocking=BadBool())
def test_lock_exit_manual_call() -> None:
lock: Any = Lock()
lock.acquire()
assert lock.__exit__(None, None, None) is None
assert not lock.locked()
lock.acquire()
assert lock.__exit__() is None
assert not lock.locked()
def test_release_unlocked() -> None:
lock = Lock()
with assertRaises(RuntimeError):
lock.release()
# Also after acquire + release
lock.acquire()
lock.release()
with assertRaises(RuntimeError):
lock.release()
[case testConcurrentNativeTupleAttributeGetSetDelete]
from threading import Barrier, Thread
from typing import Any
from mypy_extensions import trait
class Item:
def __init__(self, value: int) -> None:
self.value = value
@trait
class RefView:
refs: tuple[Item, tuple[Item, int]]
class Box(RefView):
__deletable__ = ["refs", "numbers"]
refs: tuple[Item, tuple[Item, int]]
numbers: tuple[float, float]
def __init__(self) -> None:
self.refs = (Item(0), (Item(0), 0))
self.numbers = (0.0, 0.0)
def native_writer(box: Box, count: int) -> None:
for i in range(count):
box.refs = (Item(i), (Item(i), i))
box.numbers = (float(i), float(i))
def dynamic_writer(box: Any, count: int) -> None:
for i in range(count):
box.refs = (Item(i), (Item(i), i))
box.numbers = (float(i), float(i))
def native_reader(box: Box, count: int) -> None:
for _ in range(count):
try:
refs = box.refs
except AttributeError:
pass
else:
assert refs[0].value == refs[1][0].value == refs[1][1]
try:
numbers = box.numbers
except AttributeError:
pass
else:
assert numbers[0] == numbers[1]
def trait_reader(box: RefView, count: int) -> None:
for _ in range(count):
try:
refs = box.refs
except AttributeError:
pass
else:
assert refs[0].value == refs[1][0].value == refs[1][1]
def dynamic_reader(box: Any, count: int) -> None:
for _ in range(count):
try:
refs = box.refs
except AttributeError:
pass
else:
assert refs[0].value == refs[1][0].value == refs[1][1]
try:
numbers = box.numbers
except AttributeError:
pass
else:
assert numbers[0] == numbers[1]
def native_deleter(box: Box, count: int) -> None:
for _ in range(count):
try:
del box.refs
except AttributeError:
pass
try:
del box.numbers
except AttributeError:
pass
def dynamic_deleter(box: Any, count: int) -> None:
for _ in range(count):
try:
del box.refs
except AttributeError:
pass
try:
del box.numbers
except AttributeError:
pass
def test_concurrent_tuple_attribute_get_set_delete() -> None:
# Native and descriptor access must share the owner lock. New Items on each
# store also exercise acquiring references before the old tuple is reclaimed.
# Collect worker exceptions so assertions in a thread fail the test runner.
box = Box()
# This valid tuple overlaps the undefined sentinel and needs the bitmap.
box.numbers = (-113.0, -113.0)
assert box.numbers == (-113.0, -113.0)
dynamic: Any = box
assert dynamic.numbers == (-113.0, -113.0)
del dynamic.numbers
dynamic.numbers = (-113.0, -113.0)
assert box.numbers == (-113.0, -113.0)
workers = [native_writer, dynamic_writer, native_reader, dynamic_reader,
native_deleter, dynamic_deleter, trait_reader]
barrier = Barrier(len(workers))
errors: list[BaseException] = []
def run(worker: Any) -> None:
try:
barrier.wait()
worker(box, 10_000)
except BaseException as error:
errors.append(error)
threads = [Thread(target=run, args=(worker,)) for worker in workers]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
assert not errors, errors
[case testConcurrentTupleScalarAttributeBitmap]
from threading import Barrier, Thread
from typing import Any
from testutil import assertRaises
class Box:
__deletable__ = ["pair", "flag"]
pair: tuple[float, float]
flag: float
def __init__(self) -> None:
self.pair = (-113.0, -113.0)
self.flag = -113.0
def pair_worker(box: Box, count: int) -> None:
dynamic: Any = box
for _ in range(count):
del dynamic.pair
# Only this worker touches pair. Scalar bitmap updates must neither
# restore a deleted pair's bit nor erase a successfully assigned bit.
with assertRaises(AttributeError):
pair = box.pair
box.pair = (-113.0, -113.0)
assert box.pair == (-113.0, -113.0)
del box.pair
dynamic.pair = (-113.0, -113.0)
assert dynamic.pair == (-113.0, -113.0)
def scalar_worker(box: Box, count: int) -> None:
dynamic: Any = box
for _ in range(count):
del box.flag
box.flag = -113.0
del dynamic.flag
dynamic.flag = -113.0
def test_concurrent_tuple_scalar_attribute_bitmap() -> None:
box = Box()
barrier = Barrier(2)
errors: list[BaseException] = []
def run(worker: Any) -> None:
try:
barrier.wait()
worker(box, 100_000)
except BaseException as error:
errors.append(error)
threads = [Thread(target=run, args=(worker,)) for worker in [pair_worker, scalar_worker]]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
assert not errors, errors
[case testConcurrentTupleAttributeExplicitReinitialize]
from typing import Any
class Box:
def __init__(self, value: float) -> None:
# A wide, nonrefcounted tuple makes tearing easy to observe without
# depending on the ownership semantics of repeated refcounted __init__.
self.values = (value, value, value, value, value, value, value, value, value, value, \
value, value, value, value, value, value, value, value, value, value, value, value, \
value, value, value, value, value, value, value, value, value, value)
def writer(box: Box, count: int) -> None:
for i in range(count):
Box.__init__(box, float(i))
def reader(box: Box, count: int) -> None:
for _ in range(count):
values = box.values
assert all(value == values[0] for value in values), values
def dynamic_reader(box: Any, count: int) -> None:
for _ in range(count):
values = box.values
assert all(value == values[0] for value in values), values
[file driver.py]
from threading import Barrier, Thread
from native import Box, writer, reader, dynamic_reader
box = Box(0.0)
barrier = Barrier(3)
errors = []
def run(worker):
try:
barrier.wait()
worker(box, 100_000)
except BaseException as error:
errors.append(error)
threads = [Thread(target=run, args=(worker,)) for worker in [writer, reader, dynamic_reader]]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
assert not errors, errors