python协程的实现（greenlet源码分析)

基本上读完了greenlet的源代码，代码不多，就2000行C语言的代码，其中有一部分栈寄存器的修改的代码是由汇编实现的。。。

一句话来说明greenlet的实现原理：通过栈的复制切换来实现不同协程之间的切换。。。

那么接下里来具体的来看看greenlet的代码到底是怎么实现的。。。

好了，先来看看greenlet对象对应的C语言结构体：

[cpp] view plain copy

1. /** 
2. States: 
3.   stack_stop == NULL && stack_start == NULL:  did not start yet 
4.   stack_stop != NULL && stack_start == NULL:  already finished 
5.   stack_stop != NULL && stack_start != NULL:  active 
6.  
7. **/  
8.   
9. //greenlet对象最终对应的数据的C结构体，这里可以理解为python对象的属性  
10. typedef struct _greenlet {  
11.     PyObject_HEAD  
12.     char* stack_start;   //栈的顶部  将这里弄成null，标示已经结束了  
13.     char* stack_stop;    //栈的底部  
14.     char* stack_copy;     //栈保存到的内存地址  
15.     intptr_t stack_saved;   //栈保存在外面的大小  
16.     struct _greenlet* stack_prev;  //栈之间的上下层关系  
17.     struct _greenlet* parent;    //父对象  
18.     PyObject* run_info;   //其实也就是run对象  
19.     struct _frame* top_frame;   //这里可以理解为主要是控制python程序计数器  
20.     int recursion_depth;   //栈深度  
21.     PyObject* weakreflist;  
22.     PyObject* exc_type;  
23.     PyObject* exc_value;  
24.     PyObject* exc_traceback;  
25.     PyObject* dict;  
26. } PyGreenlet;  

这里stack_start，stack_stop就是用于分别指向当前这个协程的栈的顶部与栈的底部，而且可以通过这几个标志位的值来判断当前这个greenlet对象的状态。。。

另外这里可以看到parent指针，用这个来构成greenlet对象的层次关系。。。

接下来来看看与Python对象之间对应关系：

[cpp] view plain copy

1. //这个是定义的暴露给python的greenlet对象，它以greenlet.h里面定义的_greenlet位基础，然后指定了方法，创建方法等  
2. PyTypeObject PyGreenlet_Type = {  
3.     PyVarObject_HEAD_INIT(NULL, 0)  
4.     "greenlet.greenlet",            /* tp_name */  
5.     sizeof(PyGreenlet),         /* tp_basicsize */  //指定对象的大小，其实也就是结构体的大小  
6.     0,                  /* tp_itemsize */  
7.     /* methods */  
8.     (destructor)green_dealloc,      /* tp_dealloc */  
9.     0,                  /* tp_print */  
10.     0,                  /* tp_getattr */  
11.     0,                  /* tp_setattr */  
12.     0,                  /* tp_compare */  
13.     0,                  /* tp_repr */  
14.     &green_as_number,           /* tp_as _number*/  
15.     0,                  /* tp_as _sequence*/  
16.     0,                  /* tp_as _mapping*/  
17.     0,                  /* tp_hash */  
18.     0,                  /* tp_call */  
19.     0,                  /* tp_str */  
20.     0,                  /* tp_getattro */  
21.     0,                  /* tp_setattro */  
22.     0,                  /* tp_as_buffer*/  
23.     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | GREENLET_GC_FLAGS,   /* tp_flags */  
24.     "greenlet(run=None, parent=None) -> greenlet\n\n"  
25.     "Creates a new greenlet object (without running it).\n\n"  
26.     " - *run* -- The callable to invoke.\n"  
27.     " - *parent* -- The parent greenlet. The default is the current "  
28.     "greenlet.",                            /* tp_doc */  
29.     (traverseproc)GREENLET_tp_traverse, /* tp_traverse */  
30.     (inquiry)GREENLET_tp_clear,     /* tp_clear */  
31.     0,                  /* tp_richcompare */  
32.     offsetof(PyGreenlet, weakreflist),  /* tp_weaklistoffset */  
33.     0,                  /* tp_iter */  
34.     0,                  /* tp_iternext */  
35.     green_methods,              /* tp_methods */  //对象方法的定义  
36.     0,                  /* tp_members */  
37.     green_getsets,              /* tp_getset */ //属相方法  
38.     0,                  /* tp_base */  
39.     0,                  /* tp_dict */  
40.     0,                  /* tp_descr_get */  
41.     0,                  /* tp_descr_set */  
42.     offsetof(PyGreenlet, dict),     /* tp_dictoffset */   //这个对象的dict的偏移  
43.     (initproc)green_init,           /* tp_init */  //初始化  这里主要是设置run以及parent  
44.     GREENLET_tp_alloc,          /* tp_alloc */   //内存分配，其实也就是分配sizeof(PyGreenlet)的大小  
45.     green_new,              /* tp_new */  //构造函数   这里会将parent默认的设置为全局的greenlet  
46.     GREENLET_tp_free,           /* tp_free */      //释放     
47.     (inquiry)GREENLET_tp_is_gc,     /* tp_is_gc */   //gc  
48. };  

这个里面构造以及初始化函数都提供了，那么先来看看构造函数吧，当在python中执行环境中创建greenlet对象的时候，将会先调用green_new方法，接着调用green_init方法。。。

[cpp] view plain copy

1. //创建一个greenlet对象，这个可以理解为greenlet的构造函数  
2. //这里会先将parent默认指向当前环境所属的greenlet对象  
3. //如果在greenlet对象的构造函数中带有parent对象，那么待会在init中会设置  
4. static PyObject* green_new(PyTypeObject *type, PyObject *args, PyObject *kwds)  
5. {  
6.     PyObject* o;  
7.     if (!STATE_OK)  
8.         return NULL;  
9.       
10.     //先用基本对象来构造  
11.     o = PyBaseObject_Type.tp_new(type, ts_empty_tuple, ts_empty_dict);  
12.     if (o != NULL) {   //这里默认将parent设置为ts_current，也就是在哪一个greenlet环境里面创建的，那么新创建的greenlet的parent就是所属的环境greenlet  
13.         Py_INCREF(ts_current);  
14.         ((PyGreenlet*) o)->parent = ts_current;  
15.     }  
16.     return o;  
17. }  

这个代码很好理解吧，先构造父类，接着设置当前greenlet的默认parent，这里可以看到将parent默认的设置为当前环境所属的greenlet对象，也就是说假如我们在A中创建另外一个greenlet B，而且构造函数中没有传递parent参数，这个并没有关系，因为默认就已经将B的parent设置为A了...

好了，接下来来看看初始化函数：

[cpp] view plain copy

