From cae934aab24e3d37bb0dbc87f7a06342155c07ea Mon Sep 17 00:00:00 2001 From: Daniel Pope Date: Fri, 30 Apr 2021 15:01:25 +0100 Subject: [PATCH 1/2] Add EventStream class based on 'pulse' prototype --- docs/source/reference-core.rst | 11 +++ trio/__init__.py | 1 + trio/_sync.py | 94 +++++++++++++++++++++++++ trio/tests/test_sync.py | 125 ++++++++++++++++++++++++++++++++- 4 files changed, 230 insertions(+), 1 deletion(-) diff --git a/docs/source/reference-core.rst b/docs/source/reference-core.rst index 514b5072c3..0aab11dd46 100644 --- a/docs/source/reference-core.rst +++ b/docs/source/reference-core.rst @@ -1433,6 +1433,17 @@ deadlock. Using an unbounded channel avoids this, because it means that :meth:`~trio.abc.SendChannel.send` never blocks. +Higher-level synchronization primitives +--------------------------------------- + +While events and channels are useful in a very wide range of +applications, some less common problems are best tackled with some +higher-level concurrency primitives that focus on a specific problem. + +.. autoclass:: EventStream + :members: + + Lower-level synchronization primitives ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/trio/__init__.py b/trio/__init__.py index d66ffceea9..051a8ccf0d 100644 --- a/trio/__init__.py +++ b/trio/__init__.py @@ -52,6 +52,7 @@ Lock, StrictFIFOLock, Condition, + EventStream, ) from ._highlevel_generic import aclose_forcefully, StapledStream diff --git a/trio/_sync.py b/trio/_sync.py index bf5f5d5e0b..67438375a7 100644 --- a/trio/_sync.py +++ b/trio/_sync.py @@ -784,3 +784,97 @@ def statistics(self): return _ConditionStatistics( tasks_waiting=len(self._lot), lock_statistics=self._lock.statistics() ) + + +@attr.s +class EventStream: + """A concurrency primitive for a sequence of events. + + Multiple tasks can subscribe for events on the stream using an ``async + for`` loop:: + + events = EventStream() + + ... + + async for _ in events.subscribe(): + ... + + On each loop iteration, a subcriber will be blocked if there are no new + events on the stream. An event can be "fired" on a stream, which causes + subscribers to awake:: + + events.fire() + + By default, events are coalesced, but will never be lost. That is, if any + events are fired while a subscriber is processing its last wakeup, that + subscriber will not block on the next loop iteration. + + Note that EventStream does not hold any data items associated with events. + However subscribe() does yield integer indices that indicate a position + in the event stream, which could be used. fire() returns the index of the + event added to the stream. + + """ + _write_cursor = attr.ib(default=-1) + _wakeup = attr.ib(default=None) + _closed = attr.ib(default=False) + + def close(self): + """Close the stream. + + This causes all subscribers to terminate once they have consumed + all events. + """ + self._closed = True + self._wake() + + def _wake(self): + """Wake blocked tasks.""" + if self._wakeup is not None: + self._wakeup.set() + self._wakeup = None + + def fire(self): + """Fire an event on the stream.""" + if self._closed: + raise RuntimeError( + "Cannot fire an event on a closed event stream." + ) + self._write_cursor += 1 + self._wake() + return self._write_cursor + + async def _wait(self): + """Wait for the next wakeup. + + We lazily create the Event object to block on if one does not yet + exist; this avoids creating event objects that are never awaited. + + """ + if self._wakeup is None: + self._wakeup = trio.Event() + await self._wakeup.wait() + + async def subscribe(self, from_start=False, coalesce=True): + """Subscribe for events on the stream. + + If from_start is True, then subscribe for events from the start of + the stream. + + If coalesce is True, then each iteration 'consumes' all previous + events; otherwise, each iteration consumes just one event. + """ + read_cursor = -1 if from_start else self._write_cursor + while True: + if self._write_cursor > read_cursor: + if coalesce: + read_cursor = self._write_cursor + else: + read_cursor += 1 + yield read_cursor + else: + if self._closed: + return + else: + await self._wait() diff --git a/trio/tests/test_sync.py b/trio/tests/test_sync.py index 229dea301c..e641af0f99 100644 --- a/trio/tests/test_sync.py +++ b/trio/tests/test_sync.py @@ -6,7 +6,7 @@ from .. import _core from .. import _timeouts -from .._timeouts import sleep_forever, move_on_after +from .._timeouts import sleep_forever, move_on_after, sleep from .._sync import * @@ -568,3 +568,126 @@ async def lock_taker(): await wait_all_tasks_blocked() assert record == ["started"] lock_like.release() + + +async def test_EventStream_basics(): + p = EventStream() + + wakeups = 0 + + async def background(): + nonlocal wakeups + async for i in p.subscribe(): + wakeups += 1 + + async with _core.open_nursery() as nursery: + nursery.start_soon(background) + + # The event stream starts in a blocked state (no event fired) + await wait_all_tasks_blocked() + assert wakeups == 0 + + # Calling fire() lets it run: + p.fire() + await wait_all_tasks_blocked() + assert wakeups == 1 + + # Multiple events are coalesced into one: + p.fire() + p.fire() + p.fire() + await wait_all_tasks_blocked() + assert wakeups == 2 + + p.close() + + +async def test_EventStream_while_task_is_elsewhere(autojump_clock): + p = EventStream() + + wakeups = 0 + + async def background(): + nonlocal wakeups + async for _ in p.subscribe(): + wakeups += 1 + await sleep(10) + + async with _core.open_nursery() as nursery: + nursery.start_soon(background) + + # Double-check that it's all idle and settled waiting for a event + await sleep(5) + assert wakeups == 0 + await sleep(10) + assert wakeups == 0 + + # Wake it up + p.fire() + + # Now it's sitting in sleep()... + await sleep(5) + assert wakeups == 1 + + # ...when another event arrives. + p.fire() + + # It still wakes up though + await sleep(10) + assert wakeups == 2 + + p.close() + + +async def test_EventStream_subscribe_independence(autojump_clock): + p = EventStream() + + wakeups = [0, 0] + + async def background(i, sleep_time): + nonlocal wakeups + async for _ in p.subscribe(): + wakeups[i] += 1 + await sleep(sleep_time) + + try: + async with _core.open_nursery() as nursery: + nursery.start_soon(background, 0, 10) + nursery.start_soon(background, 1, 100) + + # Initially blocked, no event fired + await sleep(200) + assert wakeups == [0, 0] + + # Firing an event wakes both tasks + p.fire() + await sleep(5) + assert wakeups == [1, 1] + + # Now + # task 0 is sleeping for 5 more seconds + # task 1 is sleeping for 95 more seconds + + # Fire events at a 10s interval; task 0 will wake up for each + # task 1 will only wake up after its sleep + p.fire() + await sleep(10) + p.fire() + assert wakeups == [2, 1] + await sleep(100) + assert wakeups == [3, 2] + + # Now task 0 is blocked on the next event + # Task 1 is sleeping for 100s + + p.fire() + await sleep(1) + assert wakeups == [4, 2] + await sleep(100) + assert wakeups == [4, 3] + + p.close() + except: + import traceback + traceback.print_exc() + raise From c84e9dd6ab518e0a6cbe6167b843a7d89209e5b1 Mon Sep 17 00:00:00 2001 From: Daniel Pope Date: Fri, 30 Apr 2021 16:50:49 +0100 Subject: [PATCH 2/2] Make EventStream final --- trio/_sync.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/trio/_sync.py b/trio/_sync.py index 67438375a7..5a95dc366c 100644 --- a/trio/_sync.py +++ b/trio/_sync.py @@ -787,7 +787,7 @@ def statistics(self): @attr.s -class EventStream: +class EventStream(metaclass=Final): """A concurrency primitive for a sequence of events. Multiple tasks can subscribe for events on the stream using an ``async