ka9q-python 3.15.1__tar.gz → 3.16.1__tar.gz

{ka9q_python-3.15.1 → ka9q_python-3.16.1}/CHANGELOG.md

@@ -1,5 +1,112 @@
 # Changelog
 
+## [3.16.1] - 2026-05-24
+
+### Fixed
+
+- **`ChannelInfo` anchor pair is now atomic** (`channel-info`).  Adds
+  `ChannelInfo.get_anchor()` / `update_anchor()` — a tuple-based
+  atomic snapshot of `(gps_time, rtp_timesnap)`.  `rtp_to_wallclock`
+  now reads the pair via `get_anchor` (single GIL-atomic attribute
+  access) instead of two separate reads; `StatusListener` writes via
+  `update_anchor` (single tuple assignment).
+
+  Why: the `StatusListener` introduced in 3.16.0 refreshes the anchor
+  in place at sub-second cadence (~450 ms on a busy host).  Direct
+  sequential reads of `channel.gps_time` followed by
+  `channel.rtp_timesnap` could land between the listener's two writes
+  and yield a torn pair off by one listener-cadence interval.
+  `rtp_to_wallclock` then returned a wall-time off by that much —
+  usually harmless, but consumers comparing against an external time
+  reference with a tight gate (e.g. hf-timestd's T5 LB-1421 NMEA
+  disambig at ±0.5 s) could be pushed across the threshold and fall
+  back to a chrony walk that itself fails during a post-restart
+  cascade.
+
+  Backward compatible: constructor kwargs (`gps_time=`,
+  `rtp_timesnap=`) and direct field reads are unchanged; consumers
+  that need the pair transactionally must call `get_anchor`.  Adds
+  5 new tests (atomic update, construction-time seed, mixed-None
+  handling, listener path, 50-iteration consistency smoke test).
+
+### Performance
+
+- **`RadiodStream`: `SO_RCVBUF` raised 0 → 64 MB** (`stream.py`).
+  Mirrors the 3.16.0-cycle `multi_stream.py` change on the
+  single-channel path.  Previously `RadiodStream` sockets fell back
+  to the kernel default (`rmem_default`, typically 16 MB on hosts
+  with sigmond's `rule_kernel_rcvbuf_adequate` provisioning) and were
+  vulnerable to GIL-stall packet loss with no other consumer competing
+  to drain the buffer.  64 MB matches the `MultiStream` cap; sigmond
+  provisions `net.core.rmem_max=128 MB` (after kernel doubling), so
+  the request is honored.  Observed on bee1 2026-05-23 closing a
+  140 ms-stall-induced `gap=13440` resequencer event on hf-timestd's
+  T6 dedicated stream.
+
+- **`MultiStream`: `SO_RCVBUF` raised 8 MB → 64 MB** (`multi_stream.py`).
+  Observed 412 M UDP `RcvbufErrors` on B4-100 since boot, driven by
+  GIL contention preventing Python receiver threads from draining the
+  kernel-doubled 16 MB sockets.  Bigger absorber → more headroom
+  across GIL stalls before packets are dropped.  After applying:
+  socket `rb` shows 134217728 (128 MB visible after kernel doubling)
+  and recv-Q sits at ~50 KB in steady state (was hitting 14 MB / 16
+  MB before).  Requires `net.core.rmem_max >= 64 MB` to be honored —
+  provisioned by sigmond in
+  `/etc/sysctl.d/99-wspr-recorder.conf` alongside this change.
+
+## [3.16.0] - 2026-05-23
+
+### Added
+
+- **`StatusListener` — continuous STATUS multicast listener.**  New
+  `ka9q.status_listener.StatusListener` class subscribes to radiod's
+  STATUS multicast (port 5006) in a background thread and refreshes
+  `ChannelInfo.gps_time` / `.rtp_timesnap` on every broadcast.  Replaces
+  the previous one-shot `discover_channels` anchor capture, which
+  froze the timing anchor at SSRC discovery — leaving `rtp_to_wallclock`
+  to project forward from a host-clock value that drifts at the
+  chrony slew rate (~3.8 µs/s on a typical disciplined host).
+
+  Mutates the registered `ChannelInfo` in place so callers holding a
+  reference (e.g. hf-timestd's cached `_t6_channel_info`) see fresh
+  values immediately.  Supports per-SSRC and wildcard callbacks for
+  explicit notification.  Uses `SO_REUSEPORT` so it can coexist with
+  `RadiodControl`'s own status socket without stealing tune/discover
+  responses — multicast packets are delivered to every joined socket.
+
+  Opt-in via `RadiodControl.start_status_listener()`; closing the
+  control object stops the listener.  See class docstring for usage.
+
+- **`RadiodControl.start_status_listener(...)` / `.stop_status_listener(...)`
+  / `.status_listener` property** — convenience wiring to attach a
+  `StatusListener` to an existing control session.  Listener is
+  stopped automatically by `RadiodControl.close()`.
+
+### Why this exists
+
+Before this release, every ka9q-python consumer (hf-timestd, codar,
+psk, hfdl, wspr, wsprdaemon-client, gpsdo-monitor) labeled data via
+`rtp_to_wallclock(rtp, channel)` with a ChannelInfo whose
+`gps_time`/`rtp_timesnap` were captured once at SSRC discovery.
+For long-running services this meant labels drifted from GPSDO truth
+at the host-clock slew rate — on bee1 (`chrony` slewing at
+~3.8 µs/s), labels accumulated ~330 ms of drift per day.
+
+The chrony SHM-push side of hf-timestd's BPSK PPS path (HPPS / HFPS)
+manifested this most visibly: TS-1 source reported tracking with
+1 ns standard deviation but drifted at the host slew rate, blocking
+DASI2 grant deployment.  Faster anchor refresh closes the drift.
+
+### Backwards compatibility
+
+- All existing tests pass unchanged.  The listener is **opt-in** —
+  consumers that don't call `start_status_listener()` see no behavior
+  change.
+- `ChannelInfo` is unchanged structurally; only its mutability
+  contract is clarified (the timing fields were always documented as
+  "the latest snapshot", which is now true continuously rather than
+  once).
+
 ## [3.15.1] - 2026-05-21
 
 ### Fixed

{ka9q_python-3.15.1/ka9q_python.egg-info → ka9q_python-3.16.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ka9q-python
-Version: 3.15.1
+Version: 3.16.1
 Summary: Python interface for ka9q-radio control and monitoring
 Home-page: https://github.com/mijahauan/ka9q-python
 Author: Michael Hauan AC0G

{ka9q_python-3.15.1 → ka9q_python-3.16.1}/ka9q/__init__.py

@@ -115,6 +115,7 @@ from .managed_stream import (
 )
 from .multi_stream import MultiStream
 from .spectrum_stream import SpectrumStream
+from .status_listener import StatusListener, StatusListenerStats
 
 __all__ = [
     # Control
@@ -178,6 +179,10 @@ __all__ = [
     # Spectrum Stream (FFT bin data receiver)
     'SpectrumStream',
 
+    # Continuous STATUS listener (live timing anchor refresh)
+    'StatusListener',
+    'StatusListenerStats',
+
     # Utilities
     'generate_multicast_ip',
     'ChannelMonitor',

{ka9q_python-3.15.1 → ka9q_python-3.16.1}/ka9q/control.py

@@ -682,6 +682,136 @@ def decode_socket(data: bytes, length: int) -> dict:
         return {'family': 'unknown', 'address': '', 'port': 0}
 
 
+def decode_status_dict(buffer: bytes) -> dict:
+    """Decode a radiod STATUS packet into a flat dictionary.
+
+    Standalone module-level decoder — does NOT require a RadiodControl
+    instance, so it's safe to call from contexts that should not open
+    a control socket (notably :class:`ka9q.status_listener.StatusListener`,
+    which would otherwise drag in a full control session just to parse
+    bytes).
+
+    Returns an empty dict for non-STATUS packets (first byte != 0).
+    Unknown TLV tags are silently skipped.
+
+    Used by :meth:`RadiodControl._decode_status_response` (which adds a
+    metric bump on top of the same parse) and by the status listener.
+    """
+    status: dict = {}
+
+    if len(buffer) == 0 or buffer[0] != 0:
+        return status  # Not a status response
+
+    cp = 1  # Skip packet type byte
+
+    while cp < len(buffer):
+        if cp >= len(buffer):
+            break
+
+        type_val = buffer[cp]
+        cp += 1
+
+        if type_val == StatusType.EOL:
+            break
+
+        if cp >= len(buffer):
+            break
+
+        optlen = buffer[cp]
+        cp += 1
+
+        # Handle extended length encoding
+        if optlen & 0x80:
+            length_of_length = optlen & 0x7f
+            optlen = 0
+            for _ in range(length_of_length):
+                if cp >= len(buffer):
+                    break
+                optlen = (optlen << 8) | buffer[cp]
+                cp += 1
+
+        if cp + optlen > len(buffer):
+            break
+
+        data = buffer[cp:cp + optlen]
+
+        # Decode based on type
+        if type_val == StatusType.COMMAND_TAG:
+            status['command_tag'] = decode_int32(data, optlen)
+        elif type_val == StatusType.GPS_TIME:
+            status['gps_time'] = decode_int64(data, optlen)
+        elif type_val == StatusType.RTP_TIMESNAP:
+            status['rtp_timesnap'] = decode_int32(data, optlen)
+        elif type_val == StatusType.RADIO_FREQUENCY:
+            status['frequency'] = decode_double(data, optlen)
+        elif type_val == StatusType.OUTPUT_SSRC:
+            status['ssrc'] = decode_int32(data, optlen)
+        elif type_val == StatusType.AGC_ENABLE:
+            status['agc_enable'] = decode_bool(data, optlen)
+        elif type_val == StatusType.GAIN:
+            status['gain'] = decode_float(data, optlen)
+        elif type_val == StatusType.RF_GAIN:
+            status['rf_gain'] = decode_float(data, optlen)
+        elif type_val == StatusType.RF_ATTEN:
+            status['rf_atten'] = decode_float(data, optlen)
+        elif type_val == StatusType.RF_AGC:
+            status['rf_agc'] = decode_int(data, optlen)
+        elif type_val == StatusType.PRESET:
+            status['preset'] = decode_string(data, optlen)
+        elif type_val == StatusType.LOW_EDGE:
+            status['low_edge'] = decode_float(data, optlen)
+        elif type_val == StatusType.HIGH_EDGE:
+            status['high_edge'] = decode_float(data, optlen)
+        elif type_val == StatusType.NOISE_DENSITY:
+            status['noise_density'] = decode_float(data, optlen)
+        elif type_val == StatusType.BASEBAND_POWER:
+            status['baseband_power'] = decode_float(data, optlen)
+        elif type_val == StatusType.OUTPUT_SAMPRATE:
+            status['sample_rate'] = decode_int(data, optlen)
+        elif type_val == StatusType.OUTPUT_ENCODING:
+            status['encoding'] = decode_int(data, optlen)
+        elif type_val == StatusType.OUTPUT_DATA_DEST_SOCKET:
+            status['destination'] = decode_socket(data, optlen)
+        elif type_val == StatusType.OUTPUT_TTL:
+            status['ttl'] = decode_int(data, optlen)
+            if status['ttl'] == 0:
+                logger.warning(
+                    f"Radiod reporting TTL=0 for SSRC "
+                    f"{status.get('ssrc', 'unknown')}: Multicast data "
+                    f"restricted to localhost loopback only!"
+                )
+        elif type_val == StatusType.LIFETIME:
+            status['lifetime'] = decode_int(data, optlen)
+        elif type_val == StatusType.DESCRIPTION:
+            status['description'] = decode_string(data, optlen)
+
+        cp += optlen
+
+    # Calculate SNR if we have the necessary data
+    if all(k in status for k in
+           ['baseband_power', 'low_edge', 'high_edge', 'noise_density']):
+        import math
+        bandwidth = abs(status['high_edge'] - status['low_edge'])
+
+        if bandwidth > 0:
+            try:
+                noise_power_db = (
+                    status['noise_density'] + 10 * math.log10(bandwidth)
+                )
+                signal_plus_noise_db = status['baseband_power']
+                noise_power = 10 ** (noise_power_db / 10)
+                signal_plus_noise = 10 ** (signal_plus_noise_db / 10)
+
+                if noise_power > 0:
+                    snr_linear = signal_plus_noise / noise_power - 1
+                    if snr_linear > 0:
+                        status['snr'] = 10 * math.log10(snr_linear)
+            except (ValueError, ZeroDivisionError, OverflowError):
+                pass
+
+    return status
+
+
 class RadiodControl:
     """
     Control interface for radiod
@@ -724,6 +854,10 @@ class RadiodControl:
         self._status_sock = None  # Cached status listener socket for tune()
         self._status_sock_lock = None  # Will be initialized when needed
         self._socket_lock = threading.RLock()  # Protect control socket operations
+
+        # Optional continuous STATUS listener (live timing anchor refresh).
+        # Lazily created by start_status_listener(); see ka9q.status_listener.
+        self._status_listener = None
         
         # Rate limiting
         self.max_commands_per_sec = max_commands_per_sec
@@ -1978,127 +2112,25 @@ class RadiodControl:
     
     def _decode_status_response(self, buffer: bytes) -> dict:
         """
-        Decode a status response packet from radiod
-        
+        Decode a status response packet from radiod (thin wrapper).
+
+        Delegates the actual parse to the module-level
+        :func:`decode_status_dict` and bumps the per-instance metric.
+        Kept as a method for backward compatibility with callers that
+        already use ``self._decode_status_response`` (e.g.
+        ``listen_status``, ``tune``).
+
         Args:
             buffer: Raw response bytes
-            
+
         Returns:
             Dictionary containing decoded status fields
         """
-        status = {}
-        
-        if len(buffer) == 0 or buffer[0] != 0:
-            return status  # Not a status response
-        
-        cp = 1  # Skip packet type byte
-        
-        while cp < len(buffer):
-            if cp >= len(buffer):
-                break
-            
-            type_val = buffer[cp]
-            cp += 1
-            
-            if type_val == StatusType.EOL:
-                break
-            
-            if cp >= len(buffer):
-                break
-            
-            optlen = buffer[cp]
-            cp += 1
-            
-            # Handle extended length encoding
-            if optlen & 0x80:
-                length_of_length = optlen & 0x7f
-                optlen = 0
-                for _ in range(length_of_length):
-                    if cp >= len(buffer):
-                        break
-                    optlen = (optlen << 8) | buffer[cp]
-                    cp += 1
-            
-            if cp + optlen > len(buffer):
-                break
-            
-            data = buffer[cp:cp + optlen]
-            
-            # Decode based on type
-            if type_val == StatusType.COMMAND_TAG:
-                status['command_tag'] = decode_int32(data, optlen)
-            elif type_val == StatusType.GPS_TIME:
-                status['gps_time'] = decode_int64(data, optlen)
-            elif type_val == StatusType.RTP_TIMESNAP:
-                status['rtp_timesnap'] = decode_int32(data, optlen)
-            elif type_val == StatusType.RADIO_FREQUENCY:
-                status['frequency'] = decode_double(data, optlen)
-            elif type_val == StatusType.OUTPUT_SSRC:
-                status['ssrc'] = decode_int32(data, optlen)
-            elif type_val == StatusType.AGC_ENABLE:
-                status['agc_enable'] = decode_bool(data, optlen)
-            elif type_val == StatusType.GAIN:
-                status['gain'] = decode_float(data, optlen)
-            elif type_val == StatusType.RF_GAIN:
-                status['rf_gain'] = decode_float(data, optlen)
-            elif type_val == StatusType.RF_ATTEN:
-                status['rf_atten'] = decode_float(data, optlen)
-            elif type_val == StatusType.RF_AGC:
-                status['rf_agc'] = decode_int(data, optlen)
-            elif type_val == StatusType.PRESET:
-                status['preset'] = decode_string(data, optlen)
-            elif type_val == StatusType.LOW_EDGE:
-                status['low_edge'] = decode_float(data, optlen)
-            elif type_val == StatusType.HIGH_EDGE:
-                status['high_edge'] = decode_float(data, optlen)
-            elif type_val == StatusType.NOISE_DENSITY:
-                status['noise_density'] = decode_float(data, optlen)
-            elif type_val == StatusType.BASEBAND_POWER:
-                status['baseband_power'] = decode_float(data, optlen)
-            elif type_val == StatusType.OUTPUT_SAMPRATE:
-                status['sample_rate'] = decode_int(data, optlen)
-            elif type_val == StatusType.OUTPUT_ENCODING:
-                status['encoding'] = decode_int(data, optlen)
-            elif type_val == StatusType.OUTPUT_DATA_DEST_SOCKET:
-                status['destination'] = decode_socket(data, optlen)
-            elif type_val == StatusType.OUTPUT_TTL:
-                status['ttl'] = decode_int(data, optlen)
-                if status['ttl'] == 0:
-                    logger.warning(f"Radiod reporting TTL=0 for SSRC {status.get('ssrc', 'unknown')}: Multicast data restricted to localhost loopback only!")
-            elif type_val == StatusType.LIFETIME:
-                status['lifetime'] = decode_int(data, optlen)
-            elif type_val == StatusType.DESCRIPTION:
-                status['description'] = decode_string(data, optlen)
-
-            cp += optlen
-        
-        # Calculate SNR if we have the necessary data
-        if all(k in status for k in ['baseband_power', 'low_edge', 'high_edge', 'noise_density']):
-            import math
-            bandwidth = abs(status['high_edge'] - status['low_edge'])
-            
-            # Guard against invalid bandwidth
-            if bandwidth > 0:
-                try:
-                    noise_power_db = status['noise_density'] + 10 * math.log10(bandwidth)
-                    signal_plus_noise_db = status['baseband_power']
-                    # Convert to linear, calculate SNR, convert back to dB
-                    noise_power = 10 ** (noise_power_db / 10)
-                    signal_plus_noise = 10 ** (signal_plus_noise_db / 10)
-                    
-                    # Guard against division by zero
-                    if noise_power > 0:
-                        snr_linear = signal_plus_noise / noise_power - 1
-                        if snr_linear > 0:
-                            status['snr'] = 10 * math.log10(snr_linear)
-                except (ValueError, ZeroDivisionError, OverflowError):
-                    # SNR calculation failed, skip it
-                    pass
-        
-        # Track status received
-        self.metrics.status_received += 1
+        status = decode_status_dict(buffer)
+        if status:
+            self.metrics.status_received += 1
         return status
-    
+
     def get_metrics(self) -> dict:
         """
         Get current metrics as a dictionary
@@ -2982,14 +3014,67 @@ class RadiodControl:
             except Exception as exc:
                 logger.warning(f"listen_status callback raised: {exc}")
 
+    # ── Continuous STATUS listener (v3.16.0+) ──────────────────────
+
+    @property
+    def status_listener(self):
+        """The continuous STATUS listener, or ``None`` if not started.
+
+        Created lazily by :py:meth:`start_status_listener`.  See
+        :py:class:`ka9q.status_listener.StatusListener` for usage —
+        register channels and callbacks via that object directly.
+        """
+        return self._status_listener
+
+    def start_status_listener(self, socket_timeout: float = 0.5):
+        """Start a continuous STATUS multicast listener (idempotent).
+
+        Spawns a background thread that subscribes to radiod's STATUS
+        multicast and refreshes the ``gps_time``/``rtp_timesnap`` anchor
+        on every broadcast for all channels registered via
+        :py:meth:`StatusListener.register_channel`.
+
+        Returns the :py:class:`StatusListener` instance.
+
+        See :py:class:`ka9q.status_listener.StatusListener` for full
+        usage, including per-SSRC callbacks.
+
+        Closing the :py:class:`RadiodControl` (via :py:meth:`close` or
+        the context manager) stops the listener.
+        """
+        from .status_listener import StatusListener
+        if self._status_listener is None:
+            self._status_listener = StatusListener(
+                status_address=self.status_address,
+                interface=self.interface,
+                socket_timeout=socket_timeout,
+            )
+        if not self._status_listener.running:
+            self._status_listener.start()
+        return self._status_listener
+
+    def stop_status_listener(self, timeout: float = 2.0):
+        """Stop the continuous STATUS listener, if running."""
+        if self._status_listener is not None:
+            self._status_listener.stop(timeout=timeout)
+
     def close(self):
         """
         Close all sockets with proper error handling
-        
+
         This method is safe to call multiple times and handles errors gracefully.
         """
         errors = []
-        
+
+        # Stop continuous STATUS listener if running
+        if self._status_listener is not None:
+            try:
+                self._status_listener.stop()
+            except Exception as e:
+                errors.append(f"status listener: {e}")
+            finally:
+                self._status_listener = None
+
         # Close control socket
         if self.socket:
             try:

{ka9q_python-3.15.1 → ka9q_python-3.16.1}/ka9q/discovery.py

@@ -22,7 +22,32 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class ChannelInfo:
-    """Information about a ka9q-radio channel"""
+    """Information about a ka9q-radio channel.
+
+    Timing anchor atomicity
+    -----------------------
+    ``gps_time`` and ``rtp_timesnap`` form a paired anchor — they were
+    captured at the same instant by radiod and only make sense together.
+    Reading them as separate attributes is **not atomic**: under
+    concurrent modification (e.g. the
+    :py:class:`ka9q.status_listener.StatusListener` background thread
+    updating both fields on every STATUS broadcast), a consumer that
+    reads ``gps_time`` then ``rtp_timesnap`` can land between the two
+    writes and get a torn pair.
+
+    For ``rtp_to_wallclock`` and other consumers that compare absolute
+    time against an external reference (where torn-pair errors of up to
+    the listener cadence — typically ~450 ms — exceed downstream gates),
+    use :py:meth:`get_anchor` to obtain a consistent snapshot, or have
+    the listener call :py:meth:`update_anchor` instead of mutating the
+    individual fields.  Both rely on Python's GIL making single attribute
+    access atomic — the snapshot is stored in ``_anchor_pair`` as a
+    single tuple, written and read in one bytecode each.
+
+    Direct reads of ``ci.gps_time`` and ``ci.rtp_timesnap`` remain valid
+    for non-paired uses (diagnostic logging, schema introspection); the
+    tear risk only matters when both are consumed transactionally.
+    """
     ssrc: int
     preset: str
     sample_rate: int
@@ -35,6 +60,66 @@ class ChannelInfo:
     encoding: int = 0  # stream encoding (0=none, 4=F32, etc)
     chain_delay_correction_ns: Optional[int] = None  # L6 BPSK PPS chain-delay calibration (nanoseconds)
 
+    def __post_init__(self):
+        # Seed the atomic-pair snapshot from the constructor args if both
+        # were provided.  Lets ``get_anchor`` return the construction-time
+        # pair before any ``update_anchor`` call has happened.
+        if self.gps_time is not None and self.rtp_timesnap is not None:
+            self._anchor_pair = (self.gps_time, self.rtp_timesnap)
+        else:
+            self._anchor_pair = None
+
+    def get_anchor(self) -> Optional[Tuple[Optional[int], Optional[int]]]:
+        """Return the ``(gps_time, rtp_timesnap)`` anchor as a single
+        atomic snapshot.
+
+        Reads a single attribute (``_anchor_pair``) — GIL-atomic, so the
+        returned tuple is always internally consistent, never torn.
+        Returns ``None`` if the anchor has not been set.
+
+        Use this from :py:func:`rtp_to_wallclock` and any other code
+        path that consumes both fields transactionally.  Direct reads
+        of ``self.gps_time`` / ``self.rtp_timesnap`` are still permitted
+        for non-paired uses but should not be combined when consistency
+        matters.
+        """
+        # Single attribute read — atomic under the GIL.
+        pair = getattr(self, '_anchor_pair', None)
+        if pair is not None:
+            return pair
+        # Backward compat fallback: synthesize from the legacy fields.
+        # Only happens when ``_anchor_pair`` was never initialised (e.g.
+        # for ChannelInfo objects constructed via __new__ in test setups).
+        gps = self.gps_time
+        rtp = self.rtp_timesnap
+        if gps is None or rtp is None:
+            return None
+        return (gps, rtp)
+
+    def update_anchor(self, gps_time: int, rtp_timesnap: int) -> None:
+        """Atomically update the ``(gps_time, rtp_timesnap)`` anchor pair.
+
+        Writes a single tuple attribute (``_anchor_pair``) — GIL-atomic.
+        Readers using :py:meth:`get_anchor` see either the old pair or
+        the new pair, never a torn combination.
+
+        Also updates the legacy ``gps_time`` and ``rtp_timesnap`` fields
+        for backward compatibility with code that reads them directly.
+        Those updates can still tear if read as a pair without
+        ``get_anchor`` — that's why the pair lives in
+        ``_anchor_pair``.  Tuple is written first so the atomic snapshot
+        is the leading edge of any state change.
+        """
+        # Atomic pair first — this is the source of truth for
+        # transactional readers.
+        self._anchor_pair = (gps_time, rtp_timesnap)
+        # Legacy field mirrors for backward compat.  Order doesn't
+        # matter for the atomic story (consumers that need both should
+        # use get_anchor); we update them so diagnostic code that reads
+        # ``.gps_time`` directly sees the current value.
+        self.gps_time = gps_time
+        self.rtp_timesnap = rtp_timesnap
+
 
 def _create_status_listener_socket(multicast_addr: str, interface: Optional[str] = None) -> socket.socket:
     """

{ka9q_python-3.15.1 → ka9q_python-3.16.1}/ka9q/multi_stream.py

@@ -326,9 +326,14 @@ class MultiStream:
             except OSError:
                 pass
 
-        # Large receive buffer for multi-channel throughput
+        # Large receive buffer for multi-channel throughput.
+        # Bumped from 8 MB → 64 MB on 2026-05-23 after observing 412M
+        # UDP RcvbufErrors on B4-100 with sustained GIL stalls.  Kernel
+        # doubles for bookkeeping → 128 MB visible in ``ss -m``.  Honored
+        # only if ``net.core.rmem_max >= 64 MB``; sigmond provisions
+        # 128 MB in /etc/sysctl.d/99-wspr-recorder.conf.
         try:
-            sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 8 * 1024 * 1024)
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 64 * 1024 * 1024)
         except OSError:
             pass
 

{ka9q_python-3.15.1 → ka9q_python-3.16.1}/ka9q/rtp_recorder.py

@@ -171,18 +171,30 @@ def rtp_to_wallclock(
         SHM samples stuck at the snapshot's wall-clock time, ~12.4 h
         behind.  Chrony filtered every sample and reach fell to 0.
     """
-    if channel.gps_time is None or channel.rtp_timesnap is None:
+    # Read the (gps_time, rtp_timesnap) anchor as a single atomic
+    # snapshot.  This matters when a background StatusListener (v3.16.0+)
+    # is mutating the anchor concurrently: separate reads of
+    # ``channel.gps_time`` and ``channel.rtp_timesnap`` could land
+    # either side of an update and yield a torn pair off by up to one
+    # listener-cadence interval (typically ~450 ms on bee1).  The
+    # tuple lives in ``_anchor_pair``, a single GIL-atomic attribute.
+    # See ChannelInfo.get_anchor() docstring for the full story.
+    anchor = channel.get_anchor()
+    if anchor is None:
+        return None
+    gps_time, rtp_timesnap = anchor
+    if gps_time is None or rtp_timesnap is None:
         return None
 
     # Convert GPS nanoseconds to Unix time
     # GPS epoch is Jan 6, 1980; Unix epoch is Jan 1, 1970
     # gps_time is nanoseconds since GPS epoch, so add GPS_UTC_OFFSET (in ns)
     # AND subtract current GPS_LEAP_SECONDS (18s) to align with UTC
-    sender_time = channel.gps_time + BILLION * (GPS_UTC_OFFSET - GPS_LEAP_SECONDS)
+    sender_time = gps_time + BILLION * (GPS_UTC_OFFSET - GPS_LEAP_SECONDS)
 
     # Signed 32-bit RTP delta — correct within ±2**31 samples of
     # the snapshot.
-    rtp_delta = int((rtp_timestamp - channel.rtp_timesnap) & 0xFFFFFFFF)
+    rtp_delta = int((rtp_timestamp - rtp_timesnap) & 0xFFFFFFFF)
     if rtp_delta > 0x7FFFFFFF:
         rtp_delta -= 0x100000000