skynet源码分析3：消息调度

本文主要是介绍skynet源码分析3：消息调度，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

从四个方面来说:

　　1、消息发送

　　2、工作线程控制

　　3、信箱调度

　　4、消息分发

与调度相关的代码实现在/skynet-src/skynet_mq.c,/skynet-src/skynet_start.c,/skynet-src/skynet_server.c三个文件中，整体上是一个m:n的调度器。

消息发送

skynet的消息定义在/skynet-src/skynet_mq.h中：

struct skynet_message {uint32_t source;int session;void * data;size_t sz;
};// type is encoding in skynet_message.sz high 8bit
#define MESSAGE_TYPE_MASK (SIZE_MAX >> 8)
#define MESSAGE_TYPE_SHIFT ((sizeof(size_t)-1) * 8)

source:消息源(sc)的句柄。

session:用来做上下文的标识

data:消息指针

sz:消息长度,消息的请求类型定义在高8位

消息发出后，会被保存在接收者sc的信箱(message_queue字段)中，发送消息也就是向信箱压入一条消息。来看看发送函数吧，在/skynet-src/skynet_server.c中：

 1 int
 2 skynet_send(struct skynet_context * context, uint32_t source, uint32_t destination , int type, int session, void * data, size_t sz) {
 3     if ((sz & MESSAGE_TYPE_MASK) != sz) {
 4         skynet_error(context, "The message to %x is too large", destination);
 5         if (type & PTYPE_TAG_DONTCOPY) {
 6             skynet_free(data);
 7         }
 8         return -1;
 9     }
10     _filter_args(context, type, &session, (void **)&data, &sz);
11 
12     if (source == 0) {
13         source = context->handle;
14     }
15 
16     if (destination == 0) {
17         return session;
18     }
19     if (skynet_harbor_message_isremote(destination)) {
20         struct remote_message * rmsg = skynet_malloc(sizeof(*rmsg));
21         rmsg->destination.handle = destination;
22         rmsg->message = data;
23         rmsg->sz = sz;
24         skynet_harbor_send(rmsg, source, session);
25     } else {
26         struct skynet_message smsg;
27         smsg.source = source;
28         smsg.session = session;
29         smsg.data = data;
30         smsg.sz = sz;
31 
32         if (skynet_context_push(destination, &smsg)) {
33             skynet_free(data);
34             return -1;
35         }
36     }
37     return session;
38 }

3-9行对消息长度做了限制，MESSAGE_TYPE_MASK等于（SIZE_MAX >> 8）,也就是最大只能为2²⁴，16MB。

_filter_args根据type做了两个处理：

1、(type & PTYPE_TAG_DONTCOPY) == 0

　　会将data复制一份用作实际发送,这种情况下原来的data就要由调用者负责释放。

2、(type & PTYPE_TAG_ALLOCSESSION) > 0

　　会从sc的session计数器分配一个session.

处理完后，type会合并到sz的高8位。

最后一步就是投递到接收者的信箱了，根据接收者句柄判断是否为远程节点，如果是就用harbo发送。(内置的集群方案，现在已经不推荐使用)。成功返回session,失败返回-1,并且释放data.

工作线程的控制

skynet运行后，会启动固定的线程来轮流调度sc(skynet_context),线程数由配置文件中的thread字段定义，默认是4个。那它是如何控制这些线程的呢？具体实现在/skynet-src/skynet_start.c中。

在208行，启动了工作线程：

static int weight[] = { -1, -1, -1, -1, 0, 0, 0, 0,1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, };struct worker_parm wp[thread];for (i=0;i<thread;i++) {wp[i].m = m;wp[i].id = i;if (i < sizeof(weight)/sizeof(weight[0])) {wp[i].weight= weight[i];} else {wp[i].weight = 0;}create_thread(&pid[i+3], thread_worker, &wp[i]);}

直接来看线程函数thread_worker把，在152行：

 1 static void *
 2 thread_worker(void *p) {
 3     struct worker_parm *wp = p;
 4     int id = wp->id;
 5     int weight = wp->weight;
 6     struct monitor *m = wp->m;
 7     struct skynet_monitor *sm = m->m[id];
 8     skynet_initthread(THREAD_WORKER);
 9     struct message_queue * q = NULL;
10     while (!m->quit) {
11         q = skynet_context_message_dispatch(sm, q, weight);
12         if (q == NULL) {
13             if (pthread_mutex_lock(&m->mutex) == 0) {
14                 ++ m->sleep;
15                 // "spurious wakeup" is harmless,
16                 // because skynet_context_message_dispatch() can be call at any time.
17                 if (!m->quit)
18                     pthread_cond_wait(&m->cond, &m->mutex);
19                 -- m->sleep;
20                 if (pthread_mutex_unlock(&m->mutex)) {
21                     fprintf(stderr, "unlock mutex error");
22                     exit(1);
23                 }
24             }
25         }
26     }
27     return NULL;
28 }

控制这种生命周期与进程一致的工作线程，主要有两个细节：1、均匀不重复的分配任务。2、不空转、最小时延。前者处理线程同步就好。来看看skynet是如何处理后者的吧:

它用得是条件变量来处理空转的，用条件变量有两点好处：1、让出cpu时间片.2、由外部决定何时唤醒，这样可以在有任务时再唤醒，既能最大化的不空转，又能减小处理任务的时延。

具体实现是条件变量的标准应用了，和《unix高级编程》条件变量的例子几乎一样。这里还有一个sleep的计数，有什么用呢？用来判断要不要调用pthread_cond_signal的。

