sync sample package

record_32d94060-9d09-4a8b-9afe-9eeb42dc7dee.json

@@ -0,0 +1,20 @@
+{
+  "answer": "Both calls can run loader because each releases _lock before invoking it. When they attempt publication, compare_and_set checks the current version and replaces the entry only if it still equals the version each call read. The first successful call increments the version; the other then sees a mismatch and returns False, so both results cannot be published from that same starting version. The loader computation itself may nevertheless be duplicated, and the code does not serialize any side effects performed by loader.",
+  "question": "If two refresh calls read the same entry version before either loader finishes, can both publish their results? What work may still be duplicated?",
+  "race_paths": [
+    "Two refresh calls can snapshot the same version and run their loaders concurrently. The first successful compare_and_set advances the version; the other call is rejected and returns False.",
+    "Because the loader runs outside the lock, its computation can be based on a value that another refresh has since replaced. The version check prevents that stale computation from overwriting the newer entry, but it does not prevent duplicated loader work or side effects."
+  ],
+  "source_code": "import threading\n\n\nclass VersionedCache:\n    def __init__(self):\n        self._entries = {}\n        self._lock = threading.Lock()\n\n    def compare_and_set(self, key, expected_version, new_value):\n        with self._lock:\n            current = self._entries.get(key)\n            if current is None or current[1] != expected_version:\n                return False\n            self._entries[key] = (new_value, expected_version + 1)\n            return True\n\n    def refresh(self, key, loader):\n        with self._lock:\n            current = self._entries.get(key)\n            if current is None:\n                return False\n            value, version = current\n\n        new_value = loader(value)\n        return self.compare_and_set(key, version, new_value)",
+  "shared_state": [
+    "_entries maps each key to a (value, version) pair; its reads and writes in these methods are protected by _lock.",
+    "The entry version is shared coordination state: compare_and_set reads it and increments it when a replacement succeeds."
+  ],
+  "execution_result": "refresh returns False if the key is absent when it takes its snapshot, or if its computed result loses the version check. It returns True when its result is stored and the entry version is incremented by one.",
+  "concurrency_mechanism": "A mutex makes the version check and entry replacement one critical section. refresh uses an optimistic pattern: it reads a value and version under the lock, computes outside the lock, then conditionally publishes only if the version is unchanged.",
+  "synchronization_boundaries": [
+    "The first with self._lock block in refresh protects reading the entry and its version.",
+    "The with self._lock block in compare_and_set protects the version comparison and replacement as one indivisible operation relative to other accesses using this instance's lock.",
+    "loader(value) runs outside the lock, so concurrent refresh computations may overlap."
+  ]
+}

record_4bc53b3e-285c-4ab6-abeb-be2a3a59a364.json

@@ -0,0 +1,20 @@
+{
+  "question": "What happens if invalidate runs after load_and_publish captures the key's epoch but before its loader finishes? Can two loads from the same epoch both publish?",
+  "answer": "invalidate increments the key's epoch and removes its cached value while holding the same lock used by publication. When the earlier load finishes, it compares the current epoch with its captured epoch under the lock. If invalidation has occurred, the epochs differ, so load_and_publish returns False without storing that value. If two loads capture the same epoch and no invalidation occurs, each can pass the epoch check and publish; the one that acquires the lock later overwrites the earlier value. The method returns whether publication succeeded, not the loaded value.",
+  "race_paths": [
+    "A load can capture an epoch, then an invalidation can increment that epoch and remove the entry before the load finishes. The later publication check rejects the old load, preventing it from restoring a value from before the invalidation.",
+    "Two loads can capture the same epoch and finish in either order. Since neither changes the epoch, both may publish; the later publication overwrites the earlier one."
+  ],
+  "source_code": "import threading\n\n\nclass CacheWithInvalidationEpochs:\n    def __init__(self):\n        self._values = {}\n        self._epochs = {}\n        self._lock = threading.Lock()\n\n    def invalidate(self, key):\n        with self._lock:\n            self._epochs[key] = self._epochs.get(key, 0) + 1\n            self._values.pop(key, None)\n\n    def load_and_publish(self, key, loader):\n        with self._lock:\n            epoch = self._epochs.get(key, 0)\n\n        value = loader()\n\n        with self._lock:\n            if self._epochs.get(key, 0) != epoch:\n                return False\n            self._values[key] = value\n            return True",
+  "shared_state": [
+    "_epochs maps keys to generation counters; invalidate increments a counter, and load_and_publish reads it before and after loading.",
+    "_values maps keys to cached values; invalidate removes entries and load_and_publish may insert them, with those operations protected by _lock."
+  ],
+  "execution_result": "If the key's epoch is unchanged when publication is attempted, the value is stored and load_and_publish returns True. If the epoch changed, the value is not stored and the method returns False; the caller can use that result to decide whether to retry or discard the loaded value.",
+  "concurrency_mechanism": "A per-key epoch acts as a generation token. A loader snapshots the token before doing work outside the lock, then checks it before publishing. Invalidation advances the token, preventing a load from an earlier generation from repopulating the cache.",
+  "synchronization_boundaries": [
+    "The lock in invalidate protects incrementing the key's epoch and removing its cached value as one operation.",
+    "The first lock block in load_and_publish protects the epoch snapshot.",
+    "The final lock block in load_and_publish protects comparing the current epoch with the snapshot and, when they match, storing the value."
+  ]
+}

