Eine kurze Diskussion des PHP-Quellcodes 31: Grundlagen der Heap-Schicht im PHP-Speicherpool

Dieser Artikel stellt hauptsächlich PHP-Quellcode 31 vor: Die Grundlage der Heap-Schicht im PHP-Speicherpool, die einen bestimmten Referenzwert hat. Jetzt kann ich sie mit Ihnen teilen

Eine kurze Diskussion des PHP-Quellcodes 31: Die Grundlagen der Heap-Schicht im PHP-Speicherpool

[Übersicht]
Der Speichermanager von PHP ist hierarchisch. Dieser Manager besteht aus drei Schichten: Speicherschicht, Heap-Schicht und Emalloc/Efree-Schicht. Die Speicherschicht wird in PHP-Quellcode-Lesehinweis 30 eingeführt: Speicherschicht im PHP-Speicherpool. Die Speicherschicht beantragt tatsächlich Speicher für das System über Funktionen wie malloc() und mmap() und gibt den angeforderten Speicher frei ()-Funktion. Die Speicherschicht gilt normalerweise für größere Speicherblöcke. Der hier angewendete große Speicher bedeutet nicht, dass die Speicherschichtstruktur den Speicher benötigt, wenn sie die Zuweisungsmethode aufruft Das Segmentformat ist relativ groß. Die Rolle der Speicherschicht besteht darin, die Speicherzuweisungsmethode für die Heap-Schicht transparent zu machen.
Oben auf der Speicherschicht befindet sich die Heap-Schicht, über die wir heute etwas lernen möchten. Die Heap-Schicht ist eine Planungsschicht, die mit der darüber liegenden Emalloc/Efree-Schicht interagiert, um die über die Speicherschicht beantragten großen Speicherblöcke aufzuteilen und sie bei Bedarf bereitzustellen. Es gibt eine Reihe von Speicherplanungsstrategien in der Heap-Schicht, die den Kernbereich der gesamten PHP-Speicherzuweisungsverwaltung darstellt.

Alle unten aufgeführten Freigaben basieren darauf, dass ZEND_DEBUG nicht geöffnet wurde.
Sehen Sie sich zunächst die an der Heap-Schicht beteiligten Strukturen an:
[Struktur]

 /* mm block type */typedef struct _zend_mm_block_info {
size_t _size;/* block的大小*/
size_t _prev;/* 计算前一个块有用到*/} zend_mm_block_info; 
 typedef struct _zend_mm_block {
zend_mm_block_info info;} zend_mm_block; typedef struct _zend_mm_small_free_block {/* 双向链表 */
zend_mm_block_info info;
struct _zend_mm_free_block *prev_free_block;/* 前一个块 */
struct _zend_mm_free_block *next_free_block;/* 后一个块 */} zend_mm_small_free_block;/* 小的空闲块*/ typedef struct _zend_mm_free_block {/* 双向链表 + 树结构 */
zend_mm_block_info info;
struct _zend_mm_free_block *prev_free_block;/* 前一个块 */
struct _zend_mm_free_block *next_free_block;/* 后一个块 */ struct _zend_mm_free_block **parent;/* 父结点 */
struct _zend_mm_free_block *child[2];/* 两个子结点*/} zend_mm_free_block; 
 
 struct _zend_mm_heap {
int                 use_zend_alloc;/* 是否使用zend内存管理器 */
void               *(*_malloc)(size_t);/* 内存分配函数*/
void                (*_free)(void*);/* 内存释放函数*/
void               *(*_realloc)(void*, size_t);
size_t              free_bitmap;/* 小块空闲内存标识 */
size_t              large_free_bitmap;  /* 大块空闲内存标识*/
size_t              block_size;/* 一次内存分配的段大小，即ZEND_MM_SEG_SIZE指定的大小，默认为ZEND_MM_SEG_SIZE   (256 * 1024)*/
size_t              compact_size;/* 压缩操作边界值，为ZEND_MM_COMPACT指定大小，默认为 2 * 1024 * 1024*/
zend_mm_segment    *segments_list;/* 段指针列表 */
zend_mm_storage    *storage;/* 所调用的存储层 */
size_t              real_size;/* 堆的真实大小 */
size_t              real_peak;/* 堆真实大小的峰值 */
size_t              limit;/* 堆的内存边界 */
size_t              size;/* 堆大小 */
size_t              peak;/* 堆大小的峰值*/
size_t              reserve_size;/* 备用堆大小*/
void               *reserve;/* 备用堆 */
int                 overflow;/* 内存溢出数*/
int                 internal;#if ZEND_MM_CACHE
unsigned int        cached;/* 已缓存大小 */
zend_mm_free_block *cache[ZEND_MM_NUM_BUCKETS];/* 缓存数组/
#endif
zend_mm_free_block *free_buckets[ZEND_MM_NUM_BUCKETS*2];/* 小块空闲内存数组 */
zend_mm_free_block *large_free_buckets[ZEND_MM_NUM_BUCKETS];/* 大块空闲内存数组*/
zend_mm_free_block *rest_buckets[2];/* 剩余内存数组 */ };

