Swoole协程之旅-中篇
最后更新于：2022-04-02 06:41:11
# Swoole协程之旅-中篇
本篇我们开始深入PHP来分析Swoole协程的PHP部分。
先从一个协程最简单的例子入手:
~~~
literals + 偏移量读取
/* ... */
};
~~~
我们已经熟知php的函数内部有自己的单独的作用域，这归功于每个zend\_op\_array包含有当前作用域下所有的堆栈信息，函数之间的调用关系也是基于zend\_op\_array的切换来实现。
* PHP栈帧
PHP执行需要的所有状态都保存在一个个通过链表结构关联的VM栈里，每个栈默认会初始化为256K，Swoole可以单独定制这个栈的大小(协程默认为8k),当栈容量不足的时候，会自动扩容，仍然以链表的关系关联每个栈。在每次函数调用的时候，都会在VM Stack空间上申请一块新的栈帧来容纳当前作用域执行所需。栈帧结构的内存布局如下所示：
~~~
+----------------------------------------+
| zend_execute_data |
+----------------------------------------+
| VAR[0] = ARG[1] | arguments
| ... |
| VAR[num_args-1] = ARG[N] |
| VAR[num_args] = CV[num_args] | remaining CVs
| ... |
| VAR[last_var-1] = CV[last_var-1] |
| VAR[last_var] = TMP[0] | TMP/VARs
| ... |
| VAR[last_var+T-1] = TMP[T] |
| ARG[N+1] (extra_args) | extra arguments
| ... |
+----------------------------------------+
~~~
zend\_execute\_data 最后要介绍的一个结构，也是最重要的一个。
~~~
struct _zend_execute_data {
const zend_op *opline;//当前执行的opcode，初始化会zend_op_array起始
zend_execute_data *call;//
zval *return_value;//返回值
zend_function *func;//当前执行的函数（非函数调用时为空）
zval This;/* this + call_info + num_args */
zend_class_entry *called_scope;//当前call的类
zend_execute_data *prev_execute_data;
zend_array *symbol_table;//全局变量符号表
void **run_time_cache; /* cache op_array->run_time_cache */
zval *literals; /* cache op_array->literals */
};
~~~
`prev_execute_data`表示前一个栈帧结构，当前栈执行结束以后，会把当前执行指针(类比PC)指向这个栈帧。 PHP的执行流程正是将很多个zend\_op\_array依次装载在栈帧上执行。这个过程可以分解为以下几个步骤：
* **1：**为当前需要执行的op\_array从vm stack上申请当前栈帧，结构如上。初始化全局变量符号表，将全局指针EG(current\_execute\_data)指向新分配的zend\_execute\_data栈帧，EX(opline)指向op\_array起始位置。
* **2:**从`EX(opline)`开始调用各opcode的C处理handler(即\_zend\_op.handler)，每执行完一条opcode将`EX(opline)++`继续执行下一条，直到执行完全部opcode，遇到函数或者类成员方法调用：
* 从`EG(function_table)`中根据function\_name取出此function对应的zend\_op\_array，然后重复步骤1，将EG(current\_execute\_data)赋值给新结构的`prev_execute_data`，再将EG(current\_execute\_data)指向新的zend\_execute\_data栈帧，然后开始执行新栈帧，从位置`zend_execute_data.opline`开始执行，函数执行完将EG(current\_execute\_data)重新指向`EX(prev_execute_data)`，释放分配的运行栈帧，执行位置回到函数执行结束的下一条opline。
* **3:**全部opcodes执行完成后将1分配的栈帧释放，执行阶段结束
* * *
有了以上php执行的细节，我们回到最初的例子，可以发现协程需要做的是，**改变原本php的运行方式，不是在函数运行结束切换栈帧，而是在函数执行当前op\_array中间任意时候（swoole内部控制为遇到IO等待），可以灵活切换到其他栈帧。**接下来我们将Zend VM和Swoole结合分析，如何创建协程栈，遇到IO切换，IO完成后栈恢复，以及协程退出时栈帧的销毁等细节。 先介绍协程PHP部分的主要结构
* 协程 php\_coro\_task
~~~
struct php_coro_task
{
/* 只列出关键结构*/
/*...*/
zval *vm_stack_top;//栈顶
zval *vm_stack_end;//栈底
zend_vm_stack vm_stack;//当前协程栈指针
/*...*/
zend_execute_data *execute_data;//当前协程栈帧
/*...*/
php_coro_task *origin_task;//上一个协程栈帧，类比prev_execute_data的作用
};
~~~
协程切换主要是针对当前栈执行发生中断时对上下文保存，和恢复。结合上面VM的执行流程我们可以知道上面几个字段的作用。
* `execute_data`栈帧指针需要保存和恢复是毋容置疑的
* `vm_stack*`系列是什么作用呢？原因是PHP是动态语言，我们上面分析到，每次有新函数进入执行和退出的时候，都需要在全局stack上创建和释放栈帧，所以需要正确保存和恢复对应的全局栈指针，才能保障每个协程栈帧得到释放，不会导致内存泄漏的问题。（当以debug模式编译PHP后，每次释放都会检查当全局栈是否合法）
* `origin_task`是当前协程执行结束后需要自动执行的前一个栈帧。
主要涉及到的操作有:
* 协程的创建`create`，在全局stack上为协程申请栈帧。
* 协程的创建是创建一个闭包函数，将函数(可以理解为需要执行的op\_array)当作一个参数传入Swoole的内建函数go();
* 协程让出，`yield`，遇到IO，保存当前栈帧的上下文信息
* 协程的恢复，`resume`,IO完成，恢复需要执行的协程上下文信息到yield让出前的状态
* 协程的退出，`exit`,协程op\_array全部执行完毕，释放栈帧和swoole协程的相关数据。
经过上面的介绍大家应该对Swoole协程在运行过程中可以在函数内部实现跳转有一个大概了解，回到最初我们例子结合上面php执行细节，我们能够知道，该例子会生成3个op\_array,分别为 主脚本，协程1，协程2。我们可以利用一些工具打印出opcodes来直观的观察一下。通常我们会使用下面两个工具
~~~
//Opcache, version >= PHP 7.1
php -d opcache.opt_debug_level=0x10000 test.php
//vld, 第三方扩展
php -d vld.active=1 test.php
~~~
我们用opcache来观察没有被优化前的opcodes,我们可以很清晰的看到这三组op\_array的详细信息。
~~~
php -dopcache.enable_cli=1 -d opcache.opt_debug_level=0x10000 test.php
$_main: ; (lines=11, args=0, vars=0, tmps=4)
; (before optimizer)
; /path-to/test.php:2-6
L0 (2): INIT_FCALL 1 96 string("go")
L1 (2): T0 = DECLARE_LAMBDA_FUNCTION string("")
L2 (6): SEND_VAL T0 1
L3 (6): DO_ICALL
L4 (7): ECHO string("main flag
")
L5 (8): INIT_FCALL 1 96 string("go")
L6 (8): T2 = DECLARE_LAMBDA_FUNCTION string("")
L7 (12): SEND_VAL T2 1
L8 (12): DO_ICALL
L9 (13): ECHO string("main end
")
L10 (14): RETURN int(1)
{closure}: ; (lines=6, args=0, vars=0, tmps=1)
; (before optimizer)
; /path-to/test.php:2-6
L0 (9): ECHO string("coro 2 start
")
L1 (10): INIT_STATIC_METHOD_CALL 1 string("co") string("sleep")
L2 (10): SEND_VAL_EX int(1) 1
L3 (10): DO_FCALL//yiled from 当前op_array [coro 1] ; resume
L4 (11): ECHO string("coro 2 exit
")
L5 (12): RETURN null
{closure}: ; (lines=6, args=0, vars=0, tmps=1)
; (before optimizer)
; /path-to/test.php:2-6
L0 (3): ECHO string("coro 1 start
")
L1 (4): INIT_STATIC_METHOD_CALL 1 string("co") string("sleep")
L2 (4): SEND_VAL_EX int(1) 1
L3 (4): DO_FCALL//yiled from 当前op_array [coro 2];resume
L4 (5): ECHO string("coro 1 exit
")
L5 (6): RETURN null
coro 1 start
main flag
coro 2 start
main end
coro 1 exit
coro 2 exit
~~~
Swoole在执行`co::sleep()`的时候让出当前控制权，跳转到下一个op\_array,结合以上注释，也就是在`DO_FCALL`的时候分别让出和恢复协程执行栈，达到原生协程控制流跳转的目的。
我们分析下`INIT_FCALL``DO_FCALL`指令在内核中如何执行。以便于更好理解函数调用栈切换的关系。
> VM内部指令会根据当前的操作数返回值等特殊化为一个c函数，我们这个例子中 有以下对应关系
>
> `INIT_FCALL`\=> ZEND\_INIT\_FCALL\_SPEC\_CONST\_HANDLER
>
> `DO_FCALL`\=> ZEND\_DO\_FCALL\_SPEC\_RETVAL\_UNUSED\_HANDLER
~~~
ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
zval *fname = EX_CONSTANT(opline->op2);
zval *func;
zend_function *fbc;
zend_execute_data *call;
fbc = CACHED_PTR(Z_CACHE_SLOT_P(fname));
if (UNEXPECTED(fbc == NULL)) {
func = zend_hash_find(EG(function_table), Z_STR_P(fname));
if (UNEXPECTED(func == NULL)) {
SAVE_OPLINE();
zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(fname));
HANDLE_EXCEPTION();
}
fbc = Z_FUNC_P(func);
CACHE_PTR(Z_CACHE_SLOT_P(fname), fbc);
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
}
}
call = zend_vm_stack_push_call_frame_ex(
opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
fbc, opline->extended_value, NULL, NULL); //从全局stack上申请当前函数的执行栈
call->prev_execute_data = EX(call); //将正在执行的栈赋值给将要执行函数栈的prev_execute_data，函数执行结束后恢复到此处
EX(call) = call; //将函数栈赋值到全局执行栈，即将要执行的函数栈
ZEND_VM_NEXT_OPCODE();
}
~~~
~~~
ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
zend_execute_data *call = EX(call);//获取到执行栈
zend_function *fbc = call->func;//当前函数
zend_object *object;
zval *ret;
SAVE_OPLINE();//有全局寄存器的时候 ((execute_data)->opline) = opline
EX(call) = call->prev_execute_data;//当前执行栈execute_data->call = EX(call)->prev_execute_data 函数执行结束后恢复到被调函数
/*...*/
LOAD_OPLINE();
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
ret = NULL;
if (0) {
ret = EX_VAR(opline->result.var);
ZVAL_NULL(ret);
}
call->prev_execute_data = execute_data;
i_init_func_execute_data(call, &fbc->op_array, ret);
if (EXPECTED(zend_execute_ex == execute_ex)) {
ZEND_VM_ENTER();
} else {
ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
zend_execute_ex(call);
}
} else if (EXPECTED(fbc->type < ZEND_USER_FUNCTION)) {
zval retval;
call->prev_execute_data = execute_data;
EG(current_execute_data) = call;
/*...*/
ret = 0 ? EX_VAR(opline->result.var) : &retval;
ZVAL_NULL(ret);
if (!zend_execute_internal) {
/* saves one function call if zend_execute_internal is not used */
fbc->internal_function.handler(call, ret);
} else {
zend_execute_internal(call, ret);
}
EG(current_execute_data) = execute_data;
zend_vm_stack_free_args(call);//释放局部变量
if (!0) {
zval_ptr_dtor(ret);
}
} else { /* ZEND_OVERLOADED_FUNCTION */
/*...*/
}
fcall_end:
/*...*/
}
zend_vm_stack_free_call_frame(call);//释放栈
if (UNEXPECTED(EG(exception) != NULL)) {
zend_rethrow_exception(execute_data);
HANDLE_EXCEPTION();
}
ZEND_VM_SET_OPCODE(opline + 1);
ZEND_VM_CONTINUE();
}
~~~
Swoole在PHP层可以按照以上方式来进行切换，至于执行过程中有IO等待发生，需要额外的技术来驱动，我们后续的文章将会介绍每个版本的驱动技术结合Swoole原有的事件模型，讲述Swoole协程如何进化到现在。
';