【lua5.2相关】 今天做了一番试验， 发现coroutine有此坑， 真神秘。

linux_c_py_php

环境是lua5.2, 主要是把5.1->5.2的api change list过了一遍, 主要想验证coroutine的工作过程, 然后发现了两个坑, 大侠看看我理解的对不对, 多谢.

1, 写C模块命名为"mod", 写C宿主调用"mod", 其中"mod"模块只包含一个函数, 用于测试coroutine.

1. [root@vps616 study]# cat src/mod.c
   
2. #include "lua.h"
   
3. #include "lualib.h"
   
4. #include "lauxlib.h"
   
5. 
   
6. static int run_twice(lua_State *L) {
   
7.     int ctx;
   
8. 
   
9.     if (lua_getctx(L, &ctx) == LUA_OK) {
   
10.         lua_pushstring(L, "hello");
    
11.         return lua_yieldk(L, 1, 2, run_twice);
    
12.     }
    
13.     lua_pushstring(L, " world");
    
14.     return 1;
    
15. }
    
16. 
    
17. static const luaL_Reg reg_api[] = {
    
18.     {"run_twice", run_twice},
    
19.     {NULL, NULL}
    
20. };
    
21. 
    
22. int luaopen_mod(lua_State *L) {
    
23.     lua_newtable(L);
    
24.     luaL_setfuncs(L, reg_api, 0);
    
25.     return 1;
    
26. }

复制代码

1. [root@vps616 study]# cat src/main.c
   
2. #include "lua.h"
   
3. #include "lualib.h"
   
4. #include "lauxlib.h"
   
5. 
   
6. int main(int argc, char* const argv[]) {
   
7.     lua_State *L = luaL_newstate();
   
8.     lua_State *LL = lua_newthread(L);
   
9.    
   
10.     lua_pushcfunction(L, luaopen_base);
    
11.     if (lua_pcall(L, 0, 0, 0) != LUA_OK) {
    
12.         return 1;
    
13.     }
    
14.     lua_pushcfunction(L, luaopen_package);
    
15.     if (lua_pcall(L, 0, 0, 0) != LUA_OK) {
    
16.         return 2;
    
17.     }
    
18.     lua_getglobal(L, "require");
    
19.     lua_pushstring(L, "mod");
    
20.     if (lua_pcall(L, 1, 1, 0) != LUA_OK) {
    
21.         return 3;
    
22.     }
    
23.     lua_getfield(L, -1, "run_twice");
    
24.     lua_pushstring(LL, "1234");
    
25.     printf("top=%d\n", lua_gettop(LL));
    
26.     lua_xmove(L, LL, 1);
    
27.     printf("top=%d\n", lua_gettop(LL));
    
28.     if (lua_resume(LL, NULL, 0) == LUA_YIELD) {
    
29.         printf("yield=%s\n", lua_tostring(LL, -1));
    
30.     }
    
31.     printf("top=%d\n", lua_gettop(LL));
    
32.     if (lua_resume(LL, NULL, 0) == LUA_OK) {
    
33.         printf("return=%s\n", lua_tostring(LL, -1));
    
34.     }
    
35.     printf("top=%d %s\n", lua_gettop(LL), lua_tostring(LL, 1));
    
36.     return 0;
    
37. }

复制代码

这个例子主要目的是观察run_twice在协程中执行的栈变化, 因为看lua.org/manual实在是描述的不太清晰.

1. [root@vps616 study]# bin/main
   
2. top=1
   
3. top=2
   
4. yield=hello
   
5. top=1
   
6. return= world
   
7. top=2 1234

复制代码

执行结果如下, 可见, yield=hello后top=1, 是yield的返回值, 而return= world之后top=2, 栈底是1234, 栈顶是 world.
我得到结论就是: 在协程未return消亡前, 协程的栈只会容纳resume与yield彼此交换的参数, 直到return才会重新将原本thread栈上的值暴露出来.
这一点和直接调用一个普通函数一样, 在函数内部(相当于thread未return)来看栈只容纳了参数, 其他参数与函数之前的内容暂时屏蔽掉了.