Wenn use_zend_alloc für die Speicheroperationsfunktion in der Heap-Struktur „Nein“ ist, wird die Speicherzuweisung vom Typ Malloc verwendet. Dies Zu diesem Zeitpunkt durchlaufen nicht alle Vorgänge die Speicherverwaltung in der Heap-Schicht und verwenden direkt Funktionen wie malloc.

Die Größe von „compact_size“ beträgt standardmäßig 2 * 1024 * 1024 (2M). Wenn die Variable ZEND_MM_COMPACT gesetzt ist, geben Sie die Größe dafür an. Wenn der Spitzenspeicher diesen Wert überschreitet, wird die Kompaktfunktion des Speichers aufgerufen , nur diese Funktion Die aktuelle Implementierung ist leer und kann in nachfolgenden Versionen hinzugefügt werden.

reserve_size ist die Größe des Reserveheaps, standardmäßig ist es ZEND_MM_RESERVE_SIZE, seine Größe ist (8*1024)
*reserve ist der Reserveheap, seine Größe ist Reserve_size, es wird zum Melden von Fehlern verwendet wenn der Speicher überläuft.

【Über USE_ZEND_ALLOC】
Die Umgebungsvariable USE_ZEND_ALLOC kann verwendet werden, um die Auswahl der Malloc- oder Emalloc-Speicherzuweisung zur Laufzeit zu ermöglichen. Die Verwendung der Speicherzuweisung vom Typ Malloc ermöglicht es externen Debuggern, die Speichernutzung zu beobachten, während die Zuweisung von Emalloc die Abstraktion des Zend-Speichermanagers verwendet, was ein internes Debuggen erfordert.
[zend_startup() -> start_memory_manager() -> alloc_globals_ctor()]

static void alloc_globals_ctor(zend_alloc_globals *alloc_globals TSRMLS_DC){
char *tmp;
alloc_globals->mm_heap = zend_mm_startup(); 
tmp = getenv("USE_ZEND_ALLOC");
if (tmp) {
alloc_globals->mm_heap->use_zend_alloc = zend_atoi(tmp, 0);
if (!alloc_globals->mm_heap->use_zend_alloc) {/* 如果不使用zend的内存管理器，同直接使用malloc函数*/
alloc_globals->mm_heap->_malloc = malloc;
alloc_globals->mm_heap->_free = free;
alloc_globals->mm_heap->_realloc = realloc;
}
}}

[Initialisierung]

[zend_mm_startup()]
Initialisieren Sie den Speicherschicht-Zuweisungsplan , initialisieren Sie die Segmentgröße und den Komprimierungsgrenzwert und rufen Sie zend_mm_startup_ex() auf, um die Heap-Schicht zu initialisieren.

