了解什么是PHP7虚拟机

广告:宝塔Linux面板高效运维的服务器管理软件 点击【 https://www.bt.cn/p/uNLv1L 】立即购买

了解什么是PHP7虚拟机

本文内容大部分翻译自Getting into the Zend Execution engine (PHP 5),并做了一些调整,原文基于PHP 5,本文基于PHP 7。

PHP : 一门解释型语言

PHP被称为脚本语言或解释型语言。为何? PHP语言没有被直接编译为机器指令,而是编译为一种中间代码的形式,很显然它无法直接在CPU上执行。 所以PHP的执行需要在进程级虚拟机上(见Virtual machine中的Process virtual machines,下文简称虚拟机)。

PHP语言,包括其他的解释型语言,其实是一个跨平台的被设计用来执行抽象指令的程序。PHP主要用于解决WEB开发相关的问题。

诸如Java, Python, C#, Ruby, Pascal, Lua, Perl, Javascript等编程语言所编写的程序,都需要在虚拟机上执行。虚拟机可以通过JIT编译技术将一部分虚拟机指令编译为机器指令以提高性能。鸟哥已经在进行PHP加入JIT支持的开发了。

推荐教程:《PHP教程》

使用解释型语言的优点:

代码编写简单,能够快速开发

自动的内存管理

抽象的数据类型,程序可移植性高

缺点:

无法直接地进行内存管理和使用进程资源

比编译为机器指令的语言速度慢:通常需要更多的CPU周期来完成相同的任务(JIT试图缩小差距,但永远不能完全消除)

抽象了太多东西,以至于当程序出问题时,许多程序员难以解释其根本原因

最后一条缺点是作者之所以写这篇文章的原因,作者觉得程序员应该去了解一些底层的东西。

作者希望能够通过这篇文章向读者讲明白PHP是如何运行的。本文所提到的关于PHP虚拟机的知识同样可以应用于其他解释型语言。通常,不同虚拟机实现上的最大不同点在于:是否使用JIT、并行的虚拟机指令(一般使用多线程实现,PHP没有使用这一技术)、内存管理/垃圾回收算法。

Zend虚拟机分为两大部分:

编译:将PHP代码转换为虚拟机指令(OPCode)

执行:执行生成的虚拟机指令

本文不会涉及到编译部分,主要关注Zend虚拟机的执行引擎。PHP7版本的执行引擎做了一部分重构,使得PHP代码的执行堆栈更加简单清晰,性能也得到了一些提升。

本文以PHP 7.0.7为示例。

OPCode


维基百科对于OPCode的解释:

Opcodes can also be found in so-called byte codes and other representations intended for a software interpreter rather than a hardware device. These software based instruction sets often employ slightly higher-level data types and operations than most hardware counterparts, but are nevertheless constructed along similar lines.

OPCode与ByteCode在概念上是不同的。

我的个人理解:OPCode作为一条指令,表明要怎么做,而ByteCode由一序列的OPCode/数据组成,表明要做什么。以一个加法为例子,OPCode是告诉执行引擎将参数1和参数2相加,而ByteCode则告诉执行引擎将45和56相加。

参考:Difference between Opcode and Bytecode和Difference between: Opcode, byte code, mnemonics, machine code and assembly

在PHP中,Zend/zend_vm_opcodes.h源码文件列出了所有支持的OPCode。通常,每个OPCode的名字都描述了其含义,比如:

ZEND_ADD:对两个操作数执行加法操作

ZEND_NEW:创建一个对象

ZEND_FETCH_DIM_R:读取操作数中某个维度的值,比如执行echo $foo[0]语句时,需要获取$foo数组索引为0的值

OPCode以zend_op结构体表示:

struct _zend_op {    const void *handler; /* 执行该OPCode的C函数 */    znode_op op1; /* 操作数1 */    znode_op op2; /* 操作数2 */    znode_op result; /* 结果 */    uint32_t extended_value; /* 额外的信息 */    uint32_t lineno; /* 该OPCode对应PHP源码所在的行 */    zend_uchar opcode; /* OPCode对应的数值 */    zend_uchar op1_type; /* 操作数1类型 */    zend_uchar op2_type; /* 操作数2类型 */    zend_uchar result_type; /* 结果类型 */};
登录后复制