1. //初始化greenlet对象，这个可以理解为在构造之后，将会调用这个方法来进行初始化，主要是检查设置run，以及设置parent  
2. //这里可能没有parent参数，不过也没有关系，因为在构造的时候就先设置为创建环境的greenlet  
3. static int green_init(PyGreenlet *self, PyObject *args, PyObject *kwargs)  
4. {  
5.     PyObject *run = NULL;  
6.     PyObject* nparent = NULL;  
7.     //看当前这两个东西是否存在  
8.     static char *kwlist[] = {"run", "parent", 0};  
9.     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:green", kwlist,  
10.                      &run, &nparent))  
11.         return -1;  
12.   
13.     if (run != NULL) {  ///这里run对象是必须有的  
14.         //设置run对象  
15.         if (green_setrun(self, run, NULL))  
16.             return -1;  
17.     }  
18.     //这里在初始化的时候可以没有parent  
19.     if (nparent != NULL && nparent != Py_None)   
20.         //如果没有指定parent对象，那么将跟对象设置,在这个里面将会进行parent链是否存在环的情况进行判断  
21.         return green_setparent(self, nparent, NULL);  
22.     return 0;  
23. }  

这里初始化函数主要是设置构造的时候传递进来的执行函数，也就是run对象，然后就如果有传递parent的话，将会将这个greenlet对象的parent设置为传递进来的greenlet对象。。。。。

接下来来看看greenlet对象对应的一些方法的定义：

[cpp] view plain copy

1. //这个就是暴露给greenlet对象的的方法了  
2. static PyMethodDef green_methods[] = {  
3.     {"switch", (PyCFunction)green_switch,  //switch方法的定义  
4.      METH_VARARGS | METH_KEYWORDS, green_switch_doc},  
5.     {"throw",  (PyCFunction)green_throw,  METH_VARARGS, green_throw_doc},  
6.     {"__getstate__", (PyCFunction)green_getstate, METH_NOARGS, NULL},  
7.     {NULL,     NULL}        /* sentinel */  
8. };  

这里就可以看到最为重要的switch方法其实对应的green_switch方法，。。嗯，那么接下来就来对照着如下python代码来分析greenlet吧：

[cpp] view plain copy

1. from greenlet import greenlet  
2.   
3. def test1(name):  
4.     print name  
5.     gr2.switch()  
6.     print "over"  
7.   
8. def test2():  
9.     print "test-2"  
10.     return "test2-fjsfjs"  
11.   
12.       
13. gr1 = greenlet(test1)  
14. gr2 = greenlet(test2)  
15. value = gr1.switch("fjsfjs")  
16. print value  

首先，得要先来看看greenlet模块的初始化：

[cpp] view plain copy

1. PyMODINIT_FUNC  
2. initgreenlet(void)  
3. #endif  
4. {  
5.     PyObject* m = NULL;  
6.     char** p = NULL;  
7.     PyObject *c_api_object;  
8.     static void *_PyGreenlet_API[PyGreenlet_API_pointers];  
9.   
10.     GREENLET_NOINLINE_INIT();  
11.   
12. #if PY_MAJOR_VERSION >= 3  
13.     m = PyModule_Create(&greenlet_module_def);  
14. #else  
15.     m = Py_InitModule("greenlet", GreenMethods);   //初始化greenlet模块，这里其实定义的方法比较的少，getcurrent啥的  
16. #endif  
17.     if (m == NULL)  
18.     {  
19.         INITERROR;  
20.     }  
21.   
22.     //为模块添加版本信息  
23.     if (PyModule_AddStringConstant(m, "__version__", GREENLET_VERSION) < 0)  
24.     {  
25.         INITERROR;  
26.     }  
27.   
28. #if PY_MAJOR_VERSION >= 3  
29.     ts_curkey = PyUnicode_InternFromString("__greenlet_ts_curkey");  
30.     ts_delkey = PyUnicode_InternFromString("__greenlet_ts_delkey");  
31. #if GREENLET_USE_TRACING  
32.     ts_tracekey = PyUnicode_InternFromString("__greenlet_ts_tracekey");  
33.     ts_event_switch = PyUnicode_InternFromString("switch");  
34.     ts_event_throw = PyUnicode_InternFromString("throw");  
35. #endif  
36. #else  
37.     ts_curkey = PyString_InternFromString("__greenlet_ts_curkey");  
38.     ts_delkey = PyString_InternFromString("__greenlet_ts_delkey");  
39. #if GREENLET_USE_TRACING  
40.     ts_tracekey = PyString_InternFromString("__greenlet_ts_tracekey");  
41.     ts_event_switch = PyString_InternFromString("switch");  
42.     ts_event_throw = PyString_InternFromString("throw");  
43. #endif  
44. #endif  
45.     if (ts_curkey == NULL || ts_delkey == NULL)  
46.     {  
47.         INITERROR;  
48.     }  
49.     if (PyType_Ready(&PyGreenlet_Type) < 0)  
50.     {  
51.         INITERROR;  
52.     }  
53.     PyExc_GreenletError = PyErr_NewException("greenlet.error", NULL, NULL);  
54.     if (PyExc_GreenletError == NULL)  
55.     {  
56.         INITERROR;  
57.     }  
58. #if PY_MAJOR_VERSION >= 3 || (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION >= 5)  
59.     PyExc_GreenletExit = PyErr_NewException("greenlet.GreenletExit",  
60.                         PyExc_BaseException, NULL);  
61. #else  
62.     PyExc_GreenletExit = PyErr_NewException("greenlet.GreenletExit",  
63.                         NULL, NULL);  
64. #endif  
65.     if (PyExc_GreenletExit == NULL)  
66.     {  
67.         INITERROR;  
68.     }  
69.   
70.     ts_empty_tuple = PyTuple_New(0);  
71.     if (ts_empty_tuple == NULL)  
72.     {  
73.         INITERROR;  
74.     }  
75.   
76.     ts_empty_dict = PyDict_New();  
77.     if (ts_empty_dict == NULL)  
78.     {  
79.         INITERROR;  
80.     }  
81.   
82.     //这里可以理解为创建root greenlet对象  
83.     ts_current = green_create_main();  //首先将ts_current创建为main greenlet  
84.     if (ts_current == NULL)  
85.     {  
86.         INITERROR;  
87.     }  
88.   
89.     Py_INCREF(&PyGreenlet_Type);  
90.   
91.     //为当前的模块添加属性  
92.     PyModule_AddObject(m, "greenlet", (PyObject*) &PyGreenlet_Type);  //这个是比较重要的，也就是greenlet的构造结构  
93.     Py_INCREF(PyExc_GreenletError);  
94.     PyModule_AddObject(m, "error", PyExc_GreenletError);  
95.     Py_INCREF(PyExc_GreenletExit);  
96.     PyModule_AddObject(m, "GreenletExit", PyExc_GreenletExit);  
97.     PyModule_AddObject(m, "GREENLET_USE_GC", PyBool_FromLong(GREENLET_USE_GC));  
98.     PyModule_AddObject(m, "GREENLET_USE_TRACING", PyBool_FromLong(GREENLET_USE_TRACING));  
99.   
100.         /* also publish module-level data as attributes of the greentype. */  
101.     for (p=copy_on_greentype; *p; p++) {  
102.         PyObject* o = PyObject_GetAttrString(m, *p);  
103.         if (!o) continue;  
104.         PyDict_SetItemString(PyGreenlet_Type.tp_dict, *p, o);  
105.         Py_DECREF(o);  
106.     }  
107.   
108.     /* 
109.      * Expose C API 
110.      */  
111.   
112.     /* types */  
113.     _PyGreenlet_API[PyGreenlet_Type_NUM] = (void *) &PyGreenlet_Type;  
114.   
115.     /* exceptions */  
116.     _PyGreenlet_API[PyExc_GreenletError_NUM] = (void *) PyExc_GreenletError;  
117.     _PyGreenlet_API[PyExc_GreenletExit_NUM] = (void *) PyExc_GreenletExit;  
118.   
119.     /* methods */  
120.     _PyGreenlet_API[PyGreenlet_New_NUM] = (void *) PyGreenlet_New;  
121.     _PyGreenlet_API[PyGreenlet_GetCurrent_NUM] =  
122.         (void *) PyGreenlet_GetCurrent;  
123.     _PyGreenlet_API[PyGreenlet_Throw_NUM] = (void *) PyGreenlet_Throw;  
124.     _PyGreenlet_API[PyGreenlet_Switch_NUM] = (void *) PyGreenlet_Switch;  
125.     _PyGreenlet_API[PyGreenlet_SetParent_NUM] =  
126.         (void *) PyGreenlet_SetParent;  
127.   
128. #ifdef GREENLET_USE_PYCAPSULE  
129.     c_api_object = PyCapsule_New((void *) _PyGreenlet_API, "greenlet._C_API", NULL);  
130. #else  
131.     c_api_object = PyCObject_FromVoidPtr((void *) _PyGreenlet_API, NULL);  
132. #endif  
133.     //为当前的模块创建C O=API  
134.     if (c_api_object != NULL)  
135.     {  
136.         PyModule_AddObject(m, "_C_API", c_api_object);  
137.     }  
138.   
139. #if PY_MAJOR_VERSION >= 3  
140.     return m;  
141. #endif  
142. }  

代码挺长的，不过其实最重要的是要做两件事情：

（1）创建默认的最顶层的greenlet对象。。。而且将ts_current这个全局变量指向它

（2）在当前模块中加入greenlet对象的namespace吧。。。（也不知道该咋说）

这里先来看看这个初始化创建的顶层的greenlet对象是怎么创建的吧：

[cpp] view plain copy

1. //创建顶层greenlet对象，栈底部为-1，顶部为1  
2. static PyGreenlet* green_create_main(void)  
3. {  
4.     PyGreenlet* gmain;  //待会创建的顶层的greenlet的引用  
5.     //创建一个字典对象  
6.     PyObject* dict = PyThreadState_GetDict();  
7.     if (dict == NULL) {  
8.         if (!PyErr_Occurred())  
9.             PyErr_NoMemory();  
10.         return NULL;  
11.     }  
12.   
13.     /* create the main greenlet for this thread */  
14.     //为当前线程创建greenlet对象  
15.     gmain = (PyGreenlet*) PyType_GenericAlloc(&PyGreenlet_Type, 0);  
16.     if (gmain == NULL)  
17.         return NULL;  
18.     gmain->stack_start = (char*) 1; //栈顶部为1  
19.     //因为无符号，所以-1其实是最大的，这里在栈的复制拷贝的时候，就可以保证这里是最原始的，因为栈是由高地址向低地址扩展的  
20.     gmain->stack_stop = (char*) -1;  //栈底部为-1  因为char*是无符号的，所以可以保证这个是最大的  
21.     gmain->run_info = dict;     
22.     Py_INCREF(dict);  
23.     return gmain;  
24. }  

这里其实最终要的就是设置了两个值，首先是stack_stop栈底指针。。设置成了-1，因为char*本身是无符号的，所以其实这里就保证了stack_stop其实设置的时最大值。。。这个很重要。。因为要明白，栈是由高地址向低地址扩展的。。然后就还设置了stack_start栈顶指针。。。

好了，greenlet模块的初始化完成了，那么接下来开始来分析python代码：

[cpp] view plain copy

1. gr1 = greenlet(test1)  

创建了一个greenlet对象，传入了一个run函数，也就是test1函数，根据前面看到的构造和初始化函数可以知道，当前gr1的parent将会指向最开始初始化建立的greenlet对象。。。

接着看python代码：

[cpp] view plain copy

1. gr2 = greenlet(test2)  

这里创建了greenlet对象，名字叫gr2，运行函数是test2，嗯，同理，它的parent也是初始化建立的greenlet对象。。。

接着看代码：

[cpp] view plain copy

1. value = gr1.switch("fjsfjs")  

这里调用gr1的switch方法，那么接下来就开始进入C语言的范围了。。我们来看看它的实现吧：

[cpp] view plain copy

1.  //greenlet对象的switch方法其实就是对应到这个方法的  
2. //其实最终调用的时g_switch方法  
3. //第一个参数是执行switch的greenlet对象，第二参数是参数数组，第三个是关键字参数  
4. static PyObject* green_switch(  
5.     PyGreenlet* self,  
6.     PyObject* args,  
7.     PyObject* kwargs)  
8. {  
9.     Py_INCREF(args);  
10.     Py_XINCREF(kwargs);  
11.     //调用g_switch方法来进行栈的切换  
12.     return single_result(g_switch(self, args, kwargs));  
13. }  

这里有3个参数，self就是调用switch方法的green let对象了，args是参数列表，kwargs是关键字参数。。。

这里调用了g_switch方法来接下里执行。。

[cpp] view plain copy