record_7f705b8a-f010-4daa-8e30-5e72edab98dd.json

@@ -0,0 +1,20 @@
+{
+  "answer": "The lock serializes the cache lookup and the decision to create or join a per-key flight. The leader runs loader outside the lock, so unrelated keys—and other code using the cache—are not blocked by the loader itself. Callers that find an existing flight wait on its event. On success, the leader stores the value and places it on the flight before signaling; waiters then return that value. On failure, the leader records the exception, removes the flight, and signals waiters, which raise the recorded exception. A later call after the failed flight has been removed can start a new load.",
+  "question": "For concurrent calls to get_or_load with the same key, which work is serialized, and what do waiting callers observe if the loader raises an exception?",
+  "race_paths": [
+    "If several callers miss the same key concurrently, the first caller to insert a flight becomes leader; the others observe that flight and wait rather than invoking loader themselves.",
+    "After a failed flight is removed, a new caller can create a new flight while callers from the failed flight are still waking and handling its exception. The new caller retries the load; the old waiters still refer to the completed flight object."
+  ],
+  "source_code": "import threading\n\n\nclass _Flight:\n    def __init__(self):\n        self.event = threading.Event()\n        self.value = None\n        self.error = None\n\n\nclass Cache:\n    def __init__(self):\n        self._values = {}\n        self._flights = {}\n        self._lock = threading.Lock()\n\n    def get_or_load(self, key, loader):\n        with self._lock:\n            if key in self._values:\n                return self._values[key]\n            flight = self._flights.get(key)\n            leader = flight is None\n            if leader:\n                flight = _Flight()\n                self._flights[key] = flight\n\n        if not leader:\n            flight.event.wait()\n            if flight.error is not None:\n                raise flight.error\n            return flight.value\n\n        try:\n            value = loader()\n        except Exception as exc:\n            with self._lock:\n                flight.error = exc\n                self._flights.pop(key, None)\n                flight.event.set()\n            raise\n\n        with self._lock:\n            self._values[key] = value\n            flight.value = value\n            self._flights.pop(key, None)\n            flight.event.set()\n        return value",
+  "shared_state": [
+    "_values maps keys to cached values; reads and writes in this method occur under _lock.",
+    "_flights maps keys to shared _Flight objects; the map is accessed under _lock, while each flight's value, error, and event communicate the outcome to its waiters."
+  ],
+  "execution_result": "For a successful load, the value is cached and returned by the leader and callers waiting on that flight. If loading raises an Exception, the leader re-raises it and waiters raise the recorded exception; the failed flight is removed, so a subsequent call may try loading again.",
+  "concurrency_mechanism": "A mutex protects the cache and per-key in-flight map, while an event lets callers for the same missing key share the leader's result or exception. This coalesces concurrent loads for a key while the flight remains registered.",
+  "synchronization_boundaries": [
+    "The with self._lock blocks protect checking and updating _values and looking up, inserting, or removing entries in _flights.",
+    "flight.event.wait() blocks followers until the leader has stored either the result or the exception and signaled completion.",
+    "loader() runs outside the mutex; its execution is not serialized by this cache lock."
+  ]
+}