每一条OPcode都以相同的方式执行:OPCode有其对应的C函数,执行该C函数时,可能会用到0、1或2个操作数(op1,op2),最后将结果存储在result中,可能还会有一些额外的信息存储在extended_value。

看下ZEND_ADD的OPCode长什么样子,在Zend/zend_vm_def.h源码文件中:

ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMPVAR|CV, CONST|TMPVAR|CV)                                                                                      {    USE_OPLINE    zend_free_op free_op1, free_op2;    zval *op1, *op2, *result;    op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);    op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);    if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            fast_long_add_function(result, op1, op2);            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        }        } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));            ZEND_VM_NEXT_OPCODE();        }        }    SAVE_OPLINE();    if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {        op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);    }    if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {        op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);    }    add_function(EX_VAR(opline->result.var), op1, op2);    FREE_OP1();    FREE_OP2();    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();}
登录后复制

可以看出这其实不是一个合法的C代码,可以把它看成代码模板。稍微解读下这个代码模板:1 就是在Zend/zend_vm_opcodes.h中define定义的ZEND_ADD的值;ZEND_ADD接收两个操作数,如果两个操作数都为IS_LONG类型,那么就调用fast_long_add_function(该函数内部使用汇编实现加法操作);如果两个操作数,都为IS_DOUBLE类型或者1个是IS_DOUBLE类型,另1个是IS_LONG类型,那么就直接执行double的加法操作;如果存在1个操作数不是IS_LONG或IS_DOUBLE类型,那么就调用add_function(比如两个数组做加法操作);最后检查是否有异常接着执行下一条OPCode。

Zend/zend_vm_def.h源码文件中的内容其实是OPCode的代码模板,在该源文件的开头处可以看到这样一段注释:

/* If you change this file, please regenerate the zend_vm_execute.h and * zend_vm_opcodes.h files by running: * php zend_vm_gen.php */
登录后复制

说明zend_vm_execute.h和zend_vm_opcodes.h,实际上包括zend_vm_opcodes.c中的C代码正是从Zend/zend_vm_def.h的代码模板生成的。

操作数类型

每个OPCode最多使用两个操作数:op1和op2。每个操作数代表着OPCode的“形参”。例如ZEND_ASSIGN OPCode将op2的值赋值给op1代表的PHP变量,而其result则没有使用到。

操作数的类型(与PHP变量的类型不同)决定了其含义以及使用方式:

IS_CV:Compiled Variable,说明该操作数是一个PHP变量

IS_TMP_VAR :虚拟机使用的临时内部PHP变量,不能够在不同OPCode中复用(复用的这一点我并不清楚,还没去研究过)

IS_VAR:虚拟机使用的内部PHP变量,能够在不同OPCode中复用(复用的这一点我并不清楚,还没去研究过)

IS_CONST:代表一个常量值

IS_UNUSED:该操作数没有任何意义,忽略该操作数

操作数的类型对性能优化和内存管理很重要。当一个OPCode的Handler需要读写操作数时,会根据操作数的类型通过不同的方式读写。

以加法例子,说明操作数类型:

$a + $b;  // IS_CV + IS_CV1 + $a;   // IS_CONST + IS_CV$$b + 3   // IS_VAR + IS_CONST!$a + 3;  // IS_TMP_VAR + IS_CONST
登录后复制OPCode Handler

我们已经知道每个OPCode Handler最多接收2个操作数,并且会根据操作数的类型读写操作数的值。如果在Handler中,通过switch判断类型,然后再读写操作数的值,那么对性能会有很大损耗,因为存在太多的分支判断了(Why is it good to avoid instruction branching where possible?),如下面的伪代码所示:

int ZEND_ADD(zend_op *op1, zend_op *op2){    void *op1_value;    void *op2_value;    switch (op1->type) {        case IS_CV:            op1_value = read_op_as_a_cv(op1);        break;        case IS_VAR:            op1_value = read_op_as_a_var(op1);        break;        case IS_CONST:            op1_value = read_op_as_a_const(op1);        break;        case IS_TMP_VAR:            op1_value = read_op_as_a_tmp(op1);        break;        case IS_UNUSED:            op1_value = NULL;        break;    }    /* ... same thing to do for op2 .../    /* do something with op1_value and op2_value (perform a math addition ?) */}
登录后复制

要知道OPCode Handler在PHP执行过程中是会被调用成千上万次的,所以在Handler中对op1、op2做类型判断,对性能并不好。

重新看下ZEND_ADD的代码模板:

ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
登录后复制

这说明ZEND_ADD接收op1和op2为CONST或TMPVAR或CV类型的操作数。

前面已经提到zend_vm_execute.h和zend_vm_opcodes.h中的C代码是从Zend/zend_vm_def.h的代码模板生成的。通过查看zend_vm_execute.h,可以看到每个OPCode对应的Handler(C函数),大部分OPCode会对应多个Handler。以ZEND_ADD为例:

static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
登录后复制

ZEND_ADD的op1和op2的类型都有3种,所以一共生成了9个Handler,每个Handler的命名规范:ZEND_{OPCODE-NAME}_SPEC_{OP1-TYPE}_{OP2-TYPE}_HANDLER()。在编译阶段,操作数的类型是已知的,也就确定了每个编译出来的OPCode对应的Handler了。

那么这些Handler之间有什么不同呢?最大的不同应该就是获取操作数的方式:

static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS){    USE_OPLINE    zval *op1, *op2, *result;    op1 = EX_CONSTANT(opline->op1);    op2 = EX_CONSTANT(opline->op2);    if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {       /* 省略 */    } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {        /* 省略 */    }    SAVE_OPLINE();    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) { //<-------- 这部分代码会被编译器优化掉        op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);    }    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) { //<-------- 这部分代码会被编译器优化掉        op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);    }    add_function(EX_VAR(opline->result.var), op1, op2);    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();}static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS){    USE_OPLINE    zval *op1, *op2, *result;    op1 = EX_CONSTANT(opline->op1);    op2 = _get_zval_ptr_cv_undef(execute_data, opline->op2.var);    //<-------- op2的获取方式与上面的CONST不同    if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {        /* 省略 */    } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {        /* 省略 */    }    SAVE_OPLINE();    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) { //<-------- 这部分代码会被编译器优化掉        op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);    }    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) { //<-------- IS_CV == IS_CV && 也会被编译器优化掉        op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);    }    add_function(EX_VAR(opline->result.var), op1, op2);    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();}
登录后复制OPArray

OPArray是指一个包含许多要被顺序执行的OPCode的数组,如下图:

OPArray由结构体_zend_op_array表示:

struct _zend_op_array {    /* Common elements */    /* 省略 */    /* END of common elements */    /* 省略 */    zend_op *opcodes; //<------ 存储着OPCode的数组    /* 省略 */};
登录后复制

在PHP中,每个PHP用户函数或者PHP脚本、传递给eval()的参数,会被编译为一个OPArray。

OPArray中包含了许多静态的信息,能够帮助执行引擎更高效地执行PHP代码。部分重要的信息如下:

当前脚本的文件名,OPArray对应的PHP代码在脚本中起始和终止的行号

/**的代码注释信息

refcount引用计数,OPArray是可共享的

try-catch-finally的跳转信息

break-continue的跳转信息

当前作用域所有PHP变量的名称

函数中用到的静态变量

literals(字面量),编译阶段已知的值,例如字符串“foo”,或者整数42

运行时缓存槽,引擎会缓存一些后续执行需要用到的东西

一个简单的例子:

$a = 8;$b = 'foo';echo $a + $b;
登录后复制

OPArray中的部分成员其内容如下:

OPArray包含的信息越多,即在编译期间尽量的将已知的信息计算好存储到OPArray中,执行引擎就能够更高效地执行。我们可以看到每个字面量都已经被编译为zval并存储到literals数组中(你可能发现这里多了一个整型值1,其实这是用于ZEND_RETURN OPCode的,PHP文件的OPArray默认会返回1,但函数的OPArray默认返回null)。OPArray所使用到的PHP变量的名字信息也被编译为zend_string存储到vars数组中,编译后的OPCode则存储到opcodes数组中。

OPCode的执行

OPCode的执行是通过一个while循环去做的:

ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMPVAR|CV, CONST|TMPVAR|CV)                                                                                      {    USE_OPLINE    zend_free_op free_op1, free_op2;    zval *op1, *op2, *result;    op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);    op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);    if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            fast_long_add_function(result, op1, op2);            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        }        } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));            ZEND_VM_NEXT_OPCODE();        }        }    SAVE_OPLINE();    if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {        op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);    }    if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {        op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);    }    add_function(EX_VAR(opline->result.var), op1, op2);    FREE_OP1();    FREE_OP2();    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();}0
登录后复制

那么是如何切换到下一个OPCode去执行的呢?每个OPCode的Handler中都会调用到一个宏:

ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMPVAR|CV, CONST|TMPVAR|CV)                                                                                      {    USE_OPLINE    zend_free_op free_op1, free_op2;    zval *op1, *op2, *result;    op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);    op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);    if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            fast_long_add_function(result, op1, op2);            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        }        } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));            ZEND_VM_NEXT_OPCODE();        }        }    SAVE_OPLINE();    if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {        op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);    }    if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {        op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);    }    add_function(EX_VAR(opline->result.var), op1, op2);    FREE_OP1();    FREE_OP2();    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();}1
登录后复制

该宏会把当前的opline+skip(skip通常是1),将opline指向下一条OPCode。opline是一个全局变量,指向当前执行的OPCode。

额外的一些东西
编译器优化

Zend/zend_vm_execute.h中,会看到如下奇怪的代码:

ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMPVAR|CV, CONST|TMPVAR|CV)                                                                                      {    USE_OPLINE    zend_free_op free_op1, free_op2;    zval *op1, *op2, *result;    op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);    op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);    if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            fast_long_add_function(result, op1, op2);            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        }        } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));            ZEND_VM_NEXT_OPCODE();        }        }    SAVE_OPLINE();    if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {        op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);    }    if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {        op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);    }    add_function(EX_VAR(opline->result.var), op1, op2);    FREE_OP1();    FREE_OP2();    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();}2
登录后复制

你可能会对if (IS_CONST == IS_UNUSED)#if 0 || (IS_CONST != IS_UNUSED)感到奇怪。看下其对应的模板代码:

ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMPVAR|CV, CONST|TMPVAR|CV)                                                                                      {    USE_OPLINE    zend_free_op free_op1, free_op2;    zval *op1, *op2, *result;    op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);    op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);    if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            fast_long_add_function(result, op1, op2);            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        }        } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));            ZEND_VM_NEXT_OPCODE();        }        }    SAVE_OPLINE();    if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {        op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);    }    if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {        op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);    }    add_function(EX_VAR(opline->result.var), op1, op2);    FREE_OP1();    FREE_OP2();    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();}3
登录后复制

PHP zend_vm_gen.php在生成zend_vm_execute.h时,会把OP1_TYPE替换为op1的类型,从而生成这样子的代码:if (IS_CONST == IS_UNUSED),但C编译器会把这些代码优化掉。

自定义Zend执行引擎的生成

zend_vm_gen.php支持传入参数--without-specializer,当使用该参数时,每个OPCode只会生成一个与之对应的Handler,该Handler中会对操作数做类型判断,然后再对操作数进行读写。

另一个参数是--with-vm-kind=CALL|SWITCH|GOTO,CALL是默认参数。

前面已提到执行引擎是通过一个while循环执行OPCode,每个OPCode中将opline增加1(通常情况下),然后回到while循环中,继续执行下一个OPCode,直到遇到ZEND_RETURN。

如果使用GOTO执行策略:

ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMPVAR|CV, CONST|TMPVAR|CV)                                                                                      {    USE_OPLINE    zend_free_op free_op1, free_op2;    zval *op1, *op2, *result;    op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);    op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);    if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            fast_long_add_function(result, op1, op2);            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        }        } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));            ZEND_VM_NEXT_OPCODE();        }        }    SAVE_OPLINE();    if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {        op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);    }    if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {        op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);    }    add_function(EX_VAR(opline->result.var), op1, op2);    FREE_OP1();    FREE_OP2();    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();}4
登录后复制

这里的goto并没有直接使用符号名,其实是goto一个特殊的用法:Labels as Values。

执行引擎中的跳转

当PHP脚本中出现if语句时,是如何跳转到相应的OPCode然后继续执行的?看下面简单的例子:

ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMPVAR|CV, CONST|TMPVAR|CV)                                                                                      {    USE_OPLINE    zend_free_op free_op1, free_op2;    zval *op1, *op2, *result;    op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);    op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);    if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            fast_long_add_function(result, op1, op2);            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        }        } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));            ZEND_VM_NEXT_OPCODE();        }        }    SAVE_OPLINE();    if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {        op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);    }    if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {        op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);    }    add_function(EX_VAR(opline->result.var), op1, op2);    FREE_OP1();    FREE_OP2();    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();}5
登录后复制

$a != 9时,JMPZ会使当前执行跳转到第5个OPCode,否则JMP会使当前执行跳转到第6个OPCode。其实就是对当前的opline赋值为跳转目标OPCode的地址。

一些性能Tips

这部分内容将展示如何通过查看生成的OPCode优化PHP代码。

echo a concatenation

示例代码:

ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMPVAR|CV, CONST|TMPVAR|CV)                                                                                      {    USE_OPLINE    zend_free_op free_op1, free_op2;    zval *op1, *op2, *result;    op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);    op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);    if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            fast_long_add_function(result, op1, op2);            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        }        } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));            ZEND_VM_NEXT_OPCODE();        }        }    SAVE_OPLINE();    if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {        op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);    }    if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {        op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);    }    add_function(EX_VAR(opline->result.var), op1, op2);    FREE_OP1();    FREE_OP2();    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();}6
登录后复制

OPArray:

ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMPVAR|CV, CONST|TMPVAR|CV)                                                                                      {    USE_OPLINE    zend_free_op free_op1, free_op2;    zval *op1, *op2, *result;    op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);    op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);    if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            fast_long_add_function(result, op1, op2);            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        }        } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));            ZEND_VM_NEXT_OPCODE();        }        }    SAVE_OPLINE();    if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {        op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);    }    if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {        op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);    }    add_function(EX_VAR(opline->result.var), op1, op2);    FREE_OP1();    FREE_OP2();    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();}7
登录后复制

$a和$b的值会被ZEND_CONCAT连接后存储到一个临时变量~4中,然后再echo输出。

CONCAT操作需要分配一块临时的内存,然后做内存拷贝,echo输出后,又要回收这块临时内存。如果把代码改为如下可消除CONCAT:

ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMPVAR|CV, CONST|TMPVAR|CV)                                                                                      {    USE_OPLINE    zend_free_op free_op1, free_op2;    zval *op1, *op2, *result;    op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);    op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);    if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            fast_long_add_function(result, op1, op2);            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        }        } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));            ZEND_VM_NEXT_OPCODE();        }        }    SAVE_OPLINE();    if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {        op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);    }    if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {        op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);    }    add_function(EX_VAR(opline->result.var), op1, op2);    FREE_OP1();    FREE_OP2();    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();}8
登录后复制

OPArray:

ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMPVAR|CV, CONST|TMPVAR|CV)                                                                                      {    USE_OPLINE    zend_free_op free_op1, free_op2;    zval *op1, *op2, *result;    op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);    op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);    if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            fast_long_add_function(result, op1, op2);            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        }        } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {        if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));            ZEND_VM_NEXT_OPCODE();        } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {            result = EX_VAR(opline->result.var);            ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));            ZEND_VM_NEXT_OPCODE();        }        }    SAVE_OPLINE();    if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {        op1 = GET_OP1_UNDEF_CV(op1, BP_VAR_R);    }    if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {        op2 = GET_OP2_UNDEF_CV(op2, BP_VAR_R);    }    add_function(EX_VAR(opline->result.var), op1, op2);    FREE_OP1();    FREE_OP2();    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();}9
登录后复制define()和const

PHP 5.3引入了const关键字。

简单地说:

define()是一个函数调用

conast是关键字,不会产生函数调用,要比define()轻量许多

/* If you change this file, please regenerate the zend_vm_execute.h and * zend_vm_opcodes.h files by running: * php zend_vm_gen.php */0
登录后复制

如果使用const:

/* If you change this file, please regenerate the zend_vm_execute.h and * zend_vm_opcodes.h files by running: * php zend_vm_gen.php */1
登录后复制

然而const在使用上有一些限制:

const关键字定义常量必须处于最顶端的作用区域,这就意味着不能在函数内,循环内以及if语句之内用const 来定义常量

const的操作数必须为IS_CONST类型

动态函数调用

尽量不要使用动态的函数名去调用函数:

/* If you change this file, please regenerate the zend_vm_execute.h and * zend_vm_opcodes.h files by running: * php zend_vm_gen.php */2
登录后复制

NOP表示不做任何操作,只是将当前opline指向下一条OPCode,编译器产生这条指令是由于历史原因。为何到PHP7还不移除它呢= =

看看使用动态的函数名去调用函数:

/* If you change this file, please regenerate the zend_vm_execute.h and * zend_vm_opcodes.h files by running: * php zend_vm_gen.php */3
登录后复制

不同点在于INIT_FCALL和INIT_DYNAMIC_CALL,看下两个函数的源码:

/* If you change this file, please regenerate the zend_vm_execute.h and * zend_vm_opcodes.h files by running: * php zend_vm_gen.php */4
登录后复制

很显然INIT_FCALL相比INIT_DYNAMIC_CALL要轻量许多。

类的延迟绑定

简单地说,类A继承类B,类B最好先于类A被定义。

/* If you change this file, please regenerate the zend_vm_execute.h and * zend_vm_opcodes.h files by running: * php zend_vm_gen.php */5
登录后复制

从生成的OPCode可以看出,上述PHP代码在运行时,执行引擎不需要做任何操作。类的定义是比较耗性能的工作,例如解析类的继承关系,将父类的方法/属性添加进来,但编译器已经做完了这些繁重的工作。

如果类A先于类B被定义:

/* If you change this file, please regenerate the zend_vm_execute.h and * zend_vm_opcodes.h files by running: * php zend_vm_gen.php */6
登录后复制

这里定义了Foo继承自Bar,但当编译器读取到Foo的定义时,编译器并不知道任何关于Bar的情况,所以编译器就生成相应的OPCode,使其定义延迟到执行时。在一些其他的动态类型的语言中,可能会产生错误:Parse error : class not found

除了类的延迟绑定,像接口、traits都存在延迟绑定耗性能的问题。

对于定位PHP性能问题,通常都是先用xhprof或xdebug profile进行定位,需要通过查看OPCode定位性能问题的场景还是比较少的。

总结

希望通过这篇文章,能让你了解到PHP虚拟机大致是如何工作的。具体opcode的执行,以及函数调用涉及到的上下文切换,有许多细节性的东西,限于本文篇幅,在另一篇文章:PHP 7 中函数调用的实现进行讲解。

推荐相关文章:《linux系统教程》

以上就是了解什么是PHP7虚拟机的详细内容,更多请关注9543建站博客其它相关文章!

广告:SSL证书一年128.66元起,点击购买~~~

9543建站博客
一个专注于网站开发、微信开发的技术类纯净博客。
作者头像
admin创始人

肥猫,知名SEO博客站长,14年SEO经验。

上一篇:怎么查看服务器有没有开启nodejs
下一篇:简析laravel怎么局部排除中间件

发表评论

关闭广告
关闭广告