Broadcast: Use hash() instead of a UUID

UUIDs are expensive to create and not really necessary in this case as
we are just keeping a local list of unique objects, so using the
object's hash is enough.

We also use a `id(self)`-based name by default if a `name` was not
provided when creating a `new_receiver()`.

A simple test using `timeit` shows a 2 orders of magnitude improvement
in Python 3.11:

```console
$ python -m timeit -s "import uuid" "uuid.uuid4()"
100000 loops, best of 5: 2.67 usec per loop
$ python -m timeit "hash(__name__)"
10000000 loops, best of 5: 19.6 nsec per loop
$ python -m timeit "id(__name__)"
10000000 loops, best of 5: 20.1 nsec per loop
```

Signed-off-by: Leandro Lucarella <[email protected]>

Author: llucax

src/frequenz/channels/_broadcast.py

@@ -10,7 +10,6 @@
 from asyncio import Condition
 from collections import deque
 from typing import Generic
-from uuid import UUID, uuid4
 
 from ._base_classes import Peekable as BasePeekable
 from ._base_classes import Receiver as BaseReceiver
@@ -109,8 +108,8 @@ def __init__(self, *, name: str | None, resend_latest: bool = False) -> None:
         self._recv_cv: Condition = Condition()
         """The condition to wait for data in the channel's buffer."""
 
-        self._receivers: dict[UUID, weakref.ReferenceType[Receiver[T]]] = {}
-        """The receivers attached to the channel, indexed by their UUID."""
+        self._receivers: dict[int, weakref.ReferenceType[Receiver[T]]] = {}
+        """The receivers attached to the channel, indexed by their hash()."""
 
         self._closed: bool = False
         """Whether the channel is closed."""
@@ -183,11 +182,8 @@ def new_receiver(self, *, name: str | None = None, limit: int = 50) -> Receiver[
         Returns:
             A Receiver instance attached to the broadcast channel.
         """
-        uuid = uuid4()
-        if name is None:
-            name = str(uuid)
-        recv: Receiver[T] = Receiver(uuid, name, limit, self)
-        self._receivers[uuid] = weakref.ref(recv)
+        recv: Receiver[T] = Receiver(name, limit, self)
+        self._receivers[hash(recv)] = weakref.ref(recv)
         if self.resend_latest and self._latest is not None:
             recv.enqueue(self._latest)
         return recv
@@ -240,14 +236,14 @@ async def send(self, msg: T) -> None:
             )
         self._chan._latest = msg
         stale_refs = []
-        for name, recv_ref in self._chan._receivers.items():
+        for _hash, recv_ref in self._chan._receivers.items():
             recv = recv_ref()
             if recv is None:
-                stale_refs.append(name)
+                stale_refs.append(_hash)
                 continue
             recv.enqueue(msg)
-        for name in stale_refs:
-            del self._chan._receivers[name]
+        for _hash in stale_refs:
+            del self._chan._receivers[_hash]
         async with self._chan._recv_cv:
             self._chan._recv_cv.notify_all()
         # pylint: enable=protected-access
@@ -261,25 +257,23 @@ class Receiver(BaseReceiver[T]):
     method.
     """
 
-    def __init__(self, uuid: UUID, name: str, limit: int, chan: Broadcast[T]) -> None:
+    def __init__(self, name: str | None, limit: int, chan: Broadcast[T]) -> None:
         """Create a broadcast receiver.
 
         Broadcast receivers have their own buffer, and when messages are not
         being consumed fast enough and the buffer fills up, old messages will
         get dropped just in this receiver.
 
         Args:
-            uuid: A uuid to identify the receiver in the broadcast channel's
-                list of receivers.
-            name: A name to identify the receiver in the logs.
+            name: A name to identify the receiver in the logs. If `None` an
+                `id(self)`-based name will be used.  This is only for debugging
+                purposes, it will be shown in the string representation of the
+                receiver.
             limit: Size of the receiver's buffer in number of messages.
             chan: a reference to the Broadcast channel that this receiver
                 belongs to.
         """
-        self._uuid: UUID = uuid
-        """The UUID to identify the receiver in the broadcast channel's list of receivers."""
-
-        self._name: str = name
+        self._name: str = name if name is not None else f"{id(self):_}"
         """The name to identify the receiver.
 
         Only used for debugging purposes.
@@ -361,8 +355,9 @@ def _deactivate(self) -> None:
         """Set the receiver as inactive and remove it from the channel."""
         self._active = False
         # pylint: disable=protected-access
-        if self._uuid in self._chan._receivers:
-            del self._chan._receivers[self._uuid]
+        _hash = hash(self)
+        if _hash in self._chan._receivers:
+            del self._chan._receivers[_hash]
         # pylint: enable=protected-access
 
     def consume(self) -> T: