Storage layer in the PHP memory pool

The memory manager of PHP is hierarchical. This manager has three layers: storage, heap, and emalloc/efree. The storage layer uses functions such as malloc () and mmap () to apply for memory from the system, and releases the applied memory through the free () function. The storage layer usually applies for a large amount of memory blocks. Here we apply for "> <LI

The memory manager of PHP is hierarchical. This manager has three layers: storage, heap, and emalloc/efree. The storage layer uses functions such as malloc () and mmap () to apply for memory from the system, and releases the applied memory through the free () function.

The storage layer usually applies for a large amount of memory blocks. The memory size requested here does not mean that the storage layer structure requires a large amount of memory, but when the heap layer calls the storage layer allocation method, the memory requested in the format of segments is relatively large. The storage layer is used to make the memory allocation method transparent to the heap layer.

First, let's look at the structure of the storage layer:

 

 

  
/* Heaps with user defined storage */
  
Typedef struct _ zend_mm_storage;
  
     
  
Typedef struct _ zend_mm_segment {
  
Size_t size;
  
Struct _ zend_mm_segment * next_segment;
  
} Zend_mm_segment;
  
     
  
Typedef struct _ zend_mm_mem_handlers {
  
Const char * name;
  
Zend_mm_storage * (* init) (void * params); // initialize the function
  
Void (* dtor) (zend_mm_storage * storage); // destructor
  
Void (* compact) (zend_mm_storage * storage );
  
Zend_mm_segment * (* _ alloc) (zend_mm_storage * storage, size_t size); // memory allocation function
  
Zend_mm_segment * (* _ realloc) (zend_mm_storage * storage, zend_mm_segment * ptr, size_t size); // realallocates the memory function.
  
Void (* _ free) (zend_mm_storage * storage, zend_mm_segment * ptr); // releases the memory function
  
} Zend_mm_mem_handlers;
  
     
  
Struct _ zend_mm_storage {
  
Const zend_mm_mem_handlers * handlers; // process the function set
  
Void * data;
  
};
 

Memory allocation method. The called function is the processing function set in the _ zend_mm_storage structure, and the memory is represented in segments.

Four memory solutions

PHP has four memory allocation schemes at the storage layer: malloc, win32, mmap_anon, and mmap_zero. By default, malloc is used to allocate memory. If ZEND_WIN32 macro is set, HeapAlloc is called to allocate memory for windows. The remaining two memory schemes are anonymous memory ING, in addition, the PHP memory solution can be modified by setting variables.

Official instructions are as follows:

The Zend MM can be tweaked using ZEND_MM_MEM_TYPE and ZEND_MM_SEG_SIZE environment variables. default values are "malloc" and "256K ". dependent on target system you can also use "mmap_anon", "mmap_zero" and "win32 & Prime; storage managers.

In the code, for the four memory allocation schemes, each processing function in zend_mm_mem_handlers is implemented. The code is described as follows:

 

 

  
/* Use the mmap memory ing function to allocate private mappings copied during memory write, and perform anonymous Ing. The ing area is not associated with any files. */
  
# Define register {"mmap_anon", zend_mm_mem_dummy_init, commit, zend_mm_mem_dummy_compact, commit, zend_mm_mem_mmap_realloc, zend_mm_mem_mmap_free}
  
   
  
/* Use the mmap memory ing function to allocate private mappings copied during memory write and map them to/dev/zero. */
  
# Define register {"mmap_zero", zend_mm_mem_mmap_zero_init, commit, zend_mm_mem_dummy_compact, commit, zend_mm_mem_mmap_realloc, zend_mm_mem_mmap_free}
  
   
  
/* Use HeapAlloc to allocate memory for windows. In this regard, VirtualAlloc () to allocate memory is written in the comment, and HeapAlloc is used in the program */
  
# Define ZEND_MM_MEM_WIN32_DSC {"win32", zend_mm_mem_win32_init, terminal, zend_mm_mem_win32_compact, terminal, terminal, zend_mm_mem_win32_free}
  
   
  
/* Use malloc to allocate memory. By default, if ZEND_WIN32 macro is added, the win32 allocation scheme is used */
  
# Define ZEND_MM_MEM_MALLOC_DSC {"malloc", zend_mm_mem_dummy_init, runtime, zend_mm_mem_malloc_realloc, zend_mm_mem_malloc_free}
  
   
  
Static const zend_mm_mem_handlers mem_handlers [] = {
  
# Ifdef HAVE_MEM_WIN32
  
ZEND_MM_MEM_WIN32_DSC,
  
# Endif
  
# Ifdef HAVE_MEM_MALLOC
  
ZEND_MM_MEM_MALLOC_DSC,
  
# Endif
  
# Ifdef HAVE_MEM_MMAP_ANON
  
ZEND_MM_MEM_MMAP_ANON_DSC,
  
# Endif
  
# Ifdef HAVE_MEM_MMAP_ZERO
  
ZEND_MM_MEM_MMAP_ZERO_DSC,
  
# Endif
  
{NULL, NULL}
  
};
 

Advantages of anonymous memory ing

Mmem_zero solution:

(SVR 4)/dev/zero Memory Mapping

