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未改变，给出警告。