Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
21 changes: 20 additions & 1 deletion grain/_src/python/dataset/transformations/prefetch.py
Original file line number Diff line number Diff line change
Expand Up @@ -17,6 +17,7 @@

import collections
from collections.abc import Iterator, Sequence
import contextlib
import copy
import functools
from multiprocessing import queues
Expand Down Expand Up @@ -431,18 +432,22 @@ def _element_spec(self) -> Any:
StateT = dict[str, Any]
# Type for the buffer elements.
BufferElementT = tuple[T, StateT, Exception | None]
_CLOSED_ERROR = ValueError("Iterator has been closed.")


def _put_iterator_elements_in_buffer(
iterator: dataset.DatasetIterator[T],
buffer: queue.Queue[BufferElementT],
should_stop: threading.Event,
stats: dataset_stats.Stats,
closed: threading.Event,
):
"""Fetches elements from the iterator and puts them in the buffer."""
try:
while not should_stop.is_set():
element = stats.record_bytes_consumed(iterator.__next__())
if closed.is_set():
return
state = copy.deepcopy(iterator.get_state())
buffer.put((element, state, None))
except Exception as e: # pylint: disable=broad-except
Expand Down Expand Up @@ -529,6 +534,7 @@ def __init__(

self._prefetch_thread: threading.Thread | None = None
self._prefetch_should_stop: threading.Event = threading.Event()
self._closed_event: threading.Event = threading.Event()
if self.autotune_buffer_size is not None:
self._buffer: (
variable_size_queue.VariableSizeQueue | queue.Queue[BufferElementT]
Expand Down Expand Up @@ -584,6 +590,7 @@ def start_prefetch(self):
buffer=self._buffer,
should_stop=self._prefetch_should_stop,
stats=self._stats,
closed=self._closed_event,
),
daemon=True,
name=f"grain-thread-prefetch-{str(self)}",
Expand All @@ -595,6 +602,7 @@ def start_prefetch(self):
stage_category=dataset_stats.IPL_CAT_PREFETCH
)
def __next__(self):
self._assert_not_closed()

if self._state is None:
self._state = self._maybe_nonnative_parent.get_state()
Expand All @@ -615,6 +623,10 @@ def __next__(self):
state = copy.deepcopy(self._maybe_nonnative_parent.get_state())
err = None

if self._closed:
with contextlib.suppress(queue.Full):
self._buffer.put_nowait((None, None, _CLOSED_ERROR)) # pyrefly: ignore[bad-argument-type]
self._assert_not_closed()
if err is not None:
self._stop_prefetch()
raise err
Expand All @@ -627,10 +639,17 @@ def __next__(self):

def close(self):
"""Stops the iterator. No further calls to the iterator are expected."""
if self._closed:
return
self._closed = True
self._stop_prefetch()
self._closed_event.set()
self._prefetch_should_stop.set()
self._clear_buffer()
if isinstance(self._maybe_nonnative_parent, dataset.DatasetIterator):
self._maybe_nonnative_parent.close()
self._stop_prefetch()
with contextlib.suppress(queue.Full):
self._buffer.put_nowait((None, None, _CLOSED_ERROR)) # pyrefly: ignore[bad-argument-type]

def _clear_buffer(self):
while True:
Expand Down
194 changes: 194 additions & 0 deletions grain/_src/python/dataset/transformations/prefetch_test.py
Original file line number Diff line number Diff line change
Expand Up @@ -608,6 +608,200 @@ def test_does_not_hang_after_stop_iteration(self):
_ = list(it)
self.assertEmpty(list(it))

@parameterized.parameters([True, False])
def test_close_unblocks_producer_waiting_in_parent_next(
self, raise_on_close: bool
):
entered_next = threading.Event()
parent_closed = threading.Event()
producer_finished = threading.Event()
parent_close_count = 0
get_state_called_after_close = False

class BlockingIterator(dataset.DatasetIterator[int]):

def __next__(self) -> int:
entered_next.set()
parent_closed.wait()
time.sleep(0.02)
try:
if raise_on_close:
self._assert_not_closed()
return 0
finally:
producer_finished.set()

def close(self) -> None:
nonlocal parent_close_count
parent_close_count += 1
super().close()
parent_closed.set()

def get_state(self):
nonlocal get_state_called_after_close
if self._closed:
get_state_called_after_close = True
return {}

def set_state(self, state):
pass