1. //在python层面中，调用了greenlet的switch方法，其实是最终调用这个来进行执行的  
2. //这里target参数就是执行switch的greenlet对象  
3. //(1)先获取运行信息，参数啥的(2)从切换到的greenlet开始，找到一个可以运行的greenlet对象，通过parent向上遍历  
4. //(3)如果这个greenlet已经是active了，那么直接调用g_switchstack方法，如果这个greenlet还没有启动，那么需要g_initialstub进行初始化  
5. static PyObject *  
6. g_switch(PyGreenlet* target, PyObject* args, PyObject* kwargs)  
7. {  
8.     /* _consumes_ a reference to the args tuple and kwargs dict, 
9.        and return a new tuple reference */  
10.     int err = 0;  
11.     PyObject* run_info;  
12.   
13.     /* check ts_current */  
14.     if (!STATE_OK) {  //如果状态不对，那么这里需要减少参数的引用计数  
15.         Py_XDECREF(args);  
16.         Py_XDECREF(kwargs);  
17.         return NULL;  
18.     }  
19.     run_info = green_statedict(target);  //获取运行信息  
20.     if (run_info == NULL || run_info != ts_current->run_info) {  //检查一下运行信息，万一是null咋办  
21.         Py_XDECREF(args);  
22.         Py_XDECREF(kwargs);  
23.         PyErr_SetString(PyExc_GreenletError, run_info  
24.                 ? "cannot switch to a different thread"  
25.                 : "cannot switch to a garbage collected greenlet");  
26.         return NULL;  
27.     }  
28.   
29.     ts_passaround_args = args;   //保存switch传进来的参数  
30.     ts_passaround_kwargs = kwargs;  //保存switch传进来的关键字参数  
31.   
32.     /* find the real target by ignoring dead greenlets, 
33.        and if necessary starting a greenlet. */  
34.     //找到真正需要指定的greenlet  
35.     while (target) {   //需要通过parent引用向上遍历，只要找到一个可用的就停止  
36.         if (PyGreenlet_ACTIVE(target)) {   //找到一个可用的greenlet  
37.             ts_target = target;   //  指向运行的greenlet  
38.             err = g_switchstack();  //切换到这个栈，里面会调用slp_switch方法，用汇编实现  
39.             break;  
40.         }  
41.         if (!PyGreenlet_STARTED(target)) {  //如果都没有启动，那么需要初始化  
42.             //这个变量挺有意思的  
43.             void* dummymarker;   //这里创建了一个新的局部变量，其实是通过它的地址待会来分割新创建的栈，用其来做新栈的底部  
44.             ts_target = target;  
45.             err = g_initialstub(&dummymarker);   //对于没有启动的协程，这里需要进行初始化  
46.             if (err == 1) {  
47.                 continue; /* retry the switch */  
48.             }  
49.             break;  
50.         }  
51.         target = target->parent;  
52.     }  
53.   
54.     /* For a very short time, immediately after the 'atomic' 
55.        g_switchstack() call, global variables are in a known state. 
56.        We need to save everything we need, before it is destroyed 
57.        by calls into arbitrary Python code. */  
58.   
59.     //这里处理switch返回参数，这里    
60.     //这里可以看出来，其实switch的返回值也是通过ts_passaround_args，ts_passaround_kwargs这两个全局变量来传递的  
61.     args = ts_passaround_args;     
62.     ts_passaround_args = NULL;  
63.     kwargs = ts_passaround_kwargs;  
64.     ts_passaround_kwargs = NULL;  
65.     if (err < 0) {   //如果在栈的切换的时候出现了错误  
66.         /* Turn switch errors into switch throws */  
67.         assert(ts_origin == NULL);  
68.         Py_CLEAR(kwargs);  
69.         Py_CLEAR(args);  
70.     } else {  
71.         PyGreenlet *origin;  
72. #if GREENLET_USE_TRACING  
73.         PyGreenlet *current;  
74.         PyObject *tracefunc;  
75. #endif  
76.         origin = ts_origin;  
77.         ts_origin = NULL;  
78. #if GREENLET_USE_TRACING  
79.         current = ts_current;  
80.         if ((tracefunc = PyDict_GetItem(current->run_info, ts_tracekey)) != NULL) {  
81.             Py_INCREF(tracefunc);  
82.             if (g_calltrace(tracefunc, args ? ts_event_switch : ts_event_throw, origin, current) < 0) {  
83.                 /* Turn trace errors into switch throws */  
84.                 Py_CLEAR(kwargs);  
85.                 Py_CLEAR(args);  
86.             }  
87.             Py_DECREF(tracefunc);  
88.         }  
89. #endif  
90.         Py_DECREF(origin);  
91.     }  
92.   
93.     /* We need to figure out what values to pass to the target greenlet 
94.        based on the arguments that have been passed to greenlet.switch(). If 
95.        switch() was just passed an arg tuple, then we'll just return that. 
96.        If only keyword arguments were passed, then we'll pass the keyword 
97.        argument dict. Otherwise, we'll create a tuple of (args, kwargs) and 
98.        return both. */  
99.     if (kwargs == NULL)  //没有关键字参数，那么直接返回参数列表  
100.     {  
101.         return args;  
102.     }  
103.     else if (PyDict_Size(kwargs) == 0)  
104.     {  
105.         Py_DECREF(kwargs);  
106.         return args;  
107.     }  
108.     else if (PySequence_Length(args) == 0)  
109.     {  
110.         Py_DECREF(args);  
111.         return kwargs;  
112.     }  
113.     else  //两种参数都有  
114.     {  
115.         PyObject *tuple = PyTuple_New(2);  
116.         if (tuple == NULL) {  
117.             Py_DECREF(args);  
118.             Py_DECREF(kwargs);  
119.             return NULL;  
120.         }  
121.         PyTuple_SET_ITEM(tuple, 0, args);  
122.         PyTuple_SET_ITEM(tuple, 1, kwargs);  
123.         return tuple;  
124.     }  
125. }  

这里target参数也就是执行了switch方法的green let对象，对应到python代码，也就是我们建立的gr1对象。。

一个while循环。。。

这里需要注意，由于我们的gr1并没有开始运行，所以将会执行如下代码：

[cpp] view plain copy

1. //这个变量挺有意思的  
2.             void* dummymarker;   //这里创建了一个新的局部变量，其实是通过它的地址待会来分割新创建的栈，用其来做新栈的底部  
3.             ts_target = target;  
4.             err = g_initialstub(&dummymarker);   //对于没有启动的协程，这里需要进行初始化  

先是在当前栈里面创建了一个dummymarker对象，然后将ts_target这个全局变量指向gr1，然后调用g_initialstub方法来初始化，并且将dummymarker的地址也传进去了。。。这个参数很重要，因为它将被设置成gr1的栈底指针。。。

好了，来看看g_initialstub方法：

[cpp] view plain copy

1. //对于刚刚创建，都还没有启动的greenlet对象，第一调用switch方法的时候将会调用这里进行初始化  
2. static int GREENLET_NOINLINE(g_initialstub)(void* mark)  
3. {  
4.     int err;  
5.     PyObject *o, *run;  
6.     PyObject *exc, *val, *tb;  
7.     PyObject *run_info;  
8.     PyGreenlet* self = ts_target;  
9.     PyObject* args = ts_passaround_args;  //获取switch传进来的参数  
10.     PyObject* kwargs = ts_passaround_kwargs;  //switch传进来的关键字参数  
11.   
12.     /* save exception in case getattr clears it */  
13.     PyErr_Fetch(&exc, &val, &tb);  
14.     /* self.run is the object to call in the new greenlet */  
15.     run = PyObject_GetAttrString((PyObject*) self, "run");  //获取run属性  
16.     if (run == NULL) {  
17.         Py_XDECREF(exc);  
18.         Py_XDECREF(val);  
19.         Py_XDECREF(tb);  
20.         return -1;  
21.     }  
22.     /* restore saved exception */  
23.     PyErr_Restore(exc, val, tb);  
24.   
25.     /* recheck the state in case getattr caused thread switches */  
26.     if (!STATE_OK) {  
27.         Py_DECREF(run);  
28.         return -1;  
29.     }  
30.   
31.     /* recheck run_info in case greenlet reparented anywhere above */  
32.     run_info = green_statedict(self);  
33.     if (run_info == NULL || run_info != ts_current->run_info) {  
34.         Py_DECREF(run);  
35.         PyErr_SetString(PyExc_GreenletError, run_info  
36.                 ? "cannot switch to a different thread"  
37.                 : "cannot switch to a garbage collected greenlet");  
38.         return -1;  
39.     }  
40.   
41.     /* by the time we got here another start could happen elsewhere, 
42.      * that means it should now be a regular switch 
43.      */  
44.     if (PyGreenlet_STARTED(self)) {  
45.         Py_DECREF(run);  
46.         ts_passaround_args = args;  
47.         ts_passaround_kwargs = kwargs;  
48.         return 1;  
49.     }  
50.   
51.     /* start the greenlet */  
52.     self->stack_start = NULL;  //设置栈的顶部为null  
53.     self->stack_stop = (char*) mark;  //设置栈底地址，其实这个地址是从当前运行栈里面新创建了一个变量来获取的  
54.   
55.     //这里设置栈之间的层次关系  
56.     if (ts_current->stack_start == NULL) {  //如果当前环境greenlet环境栈不在，那么向上设置一层  
57.         /* ts_current is dying */  
58.         self->stack_prev = ts_current->stack_prev;    
59.     } else {  
60.         self->stack_prev = ts_current;    //一般情况下就将栈层次设置为当前环境所属的greenlet  
61.     }  
62.   
63.   
64.     //初始化当前栈的信息  
65.     self->top_frame = NULL;  
66.     self->exc_type = NULL;  
67.     self->exc_value = NULL;  
68.     self->exc_traceback = NULL;  
69.     self->recursion_depth = PyThreadState_GET()->recursion_depth;  
70.   
71.     /* restore arguments in case they are clobbered */  
72.     ts_target = self;  
73.     ts_passaround_args = args;  
74.     ts_passaround_kwargs = kwargs;  
75.   
76.     /* perform the initial switch */  
77.     //栈切换，将当前环境所属的greenlet栈换出去，然后将要执行的greenlet的栈换进来  
78.       
79.   
80.     //这里为啥会返回两次呢？  
81.     //对于切换到的新的greenlet，因为在执行栈的保存的时候直接提前对于slp_switch函数返回了1 ，接下来就就开始run的执行  
82.     //而对于原来的greenlet，它的运行就已经停在了g_switchstack，并没有进行下去了，以后switch这个greenlet的时候将在这里再返回一次  
83.     //但是这个时候将会返回0  
84.     err = g_switchstack();  
85.   
86.     /* returns twice! 
87.        The 1st time with err=1: we are in the new greenlet 
88.        The 2nd time with err=0: back in the caller's greenlet 
89.     */  
90.      //当返回1的时候，表示是在新创建的greenlet里面，如果是0，那么是在调用环境的greenlet里面  
91.        //如果是在新的栈里面，那么需要执行run  
92.     if (err == 1) {  
93.         /* in the new greenlet */  
94.         PyGreenlet* origin;  
95. #if GREENLET_USE_TRACING  
96.         PyObject* tracefunc;  
97. #endif  
98.         PyObject* result;  
99.         PyGreenlet* parent;  
100.         self->stack_start = (char*) 1;  /* running */  //这里其实主要是充当标识  
101.   
102.         /* grab origin while we still can */  
103.         origin = ts_origin;  //指向切换之前的greenlet  
104.         ts_origin = NULL;  
105.   
106.         /* now use run_info to store the statedict */  
107.         o = self->run_info;  
108.         self->run_info = green_statedict(self->parent);  
109.         Py_INCREF(self->run_info);  
110.         Py_XDECREF(o);  
111.   
112. #if GREENLET_USE_TRACING  
113.         if ((tracefunc = PyDict_GetItem(self->run_info, ts_tracekey)) != NULL) {  
114.             Py_INCREF(tracefunc);  
115.             if (g_calltrace(tracefunc, args ? ts_event_switch : ts_event_throw, origin, self) < 0) {  
116.                 /* Turn trace errors into switch throws */  
117.                 Py_CLEAR(kwargs);  
118.                 Py_CLEAR(args);  
119.             }  
120.             Py_DECREF(tracefunc);  
121.         }  
122. #endif  
123.         Py_DECREF(origin);  
124.   
125.         if (args == NULL) {  
126.             /* pending exception */  
127.             result = NULL;  
128.         } else {  
129.             /* call g.run(*args, **kwargs) */  
130.             //执行run，然后获取返回的参数  
131.             result = PyEval_CallObjectWithKeywords(   //开始执行当前协程的run  
132.                 run, args, kwargs);  
133.             Py_DECREF(args);  
134.             Py_XDECREF(kwargs);  
135.         }  
136.         Py_DECREF(run);  
137.         result = g_handle_exit(result);  //这里对run的返回参数进行一下预处理  
138.   
139.         /* jump back to parent */  
140.         //这里实现了跳转到parent的逻辑  
141.         //这里可以看出，对于已经运行完了的greenlet对象，它之后是切换到parent对象上继续执行  
142.         self->stack_start = NULL;  /* dead */  //用这个标记当前greenlet已经结束了，待会在switch的时候就不会保存这个栈的数据到内存了  
143.         for (parent = self->parent; parent != NULL; parent = parent->parent) {  
144.             /* 
145.             **  这里要看到这里将run执行完之后返回的result参数传入了switch  
146.             ** 
147.  
148.             */  
149.             result = g_switch(parent, result, NULL);  
150.             /* Return here means switch to parent failed, 
151.              * in which case we throw *current* exception 
152.              * to the next parent in chain. 
153.              */  
154.             assert(result == NULL);  
155.         }  
156.         /* We ran out of parents, cannot continue */  
157.         PyErr_WriteUnraisable((PyObject *) self);  
158.         Py_FatalError("greenlets cannot continue");  
159.     }  
160.     /* back in the parent */  
161.     if (err < 0) {  
162.         /* start failed badly, restore greenlet state */  
163.         self->stack_start = NULL;  
164.         self->stack_stop = NULL;  
165.         self->stack_prev = NULL;  
166.     }  
167.     return err;  
168. }  

