Performance [P2]: Make entity method signature caching effective (#202)

* Make entity method signature caching effective

_execute_entity_batch() constructed a new _EntityExecutor inside its
per-operation loop, so the executor's _entity_method_cache was always cold
and inspect.signature() was re-run for every single entity operation.

The executor is now constructed once per batch and shares a bounded,
thread-safe signature cache owned by the worker, so a given
(entity type, operation) pair is reflected once for the lifetime of the
worker rather than once per operation.

The cache is bounded (_EntityMethodSignatureCache, 1024 entries, oldest
evicted first) because entity types and operation names come from user code
and are unbounded in principle. Writes are serialized under a lock so
concurrently processed entity work items stay safe.

Behavior is unchanged: the dispatch logic in _EntityExecutor.execute() is
untouched, so the no-argument versus input-argument distinction and all
error messages for unknown or invalid operations are preserved.
_EntityExecutor's existing three-argument constructor still works; the
shared cache is an optional fourth argument.

Fixes #186

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 2265f7b9-f8ad-4b50-a25d-19bd6f1ac96c

* Test that a non-positive signature cache bound is clamped

_EntityMethodSignatureCache clamps its bound with max(1, max_size), but
nothing covered that clamp, so the PR description overstated the test
coverage. Add regression tests for it.

The clamp is not cosmetic. Without it a bound of 0 evicts each entry
immediately after inserting it, so every lookup misses and the entity
method reflection this cache exists to avoid runs on every operation
again -- silently reintroducing the very problem this change fixes. A
negative bound is worse: the eviction loop keeps popping past an
already-empty dict and raises StopIteration.

The new tests cover a zero and negative bound, that a clamped cache
still behaves as a working size-one cache rather than a no-op, and that
an executor handed a clamped cache still reflects only once. Verified
red before green: with the clamp removed all five fail, including
'assert 3 == 1' on the reflection count.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 2265f7b9-f8ad-4b50-a25d-19bd6f1ac96c

---------

Co-authored-by: Bernd Verst <beverst@microsoft.com>
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 2265f7b9-f8ad-4b50-a25d-19bd6f1ac96c

Author: 3 people

durabletask/worker.py

@@ -535,6 +535,9 @@ def __init__(
             data_converter: DataConverter | None = None,
     ):
         self._registry = _Registry()
+        # Shared by every entity batch this worker processes so that reflected
+        # entity method signatures are computed once instead of per operation.
+        self._entity_method_cache = _EntityMethodSignatureCache()
         self._host_address = (
             host_address if host_address else shared.get_default_host_address()
         )
@@ -1373,9 +1376,17 @@ def _execute_entity_batch(
             raise RuntimeError(f"Invalid entity instance ID '{instance_id}' in entity operation request.")
 
         results: list[pb.OperationResult] = []
+        # A single executor serves the whole batch and shares the worker's
+        # bounded signature cache, so entity method reflection is not repeated
+        # for every operation.
+        executor = _EntityExecutor(
+            self._registry,
+            self._logger,
+            self._data_converter,
+            entity_method_cache=self._entity_method_cache,
+        )
         for operation in req.operations:
             start_time = datetime.now(timezone.utc)
-            executor = _EntityExecutor(self._registry, self._logger, self._data_converter)
 
             operation_result = None
 
@@ -3107,13 +3118,61 @@ def execute(
         return encoded_output
 
 
+class _EntityMethodSignatureCache:
+    """Bounded, thread-safe cache of reflected entity method signatures.
+
+    Dispatching an operation on a class-based entity requires knowing whether
+    the target method declares a required parameter, which is answered with an
+    ``inspect.signature()`` call. The answer depends only on the entity type
+    and the operation name, so it is cached here and shared across entity
+    batches (and therefore across the worker threads that process them
+    concurrently).
+
+    The cache is bounded because entity types and operation names originate
+    from user code and are unbounded in principle; once the limit is reached
+    the oldest entries are evicted instead of growing without limit.
+    """
+
+    DEFAULT_MAX_SIZE = 1024
+
+    def __init__(self, max_size: int = DEFAULT_MAX_SIZE):
+        self._max_size = max(1, max_size)
+        self._lock = Lock()
+        self._entries: dict[tuple[type, str], bool] = {}
+
+    def get(self, key: tuple[type, str]) -> bool | None:
+        """Returns the cached result for ``key``, or ``None`` when not cached."""
+        return self._entries.get(key)
+
+    def __setitem__(self, key: tuple[type, str], value: bool) -> None:
+        with self._lock:
+            self._entries[key] = value
+            # Dicts preserve insertion order, so the first key is the oldest.
+            while len(self._entries) > self._max_size:
+                self._entries.pop(next(iter(self._entries)), None)
+
+    def __contains__(self, key: object) -> bool:
+        return key in self._entries
+
+    def __len__(self) -> int:
+        return len(self._entries)
+
+
 class _EntityExecutor:
     def __init__(self, registry: _Registry, logger: logging.Logger,
-                 data_converter: DataConverter):
+                 data_converter: DataConverter,
+                 entity_method_cache: _EntityMethodSignatureCache | None = None):
         self._registry = registry
         self._logger = logger
         self._data_converter = data_converter
-        self._entity_method_cache: dict[tuple[type, str], bool] = {}
+        # When the caller supplies a cache (the worker does), reflected entity
+        # method signatures are shared with it and therefore survive beyond the
+        # lifetime of this executor.
+        self._entity_method_cache: _EntityMethodSignatureCache = (
+            entity_method_cache
+            if entity_method_cache is not None
+            else _EntityMethodSignatureCache()
+        )
 
     def execute(
             self,