Eliminated premature destruction of shared memory segments by resource tracker.

Author: applio

Lib/multiprocessing/managers.py

@@ -1316,14 +1316,6 @@ class SharedMemoryManager(BaseManager):
         _Server = SharedMemoryServer
 
         def __init__(self, *args, **kwargs):
-            if os.name == "posix":
-                # bpo-36867: Ensure the resource_tracker is running before
-                # launching the manager process, so that concurrent
-                # shared_memory manipulation both in the manager and in the
-                # current process does not create two resource_tracker
-                # processes.
-                from . import resource_tracker
-                resource_tracker.ensure_running()
             BaseManager.__init__(self, *args, **kwargs)
             util.debug(f"{self.__class__.__name__} created by pid {getpid()}")
 

Lib/multiprocessing/resource_tracker.py

@@ -39,7 +39,6 @@
 
     _CLEANUP_FUNCS.update({
         'semaphore': _multiprocessing.sem_unlink,
-        'shared_memory': _posixshmem.shm_unlink,
     })
 
 

Lib/multiprocessing/shared_memory.py

@@ -114,9 +114,6 @@ def __init__(self, name=None, create=False, size=0):
                 self.unlink()
                 raise
 
-            from .resource_tracker import register
-            register(self._name, "shared_memory")
-
         else:
 
             # Windows Named Shared Memory
@@ -235,9 +232,7 @@ def unlink(self):
         called once (and only once) across all processes which have access
         to the shared memory block."""
         if _USE_POSIX and self._name:
-            from .resource_tracker import unregister
             _posixshmem.shm_unlink(self._name)
-            unregister(self._name, "shared_memory")
 
 
 _encoding = "utf8"

Lib/test/_test_multiprocessing.py

@@ -4120,49 +4120,6 @@ def test_shared_memory_ShareableList_pickling(self):
         deserialized_sl.shm.close()
         sl.shm.close()
 
-    def test_shared_memory_cleaned_after_process_termination(self):
-        cmd = '''if 1:
-            import os, time, sys
-            from multiprocessing import shared_memory
-
-            # Create a shared_memory segment, and send the segment name
-            sm = shared_memory.SharedMemory(create=True, size=10)
-            sys.stdout.write(sm.name + '\\n')
-            sys.stdout.flush()
-            time.sleep(100)
-        '''
-        with subprocess.Popen([sys.executable, '-E', '-c', cmd],
-                              stdout=subprocess.PIPE,
-                              stderr=subprocess.PIPE) as p:
-            name = p.stdout.readline().strip().decode()
-
-            # killing abruptly processes holding reference to a shared memory
-            # segment should not leak the given memory segment.
-            p.terminate()
-            p.wait()
-
-            deadline = time.monotonic() + support.LONG_TIMEOUT
-            t = 0.1
-            while time.monotonic() < deadline:
-                time.sleep(t)
-                t = min(t*2, 5)
-                try:
-                    smm = shared_memory.SharedMemory(name, create=False)
-                except FileNotFoundError:
-                    break
-            else:
-                raise AssertionError("A SharedMemory segment was leaked after"
-                                     " a process was abruptly terminated.")
-
-            if os.name == 'posix':
-                # A warning was emitted by the subprocess' own
-                # resource_tracker (on Windows, shared memory segments
-                # are released automatically by the OS).
-                err = p.stderr.read().decode()
-                self.assertIn(
-                    "resource_tracker: There appear to be 1 leaked "
-                    "shared_memory objects to clean up at shutdown", err)
-
 #
 #
 #