File size: 5,066 Bytes
cb65407 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 | # Copyright cocotb contributors
# Licensed under the Revised BSD License, see LICENSE for details.
# SPDX-License-Identifier: BSD-3-Clause
import asyncio.queues
import collections
import heapq
from typing import Generic, TypeVar
import cocotb
from cocotb.triggers import Event, _pointer_str
class QueueFull(asyncio.queues.QueueFull):
"""Raised when the Queue.put_nowait() method is called on a full Queue."""
class QueueEmpty(asyncio.queues.QueueEmpty):
"""Raised when the Queue.get_nowait() method is called on a empty Queue."""
T = TypeVar("T")
class Queue(Generic[T]):
"""A queue, useful for coordinating producer and consumer coroutines.
If *maxsize* is less than or equal to 0, the queue size is infinite. If it
is an integer greater than 0, then :meth:`put` will block when the queue
reaches *maxsize*, until an item is removed by :meth:`get`.
"""
def __init__(self, maxsize: int = 0):
self._maxsize = maxsize
self._finished = Event()
self._finished.set()
self._getters = collections.deque()
self._putters = collections.deque()
self._init(maxsize)
def _init(self, maxsize):
self._queue = collections.deque()
def _put(self, item):
self._queue.append(item)
def _get(self):
return self._queue.popleft()
def _wakeup_next(self, waiters):
while waiters:
event, task = waiters.popleft()
if not task.done():
event.set()
break
def __repr__(self):
return f"<{type(self).__name__} {self._format()} at {_pointer_str(self)}>"
def __str__(self):
return f"<{type(self).__name__} {self._format()}>"
def __class_getitem__(cls, type):
return cls
def _format(self):
result = f"maxsize={repr(self._maxsize)}"
if getattr(self, "_queue", None):
result += f" _queue={repr(list(self._queue))}"
if self._getters:
result += f" _getters[{len(self._getters)}]"
if self._putters:
result += f" _putters[{len(self._putters)}]"
return result
def qsize(self) -> int:
"""Number of items in the queue."""
return len(self._queue)
@property
def maxsize(self) -> int:
"""Number of items allowed in the queue."""
return self._maxsize
def empty(self) -> bool:
"""Return ``True`` if the queue is empty, ``False`` otherwise."""
return not self._queue
def full(self) -> bool:
"""Return ``True`` if there are :meth:`maxsize` items in the queue.
.. note::
If the Queue was initialized with ``maxsize=0`` (the default), then
:meth:`full` is never ``True``.
"""
if self._maxsize <= 0:
return False
else:
return self.qsize() >= self._maxsize
async def put(self, item: T) -> None:
"""Put an *item* into the queue.
If the queue is full, wait until a free
slot is available before adding the item.
"""
while self.full():
event = Event(f"{type(self).__name__} put")
self._putters.append((event, cocotb.scheduler._current_task))
await event.wait()
self.put_nowait(item)
def put_nowait(self, item: T) -> None:
"""Put an *item* into the queue without blocking.
If no free slot is immediately available, raise :exc:`asyncio.QueueFull`.
"""
if self.full():
raise QueueFull()
self._put(item)
self._finished.clear()
self._wakeup_next(self._getters)
async def get(self) -> T:
"""Remove and return an item from the queue.
If the queue is empty, wait until an item is available.
"""
while self.empty():
event = Event(f"{type(self).__name__} get")
self._getters.append((event, cocotb.scheduler._current_task))
await event.wait()
return self.get_nowait()
def get_nowait(self) -> T:
"""Remove and return an item from the queue.
Return an item if one is immediately available, else raise
:exc:`asyncio.QueueEmpty`.
"""
if self.empty():
raise QueueEmpty()
item = self._get()
self._wakeup_next(self._putters)
return item
class PriorityQueue(Queue):
r"""A subclass of :class:`Queue`; retrieves entries in priority order (smallest item first).
Entries are typically tuples of the form ``(priority number, data)``.
"""
def _init(self, maxsize):
self._queue = []
def _put(self, item):
heapq.heappush(self._queue, item)
def _get(self):
return heapq.heappop(self._queue)
class LifoQueue(Queue):
"""A subclass of :class:`Queue`; retrieves most recently added entries first."""
def _init(self, maxsize):
self._queue = collections.deque()
def _put(self, item):
self._queue.append(item)
def _get(self):
return self._queue.pop()
|