协程
上次已经讲解了协程的的实现方法，和我对协程的一些理解。这里指我就先以代码说明协程的运行。
def test1():
print 12 (2)
gr2.switch() (3)
print 34 (6)
def test2():
print 56 (4)
gr1.switch() (5)
print 78 (8)
gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch() (1)
gr2.switch() (7)
输出结果为：
12
56
34
78
可以看到声明了两个协程gr1，gr2。通过协程的switch，进行协程切换。在代码后边，已经表明了协程代码执行过程。
可以比较明确的看到协程之间交互执行，这也是协程的名称的由来。他们协作进行进行工作。switch()是一个重要的方法，
它启动协程、切换协程。
协程实现
好了，开始我们的协程代码之旅。从协程的两个步骤：
Note: 如果你对Python的C extensions不是非常熟悉，建议你先看(https://docs.python.org/2/extending/extending.html)
1.创建协程(greenlet)
首先：初始化协程环境，将greenlet模块的各种状态（GreenMethods，模块变量ts_curkey等，各项Exception，当前运行ts_current，最终将这些都形成模块的
属性）请看initgreenlet。
一直到现在我们可以创建协程了，因为我们有了协程的这些Type。
创建协程，这个过程非常简单,greenlet(func)就创建了一个协程。PyGreenlet_Type(greenlet.c)已经说明了这两个方法(green_new,green_init)
green_new，创建了一个PyGreenlet，他们的parent设置为ts_current.（如果是协程A内有创建协程B，则ts_current就是协程A, B.parent就是A）
static PyObject* green_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
PyObject* o = PyBaseObject_Type.tp_new(type, ts_empty_tuple, ts_empty_dict);
if (o != NULL) {
if (!STATE_OK) {
Py_DECREF(o);
return NULL;
}
Py_INCREF(ts_current);
((PyGreenlet*) o)->parent = ts_current;
}
return o;
}
green_init,将参数进行分解，赋予self对应的PyGreenlet。
static int green_init(PyGreenlet *self, PyObject *args, PyObject *kwargs)
{
PyObject *run = NULL;
PyObject* nparent = NULL;
static char *kwlist[] = {"run", "parent", };
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:green", kwlist,
&run, &nparent))
return -; if (run != NULL) {
if (green_setrun(self, run, NULL))
return -;
}
if (nparent != NULL && nparent != Py_None)
return green_setparent(self, nparent, NULL);
return ;
}
是的很容易明白他们的意图。
2.协程切换(switch)
从green_switch->g_switch非常直接，进入协程的核心。协程切换(不需要关注协程运行环境，因为CPU整体，运行时状态的寄存器进行了切换和保存。)
g_switch(PyGreenlet* target, PyObject* args, PyObject* kwargs)
{
......(省略)
/* find the real target by ignoring dead greenlets,
and if necessary starting a greenlet. */
while (target) {
if (PyGreenlet_ACTIVE(target)) {
ts_target = target;
err = g_switchstack();
break;
}
if (!PyGreenlet_STARTED(target)) {
void* dummymarker;
ts_target = target;
err = g_initialstub(&dummymarker);
if (err == ) {
continue; /* retry the switch */
}
break;
}
target = target->parent;
}
................（省略）
}
首先就是获取真正执行的target，当然target分为两种情况，活跃的协程，没有开始的协程。按照我们的例子，gr1.switch()这个时候，
是为开始的协程，下边执行的是g_initialstub。(g_initialstu做了几件事情 保存当前协程的环境，将协程的栈空间保存到堆上，这个很简单，切换回来的时候
把堆上的运行空间复制回来就可以继续运行。不然就没有办法进行切换)
static int GREENLET_NOINLINE(g_initialstub)(void* mark)
{
........(省略)
//将协程的前后关系处理好，形成一个链
if (ts_current->stack_start == NULL) {
/* ts_current is dying */
self->stack_prev = ts_current->stack_prev;
}
else {
self->stack_prev = ts_current;
}
.....（省略）
//在g_switchstack.进行
/* perform the initial switch */
err = g_switchstack();
//纠正，这个返回twice是不正确的，返回两次，只有fork系统调用，因为完成之后，有两个进程执行。
//这个方法并没有返回两次。因为执行完成之后，就再次进行了切换。不应该认为返回两次
/* returns twice!
The 1st time with err=1: we are in the new greenlet
The 2nd time with err=0: back in the caller's greenlet
*/
if (err == ) {
/* in the new greenlet */
PyGreenlet* origin;
.........(省略) if (args == NULL) {
/* pending exception */
result = NULL;
} else {
//这个方法协程进行了真正的执行。
/* call g.run(*args, **kwargs) */
result = PyEval_CallObjectWithKeywords(
run, args, kwargs);
Py_DECREF(args);
Py_XDECREF(kwargs);
}
Py_DECREF(run);
result = g_handle_exit(result);
/* jump back to parent */
self->stack_start = NULL; /* dead */
}
// 完成之后，在进行切换
/* jump back to parent */
self->stack_start = NULL; /* dead */
for (parent = self->parent; parent != NULL; parent = parent->parent) {
result = g_switch(parent, result, NULL);
/* Return here means switch to parent failed,
* in which case we throw *current* exception
* to the next parent in chain.
*/
assert(result == NULL);
}
}
}
现在开始关心g_switchstack如何进行切换了。
g_switchstack执行了汇编slp_switch()，在这里我之查看x86汇编。
slp_switch(void)
{
/*将寄存器内容保存在协程的内存中，当恢复了协程内存之后，将内容恢复到寄存器中。新旧协程不会冲突。
协程切换，也就是将寄存器进行内容进行保存，将栈地址进行保存和恢复*/
int err;
void *ebp, *ebx;
unsigned short cw;
register int *stackref, stsizediff;
__asm__ volatile ("" : : : "esi", "edi");
__asm__ volatile ("fstcw %0" : "=m" (cw));
__asm__ volatile ("movl %%ebp, %0" : "=m" (ebp));
__asm__ volatile ("movl %%ebx, %0" : "=m" (ebx));
__asm__ ("movl %%esp, %0" : "=g" (stackref));
{
SLP_SAVE_STATE(stackref, stsizediff);
__asm__ volatile (
"addl %0, %%esp\n"
"addl %0, %%ebp\n"
:
: "r" (stsizediff)
);
SLP_RESTORE_STATE();
__asm__ volatile ("xorl %%eax, %%eax" : "=a" (err));
}
__asm__ volatile ("movl %0, %%ebx" : : "m" (ebx));
__asm__ volatile ("movl %0, %%ebp" : : "m" (ebp));
__asm__ volatile ("fldcw %0" : : "m" (cw));
__asm__ volatile ("" : : : "esi", "edi");
return err;
}
在汇编代码中，看到的内容就是保存、恢复寄存器和保存协程状态，恢复协程状态。
下边来看以下如何保存状态的SLP_SAVE_STATE-> slp_save-state
static int GREENLET_NOINLINE(slp_save_state)(char* stackref)
{
/* must free all the C stack up to target_stop */
char* target_stop = ts_target->stack_stop;
PyGreenlet* owner = ts_current;
assert(owner->stack_saved == 0);
if (owner->stack_start == NULL)
owner = owner->stack_prev; /* not saved if dying */
else
owner->stack_start = stackref; while (owner->stack_stop < target_stop) {
//owner的结束地址小于target结束地址，产生了栈覆盖
/* ts_current is entierely within the area to free */
if (g_save(owner, owner->stack_stop))
return -1; /* XXX */
owner = owner->stack_prev;
}
if (owner != ts_target) {
if (g_save(owner, target_stop))
return -1; /* XXX */
}
return 0;
} static int g_save(PyGreenlet* g, char* stop)
{
/* Save more of g's stack into the heap -- at least up to 'stop'
g->stack_stop |________|
| |
|_ _ _ _ stop . . . . .
| | ==> . .
|________| _______
| | | |
| | | |
g->stack_start |________| |_______| g->stack_copy intptr_t sz1 = g->stack_saved;
intptr_t sz2 = stop - g->stack_start;
assert(g->stack_start != NULL);
if (sz2 > sz1) {
char* c = (char*)PyMem_Realloc(g->stack_copy, sz2);
if (!c) {
PyErr_NoMemory();
return -1;
}
memcpy(c+sz1, g->stack_start+sz1, sz2-sz1);
g->stack_copy = c;
g->stack_saved = sz2;
}
return 0;
}
这就是协程栈的保存，申请内存，然后将栈memcpy进入去。
恢复，也是类似，将保存进内存，拷贝到栈上。然后将寄存器进行修改
不过有点特殊的事情是：python看不到eip（指令指针，执行下一条运行指令），而python对应的内容，在frameobject中，
有PyCodeObject，而执行的时候，在ceval.c可以看到是通过next_instr来获取python运行指令。
所以协程有top_frame,就是为了切换协程时候，对指令集合进行切换
代码中有使用PyThreadState,但是并没有用thread线程，对于PyThreadState的使用只是为了，方便的让run_info,这个函数指针，
进行处理成为各项frameobject,recursion_depth等内容。
注：
1.对于中间的汇编，还是建议好好的看一下。我刚好看了中国科技大学-孟宁出的一个视频教程《linux 内核解读》刚好对汇编有非常好的讲解。
2.而协程运行之后，greenlet的栈布局如下：（图片来源于网络）
