more lock thoughts

Author: mikeshardmind

_misc/_l.py

@@ -22,17 +22,15 @@
 
 min_res = time.get_clock_info("monotonic").resolution
 
-start = time.monotonic_ns()
 
-
-async def check(lock: AsyncLock):
+async def check(lock: AsyncLock, start: int) -> tuple[int, int]:
     async with lock:
-        v = max(random.random() / 1000, min_res)
+        v = max(random.random() / 1e10, min_res)
         s = time.monotonic_ns()
         await asyncio.sleep(v)
         e = time.monotonic_ns()
-        print(s - start, e - start, flush=True)  # noqa: T201
         await asyncio.sleep(min_res)
+        return (s - start, e - start)
 
 
 async def amain():
@@ -43,8 +41,11 @@ async def amain():
             for _ in range(10)
             for x in (True, False)
         ]
-        tsks = {loop.run(check(lock)) for loop in loops for _ in range(10)}
-        await asyncio.gather(*tsks)
+        start = time.monotonic_ns()
+        tsks = {loop.run(check(lock, start)) for loop in loops for _ in range(10)}
+        results = await asyncio.gather(*tsks)
+        results.sort()
+        print(*(f"{s} {e}" for s, e in results), sep="\n", flush=True)  # noqa: T201
 
 
 if __name__ == "__main__":

src/async_utils/_simple_lock.py

@@ -21,6 +21,18 @@
 
 # TODO: pick what public namespace to re-export this from.
 
+# This is one of the few things that should unreservedly be reimplemented natively.
+# Atomic ops allow the design here to be lockfree.
+# Actually using a futex here might improve performance further, though I doubt it.
+
+# We can also do a little bit better prior to making it native by only locking
+# if we observe multiple threads. The gain for this is minor, but not insignificant.
+
+# This particular lock implementation optimizes for the uncontested lock case.
+# This is the most important optimization for well-designed parallel code
+# with fine-grained lock use. It's also barging, which is known to be better
+# than FIFO in the case of highly contested locks.
+
 
 class AsyncLock:
     """An async lock that doesn't bind to an event loop."""
@@ -36,36 +48,26 @@ def __init__(self) -> None:
         self._lockv: bool = False
         self._internal_lock: threading.RLock = threading.RLock()
 
-    def __locked(self) -> bool:
-        with self._internal_lock:
-            return self._lockv or (any(not w.cancelled() for w in (self._waiters)))
-
     async def __aenter__(self) -> None:
-        # placing the body of acquire here
-        # causes problems with eager tasks factories.
-        await self.__acquire()
-
-    async def __acquire(self) -> None:
         with self._internal_lock:
-            if not self.__locked():
+            if not self._lockv:
                 self._lockv = True
                 return
 
         fut: cf.Future[None] = cf.Future()
 
-        with self._internal_lock:
-            self._waiters.append(fut)
+        self._waiters.append(fut)
 
         try:
             await asyncio.wrap_future(fut)
         except asyncio.CancelledError:
-            if fut.done() and not fut.cancelled():
-                self._lockv = False
+            with self._internal_lock:
+                if not self._lockv:
+                    self._maybe_wake()
             raise
 
-        finally:
-            self._maybe_wake()
-        return
+        with self._internal_lock:
+            self._lockv = True
 
     def _maybe_wake(self) -> None:
         with self._internal_lock: