slick-stream-buffer-multiplexer-py 2.2.0__tar.gz → 2.2.0.post1__tar.gz

{slick_stream_buffer_multiplexer_py-2.2.0 → slick_stream_buffer_multiplexer_py-2.2.0.post1}/API_DIFFERENCES.md

@@ -182,3 +182,9 @@ Python adds explicit lifecycle management that C++ handles via RAII:
 `remove(name)` is the one lifecycle call both sides share, with the same contract: unlink a
 segment by name without attaching to it, returning `True` on success and, on Windows, always
 `True` because a section dies with its last handle.
+
+Neither side deletes a segment on its own: not the C++ destructors (since v2.1.0), and not
+Python's `close()`, context manager or process exit. Python's dependencies keep their segments out
+of `multiprocessing`'s resource tracker for this, which would otherwise unlink them when the
+process exits. Each inner ring's own `remove_shm()` is reachable on both sides, through
+`stream_buffer` / `queue` in Python and `stream_buffer()` / `queue()` in C++.

{slick_stream_buffer_multiplexer_py-2.2.0 → slick_stream_buffer_multiplexer_py-2.2.0.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slick-stream-buffer-multiplexer-py
-Version: 2.2.0
+Version: 2.2.0.post1
 Summary: Lock-free MPMC byte stream multiplexer with C++ interoperability via shared memory
 Home-page: https://github.com/SlickQuant/slick-stream-buffer-multiplexer-py
 Author: Slick Quant
@@ -28,8 +28,8 @@ Classifier: Operating System :: MacOS
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: slick-queue-py>=2.1.0
-Requires-Dist: slick-stream-buffer-py>=2.0.0
+Requires-Dist: slick-queue-py>=2.3.0
+Requires-Dist: slick-stream-buffer-py>=2.1.0
 Dynamic: author
 Dynamic: home-page
 Dynamic: license-file
@@ -46,7 +46,7 @@ every peer of a shared queue agrees on `enable_read_last` (see
 [`enable_read_last` must match on every peer](#enable_read_last-must-match-on-every-peer)).
 
 Tracks C++ `slick/stream_buffer_multiplexer.hpp` **v2.2.0**, and requires slick-queue-py >=
-2.1.0 and slick-stream-buffer-py >= 2.0.0. The shared-memory formats are unchanged
+2.3.0 and slick-stream-buffer-py >= 2.1.0. The shared-memory formats are unchanged
 (`'SLQ1'` / `'SSB1'`), so segments written by v0.1.0 or by a C++ v1.x process are still
 readable with the default traits.
 
@@ -84,9 +84,10 @@ records referencing other producer ids are silently skipped (not counted as loss
 ## Requirements
 
 - Python 3.8+
-- [slick-queue-py](https://github.com/SlickQuant/slick-queue-py) >= 2.1.0 (queue producers need
-  its `items_per_slot`)
-- [slick-stream-buffer-py](https://github.com/SlickQuant/slick-stream-buffer-py) >= 2.0.0
+- [slick-queue-py](https://github.com/SlickQuant/slick-queue-py) >= 2.3.0 (queue producers need
+  its `items_per_slot`; 2.3.0 is the release whose segments outlive their creator)
+- [slick-stream-buffer-py](https://github.com/SlickQuant/slick-stream-buffer-py) >= 2.1.0 (likewise
+  for segment lifetime - see [Segment lifetime](#segment-lifetime))
 
 Both dependencies bundle a small C++ extension for `std::atomic` operations; this package itself
 is pure Python.
@@ -178,6 +179,8 @@ accessors return `None` for the other kind's ids.
 from slick_stream_buffer_multiplexer_py import AtomicCursor
 from multiprocessing.shared_memory import SharedMemory
 
+# On Python 3.13+ add track=False, or the resource tracker unlinks the cursor's
+# segment when this process exits - see Segment lifetime
 cursor_shm = SharedMemory(name="mux_cursor", create=True, size=8)
 shared_cursor = AtomicCursor(cursor_shm.buf, 0)
 
@@ -288,28 +291,53 @@ inner_loss = sum(p.loss_count() for p in mux.get_producer_buffers().values())
 queues = {pid: p.size for pid, p in mux.get_producer_queues().items()}
 ```
 
-## Shutdown
+## Segment lifetime
 
-Close every handle, then unlink once — the usual `shared_memory` idiom:
+Closing a multiplexer or a producer handle, leaving a `with` block, or exiting the process never
+deletes a shared-memory segment - not even one this process created - matching C++ v2.1.0 and
+later. On POSIX a name therefore stays in `/dev/shm` until it is removed explicitly, and a creator
+that finds it attaches to the existing segment instead of starting fresh: the shared record queue
+still holds its records, a producer's `own_buffer` is `False` - for either kind of producer - and a
+creator passing a different geometry raises. That is what lets a restarted producer rejoin
+consumers that are still attached.
+
+slick-queue-py (2.3.0+) and slick-stream-buffer-py (2.1.0+) keep their segments out of
+`multiprocessing`'s resource tracker for this, since it would otherwise unlink them when the
+process exits - before Python 3.13, even in a process that only attached. A `SharedMemory` your own
+code opens, such as one holding an `AtomicCursor`, is still tracked unless you pass `track=False`.
+
+Whichever process coordinates the lifetime deletes the segments - at shutdown once no peer will
+attach again, by closing every handle and then unlinking once (the usual `shared_memory` idiom):
 
 ```python
 mux.close()      # or leave a `with StreamBufferMultiplexer(...) as mux:` block
 mux.unlink()     # deletes the record queue and every registered producer's segment, both kinds
 ```
 
-`close()` keeps the registration table so `unlink()` can still reach each producer's segment, and
-`unlink()` runs once: repeating it never deletes a segment a later run has created under the same
-name. On Windows `unlink()` is a no-op — a section disappears once its last handle closes.
+or at startup, by name, for a clean start (see below). `close()` keeps the registration table so
+`unlink()` can still reach each producer's segment, and `unlink()` runs once: repeating it never
+deletes a segment a later run has created under the same name. On Windows `unlink()` is a no-op —
+a section disappears once its last handle closes.
+
+> **Upgrading from 2.0.** Before slick-queue-py 2.3.0 and slick-stream-buffer-py 2.1.0, a segment
+> on POSIX was unlinked by the resource tracker when the process that created it exited - and,
+> before Python 3.13, when any process that attached to it did. A producer that exited first
+> therefore orphaned every consumer still attached. Code that relied on that cleanup now leaves
+> segments behind and attaches to them on its next run - call `unlink()` at shutdown or
+> `remove(name)` at startup.
 
-## Stale-segment recovery
+## Removing segments by name
 
-`StreamBufferMultiplexer.remove(name)` unlinks a segment by name — it works for every kind this
-class creates, a shared record queue's, a producer stream buffer's and a producer queue's, since
-all are plain shared memory segments underneath. Use it when a previous run died mid-initialization and left a
-segment wedged, which construction over that name reports by raising:
+`StreamBufferMultiplexer.remove(name)` unlinks a segment by name without attaching to it — it
+works for every kind this class creates, a shared record queue's, a producer stream buffer's and a
+producer queue's, since all are plain shared memory segments underneath. Use it at startup for a
+clean start, and to clear a segment a previous run left wedged by dying mid-initialization, which
+construction over that name reports by raising:
 
 ```python
-StreamBufferMultiplexer.remove("md_records")        # clear what a dead run left
+StreamBufferMultiplexer.remove("md_records")        # shared record queue
+StreamBufferMultiplexer.remove("md_p0")             # a producer's stream buffer
+StreamBufferMultiplexer.remove("md_q2")             # a producer's queue
 mux = StreamBufferMultiplexer(shared_queue_size=1024, name="md_records")
 ```
 

{slick_stream_buffer_multiplexer_py-2.2.0 → slick_stream_buffer_multiplexer_py-2.2.0.post1}/README.md

@@ -9,7 +9,7 @@ every peer of a shared queue agrees on `enable_read_last` (see
 [`enable_read_last` must match on every peer](#enable_read_last-must-match-on-every-peer)).
 
 Tracks C++ `slick/stream_buffer_multiplexer.hpp` **v2.2.0**, and requires slick-queue-py >=
-2.1.0 and slick-stream-buffer-py >= 2.0.0. The shared-memory formats are unchanged
+2.3.0 and slick-stream-buffer-py >= 2.1.0. The shared-memory formats are unchanged
 (`'SLQ1'` / `'SSB1'`), so segments written by v0.1.0 or by a C++ v1.x process are still
 readable with the default traits.
 
@@ -47,9 +47,10 @@ records referencing other producer ids are silently skipped (not counted as loss
 ## Requirements
 
 - Python 3.8+
-- [slick-queue-py](https://github.com/SlickQuant/slick-queue-py) >= 2.1.0 (queue producers need
-  its `items_per_slot`)
-- [slick-stream-buffer-py](https://github.com/SlickQuant/slick-stream-buffer-py) >= 2.0.0
+- [slick-queue-py](https://github.com/SlickQuant/slick-queue-py) >= 2.3.0 (queue producers need
+  its `items_per_slot`; 2.3.0 is the release whose segments outlive their creator)
+- [slick-stream-buffer-py](https://github.com/SlickQuant/slick-stream-buffer-py) >= 2.1.0 (likewise
+  for segment lifetime - see [Segment lifetime](#segment-lifetime))
 
 Both dependencies bundle a small C++ extension for `std::atomic` operations; this package itself
 is pure Python.
@@ -141,6 +142,8 @@ accessors return `None` for the other kind's ids.
 from slick_stream_buffer_multiplexer_py import AtomicCursor
 from multiprocessing.shared_memory import SharedMemory
 
+# On Python 3.13+ add track=False, or the resource tracker unlinks the cursor's
+# segment when this process exits - see Segment lifetime
 cursor_shm = SharedMemory(name="mux_cursor", create=True, size=8)
 shared_cursor = AtomicCursor(cursor_shm.buf, 0)
 
@@ -251,28 +254,53 @@ inner_loss = sum(p.loss_count() for p in mux.get_producer_buffers().values())
 queues = {pid: p.size for pid, p in mux.get_producer_queues().items()}
 ```
 
-## Shutdown
+## Segment lifetime
 
-Close every handle, then unlink once — the usual `shared_memory` idiom:
+Closing a multiplexer or a producer handle, leaving a `with` block, or exiting the process never
+deletes a shared-memory segment - not even one this process created - matching C++ v2.1.0 and
+later. On POSIX a name therefore stays in `/dev/shm` until it is removed explicitly, and a creator
+that finds it attaches to the existing segment instead of starting fresh: the shared record queue
+still holds its records, a producer's `own_buffer` is `False` - for either kind of producer - and a
+creator passing a different geometry raises. That is what lets a restarted producer rejoin
+consumers that are still attached.
+
+slick-queue-py (2.3.0+) and slick-stream-buffer-py (2.1.0+) keep their segments out of
+`multiprocessing`'s resource tracker for this, since it would otherwise unlink them when the
+process exits - before Python 3.13, even in a process that only attached. A `SharedMemory` your own
+code opens, such as one holding an `AtomicCursor`, is still tracked unless you pass `track=False`.
+
+Whichever process coordinates the lifetime deletes the segments - at shutdown once no peer will
+attach again, by closing every handle and then unlinking once (the usual `shared_memory` idiom):
 
 ```python
 mux.close()      # or leave a `with StreamBufferMultiplexer(...) as mux:` block
 mux.unlink()     # deletes the record queue and every registered producer's segment, both kinds
 ```
 
-`close()` keeps the registration table so `unlink()` can still reach each producer's segment, and
-`unlink()` runs once: repeating it never deletes a segment a later run has created under the same
-name. On Windows `unlink()` is a no-op — a section disappears once its last handle closes.
+or at startup, by name, for a clean start (see below). `close()` keeps the registration table so
+`unlink()` can still reach each producer's segment, and `unlink()` runs once: repeating it never
+deletes a segment a later run has created under the same name. On Windows `unlink()` is a no-op —
+a section disappears once its last handle closes.
+
+> **Upgrading from 2.0.** Before slick-queue-py 2.3.0 and slick-stream-buffer-py 2.1.0, a segment
+> on POSIX was unlinked by the resource tracker when the process that created it exited - and,
+> before Python 3.13, when any process that attached to it did. A producer that exited first
+> therefore orphaned every consumer still attached. Code that relied on that cleanup now leaves
+> segments behind and attaches to them on its next run - call `unlink()` at shutdown or
+> `remove(name)` at startup.
 
-## Stale-segment recovery
+## Removing segments by name
 
-`StreamBufferMultiplexer.remove(name)` unlinks a segment by name — it works for every kind this
-class creates, a shared record queue's, a producer stream buffer's and a producer queue's, since
-all are plain shared memory segments underneath. Use it when a previous run died mid-initialization and left a
-segment wedged, which construction over that name reports by raising:
+`StreamBufferMultiplexer.remove(name)` unlinks a segment by name without attaching to it — it
+works for every kind this class creates, a shared record queue's, a producer stream buffer's and a
+producer queue's, since all are plain shared memory segments underneath. Use it at startup for a
+clean start, and to clear a segment a previous run left wedged by dying mid-initialization, which
+construction over that name reports by raising:
 
 ```python
-StreamBufferMultiplexer.remove("md_records")        # clear what a dead run left
+StreamBufferMultiplexer.remove("md_records")        # shared record queue
+StreamBufferMultiplexer.remove("md_p0")             # a producer's stream buffer
+StreamBufferMultiplexer.remove("md_q2")             # a producer's queue
 mux = StreamBufferMultiplexer(shared_queue_size=1024, name="md_records")
 ```
 

{slick_stream_buffer_multiplexer_py-2.2.0 → slick_stream_buffer_multiplexer_py-2.2.0.post1}/pyproject.toml

@@ -30,8 +30,8 @@ classifiers = [
     "Operating System :: MacOS",
 ]
 dependencies = [
-    "slick-queue-py>=2.1.0",
-    "slick-stream-buffer-py>=2.0.0",
+    "slick-queue-py>=2.3.0",
+    "slick-stream-buffer-py>=2.1.0",
 ]
 
 [project.urls]

{slick_stream_buffer_multiplexer_py-2.2.0 → slick_stream_buffer_multiplexer_py-2.2.0.post1}/requirements.txt

@@ -1,3 +1,3 @@
 # Runtime dependencies (binary-compatible Python ports of the C++ dependencies)
-slick-queue-py>=2.1.0
-slick-stream-buffer-py>=2.0.0
+slick-queue-py>=2.3.0
+slick-stream-buffer-py>=2.1.0

{slick_stream_buffer_multiplexer_py-2.2.0 → slick_stream_buffer_multiplexer_py-2.2.0.post1}/setup.py

@@ -52,8 +52,8 @@ setup(
     keywords='stream-buffer, multiplexer, lock-free, atomic, shared-memory, ipc, multiprocessing, mpmc',
     py_modules=['slick_stream_buffer_multiplexer_py'],
     install_requires=[
-        'slick-queue-py>=2.1.0',
-        'slick-stream-buffer-py>=2.0.0',
+        'slick-queue-py>=2.3.0',
+        'slick-stream-buffer-py>=2.1.0',
     ],
     python_requires='>=3.8',
     license='MIT',

{slick_stream_buffer_multiplexer_py-2.2.0 → slick_stream_buffer_multiplexer_py-2.2.0.post1}/slick_stream_buffer_multiplexer_py.py

@@ -76,10 +76,16 @@ Caveats (same as C++):
   propagated from SlickStreamBuffer.consume() before any state moves - so
   nothing is published to either the producer's ring or the shared record
   queue. A queue message is limited to the queue's size by SlickQueue.reserve().
+- No segment is ever unlinked on its own - not by close(), the context
+  manager or process exit, including through multiprocessing's resource
+  tracker, which slick-queue-py and slick-stream-buffer-py keep their segments
+  out of. A restarted producer therefore reattaches to the segments its
+  consumers still map. The coordinating process deletes them with unlink() or
+  remove(name).
 """
 from __future__ import annotations
 
-__version__ = '2.2.0'
+__version__ = '2.2.0.post1'
 
 import enum
 import operator
@@ -350,11 +356,6 @@ class ProducerQueue(_Producer):
         # items_per_slot - 1, for _dereference(): read() advances a cursor by the
         # whole reservation, which is the message length rounded up to this.
         self._item_mask = queue.items_per_slot - 1
-        # the queue's SharedMemory, held for unlink() for the same reason the
-        # multiplexer holds its record queue's: SlickQueue.close() drops its own
-        # handle, after which SlickQueue.unlink() silently does nothing. None for
-        # local memory.
-        self._shm = getattr(queue, '_shm', None)
 
     # ------------------------------------------------------------------
     # Producer side (any number of threads) - forwards to the inner queue
@@ -457,15 +458,11 @@ class ProducerQueue(_Producer):
 
     def unlink(self) -> None:
         """Unlink (delete) the underlying shared memory segment, if any. Valid
-        before or after close(), and a no-op when repeated."""
-        shm = self._shm
-        if shm is None:
-            return
-        self._shm = None  # unlink once, however many times this is called
-        try:
-            shm.unlink()
-        except Exception:
-            pass
+        before or after close(), and a no-op when repeated (see
+        SlickQueue.unlink()). The once-only guard lives on the queue, so an
+        adopted queue registered with several multiplexers is still unlinked
+        once."""
+        self._queue.unlink()
 
     def _dereference(self, sequence: int) -> MultiplexRecord:
         """Dereference a shared-queue record into this producer's queue. Falsy
@@ -552,10 +549,6 @@ class StreamBufferMultiplexer:
                 raise ValueError("shared_queue_size or name must be provided")
             self._shared_queue = SlickQueue(name=name, element_size=RECORD_SIZE,
                                             traits=traits)
-        # the queue's SharedMemory, held for unlink(): SlickQueue.close() drops
-        # its own handle, after which SlickQueue.unlink() silently does nothing -
-        # yet close-then-unlink is the documented order. None for local memory.
-        self._shared_queue_shm = getattr(self._shared_queue, '_shm', None)
 
         # One table per kind - what get_producer_buffers() / get_producer_queues()
         # hand out - plus one of every producer for read(), the counterpart of the
@@ -586,15 +579,21 @@ class StreamBufferMultiplexer:
 
     @staticmethod
     def remove(name: str) -> bool:
-        """Remove a shared memory segment by name, the stale-segment recovery step.
+        """Remove a shared memory segment by name: the explicit cleanup step, and
+        the stale-segment recovery step.
 
         Applies to every kind of name this class creates - a shared record
         queue's, a producer stream buffer's and a producer queue's - since all
-        are plain shared memory segments underneath. Use it when a previous run died
-        mid-initialization and left a segment wedged, which construction over
-        that name reports by raising::
-
-            StreamBufferMultiplexer.remove("md_records")   # clear a dead run
+        are plain shared memory segments underneath. Nothing unlinks a segment
+        on close() or process exit, so on POSIX a name outlives every process
+        that used it and the next creator attaches to it instead of starting
+        fresh. Call this from whichever process coordinates the lifetime: at
+        startup for a clean start, or at shutdown once no peer will attach
+        again. It also clears a segment a previous run left wedged by dying
+        mid-initialization, which construction over that name reports by
+        raising::
+
+            StreamBufferMultiplexer.remove("md_records")   # clear what the last run left
             mux = StreamBufferMultiplexer(shared_queue_size=1024, name="md_records")
 
         Returns:
@@ -845,6 +844,10 @@ class StreamBufferMultiplexer:
         """Unlink (delete) the shared record queue segment and all registered
         producers' segments, of both kinds.
 
+        No multiplexer does this on its own - not close(), not the context
+        manager and not process exit, as in C++ - so call it from the process
+        that coordinates the segments' lifetime, once no peer will attach again.
+
         Valid before or after close(); the documented order is the
         ``shared_memory`` idiom - close every handle, then unlink once. Deleting
         a name never touches mappings that already exist. Unlinking twice is a
@@ -856,12 +859,8 @@ class StreamBufferMultiplexer:
                 producer.unlink()  # by saved name, once - valid after close()
             except Exception:
                 pass
-        shm = self._shared_queue_shm
-        if shm is None:
-            return
-        self._shared_queue_shm = None  # unlink once, however many times this is called
         try:
-            shm.unlink()
+            self._shared_queue.unlink()  # likewise
         except Exception:
             pass
 

{slick_stream_buffer_multiplexer_py-2.2.0 → slick_stream_buffer_multiplexer_py-2.2.0.post1}/tests/test_multiplexer_shm.py

@@ -521,6 +521,147 @@ def test_shm_unlink_after_close_covers_queue_producers():
             successor.unlink()
 
 
+# ---------------------------------------------------------------------------
+# Segment lifetime: nothing unlinks a segment on its own (C++ v2.1.0+)
+# ---------------------------------------------------------------------------
+
+def _remove_all(names) -> None:
+    for n in names:
+        StreamBufferMultiplexer.remove(n)
+
+
+def _read_all(q: str, p0: str, q1: str):
+    """Open the record queue and both producers by name and read every message."""
+    mux = StreamBufferMultiplexer(name=q)
+    try:
+        mux.add_producer(0, name=p0)
+        mux.add_queue_producer(1, name=q1)
+        out = []
+        cursor = 0
+        while True:
+            rec, cursor = mux.read(cursor)
+            if not rec:
+                return out
+            out.append((rec.producer_id, bytes(rec.data)))
+    finally:
+        mux.close()
+
+
+# A fresh interpreter, so it has its own resource tracker - a multiprocessing
+# child would share the parent's, and the parent's exit would be what unlinked
+# the names.
+_LIFETIME_CHILD = r"""
+import sys
+from pathlib import Path
+root = Path(sys.argv[1])
+for p in (root, root.parent / "slick-queue-py", root.parent / "slick-stream-buffer-py"):
+    sys.path.insert(0, str(p))
+from slick_stream_buffer_multiplexer_py import StreamBufferMultiplexer
+q, p0, q1, mode, tag = sys.argv[2:7]
+if mode == 'create':
+    mux = StreamBufferMultiplexer(shared_queue_size=64, name=q)
+    pb = mux.add_producer(0, capacity=1024, control_size=16, name=p0)
+    pq = mux.add_queue_producer(1, size=1024, items_per_slot=16, name=q1)
+    assert pb.own_buffer and pq.own_buffer, "child expected to create the segments"
+else:
+    mux = StreamBufferMultiplexer(name=q)
+    pb = mux.add_producer(0, name=p0)
+    pq = mux.add_queue_producer(1, name=q1)
+data = tag.encode()
+mv = pb.prepare(len(data))
+mv[:] = data
+pb.commit(len(data))
+pb.consume(len(data))
+i = pq.reserve(len(data))
+pq[i][:len(data)] = data
+pq.publish(i, len(data))
+mux.close()
+"""
+
+
+def _run_lifetime_child(q: str, p0: str, q1: str, mode: str, tag: str) -> None:
+    import subprocess
+    result = subprocess.run(
+        [sys.executable, "-c", _LIFETIME_CHILD, str(_root), q, p0, q1, mode, tag],
+        capture_output=True, text=True, timeout=60)
+    assert result.returncode == 0, f"child failed:\n{result.stdout}\n{result.stderr}"
+    # The tracker warns about every registered name it cleans up at shutdown
+    assert "resource_tracker" not in result.stderr, result.stderr
+
+
+def test_shm_unlink_leaves_resource_tracker_alone():
+    """Regression: unlink() deleted the record queue and each queue producer's
+    segment through SharedMemory.unlink(), which before Python 3.13 also sends
+    the resource tracker an UNREGISTER. slick-queue-py keeps no registration
+    since 2.3.0, so the tracker raised KeyError and printed a traceback from its
+    own process. Routing through SlickQueue.unlink() sends nothing."""
+    from multiprocessing import resource_tracker
+    names = ("mux_py_ut_records", "mux_py_ut_p0", "mux_py_ut_q1")
+    _remove_all(names)
+    mux = StreamBufferMultiplexer(shared_queue_size=64, name=names[0])
+    mux.add_producer(0, capacity=1024, control_size=16, name=names[1])
+    mux.add_queue_producer(1, size=1024, items_per_slot=16, name=names[2])
+    mux.close()
+
+    calls = []
+    original = resource_tracker.unregister
+    resource_tracker.unregister = lambda n, rtype: calls.append((n, rtype))
+    try:
+        mux.unlink()
+    finally:
+        resource_tracker.unregister = original
+    assert calls == [], calls
+
+    if sys.platform != 'win32':
+        leaked = [n for n in names if StreamBufferMultiplexer.remove(n)]
+        assert not leaked, f"segments outlived close() + unlink(): {leaked}"
+
+
+def test_shm_creator_exit_keeps_segments():
+    """A creator's exit used to unlink its names on POSIX through the resource
+    tracker - the record queue and both kinds of producer segment - stranding
+    every consumer still attached. On Windows a section dies with its last
+    handle, which no one else holds here."""
+    if sys.platform == 'win32':
+        return
+    names = ("mux_py_cx_records", "mux_py_cx_p0", "mux_py_cx_q1")
+    _remove_all(names)
+    try:
+        _run_lifetime_child(*names, 'create', "from child")
+        assert _read_all(*names) == [(0, b"from child"), (1, b"from child")]
+
+        # A restarted creator reattaches to all three and keeps their contents
+        again = StreamBufferMultiplexer(shared_queue_size=64, name=names[0])
+        try:
+            assert not again.shared_queue._own
+            pb = again.add_producer(0, capacity=1024, control_size=16, name=names[1])
+            pq = again.add_queue_producer(1, size=1024, items_per_slot=16, name=names[2])
+            assert not pb.own_buffer
+            assert not pq.own_buffer
+        finally:
+            again.close()
+    finally:
+        _remove_all(names)
+
+
+def test_shm_attacher_exit_keeps_segments():
+    """Before Python 3.13 attaching registered every name with the attacher's
+    resource tracker too, so any peer's exit unlinked the segments on POSIX."""
+    names = ("mux_py_ax_records", "mux_py_ax_p0", "mux_py_ax_q1")
+    _remove_all(names)
+    creator = StreamBufferMultiplexer(shared_queue_size=64, name=names[0])
+    try:
+        creator.add_producer(0, capacity=1024, control_size=16, name=names[1])
+        creator.add_queue_producer(1, size=1024, items_per_slot=16, name=names[2])
+        _run_lifetime_child(*names, 'open', "first")
+        _run_lifetime_child(*names, 'open', "second")
+        assert _read_all(*names) == [
+            (0, b"first"), (1, b"first"), (0, b"second"), (1, b"second")]
+    finally:
+        creator.close()
+        creator.unlink()
+
+
 def run_all_tests():
     tests = [
         ("ShmRoundtrip", test_shm_roundtrip),
@@ -536,6 +677,10 @@ def run_all_tests():
         ("ShmQueueCrossProcessRoundtrip", test_shm_queue_cross_process_roundtrip),
         ("ShmUnlinkAfterCloseCoversQueueProducers",
          test_shm_unlink_after_close_covers_queue_producers),
+        ("ShmUnlinkLeavesResourceTrackerAlone",
+         test_shm_unlink_leaves_resource_tracker_alone),
+        ("ShmCreatorExitKeepsSegments", test_shm_creator_exit_keeps_segments),
+        ("ShmAttacherExitKeepsSegments", test_shm_attacher_exit_keeps_segments),
     ]
 
     print("=" * 70)