1. You can pass the pseudo device "/dev/zero" as a parameter to mmap and create a ing zone. The special feature of/dev/zero is that all read operations on the device file return a byte stream with a specified length of 0, and any written content is discarded. We are interested in using it to create a ing area, and using/dev/zero to create a ing area. Its content is initially 0.

2. The advantage of using/dev/zero is that when mmap creates a ing zone, it does not need a time-existent file. The pseudo file/dev/zero is enough. The disadvantage is that it can only be used between related processes. Compared with inter-process communication, inter-thread communication is more efficient. Regardless of the technology, access to shared data must be synchronized.

Mmem_anon solution:

(4.4 BSD) Anonymous Memory Mapping

1. Anonymous memory ING and use of the/dev/zero type do not require real files. To use anonymous ing, you need to input the MAP_ANON flag to mmap and set the fd parameter to-1.

2. The so-called anonymity means that the fd ing area is not associated with the file path name through fd. Anonymous memory ING is used between kinship-related processes.

Heap memory allocation statement in win32 solution

The HeapAlloc function declaration is as follows:

 

 

  
WINBASEAPI
  
_ Out_opt
  
HANDLE
  
WINAPI
  
HeapCreate (
  
_ In DWORD flOptions,
  
_ In SIZE_T dwInitialSize,
  
_ In SIZE_T dwMaximumSize
  
);
  
     
  
WINBASEAPI
  
BOOL
  
WINAPI
  
HeapDestroy (
  
_ In HANDLE hHeap
  
);
  
     
  
WINBASEAPI
  
_ Bcount (dwBytes)
  
LPVOID
  
WINAPI
  
HeapAlloc (
  
_ In HANDLE hHeap,
  
_ In DWORD dwFlags,
  
_ In SIZE_T dwBytes
  
);
  
     
  
     
  
WINBASEAPI
  
BOOL
  
WINAPI
  
HeapFree (
  
_ Inout HANDLE hHeap,
  
_ In DWORD dwFlags,
  
_ Deref LPVOID lpMem
  
);
  
     
  
WINBASEAPI
  
SIZE_T
  
WINAPI
  
HeapSize (
  
_ In HANDLE hHeap,
  
_ In DWORD dwFlags,
  
_ In LPCVOID lpMem
  
);
 

◆ HHeap indicates the starting position of the process heap memory.

◆ DwFlags indicates heap memory allocation.

◆ DwBytes is the size of heap memory allocated.

Initialization

When zend_mm_startup is started, the program sets the memory allocation scheme and segment allocation size based on the configuration, as shown in the following code:

 

 

  
ZEND_API zend_mm_heap * zend_mm_startup (void)
  
{    
  
Int I;
  
Size_t seg_size;
  
Char * mem_type = getenv ("ZEND_MM_MEM_TYPE ");
  
Char * tmp;
  
Const zend_mm_mem_handlers * handlers;
  
Zend_mm_heap * heap;
  
     
  
If (mem_type = NULL ){
  
I = 0;
  
} Else {
  
For (I = 0; mem_handlers [I]. name; I ++ ){
  
If (strcmp (mem_handlers [I]. name, mem_type) = 0 ){
  
Break;
  
      }    
  
     }    
  
If (! Mem_handlers [I]. name ){
  
Fprintf (stderr, "Wrong or unsupported zend_mm storage type '% s' \ n", mem_type );
  
Fprintf (stderr, "supported types: \ n ");
  
For (I = 0; mem_handlers [I]. name; I ++ ){
  
Fprintf (stderr, "'% s' \ n", mem_handlers [I]. name );
  
      }    
  
Exit (255 );
  
     }    
  
    }    
  
Handlers = & mem_handlers [I];
  
     
  
Tmp = getenv ("ZEND_MM_SEG_SIZE ");
  
If (tmp ){
  
Seg_size = zend_atoi (tmp, 0 );
  
If (zend_mm_low_bit (seg_size )! = Zend_mm_high_bit (seg_size )){
  
Fprintf (stderr, "ZEND_MM_SEG_SIZE must be a power of two \ n ");
  
Exit (255 );
  
} Else if (seg_size <ZEND_MM_ALIGNED_SEGMENT_SIZE + ZEND_MM_ALIGNED_HEADER_SIZE ){
  
Fprintf (stderr, "ZEND_MM_SEG_SIZE is too small \ n ");
  
Exit (255 );
  
     }    
  
} Else {
  
Seg_size = ZEND_MM_SEG_SIZE;
  
    }    
  
     
  
//... The code is omitted
  
}    
 

1,121st ~ Row 3 traverses the entire mem_handlers array and confirms the memory allocation scheme. If the ZEND_MM_MEM_TYPE variable is not set, the malloc scheme is used by default. If it is windows (ZEND_WIN32), the win32 scheme is used by default, if the ZEND_MM_MEM_TYPE variable is set, the setting scheme is used.

1,140th ~ Row 1152 confirms the size of the segment allocation. If the ZEND_MM_SEG_SIZE variable is set, the set size is used. Here, the set size is determined to be a multiple of 2 and greater than or equal to limit + ZEND_MM_ALIGNED_HEADER_SIZE; if no value is set, the default ZEND_MM_SEG_SIZE is not used.