这里可以看到，确实是将当前gr1的栈底stack_stop指向了刚刚传进来的地址，基本上上面的注释也说的比较的清楚了。。其实真正的栈的复制与切换是在如下代码：

[cpp] view plain copy

1. //这里为啥会返回两次呢？  
2. //对于切换到的新的greenlet，因为在执行栈的保存的时候直接提前对于slp_switch函数返回了1 ，接下来就就开始run的执行  
3. //而对于原来的greenlet，它的运行就已经停在了g_switchstack，并没有进行下去了，以后switch这个greenlet的时候将在这里再返回一次  
4. //但是这个时候将会返回0  
5. err = g_switchstack();  

嗯，这里将会要返回两次额。。也就是会得到两个err的值。。。为啥要返回两次了。。其实理解到了这个也就理解到了整个greenlet切换的关键了。。。返回1是在我们新的greenlet的执行环境中，也就是gr1，如果返回0，那么就是在调用switch方法所属的greenlet的环境中。。。

好了这里也说不明白为啥会返回两次。。接下来看代码吧：

[cpp] view plain copy

1. //将栈转移到真正要执行的地方去  
2. //这里将会调用使用汇编实现的slp_switch的方法，修改栈寄存器，从而将程序的运行引导到新的greenlet里面去  
3. static int g_switchstack(void)  
4. {  
5.     /* Perform a stack switch according to some global variables 
6.        that must be set before: 
7.        - ts_current: current greenlet (holds a reference) 
8.        - ts_target: greenlet to switch to (weak reference)  要转移到的greenlet 
9.        - ts_passaround_args: NULL if PyErr_Occurred(), 
10.            else a tuple of args sent to ts_target (holds a reference) 
11.        - ts_passaround_kwargs: switch kwargs (holds a reference) 
12.        On return results are passed via global variables as well: 
13.        - ts_origin: originating greenlet (holds a reference) 
14.        - ts_current: current greenlet (holds a reference) 
15.        - ts_passaround_args: NULL if PyErr_Occurred(), 
16.            else a tuple of args sent to ts_current (holds a reference) 
17.        - ts_passaround_kwargs: switch kwargs (holds a reference) 
18.        It is very important that stack switch is 'atomic', i.e. no 
19.        calls into other Python code allowed (except very few that 
20.        are safe), because global variables are very fragile. 
21.     */  
22.     int err;   //将当前栈的运行信息保存起来，以后运行的时候再恢复  
23.     {   /* save state */  
24.         PyGreenlet* current = ts_current;  //获取当前在线的greenlet对象  
25.         PyThreadState* tstate = PyThreadState_GET();  //获取当前线程信息  
26.         current->recursion_depth = tstate->recursion_depth;   //栈深度  
27.         //可以理解为当前环境所属的greenlet的执行到这里就终止了，以后恢复也会到这里来  
28.         current->top_frame = tstate->frame;    //保存当前线程执行栈的顶部帧 ，其实主要是为了处理程序计数器  
29.         current->exc_type = tstate->exc_type;   //执行类型  
30.         current->exc_value = tstate->exc_value;  
31.         current->exc_traceback = tstate->exc_traceback;  
32.     }  
33.       
34.     //其实如果是新运行的greenlet，这里没有什么可以换进来的  
35.     //这里需要理解的是：假如是A切换到B，那么A的运行将在slp_switch随着栈的切换而停滞，而B的运行将在这个里面开始，当以后重新切换到A的时候，其实也是从slp_switch开始恢复的  
36.     err = slp_switch();    //这里进行栈的切换，到这里就可以理解为当前环境greenlet的栈信息就已经切换出去了 ，然后新的greenlet对象的栈信息被换进来了  
37.       
38.     //返回小于0标示出错了  
39.     if (err < 0) {   /* error */  
40.         PyGreenlet* current = ts_current;  
41.         current->top_frame = NULL;  
42.         current->exc_type = NULL;  
43.         current->exc_value = NULL;  
44.         current->exc_traceback = NULL;  
45.   
46.         assert(ts_origin == NULL);  
47.         ts_target = NULL;  
48.     } else {   //转移到ts_target的栈，这里重新设置当前的运行信息  
49.         PyGreenlet* target = ts_target;  
50.         PyGreenlet* origin = ts_current;  
51.         PyThreadState* tstate = PyThreadState_GET();  
52.         tstate->recursion_depth = target->recursion_depth;  
53.         tstate->frame = target->top_frame;   //这里主要是为了设置python的程序计数器  
54.         target->top_frame = NULL;  
55.         tstate->exc_type = target->exc_type;  
56.         target->exc_type = NULL;  
57.         tstate->exc_value = target->exc_value;  
58.         target->exc_value = NULL;  
59.         tstate->exc_traceback = target->exc_traceback;  
60.         target->exc_traceback = NULL;  
61.   
62.         assert(ts_origin == NULL);  
63.         Py_INCREF(target);  
64.         ts_current = target;  //将当前ts_current 设置为switch到的target  
65.         ts_origin = origin;   //将ts_origin指向前面  
66.         ts_target = NULL;  
67.     }  
68.     return err;  
69. }  

这里保存了当前环境所属的greenlet的状态信息，然后调用汇编写的slp_switch方法来进行真正的栈切换，接着更改一些全局变量。。。

那么这里的关键就是要理解slp_switch方法了。。

根据不同的系统，会有不同的实现。。因为我的时mac os 64位，所以实现如下:

[cpp] view plain copy

