fixup! fixup! refactor(core): abstract cache and context [no changelog]

core/src/storage/cache.py

@@ -4,18 +4,10 @@ import gc
 from storage import cache_codec
 from storage.cache_common import SESSIONLESS_FLAG, SessionlessCache
 
-# XXX
-# Allocation notes:
-# Instantiation of a DataCache subclass should make as little garbage as possible, so
-# that the preallocated bytearrays are compact in memory.
-# That is why the initialization is two-step: first create appropriately sized
-# bytearrays, then later call `clear()` on all the existing objects, which resets them
-# to zero length. This is producing some trash - `b[:]` allocates a slice.
 
+# Cache initialization
 _SESSIONLESS_CACHE = SessionlessCache()
-
 _PROTOCOL_CACHE = cache_codec
-
 _PROTOCOL_CACHE.initialize()
 _SESSIONLESS_CACHE.clear()
 

core/src/storage/cache_codec.py

@@ -63,6 +63,13 @@ _SESSIONS: list[SessionCache] = []
 
 
 def initialize() -> None:
+    # Allocation notes:
+    # Instantiation of any DataCache subclass should make as little garbage
+    # as possible so that the preallocated bytearrays are compact in memory.
+    # That is why the initialization is two-step: first, create appropriately
+    # sized bytearrays, then call `clear()` on all existing objects, which
+    # resets them to zero length. The `clear()` function uses `arr[:]`, which
+    # allocates a slice.
     global _SESSIONS
     for _ in range(_MAX_SESSIONS_COUNT):
         _SESSIONS.append(SessionCache())

core/src/storage/cache_common.py

@@ -103,6 +103,7 @@ class DataCache:
 
     def delete(self, key: int) -> None:
         utils.ensure(key < len(self.fields))
+        # `arr[:]` allocates a slice to prevent memory fragmentation.
         self.data[key][:] = b"\x00"
 
     def clear(self) -> None: