Address CoPilot review: bound caches, add clear API, fix benchmark imports

- Add 256-entry size cap to both _deserializer_cache and
  _make_deserializers_cache to prevent unbounded growth from
  non-interned parameterized types in unprepared queries.
- Add clear_deserializer_caches() public API so that runtime Des*
  class overrides (e.g. DesBytesType = DesBytesTypeByteArray for
  cqlsh) can flush stale cached instances.
- Add get_deserializer_cache_sizes() diagnostic helper.
- Document override/cache interaction in code comments.
- Fix benchmark copyright (DataStax -> ScyllaDB), add
  pytest.importorskip guards for pytest-benchmark and Cython.
- Add 11 unit tests for cache hit/miss, clear, eviction bounds,
  and size reporting.

Author: mykaul

benchmarks/test_deserializer_cache_benchmark.py

@@ -1,4 +1,4 @@
-# Copyright DataStax, Inc.
+# Copyright ScyllaDB, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,10 +16,16 @@
 Benchmarks for find_deserializer / make_deserializers with and without caching.
 
 Run with: pytest benchmarks/test_deserializer_cache_benchmark.py -v
+
+Requires the ``pytest-benchmark`` plugin and Cython extensions to be built.
+Skipped automatically when either dependency is unavailable.
 """
 
 import pytest
 
+pytest.importorskip("pytest_benchmark")
+pytest.importorskip("cassandra.deserializers")
+
 from cassandra import cqltypes
 from cassandra.deserializers import (
     find_deserializer,

cassandra/deserializers.pyx

@@ -440,20 +440,33 @@ cdef class GenericDeserializer(Deserializer):
 #--------------------------------------------------------------------------
 # Helper utilities
 
+# Maximum number of entries in each deserializer cache.  In practice the
+# caches are bounded by the number of distinct column-type signatures in
+# the schema (typically dozens to low hundreds), but parameterized types
+# created via apply_parameters() for unprepared queries are *not*
+# interned, so repeated simple queries could accumulate entries.  The cap
+# prevents unbounded growth in such edge cases.
+cdef int _CACHE_MAX_SIZE = 256
+
 # Cache make_deserializers results keyed on the tuple of cqltype objects.
 # Using the cqltype objects themselves (rather than id()) as keys ensures
 # the dict holds strong references, preventing GC and id() reuse issues
 # with non-singleton parameterized types.
 cdef dict _make_deserializers_cache = {}
 
 def make_deserializers(cqltypes):
-    """Create an array of Deserializers for each given cqltype in cqltypes"""
+    """Create an array of Deserializers for each given cqltype in cqltypes.
+
+    The returned array may be a cached object shared across callers.
+    Callers must not modify the returned array."""
     cdef tuple key = tuple(cqltypes)
     try:
         return _make_deserializers_cache[key]
     except KeyError:
         pass
     result = obj_array([find_deserializer(ct) for ct in cqltypes])
+    if len(_make_deserializers_cache) >= _CACHE_MAX_SIZE:
+        _make_deserializers_cache.clear()
     _make_deserializers_cache[key] = result
     return result
 
@@ -464,6 +477,11 @@ cdef dict classes = globals()
 # repeated class lookups and object creation on every result set.
 # Using the object as key (rather than id()) holds a strong reference,
 # preventing GC and id() reuse issues with parameterized types.
+#
+# Note: if a Des* class is overridden at runtime (e.g. DesBytesType =
+# DesBytesTypeByteArray for cqlsh), callers must invoke
+# clear_deserializer_caches() to flush stale entries so that subsequent
+# find_deserializer() calls pick up the new class.
 cdef dict _deserializer_cache = {}
 
 cpdef Deserializer find_deserializer(cqltype):
@@ -501,10 +519,29 @@ cpdef Deserializer find_deserializer(cqltype):
         cls = GenericDeserializer
 
     cdef Deserializer result = cls(cqltype)
+    if len(_deserializer_cache) >= _CACHE_MAX_SIZE:
+        _deserializer_cache.clear()
     _deserializer_cache[cqltype] = result
     return result
 
 
+def clear_deserializer_caches():
+    """Clear the find_deserializer and make_deserializers caches.
+
+    Call this after overriding a Des* class at runtime (e.g.
+    ``deserializers.DesBytesType = deserializers.DesBytesTypeByteArray``)
+    so that subsequent lookups pick up the new class instead of returning
+    stale cached instances.
+    """
+    _deserializer_cache.clear()
+    _make_deserializers_cache.clear()
+
+
+def get_deserializer_cache_sizes():
+    """Return ``(find_cache_size, make_cache_size)`` for diagnostic use."""
+    return len(_deserializer_cache), len(_make_deserializers_cache)
+
+
 def obj_array(list objs):
     """Create a (Cython) array of objects given a list of objects"""
     cdef object[:] arr