Multiprocessing.shared_memory - Shared Memory for Direct Entry Throughout Processes¶ > 자유게시판

• 목록
• 답변
• 글쓰기
• 게시판 리스트 옵션
  • 수정
  • 삭제

This module gives a category, SharedMemory, for the allocation and management of shared memory to be accessed by a number of processes on a multicore or symmetric multiprocessor (SMP) machine. To help with the life-cycle administration of shared memory particularly throughout distinct processes, a BaseManager subclass, SharedMemoryManager, is also provided in the multiprocessing.managers module. In this module, shared memory refers to "POSIX style" shared memory blocks (although is not necessarily implemented explicitly as such) and doesn't seek advice from "distributed shared memory". This fashion of shared memory permits distinct processes to potentially learn and write to a common (or shared) area of risky memory. Processes are conventionally restricted to only have access to their own process memory house but shared memory permits the sharing of information between processes, avoiding the need to as a substitute ship messages between processes containing that knowledge. Sharing knowledge directly through memory can provide vital performance benefits in comparison with sharing information through disk or socket or different communications requiring the serialization/deserialization and copying of information.

Create an occasion of the SharedMemory class for both creating a new shared memory block or attaching to an existing shared memory block. Each shared memory block is assigned a novel identify. In this way, one course of can create a shared memory block with a selected identify and a different process can attach to that same shared Memory Wave block utilizing that very same title. As a useful resource for sharing data throughout processes, memory improvement solution shared memory blocks might outlive the original process that created them. When one process now not wants entry to a shared memory block which may still be needed by different processes, the shut() technique should be referred to as. When a shared Memory Wave block is now not wanted by any course of, the unlink() method needs to be called to make sure correct cleanup. The unique name for the requested shared memory, specified as a string. When creating a new shared memory block, if None (the default) is equipped for the name, a novel identify shall be generated.

Control whether or not a brand new shared memory block is created (True) or an current shared memory block is connected (False). The requested variety of bytes when creating a new shared memory block. As a result of some platforms select to allocate chunks of memory primarily based upon that platform’s memory page measurement, the precise size of the shared memory block could also be bigger or equal to the scale requested. When attaching to an current shared memory block, the size parameter is ignored. When True, register the shared memory block with a resource tracker process on platforms where the OS does not do this routinely. The resource tracker ensures correct cleanup of the shared memory even when all different processes with access to the memory exit without doing so. Python processes created from a typical ancestor utilizing multiprocessing amenities share a single resource tracker course of, and the lifetime of shared memory segments is dealt with automatically among these processes.

Python processes created in any other method will receive their very own useful resource tracker when accessing shared memory with monitor enabled. This will cause the shared memory to be deleted by the resource tracker of the first course of that terminates. To avoid this issue, customers of subprocess or standalone Python processes should set observe to False when there may be already another course of in place that does the bookkeeping. Windows, which has its personal tracking and robotically deletes shared memory when all handles to it have been closed. Modified in model 3.13: Added the monitor parameter. Close the file descriptor/handle to the shared memory from this instance. Depending on operating system, the underlying memory might or may not be freed even when all handles to it have been closed. To ensure correct cleanup, use the unlink() methodology. Delete the underlying shared memory block. This needs to be known as only once per shared memory block regardless of the variety of handles to it, even in other processes.

This method has no impact on Home windows, where the only solution to delete a shared memory block is to close all handles. A memoryview of contents of the shared memory block. Read-solely entry to the unique name of the shared memory block. Read-only access to measurement in bytes of the shared memory improvement solution block. A subclass of multiprocessing.managers.BaseManager which can be used for the administration of shared memory blocks throughout processes. A call to start out() on a SharedMemoryManager instance causes a new course of to be started. This new process’s sole objective is to manage the life cycle of all shared memory blocks created by it. To set off the release of all shared memory blocks managed by that course of, call shutdown() on the instance. This triggers a unlink() name on the entire SharedMemory objects managed by that process and then stops the process itself. By creating SharedMemory cases through a SharedMemoryManager, we keep away from the necessity to manually track and set off the freeing of shared memory resources.