Dec 5, 2023 · Oct 12, 2023 · Oct 12, 2023 · Oct 12, 2023 · Oct 12, 2023 · Oct 12, 2023
diff --git a/Doc/library/multiprocessing.shared_memory.rst b/Doc/library/multiprocessing.shared_memory.rst
 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.
   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 a 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).  Unless a Python process
   was created using any of the :mod:`multiprocessing` facilities (such as
   :class:`multiprocessing.Process`), it will receive its own resource tracker
   process when accessing shared memory with *track* enabled.  This will cause
   the shared memory to be deleted by the resource tracker of the first
   process that terminates.  To avoid this issue, users of :mod:`subprocess` or
   standalone Python processes should set *track* to ``False`` when there is
   already another process in place that does the bookkeeping.  *track* has
   an effect only on POSIX.  Windows has its own tracking and does not use the
   resource tracker.

   .. versionchanged:: 3.13 Added *track* parameter.

   .. 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.  :meth:`close()` should be called once access to the shared
      memory block from this 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 :meth:`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.
      :meth:`unlink()` and :meth:`close()` can be called in any order, but
      trying to access data inside a shared memory block after :meth:`unlink()`
      may result in memory access errors, depending on platform.

   .. attribute:: buf

diff --git a/Lib/multiprocessing/shared_memory.py b/Lib/multiprocessing/shared_memory.py
    _flags = os.O_RDWR
    _mode = 0o600
    _prepend_leading_slash = True if _USE_POSIX else False
    _track = True

    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:
        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
            except OSError:
                self.unlink()
                raise

            resource_tracker.register(self._name, "shared_memory")
            if self._track:
 resource_tracker.register(self._name, "shared_memory")

        else:

        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 _USE_POSIX and self._name:
            _posixshmem.shm_unlink(self._name)
            resource_tracker.unregister(self._name, "shared_memory")
            if self._track:
                resource_tracker.unregister(self._name, "shared_memory")


 _encoding = "utf8"
diff --git a/Lib/test/_test_multiprocessing.py b/Lib/test/_test_multiprocessing.py
                    "resource_tracker: There appear to be 1 leaked "
                    "shared_memory objects to clean up at shutdown", err)

    @unittest.skipIf(os.name != "posix", "resource_tracker is posix only")
    def test_shared_memory_untracking(self):
        # gh-82300: When a separate Python process accesses shared memory
        # with track=False, it must not register with the resource tracker.
        cmd = '''if 1:
            import sys
            from unittest.mock import Mock
            from multiprocessing import resource_tracker
            from multiprocessing.shared_memory import SharedMemory
            resource_tracker.register = Mock(side_effect=AssertionError)
            mem = SharedMemory(create=False, name=sys.argv[1], track=False)
            mem.close()
        '''
        mem = shared_memory.SharedMemory(create=True, size=10)
        try:
            *_, err = test.support.script_helper.assert_python_ok("-c", cmd,
                                                                  mem.name)
            self.assertEqual(err, b'')
        finally:
            mem.close()
            try:
                mem.unlink()
            except OSError:
                pass

 #
 # Test to verify that `Finalize` works.
 #
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
 Add ``track`` parameter to:class:`multiprocessing.shared_memory.SharedMemory` that allows using shared memory blocks without having to register with the resource tracker.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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)
pan324 marked this conversation as resolved. OutdatedShow resolvedHide resolved

		Creates a new shared memory block or attaches to an existing shared
		memory block. Each shared memory block is assigned a unique name.
Expand DownExpand Up		@@ -64,26 +64,38 @@ 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 a 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). Unless a Python process
		was created using any of the :mod:`multiprocessing` facilities (such as
		:class:`multiprocessing.Process`), it will receive its own resource tracker
		process when accessing shared memory with track enabled. This will cause
		the shared memory to be deleted by the resource tracker of the first
		process that terminates. To avoid this issue, users of :mod:`subprocess` or
		standalone Python processes should set track to ``False`` when there is
		already another process in place that does the bookkeeping. track has
		an effect only on POSIX. Windows has its own tracking and does not use the
		resource tracker.
gpshead marked this conversation as resolved. OutdatedShow resolvedHide resolved

		.. versionchanged:: 3.13 Added track parameter.

		.. 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. :meth:`close()` should be called once access to the shared
		memory block from this 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 :meth:`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
gpshead marked this conversation as resolved. Show resolvedHide resolved
		once per shared memory block regardless of the number of handles to it.
pan324 marked this conversation as resolved. OutdatedShow resolvedHide resolved
		:meth:`unlink()` and :meth:`close()` can be called in any order, but
		trying to access data inside a shared memory block after :meth:`unlink()`
		may result in memory access errors, depending on platform.
pan324 marked this conversation as resolved. Show resolvedHide resolved

		.. attribute:: buf

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -71,8 +71,9 @@ class SharedMemory:
		_flags = os.O_RDWR
		_mode = 0o600
		_prepend_leading_slash = True if _USE_POSIX else False
		_track = True

pan324 marked this conversation as resolved. Show resolvedHide resolved
		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:
Expand All		@@ -82,6 +83,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
Expand DownExpand Up		@@ -116,8 +118,8 @@ def __init__(self, name=None, create=False, size=0):
		except OSError:
		self.unlink()
		raise

		resource_tracker.register(self._name, "shared_memory")
		if self._track:
		resource_tracker.register(self._name, "shared_memory")

		else:

Expand DownExpand Up		@@ -239,9 +241,11 @@ 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."""
gpshead marked this conversation as resolved. OutdatedShow resolvedHide resolved

		if _USE_POSIX and self._name:
		_posixshmem.shm_unlink(self._name)
		resource_tracker.unregister(self._name, "shared_memory")
		if self._track:
		resource_tracker.unregister(self._name, "shared_memory")


		_encoding = "utf8"
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -4440,6 +4440,31 @@ def test_shared_memory_cleaned_after_process_termination(self):
		"resource_tracker: There appear to be 1 leaked "
		"shared_memory objects to clean up at shutdown", err)

		@unittest.skipIf(os.name != "posix", "resource_tracker is posix only")
		def test_shared_memory_untracking(self):
gpshead marked this conversation as resolved. Show resolvedHide resolved
		# gh-82300: When a separate Python process accesses shared memory
		# with track=False, it must not register with the resource tracker.
gpshead marked this conversation as resolved. OutdatedShow resolvedHide resolved
		cmd = '''if 1:
		import sys
		from unittest.mock import Mock
		from multiprocessing import resource_tracker
		from multiprocessing.shared_memory import SharedMemory
		resource_tracker.register = Mock(side_effect=AssertionError)
		mem = SharedMemory(create=False, name=sys.argv[1], track=False)
		mem.close()
		'''
		mem = shared_memory.SharedMemory(create=True, size=10)
		try:
		*_, err = test.support.script_helper.assert_python_ok("-c", cmd,
		mem.name)
		self.assertEqual(err, b'')
		finally:
		mem.close()
		try:
		mem.unlink()
		except OSError:
gpshead marked this conversation as resolved. Show resolvedHide resolved
		pass

		#
		# Test to verify that `Finalize` works.
		#
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		Add ``track`` parameter to:class:`multiprocessing.shared_memory.SharedMemory` that allows using shared memory blocks without having to register with the resource tracker.
pan324 marked this conversation as resolved. OutdatedShow resolvedHide resolved