class BlockingDataset(dataset.IterDataset[int]):

def __iter__(self) -> dataset.DatasetIterator[int]:
return BlockingIterator()

it = prefetch.ThreadPrefetchIterDataset(
BlockingDataset(), prefetch_buffer_size=2
).__iter__()
it.start_prefetch()
self.assertTrue(entered_next.wait(timeout=5.0))

closed_done = threading.Event()
producer_finished_on_first_close = False

def close_iter():
nonlocal producer_finished_on_first_close
it.close()
producer_finished_on_first_close = producer_finished.is_set()
it.close()
closed_done.set()

closer = threading.Thread(target=close_iter, daemon=True)
closer.start()
self.assertTrue(closed_done.wait(timeout=5.0))
closer.join(timeout=1.0)
self.assertTrue(parent_closed.is_set())
self.assertEqual(parent_close_count, 1)
self.assertTrue(producer_finished_on_first_close)
self.assertFalse(get_state_called_after_close)

def test_close_clears_buffer_and_stops_producer_before_closing_parent(self):
second_fetched = threading.Event()
producer_thread: threading.Thread | None = None
producer_exited_before_parent_close = False
calls = 0

class FullBufferIterator(dataset.DatasetIterator[int]):

def __next__(self) -> int:
nonlocal calls, producer_thread
calls += 1
if calls == 1:
producer_thread = threading.current_thread()
elif calls == 2:
second_fetched.set()
return calls

def close(self) -> None:
nonlocal producer_exited_before_parent_close
if producer_thread is not None:
producer_thread.join(timeout=0.5)
producer_exited_before_parent_close = not producer_thread.is_alive()
time.sleep(0.02)
super().close()

def get_state(self):
return {}

def set_state(self, state):
pass

it = prefetch.ThreadPrefetchDatasetIterator(
FullBufferIterator(), prefetch_buffer_size=1
)
it.start_prefetch()
self.assertTrue(second_fetched.wait(timeout=5.0))
time.sleep(0.02)
it.close()
self.assertTrue(producer_exited_before_parent_close)
self.assertEqual(calls, 2)

@parameterized.parameters([0, 2])
def test_next_after_close_raises_without_querying_parent(
self, prefetch_buffer_size: int
):

class StrictParentIterator(dataset.DatasetIterator[int]):

def __next__(self) -> int:
self._assert_not_closed()
return 0

def get_state(self):
if self._closed:
raise RuntimeError('get_state called after close')
return {}

def set_state(self, state):
pass

it = prefetch.ThreadPrefetchDatasetIterator(
StrictParentIterator(), prefetch_buffer_size=prefetch_buffer_size
)
it.close()
for _ in range(2):
with self.assertRaisesRegex(
ValueError, 'Trying to advance a closed iterator'
):
next(it)

def test_close_unblocks_waiting_consumers(self):
entered_next = threading.Event()
parent_closed = threading.Event()

class BlockingIterator(dataset.DatasetIterator[int]):

def __next__(self) -> int:
entered_next.set()
parent_closed.wait()
self._assert_not_closed()
return 0

def close(self) -> None:
super().close()
parent_closed.set()

def get_state(self):
return {}

def set_state(self, state):
pass

class BlockingDataset(dataset.IterDataset[int]):

def __iter__(self) -> dataset.DatasetIterator[int]:
return BlockingIterator()

it = prefetch.ThreadPrefetchIterDataset(
BlockingDataset(), prefetch_buffer_size=2
).__iter__()
it.start_prefetch()
self.assertTrue(entered_next.wait(timeout=5.0))

c1_started = threading.Event()
c2_started = threading.Event()

def consume(started: threading.Event):
started.set()
return next(it)

with futures.ThreadPoolExecutor(max_workers=2) as pool:
f1 = pool.submit(consume, c1_started)
f2 = pool.submit(consume, c2_started)
self.assertTrue(c1_started.wait(timeout=5.0))
self.assertTrue(c2_started.wait(timeout=5.0))
time.sleep(0.05)
it.close()
with self.assertRaisesRegex(
ValueError, 'Trying to advance a closed iterator'
):
f1.result(timeout=5.0)
with self.assertRaisesRegex(
ValueError, 'Trying to advance a closed iterator'
):
f2.result(timeout=5.0)

def test_nonnative_iterator(self):

class TestIterator:
Expand Down
Loading
⌂ 换网址