第二节 PHP中的内存管理

• 是否有足够的内存供我们的程序使用；
• 如何从足够可用的内存中获取部分内存；
• 对于使用后的内存，是否可以将其销毁并将其重新分配给其它程序使用。 与此对应，PHP的内存管理也包含这样的内容，只是这些内存在ZEND内核中是以宏的形式作为接口提供给外部使用。后面两个操作分别对应emalloc宏，efree宏，而第一个操作可以根据emalloc宏返回结果检测。

/* Standard wrapper macros */
#define emalloc(size)                       _emalloc((size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define safe_emalloc(nmemb, size, offset)   _safe_emalloc((nmemb), (size), (offset) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define efree(ptr)                          _efree((ptr) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define ecalloc(nmemb, size)                _ecalloc((nmemb), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define erealloc(ptr, size)                 _erealloc((ptr), (size), 0 ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define safe_erealloc(ptr, nmemb, size, offset) _safe_erealloc((ptr), (nmemb), (size), (offset) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define erealloc_recoverable(ptr, size)     _erealloc((ptr), (size), 1 ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define estrdup(s)                          _estrdup((s) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define estrndup(s, length)                 _estrndup((s), (length) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define zend_mem_block_size(ptr)            _zend_mem_block_size((ptr) TSRMLS_CC ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)

/* 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];    /* 剩余内存数组*/
 
};

#define ZEND_MM_BUCKET_INDEX(true_size)     ((true_size>>ZEND_MM_ALIGNMENT_LOG2)-(ZEND_MM_ALIGNED_MIN_HEADER_SIZE>>ZEND_MM_ALIGNMENT_LOG2))

#define ZEND_MM_SMALL_FREE_BUCKET(heap, index) \
(zend_mm_free_block*) ((char*)&heap->free_buckets[index * 2] + \
    sizeof(zend_mm_free_block*) * 2 - \
    sizeof(zend_mm_small_free_block))

p = ZEND_MM_SMALL_FREE_BUCKET(heap, 0);
for (i = 0; i < ZEND_MM_NUM_BUCKETS; i++) {
    p->next_free_block = p;
    p->prev_free_block = p;
    p = (zend_mm_free_block*)((char*)p + sizeof(zend_mm_free_block*) * 2);
    heap->large_free_buckets[i] = NULL;
}

#define ZEND_MM_LARGE_BUCKET_INDEX(S) zend_mm_high_bit(S)
 
 
static inline unsigned int zend_mm_high_bit(size_t _size)
{
 
..//省略若干不同环境的实现
    unsigned int n = 0;
    while (_size != 0) {
        _size = _size >> 1;
        n++;
    }
    return n-1;
}

一般来说，右移分为逻辑右移和算术右移。逻辑位移在在左端补K个0，算术右移在左端补K个最高有效位的值。 C语言标准没有明确定义应该使用哪种方式。对于无符号数据，右移必须是逻辑的。对于有符号的数据，则二者都可以。 但是，现实中都会默认为算术右移。

• 第一步 通过索引获取树型结构第一个结点并作为当前结点，如果第一个结点为空，则将内存放到第一个元素的结点位置，返回，否则转第二步
• 第二步 从当前结点出发，查找下一个结点，并将其作为当前结点
• 第三步 判断当前结点内存的大小与需要分配的内存大小是否一样如果大小一样则以双向链表的结构将新的元素添加到结点元素的后面第一个元素的位置。否则转四步
• 第四步 判断当前结点是否为空，如果为空，则占据结点位置，结束查找，否则第二步。 从以上的过程我们可以画出large_free_buckets列表的结构如图6.3所示：

/* Heaps with user defined storage */
typedef struct _zend_mm_storage 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);    //    初始化函数
    void (*dtor)(zend_mm_storage *storage);    //    析构函数
    void (*compact)(zend_mm_storage *storage);
    zend_mm_segment* (*_alloc)(zend_mm_storage *storage, size_t size);    //    内存分配函数
    zend_mm_segment* (*_realloc)(zend_mm_storage *storage, zend_mm_segment *ptr, size_t size);    //    重新分配内存函数
    void (*_free)(zend_mm_storage *storage, zend_mm_segment *ptr);    //    释放内存函数
} zend_mm_mem_handlers;
 
struct _zend_mm_storage {
    const zend_mm_mem_handlers *handlers;    //    处理函数集
    void *data;
};

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″ storage managers.

/* 使用mmap内存映射函数分配内存 写入时拷贝的私有映射，并且匿名映射，映射区不与任何文件关联。*/
# define ZEND_MM_MEM_MMAP_ANON_DSC {"mmap_anon", zend_mm_mem_dummy_init, zend_mm_mem_dummy_dtor, zend_mm_mem_dummy_compact, zend_mm_mem_mmap_anon_alloc, zend_mm_mem_mmap_realloc, zend_mm_mem_mmap_free}
 
/* 使用mmap内存映射函数分配内存 写入时拷贝的私有映射，并且映射到/dev/zero。*/
# define ZEND_MM_MEM_MMAP_ZERO_DSC {"mmap_zero", zend_mm_mem_mmap_zero_init, zend_mm_mem_mmap_zero_dtor, zend_mm_mem_dummy_compact, zend_mm_mem_mmap_zero_alloc, zend_mm_mem_mmap_realloc, zend_mm_mem_mmap_free}
 
/* 使用HeapAlloc分配内存 windows版本 关于这点，注释中写的是VirtualAlloc() to allocate memory，实际在程序中使用的是HeapAlloc*/
# define ZEND_MM_MEM_WIN32_DSC {"win32", zend_mm_mem_win32_init, zend_mm_mem_win32_dtor, zend_mm_mem_win32_compact, zend_mm_mem_win32_alloc, zend_mm_mem_win32_realloc, zend_mm_mem_win32_free}
 
/* 使用malloc分配内存 默认为此种分配 如果有加ZEND_WIN32宏，则使用win32的分配方案*/
# define ZEND_MM_MEM_MALLOC_DSC {"malloc", zend_mm_mem_dummy_init, zend_mm_mem_dummy_dtor, zend_mm_mem_dummy_compact, zend_mm_mem_malloc_alloc, 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, NULL, NULL, NULL, NULL}
};