[zend_mm_startup() -> zend_mm_startup_ex()]
[Speicherausrichtung]
Die Speicherausrichtungsberechnung hat offensichtlich zwei Ziele: Eines besteht darin, die Anzahl zu reduzieren der Speicherzugriffe durch die CPU; die zweite besteht darin, die Effizienz des Speicherplatzes hoch genug zu halten.

 # define ZEND_MM_ALIGNMENT 8 #define ZEND_MM_ALIGNMENT_MASK ~(ZEND_MM_ALIGNMENT-1) 
 #define ZEND_MM_ALIGNED_SIZE(size)(((size) + ZEND_MM_ALIGNMENT - 1) & ZEND_MM_ALIGNMENT_MASK) 
 #define ZEND_MM_ALIGNED_HEADER_SIZEZEND_MM_ALIGNED_SIZE(sizeof(zend_mm_block))
 #define ZEND_MM_ALIGNED_FREE_HEADER_SIZEZEND_MM_ALIGNED_SIZE(sizeof(zend_mm_small_free_block))

PHP verwendet die Speicherausrichtung im Speicher der zugewiesenen Blöcke. Wenn die unteren drei Ziffern der erforderlichen Speichergröße nicht 0 sind (nicht durch 8 teilbar), dann addiere 7 zu den unteren drei Ziffern und ~7 führt eine UND-Operation aus, d. h. für Speichergrößen, die kein ganzzahliges Vielfaches von 8 sind, wird die Speichergröße so vervollständigt, dass sie gleichmäßig durch 8 teilbar ist.
Auf Win32-Maschinen sind die numerischen Größen, die einigen Makros entsprechen:
ZEND_MM_MIN_SIZE=8
ZEND_MM_MAX_SMALL_SIZE=272
ZEND_MM_ALIGNED_HEADER_SIZE=8
ZEND_MM_ALIGNED_FREE_HEADER_SIZE=16
ZEND_MM_ MIN_ALLOC_BLOCK_SIZE=8
ZEND_MM_ALIGNED_MIN_HEADER_SIZE =16
ZEND_MM_ALIGNED_SEGMENT_SIZE=8

Wenn Sie einen Block mit einer Größe von 9 Bytes zuweisen möchten, beträgt seine tatsächlich zugewiesene Größe ZEND_MM_ALIGNED_SIZE(9 + 8)=24

[Blockpositionierung 】
Die beiden rechten Ziffern des zugewiesenen Speichers werden zur Kennzeichnung des Speichertyps verwendet.
Die Definition seiner Größe ist #define ZEND_MM_TYPE_MASK ZEND_MM_LONG_CONST(0×3)

Der unten gezeigte Code ist die Positionierung des Blocks

 #define ZEND_MM_NEXT_BLOCK(b)ZEND_MM_BLOCK_AT(b, ZEND_MM_BLOCK_SIZE(b))
 #define ZEND_MM_PREV_BLOCK(b)ZEND_MM_BLOCK_AT(b, -(int)((b)->info._prev & ~ZEND_MM_TYPE_MASK)) 
 #define ZEND_MM_BLOCK_AT(blk, offset)((zend_mm_block *) (((char *) (blk))+(offset)))
 #define ZEND_MM_BLOCK_SIZE(b)((b)->info._size & ~ZEND_MM_TYPE_MASK)#define ZEND_MM_TYPE_MASKZEND_MM_LONG_CONST(0x3)

Das nächste Element des aktuellen Blocks ist das Die Kopfposition des aktuellen Blocks plus die Länge des gesamten Blocks (abzüglich der Länge des Typs).
Das vorherige Element des aktuellen Blocks ist die Kopfposition des aktuellen Blocks minus der Länge des vorherigen Blocks (minus der Länge des Typs).
Die Länge des vorherigen Blocks wird bei der Initialisierung des Blocks auf das Ergebnis der ODER-Verknüpfung der aktuellen Blockgröße und des Blocktyps festgelegt.

Das Obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, er wird für das Studium aller hilfreich sein. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website.

Verwandte Empfehlungen:

Eine kurze Diskussion des PHP-Quellcodes 30: Die Speicherschicht im PHP-Speicherpool

Eine kurze Diskussion über PHP-Quellcode 29: Über die Vererbung von Schnittstellen

Eine kurze Diskussion über PHP-Quellcode 28: Über Klassenstruktur und Vererbung

Das obige ist der detaillierte Inhalt vonEine kurze Diskussion des PHP-Quellcodes 31: Grundlagen der Heap-Schicht im PHP-Speicherpool. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!