1. //因为当前所属的greenlet的执行栈肯定是在栈层次最上面的  
2. //如果这里要切换到的greenlet的栈其实还在下面，那么需要将前面的栈的信息都拷贝到堆空间里面去  
3. //当然这里也存在特殊情况，例如切换到的时新的greenlet，那么其实就不用拷贝  
4. static int  
5. slp_switch(void)  
6. {  
7.     int err;  
8.     void* rbp;  
9.     void* rbx;  
10.     unsigned int csr;  
11.     unsigned short cw;  
12.     register long *stackref, stsizediff;  
13.     __asm__ volatile ("" : : : REGS_TO_SAVE);  
14.     __asm__ volatile ("fstcw %0" : "=m" (cw));  
15.     __asm__ volatile ("stmxcsr %0" : "=m" (csr));  
16.     //这里先获取以及保存rbp,rbx,rsp三个寄存器的数据  
17.     __asm__ volatile ("movq %%rbp, %0" : "=m" (rbp));  
18.     __asm__ volatile ("movq %%rbx, %0" : "=m" (rbx));  
19.     __asm__ ("movq %%rsp, %0" : "=g" (stackref));   //将栈顶的地址（rsp）保存到stackref  
20.     {  
21.         //这里会将栈之间的偏移保存到stsizediff变量  
22.         //这里是宏定义，如果要切换到的greenlet并没有运行，那么这里宏定义里面就会提前返回1那么g_initialstub里面就可以开始run的执行了  
23.         //这里可以看到其实栈的保存是最终地址保存到slp_switch这一层的  
24.         SLP_SAVE_STATE(stackref, stsizediff);  // 把栈的信息保存到堆空间里面去  
25.         //修改rbp以及rsp寄存器值，用于将当前栈切换到新要执行的greenlet的执行栈  
26.         __asm__ volatile (  
27.             "addq %0, %%rsp\n"  
28.             "addq %0, %%rbp\n"  
29.             :  
30.             : "r" (stsizediff)  
31.             );  
32.         SLP_RESTORE_STATE();  //对于刚刚运行的greenlet，这里其实没有什么恢复的  
33.         __asm__ volatile ("xorq %%rax, %%rax" : "=a" (err));  
34.     }  
35.      // 这里要注意，前后rbp，rbx的值已经改变了，因为栈的数据已经改变了  
36.     //因为这里已经恢复了切换到的greenlet的栈的信息，所以这里恢复的其实是切换到的greenlet的栈的寄存器的地址  
37.     __asm__ volatile ("movq %0, %%rbx" : : "m" (rbx));  
38.     __asm__ volatile ("movq %0, %%rbp" : : "m" (rbp));  
39.     __asm__ volatile ("ldmxcsr %0" : : "m" (csr));  
40.     __asm__ volatile ("fldcw %0" : : "m" (cw));  
41.     __asm__ volatile ("" : : : REGS_TO_SAVE);  
42.     return err;  
43. }  

这里最主要的就是先保存了rbp以及rbx寄存器的值，然后将rsp寄存器的值保存到寄存器变量stackref中，

rbp：当前函数的栈底指针

rsp：当前函数栈的栈顶指针

然后调用SLP_SAVE_STATE 来进行当前栈的保存，这个是一个宏定义，如下：

[cpp] view plain copy

1. //第一个参数是当前栈的顶部的地址，第二个变量用于保存栈之间的偏移  
2. //这里如果要切换到的greenlet对象还没有开始，那么返回1  
3. #define SLP_SAVE_STATE(stackref, stsizediff)        \  
4.   stackref += STACK_MAGIC;              \  
5.   if (slp_save_state((char*)stackref)) return -1;   \  
6.   if (!PyGreenlet_ACTIVE(ts_target)) return 1;      \  
7.   stsizediff = ts_target->stack_start - (char*)stackref     

这里先是调用slp_save_state方法来保存栈，如下：

[cpp] view plain copy

1. //保存栈的信息，参数是当前栈顶的地址  
2. //这里保存的原则就是，将要切换到的greenlet的对象的栈更上层的栈都保存起来  
3. static int GREENLET_NOINLINE(slp_save_state)(char* stackref)  
4. {  
5.   
6.     /* must free all the C stack up to target_stop */  
7.     char* target_stop = ts_target->stack_stop;  //获取要切换到的greenlet的栈底部  
8.     PyGreenlet* owner = ts_current;  //当前环境所属的greenlet  
9.     assert(owner->stack_saved == 0);  
10.     if (owner->stack_start == NULL) {  //这个表示当前greenlet已经执行完了，那么指向栈层次的上一个greenlet  
11.         owner = owner->stack_prev;  /* not saved if dying */  
12.     } else {  
13.         owner->stack_start = stackref;   //设置当前环境所属greenlet的栈的顶部地址  
14.     }  
15.   
16.       
17.     //这里是要保存所有在当前栈层次上更深的栈的信息，将他们保存起来防止干扰  
18.     while (owner->stack_stop < target_stop) {  //因为栈是从高地址向低地址部分延伸的  
19.         /* ts_current is entierely within the area to free */  
20.         if (g_save(owner, owner->stack_stop))  //将这个greenlet的栈的信息保存到堆空间  
21.             return -1;  /* XXX */  
22.         owner = owner->stack_prev;  //向上遍历  
23.     }  
24.     //这里确实存在可能等于的情况，例如在mai中创建一个协程T1，那么它的parent也就是root，然后switch进行调度，当执行完了之后，start_start会被设置为null  
25.     //接下来会被switch到parent，那么在上面，owner将会北被指向prev，其实也就是parent，这里就相等了  
26.     if (owner != ts_target) {  //如果当前环境的greelet不是要切换到的greenlet，那么保存当前  
27.         if (g_save(owner, target_stop))  
28.             return -1;  /* XXX */  
29.     }  
30.     return 0;  
31. }  

这里可以代码的大体意思就是将属于要切换到的greenlet gr1的栈  更上面greenlet的栈数据都保存起来。。

而这里，ts_current全局变量其实是最开始初始化建立的root greenlet对象，它的栈的栈底指针值是最大的，所以最终只会执行如下代码：

[cpp] view plain copy

1. if (owner != ts_target) {  //如果当前环境的greelet不是要切换到的greenlet，那么保存当前  
2.         if (g_save(owner, target_stop))  
3.             return -1;  /* XXX */  
4.     }  

而且，这里传进来的stackref参数其实是slp_switch方法的栈顶地址，我们来看看当前栈的情况：

再看看g_save方法：

[cpp] view plain copy

1. //将这个greenlet的栈的信息保存到堆空间里面去  
2. static int g_save(PyGreenlet* g, char* stop)  
3. {  
4.     /* Save more of g's stack into the heap -- at least up to 'stop' 
5.  
6.        g->stack_stop |________| 
7.                      |        | 
8.              |    __ stop       . . . . . 
9.                      |        |    ==>  .       . 
10.              |________|          _______ 
11.              |        |         |       | 
12.              |        |         |       | 
13.       g->stack_start |        |         |_______| g->stack_copy 
14.  
15.      */  
16.     intptr_t sz1 = g->stack_saved;  
17.   
18.     //计算要保存的栈的大小  
19.     intptr_t sz2 = stop - g->stack_start;   //栈的大小  
20.     assert(g->stack_start != NULL);  
21.     if (sz2 > sz1) {     //标示栈的大小已经改变了  
22.         char* c = (char*)PyMem_Realloc(g->stack_copy, sz2);  
23.         if (!c) {  
24.             PyErr_NoMemory();  
25.             return -1;  
26.         }  
27.         memcpy(c+sz1, g->stack_start+sz1, sz2-sz1);  
28.         g->stack_copy = c;  //表示栈的信息保存到了这个地方  
29.         g->stack_saved = sz2;   //保存了这么大的大小  
30.     }  
31.     return 0;  
32. }  

可以看到，其实保存的是dummymarker到slp_switch栈顶地址这段空间的值。。嗯，这个很重要。。。

接着因为我们切换到的greenlet gr1 并没有运行，所以直接提前返回1了，那么当前slp_switch将会返回1，然后g_switchstack方法也就返回了1，那么也就是解释了在g_initialstub方法中的第一个返回1是怎么来的。。。

