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
   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 withthe resource
   *track*, when enabled, registers the shared memory block witha 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``.
   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 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.
      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()

      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.
      Therefore, 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.
      :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
        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
        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)
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.
 #
Original file line number	Diff line number	Diff line change
Expand Up		@@ -64,34 +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 withthe resource
		track, when enabled, registers the shared memory block witha 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``.
		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 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.
		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()

		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
		After requesting its deletion, a shared memory block may or may not be
		immediately destroyed, and this behavior may differ across platforms.
		Therefore, 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.
		: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		@@ -82,7 +82,6 @@ def __init__(self, name=None, create=False, size=0, track=True):
		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		@@ -240,8 +239,6 @@ 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 not self._track:
		raise TypeError("unlink() must be called by a tracking instance")

		if _USE_POSIX and self._name:
		_posixshmem.shm_unlink(self._name)
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