| # 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 |