上面这个感悟是否和谐, 求指正.



再就是之前在5.1里被lua_yield坑过, 那个版本yield只能抛回给lua函数而不能抛回给c函数, 5.2有了k系列就不一样了, 但我看5.2手册里lua_yield的说明太朦胧:

int lua_yield (lua_State *L, int nresults);

This function is equivalent to lua_yieldk, but it has no continuation (see §4.7). Therefore, when the thread resumes, it returns to the function that called the function calling lua_yield.

我以为这句话的描述是lua_yield相当于lua_yieldk的function传入当前的function, 但实际上当再次resume的时候并没有重新调用发起lua_yield的那个函数, 而是当再次resume直接返回true, 栈也是空的, 我就是很郁闷了.

根据这个结论, 我认为lua_yield是在lua_pcallk/lua_callk的callee函数中调用的, 这样再次resume执行的是lua_pcallk/lua_callk指定的function。

这个结论是否和谐?

linux_c_py_php

@starwing83

linux_c_py_php

拜读了, 前两个例子非常深刻, 一开始也不好理解, 好在最后都理解了.

第一个pcallk的例子, 第一次resume进入wrap, 调用c_callback, 从而通过pcallk直接yield到wrap(这里pcallk里如果发生了yield, 直接就goto走了, pcallk根本不会返回, 再次resume也是进入c_cont并返回), 第二次resume进入c_cont并从c_callback函数返回到wrap内的调用点, 最后由wrap自己return nil.

我原本以为再次resume后return是返回到coroutine, 没想到这里是返回到c_callback的调用点...

C里调coroutine真是绕脑子, 应该是我没用过pcallk的原因, 都是直接newthread然后就lua_resume了, 所以产生这种错误认知, 这个错误认知应该是因为直接lua_resume->yield和resume->pcallk->yield中间的pcallk没有关注过.

这个理解对吗? 自我感觉pcallk这里不太对劲, 求讲解. 就是说, pcallk调用的函数里yield是返回到resume, 而return是返回到哪里呢? 我试了一下, 不是返回到pcallk, 而是返回到c_callback, 这是梦吗...

第二个例子一开始没看懂, 硬是读了几遍描述, 才搞清楚coroutine只是作用在Login这个逻辑上, 即server::login是登陆接口, 但它是不阻塞的, 在设置了login的callback后, 立即yield, 相当于这个登陆coroutine线程的CPU让出了, 等外部继续epoll等事件循环并触发Login的callback后, 会调用coroutine.resume将cpu让给server::login, 完成登陆.

实际上这个过程没有并发行为, 执行是串行的, 但coroutine帮忙让代码看起来像是阻塞的, 并且利用thread的栈保持了登陆的状态, 也可以说是一个断点, 等待事件触发后推动断点.

starwing83 发表于 2013-01-15 15:23
文档其实不是不清，需要一些背景知识，比如对resume的本质的了解和对continuation这个概念本身的了解，以及 ...

linux_c_py_php

@starwing83

哥, 再指导指导吧, 我快找到感觉了.

linux_c_py_php 发表于 2013-01-15 23:41
拜读了, 前两个例子非常深刻, 一开始也不好理解, 好在最后都理解了.

第一个pcallk的例子, 第一次resume进 ...

linux_c_py_php

但是我在lua里实现相同的东西， 再次resume的返回点却是callback函数内部, 而不是像c_callback那样直接返回到wrap调用c_callback的位置.

这个原理怎么分析...

1. [root@vps616 study]# ./main.lua   
   
2. coroutine yielding
   
3. 5
   
4. coroutine resumed
   
5. the end
   
6. [root@vps616 study]# cat main.lua
   
7. #!/usr/bin/env lua
   
8. 
   
9. --c = require('c')                 
   
10.   
    
11. function callback(f)
    
12.     n = f()
    
13.     print(n)
    
14. end
    
15. 
    
16. co = coroutine.create(function()
    
17.   print('coroutine yielding')   
    
18.   callback(function()         
    
19.     coroutine.yield()
    
20.     return 5
    
21.   end)
    
22.   print('coroutine resumed')   
    
23. end)                             
    
