skynet1.0阅读笔记2_skynet的消息投递skynet.call
为了了解 skynet.call 的调用过程，需要先看看 skynet的队列是如何把包分到不同工作线程的。看下图
查看 global_queue 的skynet_globalmq_push和skynet_globamq_pop,很容易可以找到两个关键的函数:
skyent_context_push
和
skynet_context_message_dispatch
先来看出口,skynet_context_message_dispatch。在skynet的启动函数中，我们已经知道skynet_start里面的start(config->thread)启动了 worker等线程:
thread_worker(void *p) { //初始化 ... struct message_queue * q = NULL; while (!m->quit) { //循环调用 skynet_context_message_dispatch q = skynet_context_message_dispatch(sm, q, weight); if (q == NULL) { //没包了就挂其线程 ... } } return NULL; }
很清晰的代码，worker线程不断调用 skynet_context_message_dispatch 来读取q里面的skynet_message 队列，并进行分发。我们来看它是怎么分发的。
struct message_queue * skynet_context_message_dispatch(struct skynet_monitor *sm, struct message_queue *q, int weight) { //q为空时，重新从global_queue中取下一个 message_queue if (q == NULL) { q = skynet_globalmq_pop(); if (q==NULL) return NULL; } //当前 message_queue 所属服务的 context 的handle id uint32_t handle = skynet_mq_handle(q); struct skynet_context * ctx = skynet_handle_grab(handle); if (ctx == NULL) { struct drop_t d = { handle }; skynet_mq_release(q, drop_message, &d); return skynet_globalmq_pop(); } int i,n=1; struct skynet_message msg; for (i=0;i<n;i++) { //从message_queue 中 pop一个msg出来 if (skynet_mq_pop(q,&msg)) { //若message_queue为空,返回1表示失败,释放ctx的引用次数 skynet_context_release(ctx); //把返回global_queue里面的下一个message_queue,以供skynet_context_message_dispatch调用 return skynet_globalmq_pop(); } else if (i==0 && weight >= 0) { n = skynet_mq_length(q); n >>= weight; } int overload = skynet_mq_overload(q); if (overload) { skynet_error(ctx, "May overload, message queue length = %d", overload); } skynet_monitor_trigger(sm, msg.source , handle); //若 ctx->cb不为空，使用dispatch_message调用 ctx->cb if (ctx->cb == NULL) { skynet_free(msg.data); } else { dispatch_message(ctx, &msg); } skynet_monitor_trigger(sm, 0,0); } assert(q == ctx->queue); //若global_queue中还有下一个message_queue，返回下一个message_queue供分发，若为空则继续执行当前message_queue的请求 struct message_queue *nq = skynet_globalmq_pop(); if (nq) { // If global mq is not empty , push q back, and return next queue (nq) // Else (global mq is empty or block, don't push q back, and return q again (for next dispatch) skynet_globalmq_push(q); q = nq; } skynet_context_release(ctx); return q; }
那么，从全局队列最终拿到的 skynet_message包，最后交由了 dispatch_message和ctx-cb来处理了。dispatch_message把msg里面的东西取出来后，调用ctx->cb来进行处理
static void dispatch_message(struct skynet_context *ctx, struct skynet_message *msg) { ... if (!ctx->cb(ctx, ctx->cb_ud, type, msg->session, msg->source, msg->data, sz)) { skynet_free(msg->data); } CHECKCALLING_END(ctx) }
在skynet的启动笔记中，已经知道了，首先是：
snlua_init 用 skynet_callback(ctx,l,_launch) 把 ctx->cb注册为 _launch
然后立马投递第一个消息
消息重新进到 dispatch_message,调用 _launch ，把 ctx->cb注册为 skynet.dispatch_message
启动完成后，以后的所有消息其实都进到了 skynet.dispatch_message,然后调用了 raw_dispatch_message
function skynet.dispatch_message(...) local succ, err = pcall(raw_dispatch_message,...) ... end
那接着来看 raw_dispatch_message
local function raw_dispatch_message(prototype, msg, sz, session, source, ...) if prototype == 1 then ... else local p = proto[prototype] ... local f = p.dispatch if f then ... local co = co_create(f) ... suspend(co, coroutine.resume(co, session,source, p.unpack(msg,sz, ...))) end end end
接下来要找的是 proto[prototype].disproto所有位置，找出那里定义 dispatch
的。看到 这个函数：
function skynet.register_protocol(class) local name = class.name local id = class.id ... proto[name] = class proto[id] = class end
以及
function skynet.dispatch(typename, func) local p = proto[typename] if func then local ret = p.dispatch p.dispatch = func return ret else return p and p.dispatch end end
没错了，就是class.dispatch 。所有的消息，最终进到的就是 class.dispatch。
///////////////////////////////////////////////////////////////////////
skynet.regiser_protocol 和 skynet.dispatch 你会在lua服务中经常看见。以launcher.lua为例子
launcher.lua在启动时，注册一个 name为"text"的table,它的dispatch也定义在下面
所以你应该能看到 skynet.call(".launcher","text",...)这种调用
skynet.register_protocol { name = "text", id = skynet.PTYPE_TEXT, unpack = skynet.tostring, dispatch = function(session, address , cmd) if cmd == "" then command.LAUNCHOK(address) elseif cmd == "ERROR" then command.ERROR(address) else error ("Invalid text command " .. cmd) end end, } //定义 launcher服务的 proto["lua"] 的dispatch skynet.dispatch("lua", function(session, address, cmd , ...) cmd = string.upper(cmd) local f = command[cmd] if f then local ret = f(address, ...) if ret ~= NORET then skynet.ret(skynet.pack(ret)) end else skynet.ret(skynet.pack {"Unknown command"} ) end end)
但这里还有一个问题，上面的proto["lua"] 是谁注册的呢？ 查找skynet.register_protocol,我们能找到这个位置:
--skynet.lua ----- register protocol do local REG = skynet.register_protocol REG { name = "lua", id = skynet.PTYPE_LUA, pack = skynet.pack, unpack = skynet.unpack, } REG { name = "response", id = skynet.PTYPE_RESPONSE, } REG { name = "error", id = skynet.PTYPE_ERROR, unpack = function(...) return ... end, dispatch = _error_dispatch, } end
在你第一次require "skynet"
的时候，它已经默认帮你注册了"lua","response","error"3种消息，然后你创建新的lua服务时，调用skynet.dispatch 为 proto["lua"] 指定dispatch，之后通过 skynet.call("服务名","lua",...) 调用的消息就能最终投递到你定义的处理函数里面了。
到了这里，从队列取出数据，并分发到指定处理函数dispath的完整流程我们以及看到了。接下来，我们来看 消息是如果放入global_queue的。
来看 skynet.call 函数(skynet.send其实也一样的，只是它不管返回)
function skynet.call(addr, typename, ...) //如proto["lua"] ,消息类型id放入msg中 local p = proto[typename] local session = c.send(addr, p.id , nil , p.pack(...)) ... //等待返回 return p.unpack(yield_call(addr, session)) end
这里的 c.send 的调用，我们看一下 c 的定义：
local c = require "skynet.core"
这里的 skynet.core ,实际上调用的是 skynet.so ,而从 skynet 的make log我们可以看到这样一行：
cc -g -O2 -Wall -I3rd/lua -fPIC --shared lualib-src/lua-skynet.c lualib-src/lua-seri.c -o luaclib/skynet.so -Iskynet-src -Iservice-src -Ilualib-src
在 lualib-src/lua-skynet.c 中，我们看到这段代码:
luaL_Reg l[] = { { "send" , _send }, { "genid", _genid }, { "redirect", _redirect }, { "command" , _command }, { "intcommand", _intcommand }, { "error", _error }, { "tostring", _tostring }, { "harbor", _harbor }, { "pack", _luaseri_pack }, { "unpack", _luaseri_unpack }, { "packstring", lpackstring }, { "trash" , ltrash }, { "callback", _callback }, { NULL, NULL }, };
这里的 luaL_Reg 把c函数注册到lua中，从而让lua调用这些函数。
所以 c.send 调用的，就是这里的 _send
_send 调用了 skynet_send ,如果目标在当前进程，将调用 skynet_context_push
然后 skyent_context_push 调用
skynet_mq_push(ctx->queue, message);
把消息放如了全局队列,最后来看看 skynet_mq_push ：
void skynet_mq_push(struct message_queue *q, struct skynet_message *message) { assert(message); SPIN_LOCK(q) //把msg放到队列尾，然后 ++ q->taiskynet_globalmq_pushl q->queue[q->tail] = *message; if (++ q->tail >= q->cap) { q->tail = 0; } if (q->head == q->tail) { expand_queue(q); } //若ctx->queue未放入global_queue，放进去 if (q->in_global == 0) { q->in_global = MQ_IN_GLOBAL; skynet_globalmq_push(q); } SPIN_UNLOCK(q) }
值得一提的是，取消息从 ctx->queue 的head开始取，push消息则是从 tail push。
所以先投递的消息会先执行，但由于协程的原因，还是不能保证先投递的消息先执行完。