最后还有一个问题，等待的线程是在哪里被唤醒的呢？在socket线程和timer线程里唤醒的，前者有socket消息时会调用一次，后者每个刷新时间会唤醒一次。

信箱的调度

上一篇时，在sc里我们看到过一个message_queue类型的字段，这就是信箱。skynet中用了两种队列来存储消息并完成调度，下面称为12级队列，1级队列是一个单链表，每个节点是2级队列，2级队列(message_queue)是一个自动扩展的循环队列，用来存储消息。这两个队列实现在/skynet-src/skynet_mq.c中，实现的很简单，并没有用复杂的无锁结构，而是自旋锁保证线程安全的链表，循环队列。

信箱的调度就是12级队列的调度，整体结构描述如下：

while(1){

　　1级队列出队；

　　调度2级队列；

1级队列入队；

}

这部分实现在/skynet-src/skynet_server的275行skynet_context_message_dispatch()中：

 1 struct message_queue * 
 2 skynet_context_message_dispatch(struct skynet_monitor *sm, struct message_queue *q, int weight) {
 3     if (q == NULL) {
 4         q = skynet_globalmq_pop();
 5         if (q==NULL)
 6             return NULL;
 7     }
 8 
 9     uint32_t handle = skynet_mq_handle(q);
10 
11     struct skynet_context * ctx = skynet_handle_grab(handle);
12     if (ctx == NULL) {
13         struct drop_t d = { handle };
14         skynet_mq_release(q, drop_message, &d);
15         return skynet_globalmq_pop();
16     }
17 
18     int i,n=1;
19     struct skynet_message msg;
20 
21     for (i=0;i<n;i++) {
22         if (skynet_mq_pop(q,&msg)) {
23             skynet_context_release(ctx);
24             return skynet_globalmq_pop();
25         } else if (i==0 && weight >= 0) {
26             n = skynet_mq_length(q);
27             n >>= weight;
28         }
29         int overload = skynet_mq_overload(q);
30         if (overload) {
31             skynet_error(ctx, "May overload, message queue length = %d", overload);
32         }
33 
34         skynet_monitor_trigger(sm, msg.source , handle);
35 
36         if (ctx->cb == NULL) {
37             skynet_free(msg.data);
38         } else {
39             dispatch_message(ctx, &msg);
40         }
41 
42         skynet_monitor_trigger(sm, 0,0);
43     }
44 
45     assert(q == ctx->queue);
46     struct message_queue *nq = skynet_globalmq_pop();
47     if (nq) {
48         // If global mq is not empty , push q back, and return next queue (nq)
49         // Else (global mq is empty or block, don't push q back, and return q again (for next dispatch)
50         skynet_globalmq_push(q);
51         q = nq;
52     } 
53     skynet_context_release(ctx);
54 
55     return q;
56 }

这个函数的作用是,调度传入的2级队列，并返回下一个可调度的2级队列。在上面的实现中，有四个细节之处：

1、22-24行，当2级队列为空时并没有将其压入1级队列，那它从此就消失了吗？不，这样做是为了减少空转1级队列，那这个2级队列是什么时候压回的呢？在message_queue中，有一个

in_global标记是否在1级队列中，当2级队列的出队(skynet_mq_pop)失败时，这个标记就会被置0,在2级队列入队时(skynet_mq_push)会判断这个标记，如果为0，那么就会将自己压入1级队列。(skynet_mq_mark_release也会判断)所以这个2级队列在下次入队时会压回。

2、25-27,修改了for循环的次数，也就是每次调度处理多少条消息。这个次数与传入的weight有关，我们回过头来看这个weight是从哪里来的，源头在工作线程创建时：

static int weight[] = { -1, -1, -1, -1, 0, 0, 0, 0,1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, };struct worker_parm wp[thread];for (i=0;i<thread;i++) {wp[i].m = m;wp[i].id = i;if (i < sizeof(weight)/sizeof(weight[0])) {wp[i].weight= weight[i];} else {wp[i].weight = 0;}create_thread(&pid[i+3], thread_worker, &wp[i]);}

再来看看 n >>= weight,嗯，大致就是：把工作线程分为组，前四组每组8个，超过的归入第5组，AE组每次调度处理一条消息,B组每次处理(n/2)条，C组每次处理(n/4)条，D组每次处理(n/8)条。是为了均匀的使用多核。

3、29-32做了一个负载判断，负载的阀值是1024。不过也仅仅是输出一条log提醒一下而以.

4、34、42触发了一下monitor,这个监控是用来检测消息处理是否发生了死循环，不过也仅仅只是输出一条log提醒一下。这个检测是放在一个专门的监控线程里做的，判断死循环的时间是5秒。具体机制这里就不说了，其实现在/skynet-src/skynet_monitor.c中

消息分发

信箱调度时，从2级队列取出消息后就会调用dispatch_message函数做分发，在/skynet-src/skynet_server.c中：

 1 static void
 2 dispatch_message(struct skynet_context *ctx, struct skynet_message *msg) {
 3     assert(ctx->init);
 4     CHECKCALLING_BEGIN(ctx)
 5     pthread_setspecific(G_NODE.handle_key, (void *)(uintptr_t)(ctx->handle));
 6     int type = msg->sz >> MESSAGE_TYPE_SHIFT;
 7     size_t sz = msg->sz & MESSAGE_TYPE_MASK;
 8     if (ctx->logfile) {
 9         skynet_log_output(ctx->logfile, msg->source, type, msg->session, msg->data, sz);
10     }
11     if (!ctx->cb(ctx, ctx->cb_ud, type, msg->session, msg->source, msg->data, sz)) {
12         skynet_free(msg->data);
13     } 
14     CHECKCALLING_END(ctx)
15 }