python · gpshead · Dec 5, 2023 · Oct 12, 2023 · Oct 12, 2023 · Oct 12, 2023
@@ -36,7 +36,7 @@ or other communications requiring the serialization/deserialization and
 copying of data.
 
 
-.. class:: SharedMemory(name=None, create=False, size=0)
+.. class:: SharedMemory(name=None, create=False, size=0, track=True)
 
    Creates a new shared memory block or attaches to an existing shared
    memory block.  Each shared memory block is assigned a unique name.
@@ -64,26 +64,34 @@ copying of data.
    memory block may be larger or equal to the size requested.  When attaching
    to an existing shared memory block, the ``size`` parameter is ignored.
 
+   *track*, when enabled, registers the shared memory block with the resource
+   tracker process.  This process ensures proper cleanup of shared memory
+   blocks even when all other processes with access to the memory have failed
+   to do so (mainly due to being killed by signals).  The resource tracker is
+   overzealous in certain situations and might delete a shared memory block
+   when any process with access to the shared memory has terminated.  *track*
+   should be set to ``False`` if there is already another process in place
+   that does the bookkeeping.  In most situations, this means that *track*
+   should be set to ``False`` when *create* is set to ``False``.
+
    .. method:: close()
 
-      Closes access to the shared memory from this instance.  In order to
-      ensure proper cleanup of resources, all instances should call
-      ``close()`` once the instance is no longer needed.  Note that calling
-      ``close()`` does not cause the shared memory block itself to be
-      destroyed.
+      Closes the file descriptor/handle to the shared memory from this
+      instance.  All instances should call ``close()`` once the instance
+      is no longer needed.  Depending on operating system, the underlying
+      memory may or may not be freed even if all handles to it have been
+      closed.  To ensure proper cleanup, use the ``unlink()`` method.
 
    .. method:: unlink()
 
-      Requests that the underlying shared memory block be destroyed.  In
-      order to ensure proper cleanup of resources, ``unlink()`` should be
-      called once (and only once) across all processes which have need
-      for the shared memory block.  After requesting its destruction, a
-      shared memory block may or may not be immediately destroyed and
-      this behavior may differ across platforms.  Attempts to access data
-      inside the shared memory block after ``unlink()`` has been called may
-      result in memory access errors.  Note: the last process relinquishing
-      its hold on a shared memory block may call ``unlink()`` and
-      :meth:`close()` in either order.
+      Deletes the underlying shared memory block.  This should be called only
+      once per shared memory block regardless of the number of handles to it.
+      After requesting its deletion, a shared memory block may or may not be
+      immediately destroyed and this behavior may differ across platforms.
+      Attempts to access data inside the shared memory block after
+      ``unlink()`` has been called may result in memory access errors.
+      To ensure proper bookkeeping, ``unlink()`` may only be called by
+      an instance with *track* enabled.
 
    .. attribute:: buf
 

@@ -72,7 +72,7 @@ class SharedMemory:
     _mode = 0o600
     _prepend_leading_slash = True if _USE_POSIX else False
 
-    def __init__(self, name=None, create=False, size=0):
+    def __init__(self, name=None, create=False, size=0, track=True):
         if not size >= 0:
             raise ValueError("'size' must be a positive integer")
         if create:
@@ -82,6 +82,7 @@ def __init__(self, name=None, create=False, size=0):
         if name is None and not self._flags & os.O_EXCL:
             raise ValueError("'name' can only be None if create=True")
 
+        self._track = track
         if _USE_POSIX:
 
             # POSIX Shared Memory
@@ -116,8 +117,8 @@ def __init__(self, name=None, create=False, size=0):
             except OSError:
                 self.unlink()
                 raise
-
-            resource_tracker.register(self._name, "shared_memory")
+            if track:
+                resource_tracker.register(self._name, "shared_memory")
 
         else:
 
@@ -239,6 +240,9 @@ def unlink(self):
         In order to ensure proper cleanup of resources, unlink should be
         called once (and only once) across all processes which have access
         to the shared memory block."""
+        if not self._track:
+            raise TypeError("unlink() must be called by a tracking instance")
+
         if _USE_POSIX and self._name:
             _posixshmem.shm_unlink(self._name)
             resource_tracker.unregister(self._name, "shared_memory")

diff --git a/Misc/NEWS.d/next/Library/2023-10-12-18-19-47.gh-issue-82300.P8-O38.rst b/Misc/NEWS.d/next/Library/2023-10-12-18-19-47.gh-issue-82300.P8-O38.rst
@@ -0,0 +1 @@
+Add ``track`` parameter that allows using shared memory blocks without having to register with the resource tracker.
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		Add ``track`` parameter that allows using shared memory blocks without having to register with the resource tracker.
pan324 marked this conversation as resolved. Show resolved Hide resolved