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 == 0)
        return NULL;
    struct skynet_context * ctx = skynet_handle_grab(handle);
    if (ctx == NULL)
        return NULL;
    param = strchr(param, ' ');
    int sig = 0;
    if (param) {
        sig = strtol(param, NULL, 0);
    }
    // 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 == 0) {
#ifdef lua_checksig
    // If our lua support signal (modified lua version by skynet), trigger it.
    skynet_sig_L = l->L;
#endif
    } else if (signal == 1) {
        skynet_error(l->ctx, "Current Memory %.3fK", (float)l->mem / 1024);
    }
}

    可以看到，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=0;i<n;i++) {
            skynet_monitor_check(m->m[i]);
        }
        for (i=0;i<5;i++) {
            CHECK_ABORT
            sleep(1);
        }
    }

    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=1;
    struct skynet_message msg;

    for (i=0;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, 0,0);
    }

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