skynet源码阅读<7>--死循环检测

在使用skynet开发时，你也许会碰到类似这样的警告：A message from [ :0100000f ] to [ :0100000a ] maybe in an endless loop (version = 137)
    它表示你的代码在某处陷入了死循环。但是如何找到死循环的点呢？可以这样做：
    1）本机登陆skynet控制台：nc 127.0.0.1 8000 ==> telnet登录skynet
    2）输入命令：signal addr 0                 ==> 向目标服务地址addr发送信号0，在本例中应为：signal :0100000a 0
    此时目标地址addr所指服务会退出死循环并打印错误堆栈。关于进一步使用skynet console的教程，请参考skynet在git上的wiki：https://github.com/cloudwu/skynet/wiki/DebugConsole
    死循环检测的问题解决了，让我们趁着这个机会，探索下这背后的原理吧。
    skynet console是通过debug_console.lua来实现的，可以看到signal函数：

 function COMMAND.signal(address, sig)

     address = skynet.address(adjust_address(address))

     if sig then

         core.command("SIGNAL", string.format("%s %d",address,sig))

     else

         core.command("SIGNAL", address)

     end

 end

顺藤摸瓜，我们来到skynet_server.c中的cmd_signal函数：

 static const char *

 cmd_signal(struct skynet_context * context, const char * param) {

     uint32_t handle = tohandle(context, param);

     if (handle == )

         return NULL;

     struct skynet_context * ctx = skynet_handle_grab(handle);

     if (ctx == NULL)

         return NULL;

     param = strchr(param, ' ');

     int sig = ;

     if (param) {

         sig = strtol(param, NULL, );

     }

     // NOTICE: the signal function should be thread safe.

     skynet_module_instance_signal(ctx->mod, ctx->instance, sig);

     skynet_context_release(ctx);

     return NULL;

 }

解析出signal参数后调用skynet_module_instance_signal：

 void

 skynet_module_instance_signal(struct skynet_module *m, void *inst, int signal) {

     if (m->signal) {

         m->signal(inst, signal);

     }

 }

其调用通过动态库加载的API：m->signal，它是在加载skynet module时动态加载的，Lua服务对应的module是snlua，我们看下service_snlua.c中的snlua_signal函数做了什么：

 void

 snlua_signal(struct snlua *l, int signal) {

     skynet_error(l->ctx, "recv a signal %d", signal);

     if (signal == ) {

 #ifdef lua_checksig

     // If our lua support signal (modified lua version by skynet), trigger it.

     skynet_sig_L = l->L;

 #endif

     } else if (signal == ) {

         skynet_error(l->ctx, "Current Memory %.3fK", (float)l->mem / );

     }

 }

可以看到，signal为0时，将skynet_sig_L置空。那么skynet_sig_L是干嘛用的呢？在lua的lvm.c中有如下定义：

 /* Add by skynet */

 lua_State * skynet_sig_L = NULL;

 LUA_API void

 lua_checksig_(lua_State *L) {

   if (skynet_sig_L == G(L)->mainthread) {

     skynet_sig_L = NULL;

     lua_pushnil(L);

     lua_error(L);

   }

 }

即如果skynet_sig_L为lua主线程G(L)->mainthread的话，那么将其置空并主动报错，在lua_error中会展开堆栈信息。

在lua.h中定义了lua_checksig宏：

 #define lua_checksig(L) if (skynet_sig_L) { lua_checksig_(L); }

查找此宏的引用点：

在虚拟机指令：跳转OP_JMP、尾调用OP_TAILCALL、for循环OP_FORLOOP、OP_TFORLOOP处都会做checksig检查。除了for循环之外的其它循环，比如while或repeat，在LUA中都是通过条件判断结合JMP跳转来实现的，因此也是可以被检查报错的。对于无限递归的情况，如果递归函数可以被优化成尾调用的话，那么会在TAILCALL中被检查并报错。至此，如何打断死循环并报错跳出的处理我们已经清楚了，可是新的问题又来了，skynet中是如何检测到死循环发生的呢？

回想skynet启动时，会创建monitor线程，监视各个线程对应的skynet_monitor参数的情况：

 static void *

 thread_monitor(void *p) {

     struct monitor * m = p;

     int i;

     int n = m->count;

     skynet_initthread(THREAD_MONITOR);

     for (;;) {

         CHECK_ABORT

         for (i=;i<n;i++) {

             skynet_monitor_check(m->m[i]);

         }

         for (i=;i<;i++) {

             CHECK_ABORT

             sleep();

         }

     }

     return NULL;

 }

skynet_monitor_check监视的内容：

 void

 skynet_monitor_check(struct skynet_monitor *sm) {

     if (sm->version == sm->check_version) {

         if (sm->destination) {

             skynet_context_endless(sm->destination);

             skynet_error(NULL, "A message from [ :%08x ] to [ :%08x ] maybe in an endless loop (version = %d)", sm->source , sm->destination, sm->version);

         }

     } else {

         sm->check_version = sm->version;

     }

 }

skynet_monitor有个version参数，上节中我们讨论过消息分发，每次消息分发时，分发前置monitor->destination并自增version，分发后置monitor->destination为空并自增version（为简化，以下代码做了裁剪）：

 struct message_queue *

 skynet_context_message_dispatch(struct skynet_monitor *sm, struct message_queue *q, int weight) {

     uint32_t handle = skynet_mq_handle(q);

     struct skynet_context * ctx = skynet_handle_grab(handle);

     int i,n=;

     struct skynet_message msg;

     for (i=;i<n;i++) {

         if (skynet_mq_pop(q,&msg)) {

             skynet_context_release(ctx);

             return skynet_globalmq_pop();

         }

         skynet_monitor_trigger(sm, msg.source , handle);

         dispatch_message(ctx, &msg);

         skynet_monitor_trigger(sm, ,);

     }

     assert(q == ctx->queue);

     struct message_queue *nq = skynet_globalmq_pop();

     if (nq) {

         skynet_globalmq_push(q);

         q = nq;

     }

     skynet_context_release(ctx);

     return q;

 }

这样，当线程X处理消息陷入长久的阻滞时，monitor线程便会检测到X正在处理消息（skynet_monitor->destination不为空）并且version未改变，给出警告。

巴特西

skynet源码阅读<7>--死循环检测

最新文章

热门文章