那么当前的执行回到了g_initialstub方法中，因为返回了1，所以可以执行如下代码了：

[cpp] view plain copy

1. result = PyEval_CallObjectWithKeywords(   //开始执行当前协程的run  
2.                 run, args, kwargs);  

这里就是调用新的greenlet  也就是gr1 的run也就是我们python代码中的test1函数。。。

[cpp] view plain copy

1. def test1(name):  
2.     print name  
3.     gr2.switch()  
4.     print "over"  

用上述同理的方法，来分析gr2.switch()，这里将会切换到gr2的执行，也就是test2函数，在执行之前gr2的栈的内容也将会被保存。。。

[cpp] view plain copy

1. def test2():  
2.     print "test-2"  
3.     return "test2-fjsfjs"  

当test2执行完了之后，将会执行回到 g_initialstub中，执行如下代码：

[cpp] view plain copy

1. /* jump back to parent */  
2.         //这里实现了跳转到parent的逻辑  
3.         //这里可以看出，对于已经运行完了的greenlet对象，它之后是切换到parent对象上继续执行  
4.         self->stack_start = NULL;  /* dead */  //用这个标记当前greenlet已经结束了，待会在switch的时候就不会保存这个栈的数据到内存了  
5.         for (parent = self->parent; parent != NULL; parent = parent->parent) {  
6.             /* 
7.             **  这里要看到这里将run执行完之后返回的result参数传入了switch  
8.             ** 
9.  
10.             */  
11.             result = g_switch(parent, result, NULL);  
12.             /* Return here means switch to parent failed, 
13.              * in which case we throw *current* exception 
14.              * to the next parent in chain. 
15.              */  
16.             assert(result == NULL);  
17.         }  

也就是将切换到parent来运行，这里parent也就是最开始初始化建立的greenlet对象。。。

那么这里在slp_switch方法中就会产生不一样的地方了。。。

[cpp] view plain copy

1. //因为当前所属的greenlet的执行栈肯定是在栈层次最上面的  
2. //如果这里要切换到的greenlet的栈其实还在下面，那么需要将前面的栈的信息都拷贝到堆空间里面去  
3. //当然这里也存在特殊情况，例如切换到的时新的greenlet，那么其实就不用拷贝  
4. static int  
5. slp_switch(void)  
6. {  
7.     int err;  
8.     void* rbp;  
9.     void* rbx;  
10.     unsigned int csr;  
11.     unsigned short cw;  
12.     register long *stackref, stsizediff;  
13.     __asm__ volatile ("" : : : REGS_TO_SAVE);  
14.     __asm__ volatile ("fstcw %0" : "=m" (cw));  
15.     __asm__ volatile ("stmxcsr %0" : "=m" (csr));  
16.     //这里先获取以及保存rbp,rbx,rsp三个寄存器的数据  
17.     __asm__ volatile ("movq %%rbp, %0" : "=m" (rbp));  
18.     __asm__ volatile ("movq %%rbx, %0" : "=m" (rbx));  
19.     __asm__ ("movq %%rsp, %0" : "=g" (stackref));   //将栈顶的地址（rsp）保存到stackref  
20.     {  
21.         //这里会将栈之间的偏移保存到stsizediff变量  
22.         //这里是宏定义，如果要切换到的greenlet并没有运行，那么这里宏定义里面就会提前返回1那么g_initialstub里面就可以开始run的执行了  
23.         //这里可以看到其实栈的保存是最终地址保存到slp_switch这一层的  
24.         SLP_SAVE_STATE(stackref, stsizediff);  // 把栈的信息保存到堆空间里面去  
25.         //修改rbp以及rsp寄存器值，用于将当前栈切换到新要执行的greenlet的执行栈  
26.         __asm__ volatile (  
27.             "addq %0, %%rsp\n"  
28.             "addq %0, %%rbp\n"  
29.             :  
30.             : "r" (stsizediff)  
31.             );  
32.         SLP_RESTORE_STATE();  //对于刚刚运行的greenlet，这里其实没有什么恢复的  
33.         __asm__ volatile ("xorq %%rax, %%rax" : "=a" (err));  
34.     }  
35.      // 这里要注意，前后rbp，rbx的值已经改变了，因为栈的数据已经改变了,虽然代码指令没有变，但是栈已经变了  
36.     //因为这里已经恢复了切换到的greenlet的栈的信息，所以这里恢复的其实是切换到的greenlet的栈的寄存器的地址  
37.     __asm__ volatile ("movq %0, %%rbx" : : "m" (rbx));  
38.     __asm__ volatile ("movq %0, %%rbp" : : "m" (rbp));  
39.     __asm__ volatile ("ldmxcsr %0" : : "m" (csr));  
40.     __asm__ volatile ("fldcw %0" : : "m" (cw));  
41.     __asm__ volatile ("" : : : REGS_TO_SAVE);  
42.     return err;  
43. }  

这里在执行宏定义SLP_SAVE_STATE的时候将不会提前将slp_switch函数返回，而是将会计算得到当前gr2的栈与parent栈的偏移量，存在stsizediff寄存器变量中。。。

然后通过汇编来修改rsp与rbp寄存器的值，达到切换栈的效果。。。

然后SLP_RESTORE_STATE调用这个宏定义将以前保存的parent 的栈数据。。。前面已经说过了，也就是：

也就是说，接下来执行的代码

[cpp] view plain copy

1.     __asm__ volatile ("xorq %%rax, %%rax" : "=a" (err));  
2. }  
3.  // 这里要注意，前后rbp，rbx的值已经改变了，因为栈的数据已经改变了,虽然代码指令没有变，但是栈已经变了  
4. //因为这里已经恢复了切换到的greenlet的栈的信息，所以这里恢复的其实是切换到的greenlet的栈的寄存器的地址  
5. __asm__ volatile ("movq %0, %%rbx" : : "m" (rbx));  
6. __asm__ volatile ("movq %0, %%rbp" : : "m" (rbp));  
7. __asm__ volatile ("ldmxcsr %0" : : "m" (csr));  
8. __asm__ volatile ("fldcw %0" : : "m" (cw));  
9. __asm__ volatile ("" : : : REGS_TO_SAVE);  
10. return err;  

他们的运行已经在以前parent，也就是初始化建立的greenlet对象的栈里面执行了。。。这里也就解释了为啥在g_initialstub函数中，g_switchstack会返回两次，前面一次会返回1，而这一次会返回0.。。

那么到这里value = gr1.switch("fjsfjs")也就执行完了。。

回到最开的python代码：

执行：print value

到这里greenlet是如何实现栈的复制与切换就说的差不多了。。。。

当然还有一些东西没有说，例如参数的传递啥的。。就不细说了，看代码都能比较容易明白。。。