24.                                  
    
25. coroutine.resume(co)
    
26. coroutine.resume(co)
    
27.                                  
    
28. print('the end')  

复制代码

linux_c_py_php 发表于 2013-01-15 23:42
@starwing83

哥, 再指导指导吧, 我快找到感觉了.

linux_c_py_php

与之对应的C实现只能是这样, 根本不会从pcallk返回, 而且是直接从c_cont中return到c.callback被调用位置, 为何有差别? 无法实现成一致的么? 什么道理?

1. [root@vps616 study]# ./main.lua   
   
2. coroutine yielding
   
3. 5
   
4. coroutine resumed
   
5. the end
   
6. [root@vps616 study]# cat main.lua
   
7. #!/usr/bin/env lua
   
8. 
   
9. c = require('c')                 
   
10.   
    
11. co = coroutine.create(function()
    
12.   print('coroutine yielding')   
    
13.   n = c.callback(function()         
    
14.     coroutine.yield()
    
15.   end)
    
16.   print(n)
    
17.   print('coroutine resumed')   
    
18. end)                             
    
19.                                  
    
20. coroutine.resume(co)
    
21. coroutine.resume(co)
    
22.                                  
    
23. print('the end')  
    
24. [root@vps616 study]# cat src/mod.c
    
25. #include<stdio.h>                                                     
    
26. #include<stdlib.h>                                                   
    
27. #include<lua.h>                                                      
    
28. #include<lualib.h>                                                   
    
29. #include<lauxlib.h>                                                   
    
30.                                                                        
    
31. static int c_cont(lua_State *L) {                                    
    
32.     lua_pushinteger(L, 5);
    
33.     return 1;  //这里返回到了c_callback被调用的位置, 也就是lua里的调用点                                                      
    
34. }                                                                     
    
35.                                                                        
    
36. static int c_callback(lua_State *L){                                 
    
37.   int ret = lua_pcallk(L, 0, 0, 0, 0, c_cont);                        
    
38.   if(ret) {                                                           
    
39.     fprintf(stderr, "Error: %s\n", lua_tostring(L, -1));              
    
40.     lua_pop(L, 1);                                                   
    
41.     exit(1);                                                         
    
42.   }                                                                  
    
43.   return 0;
    
44. }                                                                     
    
45.                                                                        
    
46. static const luaL_Reg c[] = {                                         
    
47.   {"callback", c_callback},                                          
    
48.   {NULL, NULL}                                                        
    
49. };                                                                    
    
50.                                                                        
    
51. int luaopen_c (lua_State *L) {                             
    
52.   /* 使用新的 luaL_newlib 函数 */                                    
    
53.   luaL_newlib(L, c);                                                  
    
54.   return 1;                                                           
    
55. }

复制代码

linux_c_py_php

非常感谢starwing83, 很受用, 有问题再找你哈.

linux_c_py_php

@starwing83

追加个问题, 对于blog里的例子, 如果coroutine.create的这个function我不用lua写, 而是在c宿主程序里传入一个c的function（先调用printf，再调用lua里的c.function,再调用c的printf）并在c里resume, 那么当再次resume时, 执行c_cont后return到的应该直接是resume点, 而不会是c.callback的调用点吧, 第一次yield应该已经破坏掉了除了main thread以外的所有C堆栈了吧.

linux_c_py_php

晚上回家会自己试验一下, 大哥有空也给指教指教.

我的感受是lua是解释器执行, 所以它的堆栈是可以维持的, 并在再次resume时, 避开c.callback的堆栈破坏不说, 应当可以正常从c.callback(c_cont)返回.
但如果这个wrapper是c的，那么resume的这个wrapper的C堆栈也会被破坏，没法继续执行。

linux_c_py_php 发表于 2013-01-21 18:58
@starwing83

追加个问题, 对于blog里的例子, 如果coroutine.create的这个function我不用lua写, 而是在c宿 ...

linux_c_py_php

very good, thanks very very much!

starwing83 发表于 2013-01-21 19:16
回复 17# linux_c_py_php