新的垃圾回收

如前面所说，在PHP中，主要的内存管理手段是引用计数，引入垃圾收集机制的目的是为了打破引用计数中的循环引用，从而防止因为这个而产生的内存泄露。垃圾收集机制基于PHP的动态内存管理而存在。PHP5.3为引入垃圾收集机制，在变量存储的基本结构上有一些变动，如下所示：

  1. struct _zval_struct {
  2.     /* Variable information */
  3.     zvalue_value value;     /* value */
  4.     zend_uint refcount__gc;
  5.     zend_uchar type;    /* active type */
  6.     zend_uchar is_ref__gc;
  7. };

与PHP5.3之前的版本相比，引用计数字段refcount和是否引用字段is_ref都在其后面添加了__gc以用于新的的垃圾回收机制。在PHP的源码风格中，大量的宏是一个非常鲜明的特点。这些宏相当于一个接口层，它屏蔽了接口层以下的一些底层实现，如，ALLOC_ZVAL宏，这个宏在PHP5.3之前是直接调用PHP的内存管理分配函数emalloc分配内存，所分配的内存大小由变量的类型等大小决定。在引入垃圾回收机制后，ALLOC_ZVAL宏直接采用新的垃圾回收单元结构，所分配的大小都是一样的，全部是zval_gc_info结构体所占内存大小，并且在分配内存后，初始化这个结构体的垃圾回收机制。如下代码：

  1. /* The following macroses override macroses from zend_alloc.h */
  2. #undef  ALLOC_ZVAL
  3. #define ALLOC_ZVAL(z)                                   \
  4.     do {                                                \
  5.         (z) = (zval*)emalloc(sizeof(zval_gc_info));     \
  6.         GC_ZVAL_INIT(z);                                \
  7.     } while (0)

zend_gc.h文件在zend.h的749行被引用：#include “zend_gc.h”从而替换覆盖了在237行引用的zend_alloc.h文件中的ALLOC_ZVAL等宏在新的的宏中，关键性的改变是对所分配内存大小和分配内容的改变，在以前纯粹的内存分配中添加了垃圾收集机制的内容，所有的内容都包括在zval_gc_info结构体中：

  1. typedef struct _zval_gc_info {
  2.     zval z;
  3.     union {
  4.         gc_root_buffer       *buffered;
  5.         struct _zval_gc_info *next;
  6.     } u;
  7. } zval_gc_info;

对于任何一个ZVAL容器存储的变量，分配了一个zval结构，这个结构确保其和以zval变量分配的内存的开始对齐，从而在zval_gc_info类型指针的强制转换时，其可以作为zval使用。在zval字段后面有一个联合体:u。u包括gc_root_buffer结构的buffered字段和zval_gc_info结构的next字段。这两个字段一个是表示垃圾收集机制缓存的根结点，一个是zval_gc_info列表的下一个结点，垃圾收集机制缓存的结点无论是作为根结点，还是列表结点，都可以在这里体现。ALLOC_ZVAL在分配了内存后会调用GC_ZVAL_INIT用来初始化替代了zval的zval_gc_info，它会把zval_gc_info中的成员u的buffered字段设置成NULL，此字段仅在将其放入垃圾回收缓冲区时才会有值，否则会一直是NULL。由于PHP中所有的变量都是以zval变量的形式存在，这里以zval_gc_info替换zval，从而成功实现垃圾收集机制在原有系统中的集成。

PHP的垃圾回收机制在PHP5.3中默认为开启，但是我们可以通过配置文件直接设置为禁用，其对应的配置字段为：zend.enable_gc。在php.ini文件中默认是没有这个字段的，如果我们需要禁用此功能，则在php.ini中添加zend.enable_gc=0或zend.enable_gc=off。除了修改php.ini配置zend.enable_gc，也可以通过调用gc_enable()/gc_disable()函数来打开/关闭垃圾回收机制。这些函数的调用效果与修改配置项来打开或关闭垃圾回收机制的效果是一样的。除了这两个函数PHP提供了gc_collect_cycles()函数可以在根缓冲区还没满时强制执行周期回收。与垃圾回收机制是否开启在PHP源码中有一些相关的操作和字段。在zend.c文件中有如下代码：

  1.  
  2. static ZEND_INI_MH(OnUpdateGCEnabled) /* {{{ */
  3. {
  4.     OnUpdateBool(entry, new_value, new_value_length, mh_arg1, mh_arg2, mh_arg3, stage TSRMLS_CC);
  5.  
  6.     if (GC_G(gc_enabled)) {
  7.         gc_init(TSRMLS_C);
  8.     }
  9.  
  10.     return SUCCESS;
  11. }
  12. /* }}} */
  13.  
  14. ZEND_INI_BEGIN()
  15.     ZEND_INI_ENTRY("error_reporting",               NULL,       ZEND_INI_ALL,       OnUpdateErrorReporting)
  16.     STD_ZEND_INI_BOOLEAN("zend.enable_gc",              "1",    ZEND_INI_ALL,       OnUpdateGCEnabled,      gc_enabled,     zend_gc_globals,        gc_globals)
  17. #ifdef ZEND_MULTIBYTE
  18.     STD_ZEND_INI_BOOLEAN("detect_unicode", "1", ZEND_INI_ALL, OnUpdateBool, detect_unicode, zend_compiler_globals, compiler_globals)
  19. #endif
  20. ZEND_INI_END()

zend.enable_gc对应的操作函数为ZEND_INI_MH(OnUpdateGCEnabled)，如果开启了垃圾回收机制，即GC_G(gc_enabled)为真，则会调用gc_init函数执行垃圾回收机制的初始化操作。gc_init函数在zend/zend_gc.c 121行，此函数会判断是否开启垃圾回收机制，如果开启，则初始化整个机制，即直接调用malloc给整个缓存列表分配10000个gc_root_buffer内存空间。这里的10000是硬编码在代码中的，以宏GC_ROOT_BUFFER_MAX_ENTRIES存在，如果需要修改这个值，则需要修改源码，重新编译PHP。gc_init函数在预分配内存后调用gc_reset函数重置整个机制用到的一些全局变量，如设置gc运行的次数统计(gc_runs)和gc中垃圾的个数(collected)为0，设置双向链表头结点的上一个结点和下一个结点指向自己等。除了这种提的一些用于垃圾回收机制的全局变量，还有其它一些使用较多的变量，部分说明如下：

  1. typedef struct _zend_gc_globals {
  2.     zend_bool         gc_enabled;   /* 是否开启垃圾收集机制 */
  3.     zend_bool         gc_active;    /* 是否正在进行 */
  4.  
  5.     gc_root_buffer   *buf;              /* 预分配的缓冲区数组，默认为10000（preallocated arrays of buffers）   */
  6.     gc_root_buffer    roots;            /* 列表的根结点（list of possible roots of cycles） */
  7.     gc_root_buffer   *unused;           /* 没有使用过的缓冲区列表(list of unused buffers)           */
  8.     gc_root_buffer   *first_unused;     /* 指向第一个没有使用过的缓冲区结点（pointer to first unused buffer）   */
  9.     gc_root_buffer   *last_unused;      /* 指向最后一个没有使用过的缓冲区结点，此处为标记结束用(pointer to last unused buffer)    */
  10.  
  11.     zval_gc_info     *zval_to_free;     /* 将要释放的zval变量的临时列表（temporaryt list of zvals to free） */
  12.     zval_gc_info     *free_list;        /* 临时变量，需要释放的列表开头 */
  13.     zval_gc_info     *next_to_free;     /* 临时变量，下一个将要释放的变量位置*/
  14.  
  15.     zend_uint gc_runs;  /* gc运行的次数统计 */
  16.     zend_uint collected;    /* gc中垃圾的个数 */
  17.  
  18.     // 省略...

}

当我们使用一个unset操作想清除这个变量所占的内存时（可能只是引用计数减一），会从当前符号的哈希表中删除变量名对应的项，在所有的操作执行完后，并对从符号表中删除的项调用一个析构函数，临时变量会调用zval_dtor，一般的变量会调用zval_ptr_dtor。

当然我们无法在PHP的函数集中找到unset函数，因为它是一种语言结构。 其对应的中间代码为ZEND_UNSET，在Zend/zend_vm_execute.h文件中你可以找到与它相关的实现。

zval_ptr_dtor并不是一个函数，只是一个长得有点像函数的宏。在Zend/zend_variables.h文件中，这个宏指向函数_zval_ptr_dtor。在Zend/zend_execute_API.c 424行，函数相关代码如下：

  1. ZEND_API void _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC) /* {{{ */
  2. {
  3. #if DEBUG_ZEND>=2
  4.     printf("Reducing refcount for %x (%x): %d->%d\n", *zval_ptr, zval_ptr, Z_REFCOUNT_PP(zval_ptr), Z_REFCOUNT_PP(zval_ptr) - 1);
  5. #endif
  6.     Z_DELREF_PP(zval_ptr);
  7.     if (Z_REFCOUNT_PP(zval_ptr) == 0) {
  8.         TSRMLS_FETCH();
  9.  
  10.         if (*zval_ptr != &EG(uninitialized_zval)) {
  11.             GC_REMOVE_ZVAL_FROM_BUFFER(*zval_ptr);
  12.             zval_dtor(*zval_ptr);
  13.             efree_rel(*zval_ptr);
  14.         }
  15.     } else {
  16.         TSRMLS_FETCH();
  17.  
  18.         if (Z_REFCOUNT_PP(zval_ptr) == 1) {
  19.             Z_UNSET_ISREF_PP(zval_ptr);
  20.         }
  21.  
  22.         GC_ZVAL_CHECK_POSSIBLE_ROOT(*zval_ptr);
  23.     }
  24. }
  25. /* }}} */

从代码我们可以很清晰的看出这个zval的析构过程，关于引用计数字段做了以下两个操作：

  • 如果变量的引用计数为1，即减一后引用计数为0，直接清除变量。如果当前变量如果被缓存，则需要清除缓存
  • 如果变量的引用计数大于1，即减一后引用计数大于0，则将变量放入垃圾列表。如果变量存在引用，则去掉其引用。
    将变量放入垃圾列表的操作是GC_ZVAL_CHECK_POSSIBLE_ROOT，这也是一个宏，其对应函数gc_zval_check_possible_root，但是此函数仅对数组和对象执行垃圾回收操作。对于数组和对象变量，它会调用gc_zval_possible_root函数。
  1. ZEND_API void gc_zval_possible_root(zval *zv TSRMLS_DC)
  2. {
  3.     if (UNEXPECTED(GC_G(free_list) != NULL &&
  4.                    GC_ZVAL_ADDRESS(zv) != NULL &&
  5.                    GC_ZVAL_GET_COLOR(zv) == GC_BLACK) &&
  6.                    (GC_ZVAL_ADDRESS(zv) < GC_G(buf) ||
  7.                     GC_ZVAL_ADDRESS(zv) >= GC_G(last_unused))) {
  8.         /* The given zval is a garbage that is going to be deleted by
  9.          * currently running GC */
  10.         return;
  11.     }
  12.  
  13.     if (zv->type == IS_OBJECT) {
  14.         GC_ZOBJ_CHECK_POSSIBLE_ROOT(zv);
  15.         return;
  16.     }
  17.  
  18.     GC_BENCH_INC(zval_possible_root);
  19.  
  20.     if (GC_ZVAL_GET_COLOR(zv) != GC_PURPLE) {
  21.         GC_ZVAL_SET_PURPLE(zv);
  22.  
  23.         if (!GC_ZVAL_ADDRESS(zv)) {
  24.             gc_root_buffer *newRoot = GC_G(unused);
  25.  
  26.             if (newRoot) {
  27.                 GC_G(unused) = newRoot->prev;
  28.             } else if (GC_G(first_unused) != GC_G(last_unused)) {
  29.                 newRoot = GC_G(first_unused);
  30.                 GC_G(first_unused)++;
  31.             } else {
  32.                 if (!GC_G(gc_enabled)) {
  33.                     GC_ZVAL_SET_BLACK(zv);
  34.                     return;
  35.                 }
  36.                 zv->refcount__gc++;
  37.                 gc_collect_cycles(TSRMLS_C);
  38.                 zv->refcount__gc--;
  39.                 newRoot = GC_G(unused);
  40.                 if (!newRoot) {
  41.                     return;
  42.                 }
  43.                 GC_ZVAL_SET_PURPLE(zv);
  44.                 GC_G(unused) = newRoot->prev;
  45.             }
  46.  
  47.             newRoot->next = GC_G(roots).next;
  48.             newRoot->prev = &GC_G(roots);
  49.             GC_G(roots).next->prev = newRoot;
  50.             GC_G(roots).next = newRoot;
  51.  
  52.             GC_ZVAL_SET_ADDRESS(zv, newRoot);
  53.  
  54.             newRoot->handle = 0;
  55.             newRoot->u.pz = zv;
  56.  
  57.             GC_BENCH_INC(zval_buffered);
  58.             GC_BENCH_INC(root_buf_length);
  59.             GC_BENCH_PEAK(root_buf_peak, root_buf_length);
  60.         }
  61.     }
  62. }

在前面说到gc_zval_check_possible_root函数仅对数组和对象执行垃圾回收操作，然而在gc_zval_possible_root函数中，针对对象类型的变量会去调用GC_ZOBJ_CHECK_POSSIBLE_ROOT宏。而对于其它的可用于垃圾回收的机制的变量类型其调用过程如下：

  • 检查zval结点信息是否已经放入到结点缓冲区，如果已经放入到结点缓冲区，则直接返回，这样可以优化其性能。然后处理对象结点，直接返回，不再执行后面的操作
  • 判断结点是否已经被标记为紫色，如果为紫色则不再添加到结点缓冲区，此处在于保证一个结点只执行一次添加到缓冲区的操作。
  • 将结点的颜色标记为紫色，表示此结点已经添加到缓冲区，下次不用再做添加
  • 找出新的结点的位置，如果缓冲区满了，则执行垃圾回收操作。

  • 将新的结点添加到缓冲区所在的双向链表。
    在gc_zval_possible_root函数中，当缓冲区满时，程序调用gc_collect_cycles函数，执行垃圾回收操作。其中最关键的几步就是：

  • 第628行 此处为其官方文档中算法的步骤 B ，算法使用深度优先搜索查找所有可能的根，找到后将每个变量容器中的引用计数减1，为确保不会对同一个变量容器减两次“1”，用灰色标记已减过1的。

  • 第629行 这是算法的步骤 C ，算法再一次对每个根节点使用深度优先搜索，检查每个变量容器的引用计数。如果引用计数是 0 ，变量容器用白色来标记。如果引用次数大于0，则恢复在这个点上使用深度优先搜索而将引用计数减1的操作（即引用计数加1），然后将它们重新用黑色标记。

  • 第630行 算法的最后一步 D ，算法遍历根缓冲区以从那里删除变量容器根(zval roots)，同时，检查是否有在上一步中被白色标记的变量容器。每个被白色标记的变量容器都被清除。在[gc_collect_cycles() -> gc_collect_roots() -> zval_collect_white() ]中我们可以看到，对于白色标记的结点会被添加到全局变量zval_to_free列表中。此列表在后面的操作中有用到。
    PHP的垃圾回收机制在执行过程中以四种颜色标记状态。

  • GC_WHITE 白色表示垃圾

  • GC_PURPLE 紫色表示已放入缓冲区
  • GC_GREY 灰色表示已经进行了一次refcount的减一操作
  • GC_BLACK 黑色是默认颜色，正常
    相关的标记以及操作代码如下：
  1. #define GC_COLOR  0x03
  2.  
  3. #define GC_BLACK  0x00
  4. #define GC_WHITE  0x01
  5. #define GC_GREY   0x02
  6. #define GC_PURPLE 0x03
  7.  
  8. #define GC_ADDRESS(v) \
  9.     ((gc_root_buffer*)(((zend_uintptr_t)(v)) & ~GC_COLOR))
  10. #define GC_SET_ADDRESS(v, a) \
  11.     (v) = ((gc_root_buffer*)((((zend_uintptr_t)(v)) & GC_COLOR) | ((zend_uintptr_t)(a))))
  12. #define GC_GET_COLOR(v) \
  13.     (((zend_uintptr_t)(v)) & GC_COLOR)
  14. #define GC_SET_COLOR(v, c) \
  15.     (v) = ((gc_root_buffer*)((((zend_uintptr_t)(v)) & ~GC_COLOR) | (c)))
  16. #define GC_SET_BLACK(v) \
  17.     (v) = ((gc_root_buffer*)(((zend_uintptr_t)(v)) & ~GC_COLOR))
  18. #define GC_SET_PURPLE(v) \
  19.     (v) = ((gc_root_buffer*)(((zend_uintptr_t)(v)) | GC_PURPLE))

以上的这种以位来标记状态的方式在PHP的源码中使用频率较高，如内存管理等都有用到，这是一种比较高效及节省的方案。但是在我们做数据库设计时可能对于字段不能使用这种方式，应该是以一种更加直观，更加具有可读性的方式实现。

原文: http://www.php-internals.com/book?p=chapt06/06-04-01-new-garbage-collection