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

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

This module provides a class, SharedMemory, for the allocation and management of shared memory to be accessed by one or more processes on a multicore or symmetric multiprocessor (SMP) machine. To help with the life-cycle administration of shared memory especially throughout distinct processes, a BaseManager subclass, SharedMemoryManager, can also be offered within the multiprocessing.managers module. In this module, shared memory refers to "POSIX style" shared memory blocks (though is not essentially implemented explicitly as such) and does not seek advice from "distributed shared memory". This fashion of shared memory permits distinct processes to probably read and write to a standard (or shared) region of unstable Memory Wave. Processes are conventionally limited to solely have entry to their own process memory area however shared memory permits the sharing of data between processes, avoiding the need to as an alternative send messages between processes containing that data. Sharing knowledge instantly through memory can present significant performance advantages compared to sharing data via disk or socket or other communications requiring the serialization/deserialization and copying of data.

Create an instance of the SharedMemory class for both creating a brand new shared memory block or attaching to an existing shared memory block. Every shared memory block is assigned a novel title. In this fashion, one process can create a shared memory block with a specific identify and a special course of can attach to that very same shared memory block utilizing that same name. As a resource for sharing knowledge across processes, shared memory blocks may outlive the original process that created them. When one process now not needs entry to a shared memory block that might nonetheless be needed by other processes, the shut() method needs to be referred to as. When a shared memory block is not wanted by any course of, the unlink() method ought to be called to make sure proper cleanup. The distinctive name for the requested shared memory, specified as a string. When creating a new shared memory block, if None (the default) is supplied for the title, a novel name will be generated.

Control whether or not a new shared memory block is created (True) or an current shared memory block is attached (False). The requested number of bytes when creating a new shared memory block. Because some platforms select to allocate chunks of memory based upon that platform’s memory web page measurement, the precise measurement of the shared memory block may be bigger or equal to the dimensions requested. When attaching to an current shared memory block, the dimensions parameter is ignored. When True, Memory Wave Program register the shared memory block with a resource tracker course of on platforms the place the OS doesn't do this routinely. The useful resource tracker ensures proper cleanup of the shared memory even if all other processes with access to the Memory Wave exit with out doing so. Python processes created from a standard ancestor using multiprocessing services share a single useful resource tracker process, and the lifetime of shared memory segments is dealt with routinely amongst these processes.

Python processes created in every other manner will obtain their own resource tracker when accessing shared memory with track enabled. This may cause the shared memory to be deleted by the useful resource tracker of the primary process that terminates. To keep away from this challenge, users of subprocess or standalone Python processes ought to set observe to False when there's 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. Changed in version 3.13: Added the monitor parameter. Shut the file descriptor/handle to the shared memory from this instance. Relying on operating system, the underlying memory may or might not be freed even when all handles to it have been closed. To make sure correct cleanup, use the unlink() methodology. Delete the underlying shared memory block. This needs to be known as solely once per shared memory block whatever the variety of handles to it, even in other processes.

This method has no effect on Windows, the place the one approach to delete a shared memory block is to shut all handles. A memoryview of contents of the shared memory block. Learn-only access to the distinctive name of the shared memory block. Learn-only entry to dimension in bytes of the shared memory block. A subclass of multiprocessing.managers.BaseManager which can be used for the management of shared Memory Wave Program blocks throughout processes. A call to start out() on a SharedMemoryManager occasion causes a brand new course of to be began. This new process’s sole purpose is to handle the life cycle of all shared memory blocks created through it. To set off the release of all shared memory blocks managed by that course of, name shutdown() on the instance. This triggers a unlink() call on the entire SharedMemory objects managed by that course of and then stops the process itself. By creating SharedMemory instances by way of a SharedMemoryManager, we avoid the necessity to manually track and set off the freeing of shared memory sources.