├── README.md ├── demo └── demo.c ├── img ├── reference.png └── zval.png ├── reference.md └── zval.md /README.md: -------------------------------------------------------------------------------- 1 | # php7-internal 2 | 3 | #### 版权申明 4 | ```` 5 | 本文是原创作品，包括文字、资料、图片、网页格式，转载时请标注作者与来源。非经允许，不得用于赢利目的。 6 | ```` 7 | 8 | - [深入理解PHP7之zval](https://github.com/laruence/php7-internal/blob/master/zval.md) 9 | - [深入理解PHP7之REFERENCE](https://github.com/laruence/php7-internal/blob/master/reference.md) 10 | -------------------------------------------------------------------------------- /demo/demo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char **argv) { 4 | printf("%s\n", "Hello PHP7!"); 5 | return 0; 6 | } 7 | -------------------------------------------------------------------------------- /img/reference.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laruence/php7-internal/3cbc04f165a304a1dff32224fe5b1f0af2a5e8b7/img/reference.png -------------------------------------------------------------------------------- /img/zval.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laruence/php7-internal/3cbc04f165a304a1dff32224fe5b1f0af2a5e8b7/img/zval.png -------------------------------------------------------------------------------- /reference.md: -------------------------------------------------------------------------------- 1 | ### 深入理解PHP7之REFERENCE 2 | 3 | ##### 版权申明: 4 | ```` 5 | 本文是原创作品，包括文字、资料、图片、网页格式，转载时请标注作者与来源。非经允许，不得用于赢利目的。 6 | ```` 7 | 8 | #### REFERENCE 9 | 上一章说过引用(REFERENCE)在PHP5的时候是一个标志位, 而在PHP7以后我们把它变成了一种新的类型:`IS_REFERNCE`. 然而引用是一种很常见的应用, 所以这个变化带来了很多的变化, 也给我们在做PHP7开发的时候, 因为有的时候疏忽忘了处理这个类型, 而带来不少的bug. 10 | 11 | 最简单的情况, 就是在处理各种类型的时候, 从此以后我们要多考虑这种新的类型, 比如在PHP7中, 这样的代码形式就变得很常见了: 12 | ````c 13 | try_again: 14 | swtich (Z_TYPE_P(zv)) { 15 | case IS_TRING: 16 | break; 17 | case IS_ARRAY: 18 | break; 19 | ... 20 | case IS_REFERENCE: 21 | zv = Z_REFVAL_P(zv); //解引用 22 | goto try_again; 23 | break; 24 | } 25 | ```` 26 | 27 | 如果大家自己写的扩展, 如果忘了考虑这种新的类型, 那么就会导致问题. 28 | 29 | #### 为什么? 30 | 那么既然这种新类型会带来这么多问题, 那么当时为什么要用把引用变成一种类型呢? 为什么不还是使用一个标志位呢? 31 | 32 | 一句话来说, 就是我们不得不这么做. -_# 33 | 34 | 前面说到, Hashtable直接存储的是zval, 这样在符号表中, 俩个zval如何共用一个数值呢? 对于字符串等复杂类型来说还好, 我们貌似可以在`zend_refcounted`结构中加入一个标志位来表明是引用来解决, 然而这个也会遇到Change On Write带来的复制, 但是我们知道在PHP7中, 一些类型是直接存储在zval中的, 比如`IS_LONG`, 但是引用类型是需要引用计数的, 那么对于一个是`IS_LONG`并且又是`IS_REFERNCE`的zval该如何表示呢? 35 | 36 | 为此, 我们创造了这个新的类型: 37 | 38 | ![IS_REFERNCE](/img/reference.png) 39 | 40 | 如图所示, 引用是一种新的类型:`zend_reference`, 对于`IS_REFERNCE`类型的zval, `zval.value.ref`是一个指向`zend_reference`的指针, 它包含了引用计数和一个zval, 具体的zval的值是存在`zval.value.ref->val`中的. 41 | 42 | 所以对于`IS_LONG`的引用来说, 就用一个类型是`IS_REFERNCE`的zval, 它指向一个`zend_reference`, 而这个`zend_reference->val`中是一个类型为`IS_LONG`的zval. 43 | 44 | #### Change On Write 45 | PHP采用引用计数来做简单的垃圾回收, 考虑如下的代码: 46 | ````php 47 | 52 | ```` 53 | `$ref`和`$val`是指向同一个zval的引用, 在PHP5的时候, 我们是通过一个引用计数为2, 并且引用标志位为1来表示这种情况, 当把`$val`复制给`$copy`(line 3)的时候, 我们发现$val是一个计数大于1的引用, 所以要产生Change on write, 也就是分离. 所以我们需要复制这个zval. 54 | 55 | 而在PHP7中, 情况就变得简单了很多, 首先在引用赋值给`$ref`(line 2)的时候, 生成一个`IS_REFERNCE`类型, 然后因为此时有俩个变量引用它所以`zend_reference`这个结构的引用计数`zval.value.ref->gc.refcount`为2. 56 | 57 | 再随后的赋值给`$copy`(line 3)的时候, 发现`$val`是一个引用, 于是让`$copy`指向的是`zval.value.ref->val`, 也就是字符串值为`laruence`的zval, 然后把zval的引用计数+1, 也就是`zval.value.ref->val.value.str.gc.refcount`为2. 并没有产生复制. 58 | 59 | 从而这就很好的解决了上一章所说的PHP5的那个经典的问题, 比如我们在PHP7下运行上一章的那个问题, 我们得到的结果是: 60 | ```` 61 | $ php-7.0/sapi/cli/php /tmp/1.php 62 | Used 0.00021380008539 63 | Used 0.00020173048281 64 | ```` 65 | 66 | 可见确实没有发生复制, 从而不会产生任何的性能问题. 67 | 68 | #### 69 | 70 | 待续.... 71 | -------------------------------------------------------------------------------- /zval.md: -------------------------------------------------------------------------------- 1 | ### 深入理解PHP7之zval 2 | 3 | PHP7已经发布, 如承诺, 我也要开始这个系列的文章的编写, 今天我想先和大家聊聊zval的变化. 在讲zval变化的之前我们先来看看zval在PHP5下面是什么样子 4 | 5 | ##### 版权申明: 6 | ```` 7 | 本文是原创作品，包括文字、资料、图片、网页格式，转载时请标注作者与来源。非经允许，不得用于赢利目的。 8 | ```` 9 | 10 | #### PHP5 11 | ##### zval回顾 12 | 在PHP5的时候, zval的定义如下: 13 | ````c 14 | struct _zval_struct { 15 | union { 16 | long lval; 17 | double dval; 18 | struct { 19 | char *val; 20 | int len; 21 | } str; 22 | HashTable *ht; 23 | zend_object_value obj; 24 | zend_ast *ast; 25 | } value; 26 | zend_uint refcount__gc; 27 | zend_uchar type; 28 | zend_uchar is_ref__gc; 29 | }; 30 | 31 | ```` 32 | 33 | 对PHP5内核有了解的同学应该对这个结构比较熟悉, 因为zval可以表示一切PHP中的数据类型, 所以它包含了一个type字段, 表示这个zval存储的是什么类型的值, 常见的可能选项是`IS_NULL`, `IS_LONG`, `IS_STRING`, `IS_ARRAY`, `IS_OBJECT`等等. 34 | 35 | 根据type字段的值不同, 我们就要用不同的方式解读value的值, 这个value是个联合体, 比如对于type是`IS_STRING`, 那么我们应该用`value.str`来解读`zval.value`字段, 而如果type是`IS_LONG`, 那么我们就要用`value.lval`来解读. 36 | 37 | 另外, 我们知道PHP是用引用计数来做基本的垃圾回收的, 所以zval中有一个`refcount__gc`字段, 表示这个zval的引用数目, 但这里有一个要说明的, 在5.3以前, 这个字段的名字还叫做`refcount`, 5.3以后, 在引入新的垃圾回收算法来对付循环引用计数的时候, 作者加入了大量的宏来操作`refcount`, 为了能让错误更快的显现, 所以改名为`refcount__gc`, 迫使大家都使用宏来操作`refcount`. 38 | 39 | 类似的, 还有`is_ref`, 这个值表示了PHP中的一个类型是否是引用, 这里我们可以看到是不是引用是一个标志位. 40 | 41 | 这就是PHP5时代的zval, 在2013年我们做PHP5的opcache JIT的时候, 因为JIT在实际项目中表现不佳, 我们转而意识到这个结构体的很多问题. 而PHPNG项目就是从改写这个结构体而开始的. 42 | 43 | ##### 存在的问题 44 | 45 | PHP5的zval定义是随着Zend Engine 2诞生的, 随着时间的推移, 当时设计的局限性也越来越明显: 46 | 47 | 首先这个结构体的大小是(在64位系统)24个字节, 我们仔细看这个`zval.value`联合体, 其中`zend_object_value`是最大的长板, 它导致整个value需要16个字节, 这个应该是很容易可以优化掉的, 比如把它挪出来, 用个指针代替,因为毕竟`IS_OBJECT`也不是最最常用的类型. 48 | 49 | 第二, 这个结构体的每一个字段都有明确的含义定义, 没有预留任何的自定义字段, 导致在PHP5时代做很多的优化的时候, 需要存储一些和zval相关的信息的时候, 不得不采用其他结构体映射, 或者外部包装后打补丁的方式来扩充zval, 比如5.3的时候新引入专门解决循环引用的GC, 它不得采用如下的比较hack的做法: 50 | ````c 51 | /* The following macroses override macroses from zend_alloc.h */ 52 | #undef ALLOC_ZVAL 53 | #define ALLOC_ZVAL(z) \ 54 | do { \ 55 | (z) = (zval*)emalloc(sizeof(zval_gc_info)); \ 56 | GC_ZVAL_INIT(z); \ 57 | } while (0) 58 | ```` 59 | 60 | 它用`zval_gc_info`劫持了zval的分配: 61 | ````c 62 | typedef struct _zval_gc_info { 63 | zval z; 64 | union { 65 | gc_root_buffer *buffered; 66 | struct _zval_gc_info *next; 67 | } u; 68 | } zval_gc_info; 69 | ```` 70 | 71 | 然后用`zval_gc_info`来扩充了zval, 所以实际上来说我们在PHP5时代申请一个zval其实真正的是分配了32个字节, 但其实GC只需要关心`IS_ARRAY和IS_OBJECT`类型, 这样就导致了大量的内存浪费. 72 | 73 | 还比如我之前做的Taint扩展, 我需要对于给一些字符串存储一些标记, zval里没有任何地方可以使用, 所以我不得不采用非常手段: 74 | ````c 75 | Z_STRVAL_PP(ppzval) = erealloc(Z_STRVAL_PP(ppzval), Z_STRLEN_PP(ppzval) + 1 + PHP_TAINT_MAGIC_LENGTH); 76 | PHP_TAINT_MARK(*ppzval, PHP_TAINT_MAGIC_POSSIBLE); 77 | ```` 78 | 就是把字符串的长度扩充一个int, 然后用magic number做标记写到后面去, 这样的做法安全性和稳定性在技术上都是没有保障的 79 | 80 | 第三, PHP的zval大部分都是按值传递, 写时拷贝的值, 但是有俩个例外, 就是对象和资源, 他们永远都是按引用传递, 这样就造成一个问题, 对象和资源在除了zval中的引用计数以外, 还需要一个全局的引用计数, 这样才能保证内存可以回收. 所以在PHP5的时代, 以对象为例, 它有俩套引用计数, 一个是zval中的, 另外一个是obj自身的计数: 81 | ````c 82 | typedef struct _zend_object_store_bucket { 83 | zend_bool destructor_called; 84 | zend_bool valid; 85 | union _store_bucket { 86 | struct _store_object { 87 | void *object; 88 | zend_objects_store_dtor_t dtor; 89 | zend_objects_free_object_storage_t free_storage; 90 | zend_objects_store_clone_t clone; 91 | const zend_object_handlers *handlers; 92 | zend_uint refcount; 93 | gc_root_buffer *buffered; 94 | } obj; 95 | struct { 96 | int next; 97 | } free_list; 98 | } bucket; 99 | } zend_object_store_bucket; 100 | ```` 101 | 102 | 除了上面提到的两套引用以外, 如果我们要获取一个object, 则我们需要通过如下方式: 103 | 104 | ````c 105 | EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(z)].bucket.obj 106 | ```` 107 | 108 | 经过漫长的多次内存读取, 才能获取到真正的objec对象本身. 效率可想而知. 109 | 110 | 这一切都是因为Zend引擎最初设计的时候, 并没有考虑到后来的对象. 一个良好的设计, 一旦有了意外, 就会导致整个结构变得复杂, 维护性降低, 这是一个很好的例子. 111 | 112 | 第四, 我们知道PHP中, 大量的计算都是面向字符串的, 然而因为引用计数是作用在zval的, 那么就会导致如果要拷贝一个字符串类型的zval, 我们别无他法只能复制这个字符串. 当我们把一个zval的字符串作为key添加到一个数组里的时候, 我们别无他法只能复制这个字符串. 虽然在PHP5.4的时候, 我们引入了INTERNED STRING, 但是还是不能根本解决这个问题. 113 | 114 | 还比如, PHP中大量的结构体都是基于Hashtable实现的, 增删改查Hashtable的操作占据了大量的CPU时间, 而字符串要查找首先要求它的Hash值, 理论上我们完全可以把一个字符串的Hash值计算好以后, 就存下来, 避免再次计算等等 115 | 116 | 第五, 这个是关于引用的, PHP5的时代, 我们采用写时分离, 但是结合到引用这里就有了一个经典的性能问题: 117 | 118 | ````php 119 | 129 | ```` 130 | 131 | 当我们调用dummy的时候, 本来只是简单的一个传值就行的地方, 但是因为$array曾经引用赋值给了$b, 所以导致$array变成了一个引用, 于是此处就会发生分离, 导致数组复制, 从而极大的拖慢性能, 这里有一个简单的测试: 132 | 133 | ````php 134 | 155 | ```` 156 | 157 | 我们在5.6下运行这个例子, 得到如下结果: 158 | ```` 159 | $ php-5.6/sapi/cli/php /tmp/1.php 160 | Used 0.00045204162597656S 161 | Used 4.2051479816437S 162 | ```` 163 | 相差1万倍之多. 这就造成, 如果在一大段代码中, 我不小心把一个变量变成了引用(比如foreach as &$v), 那么就有可能触发到这个问题, 造成严重的性能问题, 然而却又很难排查. 164 | 165 | 第六, 也是最重要的一个, 为什么说它重要呢? 因为这点促成了很大的性能提升, 我们习惯了在PHP5的时代调用`MAKE_STD_ZVAL`在堆内存上分配一个zval, 然后对他进行操作, 最后呢通过`RETURN_ZVAL`把这个zval的值"copy"给`return_value`, 然后又销毁了这个zval, 比如`pathinfo`这个函数: 166 | ````c 167 | PHP_FUNCTION(pathinfo) 168 | { 169 | ..... 170 | MAKE_STD_ZVAL(tmp); 171 | array_init(tmp); 172 | ..... 173 | 174 | if (opt == PHP_PATHINFO_ALL) { 175 | RETURN_ZVAL(tmp, 0, 1); 176 | } else { 177 | ..... 178 | } 179 | ```` 180 | 181 | 这个tmp变量, 完全是一个临时变量的作用, 我们又何必在堆内存分配它呢? `MAKE_STD_ZVAL/ALLOC_ZVAL`在PHP5的时候, 到处都有, 是一个非常常见的用法, 如果我们能把这个变量用栈分配, 那无论是内存分配, 还是缓存友好, 都是非常有利的 182 | 183 | 还有很多, 我就不一一详细列举了, 但是我相信你们也有了和我们当时一样的想法, zval必须得改改了, 对吧? 184 | 185 | #### PHP7 186 | 187 | ##### 现在的zval 188 | 到了PHP7中, zval变成了如下的结构, 要说明的是, 这个是现在的结构, 已经和PHPNG时候有了一些不同了, 因为我们新增加了一些解释 (联合体的字段), 但是总体大小, 结构, 是和PHPNG的时候一致的: 189 | ````c 190 | struct _zval_struct { 191 | union { 192 | zend_long lval; /* long value */ 193 | double dval; /* double value */ 194 | zend_refcounted *counted; 195 | zend_string *str; 196 | zend_array *arr; 197 | zend_object *obj; 198 | zend_resource *res; 199 | zend_reference *ref; 200 | zend_ast_ref *ast; 201 | zval *zv; 202 | void *ptr; 203 | zend_class_entry *ce; 204 | zend_function *func; 205 | struct { 206 | uint32_t w1; 207 | uint32_t w2; 208 | } ww; 209 | } value; 210 | union { 211 | struct { 212 | ZEND_ENDIAN_LOHI_4( 213 | zend_uchar type, /* active type */ 214 | zend_uchar type_flags, 215 | zend_uchar const_flags, 216 | zend_uchar reserved) /* call info for EX(This) */ 217 | } v; 218 | uint32_t type_info; 219 | } u1; 220 | union { 221 | uint32_t var_flags; 222 | uint32_t next; /* hash collision chain */ 223 | uint32_t cache_slot; /* literal cache slot */ 224 | uint32_t lineno; /* line number (for ast nodes) */ 225 | uint32_t num_args; /* arguments number for EX(This) */ 226 | uint32_t fe_pos; /* foreach position */ 227 | uint32_t fe_iter_idx; /* foreach iterator index */ 228 | } u2; 229 | }; 230 | ```` 231 | 232 | 虽然看起来变得好大, 但其实你仔细看, 全部都是联合体, 这个新的zval在64位环境下,现在只需要16个字节(2个指针size), 它主要分为俩个部分, `value`和扩充字段, 而扩充字段又分为`u1`和`u2`俩个部分, 其中`u1`是type info, `u2`是各种辅助字段. 233 | 234 | 235 | 其中`value`部分, 是一个`size_t`大小(一个指针大小), 可以保存一个指针, 或者一个`long`, 或者一个`double`. 236 | 237 | 而type info部分则保存了这个zval的类型. 扩充辅助字段则会在多个其他地方使用, 比如`next`, 就用在取代Hashtable中原来的拉链指针, 这部分会在以后介绍HashTable的时候再来详解. 238 | 239 | 240 | ##### 类型 241 | 242 | PHP7中的zval的类型做了比较大的调整, 总体来说有如下17种类型: 243 | ````c 244 | /* regular data types */ 245 | #define IS_UNDEF 0 246 | #define IS_NULL 1 247 | #define IS_FALSE 2 248 | #define IS_TRUE 3 249 | #define IS_LONG 4 250 | #define IS_DOUBLE 5 251 | #define IS_STRING 6 252 | #define IS_ARRAY 7 253 | #define IS_OBJECT 8 254 | #define IS_RESOURCE 9 255 | #define IS_REFERENCE 10 256 | 257 | /* constant expressions */ 258 | #define IS_CONSTANT 11 259 | #define IS_CONSTANT_AST 12 260 | 261 | /* fake types */ 262 | #define _IS_BOOL 13 263 | #define IS_CALLABLE 14 264 | 265 | /* internal types */ 266 | #define IS_INDIRECT 15 267 | #define IS_PTR 17 268 | ```` 269 | 270 | 其中PHP5的时候的`IS_BOOL`类型, 现在拆分成了`IS_FALSE`和`IS_TRUE`俩种类型. 而原来的引用是一个标志位, 现在的引用是一种新的类型. 271 | 272 | 对于`IS_INDIRECT`和`IS_PTR`来说, 这俩个类型是用在内部的保留类型, 用户不会感知到, 这部分会在后续介绍HashTable的时候也一并介绍. 273 | 274 | 从PHP7开始, 对于在zval的`value`字段中能保存下的值, 就不再对他们进行引用计数了, 而是在拷贝的时候直接赋值, 这样就省掉了大量的引用计数相关的操作, 这部分类型有: 275 | ```` 276 | IS_LONG 277 | IS_DOUBLE 278 | ```` 279 | 当然对于那种根本没有值, 只有类型的类型, 也不需要引用计数了: 280 | ```` 281 | IS_NULL 282 | IS_FALSE 283 | IS_TRUE 284 | ```` 285 | 286 | 而对于复杂类型, 一个`size_t`保存不下的, 那么我们就用`value`来保存一个指针, 这个指针指向这个具体的值, 引用计数也随之作用于这个值上, 而不在是作用于zval上了. 287 | 288 | ![zval示意图](img/zval.png) 289 | 290 | 以`IS_ARRAY`为例: 291 | 292 | ````c 293 | struct _zend_array { 294 | zend_refcounted_h gc; 295 | union { 296 | struct { 297 | ZEND_ENDIAN_LOHI_4( 298 | zend_uchar flags, 299 | zend_uchar nApplyCount, 300 | zend_uchar nIteratorsCount, 301 | zend_uchar reserve) 302 | } v; 303 | uint32_t flags; 304 | } u; 305 | uint32_t nTableMask; 306 | Bucket *arData; 307 | uint32_t nNumUsed; 308 | uint32_t nNumOfElements; 309 | uint32_t nTableSize; 310 | uint32_t nInternalPointer; 311 | zend_long nNextFreeElement; 312 | dtor_func_t pDestructor; 313 | }; 314 | ```` 315 | 316 | `zval.value.arr`将指向上面的这样的一个结构体, 由它实际保存一个数组, 引用计数部分保存在`zend_refcounted_h`结构中: 317 | ````c 318 | typedef struct _zend_refcounted_h { 319 | uint32_t refcount; /* reference counter 32-bit */ 320 | union { 321 | struct { 322 | ZEND_ENDIAN_LOHI_3( 323 | zend_uchar type, 324 | zend_uchar flags, /* used for strings & objects */ 325 | uint16_t gc_info) /* keeps GC root number (or 0) and color */ 326 | } v; 327 | uint32_t type_info; 328 | } u; 329 | } zend_refcounted_h; 330 | ```` 331 | 332 | 所有的复杂类型的定义, 开始的时候都是`zend_refcounted_h`结构, 这个结构里除了引用计数以外, 还有GC相关的结构. 从而在做GC回收的时候, GC不需要关心具体类型是什么, 所有的它都可以当做`zend_refcounted*`结构来处理. 333 | 334 | 另外有一个需要说明的就是大家可能会好奇的`ZEND_ENDIAN_LOHI_4`宏, 这个宏的作用是简化赋值, 它会保证在大端或者小端的机器上, 它定义的字段都按照一样顺序排列存储, 从而我们在赋值的时候, 不需要对它的字段分别赋值, 而是可以统一赋值, 比如对于上面的array结构为例, 就可以通过: 335 | ````c 336 | arr1.u.flags = arr2.u.flags; 337 | ```` 338 | 一次完成相当于如下的赋值序列: 339 | ````c 340 | arr1.u.v.flags = arr2.u.v.flags; 341 | arr1.u.v.nApplyCount = arr2.u.v.nApplyCount; 342 | arr1.u.v.nIteratorsCount = arr2.u.v.nIteratorsCount; 343 | arr1.u.v.reserve = arr2.u.v.reserve; 344 | ```` 345 | 346 | 还有一个大家可能会问到的问题是, 为什么不把type类型放到zval类型的前面, 因为我们知道当我们去用一个zval的时候, 首先第一点肯定是先去获取它的类型. 这里的一个原因是, 一个是俩者差别不大, 另外就是考虑到如果以后JIT的话, zval的类型如果能够通过类型推导获得, 就根本没有必要去读取它的type值了. 347 | 348 | ##### 标志位 349 | 350 | 除了数据类型以外， 以前的经验也告诉我们， 一个数据除了它的类型以外， 还应该有很多其他的属性， 比如对于INTERNED STRING，它是一种在整个PHP请求期都存在的字符串(比如你写在代码中的字面量), 它不会被引用计数回收. 在5.4的版本中我们是通过预先申请一块内存， 然后再这个内存中分配字符串， 最后用指针地址来比较， 如果一个字符串是属于INTERNED STRING的内存范围内， 就认为它是INTERNED STRING. 这样做的缺点显而易见， 就是当内存不够的时候， 我们就没有办法分配INTERNED STRING了， 另外也非常丑陋， 所以如果一个字符串能有一些属性定义则这个实现就可以变得很优雅. 351 | 352 | 还有， 比如现在我们对于`IS_LONG`, `IS_TRUE`等类型不再进行引用计数了， 那么当我们拿到一个zval的时候如何判断它需要不需要引用计数呢？ 想当然的我们可能会说用: 353 | ````c 354 | if (Z_TYPE_P(zv) >= IS_STRING) { 355 | //需要引用计数 356 | } 357 | ```` 358 | 359 | 但是你忘了， 还有INTERNED STRING的存在啊， 所以你也许要这么写了： 360 | ````c 361 | if (Z_TYPE_P(zv) >= IS_STRING && !IS_INTERNED(Z_STR_P(zv))) { 362 | //需要引用计数 363 | } 364 | ```` 365 | 366 | 是不是已经让你感觉到有点不对劲了? 嗯，别急， 还有呢， 我们还在5.6的时候引入了常量数组， 这个数组呢会存储在Opcache的共享内存中， 它也不需要引用计数： 367 | 368 | ````c 369 | if (Z_TYPE_P(zv) >= IS_STRING && !IS_INTERNED(Z_STR_P(zv)) 370 | && (Z_TYPE_P(zv) != IS_ARRAY || !Z_IS_IMMUTABLE(Z_ARRVAL(zv)))) { 371 | //需要引用计数 372 | } 373 | ```` 374 | 你是不是也觉得这简直太丑陋了， 简直不能忍受这样墨迹的代码， 对吧？ 375 | 376 | 是的，我们早想到了，回头看之前的zval定义， 注意到`type_flags`了么? 我们引入了一个标志位， 叫做`IS_TYPE_REFCOUNTED`, 它会保存在`zval.u1.v.type_flags`中， 我们对于需要引用计数的类型就赋予这个标志， 所以上面的判断就可以变得很优雅： 377 | ````c 378 | if (!(Z_TYPE_FLAGS(zv) & IS_TYPE_REFCOUNTED)) { 379 | } 380 | ```` 381 | 382 | 而对于INTERNED STRING来说， 这个`IS_STR_INTERNED`标志位应该是作用于字符串本身而不是zval的. 383 | 384 | 那么类似这样的标志位一共有多少呢？作用于zval的有： 385 | ````c 386 | IS_TYPE_CONSTANT //是常量类型 387 | IS_TYPE_IMMUTABLE //不可变的类型， 比如存在共享内存的数组 388 | IS_TYPE_REFCOUNTED //需要引用计数的类型 389 | IS_TYPE_COLLECTABLE //可能包含循环引用的类型(IS_ARRAY, IS_OBJECT) 390 | IS_TYPE_COPYABLE //可被复制的类型， 还记得我之前讲的对象和资源的例外么？ 对象和资源就不是 391 | IS_TYPE_SYMBOLTABLE //zval保存的是全局符号表， 这个在我之前做了一个调整以后没用了， 但还保留着兼容， 392 | //下个版本会去掉 393 | ```` 394 | 作用于字符串的有: 395 | ````c 396 | IS_STR_PERSISTENT //是malloc分配内存的字符串 397 | IS_STR_INTERNED //INTERNED STRING 398 | IS_STR_PERMANENT //不可变的字符串， 用作哨兵作用 399 | IS_STR_CONSTANT //代表常量的字符串 400 | IS_STR_CONSTANT_UNQUALIFIED //带有可能命名空间的常量字符串 401 | ```` 402 | 作用于数组的有: 403 | ````c 404 | #define IS_ARRAY_IMMUTABLE //同IS_TYPE_IMMUTABLE 405 | ```` 406 | 作用于对象的有： 407 | ````c 408 | IS_OBJ_APPLY_COUNT //递归保护 409 | IS_OBJ_DESTRUCTOR_CALLED //析构函数已经调用 410 | IS_OBJ_FREE_CALLED //清理函数已经调用 411 | IS_OBJ_USE_GUARDS //魔术方法递归保护 412 | IS_OBJ_HAS_GUARDS //是否有魔术方法递归保护标志 413 | ```` 414 | 有了这些预留的标志位， 我们就会很方便的做一些以前不好做的事情， 就比如我自己的Taint扩展， 现在把一个字符串标记为污染的字符串就会变得无比简单： 415 | ````c 416 | /* it's important that make sure 417 | * this value is not used by Zend or 418 | * any other extension agianst string */ 419 | #define IS_STR_TAINT_POSSIBLE (1<<7) 420 | #define TAINT_MARK(str) (GC_FLAGS((str)) |= IS_STR_TAINT_POSSIBLE) 421 | ```` 422 | 这个标记就会一直随着这个字符串的生存而存在的， 省掉了我之前的很多tricky的做法. 423 | 424 | #### ZVAL预先分配 425 | 前面我们说过, PHP5的zval分配采用的是堆上分配内存, 也就是在PHP预案代码中随处可见的MAKE_STD_ZVAL和ALLOC_ZVAL宏. 我们也知道了本来一个zval只需要24个字节, 但是算上gc_info, 其实分配了32个字节, 再加上PHP自己的内存管理在分配内存的时候都会在内存前面保留一部分信息: 426 | ````c 427 | typedef struct _zend_mm_block { 428 | zend_mm_block_info info; 429 | #if ZEND_DEBUG 430 | unsigned int magic; 431 | # ifdef ZTS 432 | THREAD_T thread_id; 433 | # endif 434 | zend_mm_debug_info debug; 435 | #elif ZEND_MM_HEAP_PROTECTION 436 | zend_mm_debug_info debug; 437 | #endif 438 | } zend_mm_block; 439 | ```` 440 | 441 | 从而导致实际上我们只需要24字节的内存, 但最后竟然分配48个字节之多. 442 | 443 | 444 | 然而大部分的zval, 尤其是扩展函数内的zval, 我们想想它接受的参数来自外部的zval, 它把返回值返回给return_value, 这个也是来自外部的zval, 而中间变量的zval完全可以采用栈上分配. 也就是说大部分的内部函数都不需要在堆上分配内存, 它需要的zval都可以来自外部. 445 | 446 | 于是当时我们做了一个大胆的想法, 所有的zval都不需要单独申请. 447 | 448 | 而这个也很容易证明, PHP脚本中使用的zval, 要么存在于符号表, 要么就以临时变量(`IS_TMP_VAR`)或者编译变量(`IS_CV`)的形式存在. 前者存在于一个Hashtable中, 而在PHP7中Hashtable默认保存的就是zval, 这部分的zval完全可以在Hashtable分配的时候一次性分配出来, 后面的存在于execute_data之后, 数量也在编译时刻确定好了, 也可以随着execute_data一次性分配, 所以我们确实不再需要单独在堆上申请zval了. 449 | 450 | 所以, 在PHP7开始, 我们移除了MAKE_STD_ZVAL/ALLOC_ZVAL宏, 不再支持存堆内存上申请zval. 函数内部使用的zval要么来自外面输入, 要么使用在栈上分配的临时zval. 451 | 452 | 在后来的实践中, 总结出来的可能对于开发者来说最大的变化就是, 之前的一些内部函数, 通过一些操作获得一些信息, 然后分配一个zval, 返回给调用者的情况: 453 | ````c 454 | static zval * php_internal_function() { 455 | ..... 456 | str = external_function(); 457 | 458 | MAKE_STD_ZVAL(zv); 459 | 460 | ZVAL_STRING(zv, str, 0); 461 | 462 | return zv; 463 | } 464 | PHP_FUNCTION(test) { 465 | RETURN_ZVAL(php_internal_function(), 1, 1); 466 | } 467 | ```` 468 | 469 | 要么修改为, 这个zval由调用者传递: 470 | 471 | ````c 472 | static void php_internal_function(zval *zv) { 473 | ..... 474 | str = external_function(); 475 | 476 | ZVAL_STRING(zv, str); 477 | efree(str); 478 | } 479 | 480 | PHP_FUNCTION(test) { 481 | php_internal_function(return_value); 482 | } 483 | ```` 484 | 485 | 要么修改为, 这个函数返回原始素材: 486 | ````c 487 | static char * php_internal_function() { 488 | ..... 489 | str = external_function(); 490 | return str; 491 | } 492 | 493 | PHP_FUNCTION(test) { 494 | str = php_internal_function(); 495 | RETURN_STRING(str); 496 | efree(str); 497 | } 498 | ```` 499 | 500 | #### 总结 501 | 502 | (这块还没想好怎么说, 本来我是要引出Hashtable不再存在zval**, 从而引出引用类型的存在的必要性, 但是如果不先讲Hashtable的结构, 这个引出貌似很突兀, 先这么着吧, 以后再来修改) 503 | 504 | 到现在我们基本上把zval的变化概况介绍完毕, 抽象的来说, 其实在PHP7中的zval, 已经变成了一个值指针, 它要么保存着原始值, 要么保存着指向一个保存原始值的指针. 也就是说现在的zval相当于PHP5的时候的zval *. 只不过相比于zval *, 直接存储zval, 我们可以省掉一次指针解引用, 从而提高缓存友好性. 505 | 506 | 其实PHP7的性能, 我们并没有引入什么新的技术模式, 不过就是主要来自, 持续不懈的降低内存占用, 提高缓存友好性, 降低执行的指令数的这些原则而来的, 可以说PHP7的重构就是这三个原则. 507 | --------------------------------------------------------------------------------