Cache pid via os.register_at_fork to spare aarch64 vDSO miss on hot path

os.getpid() is a vDSO syscall on x86-64 Linux (~30 ns/call) but not
on aarch64 Linux (~700 ns/call). Cycle 20's fork guard added the
syscall to every public method on Connection / DqliteConnection /
ConnectionPool / ClusterClient — on aarch64 each cursor.execute()
or pool.acquire() pays ~1.4 µs of pure syscall overhead.

Cache the pid in a module-level int (``dqliteclient.connection.
_current_pid``) and refresh on fork via
``os.register_at_fork(after_in_child=...)``, which Python guarantees
runs in the child before user code resumes. Public-method checks
become a Python int-equality (~10 ns) regardless of arch.

Migrate every fork-pid check site (DqliteConnection ×2,
ConnectionPool ×3, ClusterClient ×1) to read the cache. The dbapi
sync + async sides import the cache from the client module as the
single source of truth; that keeps a single register_at_fork hook
covering the whole stack and avoids drift if a future arch
refresher is needed.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: antoineleclair

src/dqliteclient/cluster.py

@@ -8,6 +8,7 @@
 from collections.abc import Callable, Iterable
 from typing import Final, NoReturn
 
+from dqliteclient import connection as _conn_mod
 from dqliteclient.connection import DqliteConnection, _parse_address, _validate_timeout
 from dqliteclient.exceptions import (
     ClusterError,
@@ -222,7 +223,7 @@ async def find_leader(self, *, trust_server_heartbeat: bool = False) -> str:
         (re-poll the node store between probes) costs an extra await
         per probe to close a window most callers do not exercise.
         """
-        if os.getpid() != self._creator_pid:
+        if _conn_mod._current_pid != self._creator_pid:
             # Fork-after-init: the slot map holds parent-loop tasks
             # that the child cannot drive. Surface a clear
             # InterfaceError instead of letting a sibling task land

src/dqliteclient/connection.py

@@ -36,6 +36,27 @@
 
 logger = logging.getLogger(__name__)
 
+# Fork-aware pid cache. ``os.getpid()`` is a vDSO syscall on x86-64
+# Linux (~30 ns/call) but not on aarch64 Linux (~700 ns/call), so a
+# per-call check that fires on every public method became a measurable
+# overhead on aarch64 deployments. Cache the pid in a module-level int
+# and refresh on fork via ``os.register_at_fork(after_in_child=...)``,
+# which Python guarantees runs in the child before user code resumes.
+# Callers compare against ``_current_pid`` instead of ``os.getpid()``;
+# the comparison is a Python int-equality (~10 ns) regardless of
+# arch. ``register_at_fork`` is unavailable on Windows; fall back to
+# ``os.getpid`` there (Windows has no fork anyway).
+_current_pid: int = os.getpid()
+
+
+def _refresh_pid_cache() -> None:
+    global _current_pid
+    _current_pid = os.getpid()
+
+
+if hasattr(os, "register_at_fork"):
+    os.register_at_fork(after_in_child=_refresh_pid_cache)
+
 # Bare ``BEGIN`` opens an implicit ``DEFERRED`` transaction per SQLite's
 # grammar default. dqlite's Raft FSM serializes transactions regardless
 # of the qualifier, so DEFERRED / IMMEDIATE / EXCLUSIVE collapse to the
@@ -1128,7 +1149,7 @@ async def close(self) -> None:
         # silent on already-closed inputs — silently no-oping in the
         # child preserves that contract for the GC / __del__ path that
         # commonly drives close in a forked worker.
-        if os.getpid() != self._creator_pid:
+        if _current_pid != self._creator_pid:
             # Drop every reference that crosses the fork boundary so
             # GC in the child doesn't keep parent-loop primitives or
             # the inherited socket FD alive. ``_pending_drain`` in
@@ -1311,7 +1332,7 @@ def _check_in_use(self) -> None:
         use after pool release, missing async context, wrong event
         loop, concurrent operation, or transaction owned by another
         task."""
-        if os.getpid() != self._creator_pid:
+        if _current_pid != self._creator_pid:
             raise InterfaceError(
                 "Connection used after fork; reconstruct from configuration in the target process."
             )

src/dqliteclient/pool.py

@@ -9,6 +9,7 @@
 from types import TracebackType
 from typing import Any, Final, NoReturn
 
+from dqliteclient import connection as _conn_mod
 from dqliteclient.cluster import ClusterClient
 from dqliteclient.connection import (
     _TRANSACTION_ROLLBACK_SQL,
@@ -327,7 +328,7 @@ async def initialize(self) -> None:
         (single digits) unless steady-state concurrency demands warm
         connections at engine startup.
         """
-        if os.getpid() != self._creator_pid:
+        if _conn_mod._current_pid != self._creator_pid:
             raise InterfaceError(
                 "Pool used after fork; reconstruct from configuration in the target process."
             )
@@ -679,7 +680,7 @@ async def _drain_remaining_after_cancel(self) -> None:
     @asynccontextmanager
     async def acquire(self) -> AsyncIterator[DqliteConnection]:
         """Acquire a connection from the pool."""
-        if os.getpid() != self._creator_pid:
+        if _conn_mod._current_pid != self._creator_pid:
             raise InterfaceError(
                 "Pool used after fork; reconstruct from configuration in the target process."
             )
@@ -1330,7 +1331,7 @@ async def close(self) -> None:
         # ``_close_done`` set but not yet ``set()``) does not block on
         # an Event bound to the parent's loop. Awaiting that Event in
         # the child's fresh loop hangs forever.
-        if os.getpid() != self._creator_pid:
+        if _conn_mod._current_pid != self._creator_pid:
             self._closed = True
             return
         if self._closed: