skynet源码分析（3）--消息名字和ID之handle

作者:shihuaping0918@163.com，转载请注明作者

消息机制是skynet中一个比较难理解的东西，在开始分析代码前，建议先读一下云风的博客和skynet的WIKI。SKYNET设计综述：http://blog.codingnow.com/2012/09/the_design_of_skynet.html，CLUSTER：https://github.com/cloudwu/skynet/wiki/Cluster。

SKYNET设计综述讲到模块被称为服务。“服务间可以自由发送消息。每个模块可以向 Skynet 框架注册一个 callback 函数，用来接收发给它的消息。”还提到“把一个符合规范的 C 模块，从动态库（so 文件）中启动起来，绑定一个永不重复（即使模块退出）的数字 id 做为其 handle 。Skynet 提供了名字服务，还可以给特定的服务起一个易读的名字，而不是用 id 来指代它。id 和运行时态相关，无法保证每次启动服务，都有一致的 id ，但名字可以。”今天要分析的两个文件skynet_handle.c和skynet_handle.h就是实现名字服务的。

而WIKI中的CLUSTER讲到的是harbor相关的内容，“每个 skynet 服务都有一个全网唯一的地址，这个地址是一个 32bit 数字，其高 8bit 标识着它所属 slave 的号码。即 harbor id 。在 master/slave 网络中，id 为 0 是保留的。所以最多可以有 255 个 slave 节点。”

前面写这么一大段东西都是分析代码所需要的，不是为了凑字数，也不是为了别的原因。下面开始分析代码。

#include "skynet.h"

#define DEFAULT_SLOT_SIZE 4
#define MAX_SLOT_SIZE 0x40000000

//名字服务结构，一个名字对应一个handle
struct handle_name {
    char * name; //服务名字
    uint32_t handle; //服务ID，下面以handle来称呼
};
//保存handle/name列表的数据结构，skynet_handle_init会初始化它
struct handle_storage {
    struct rwlock lock;

    uint32_t harbor;//这就是wiki里提到的harbor!!
    uint32_t handle_index; //必须从1开始
    int slot_size; //数组长度
    struct skynet_context ** slot; //数组，实际上里面存的是服务的上下文
    
    int name_cap; //容量
    int name_count; //长度或者说个数
    struct handle_name *name; //数组
};

static struct handle_storage *H = NULL;

//注册服务，返回给它一个handle
uint32_t
skynet_handle_register(struct skynet_context *ctx) {
    struct handle_storage *s = H;

    rwlock_wlock(&s->lock);
    //死循环，所以服务数量如果太大了你懂得
    for (;;) {
        int i;
        for (i=0;i<s->slot_size;i++) { //遍历服务列表，找个空位
            uint32_t handle = (i+s->handle_index) & HANDLE_MASK; //只取后24位
            int hash = handle & (s->slot_size-1); //&操作符，就是取到一个小于s->slot_size-1的值，slot_size-1源码下方有详细解释。
            if (s->slot[hash] == NULL) { //没有hash碰撞，好巧
                s->slot[hash] = ctx;
                s->handle_index = handle + 1; //handle_index增加了

                rwlock_wunlock(&s->lock);

                handle |= s->harbor; // 位操作或，把harbor id附上去，实在不理解你就把它当加法吧
                return handle;
            }
        }
//不幸的事情发生了，一直都在HASH碰撞，也就是说坑已经填满了
        assert((s->slot_size*2 - 1) <= HANDLE_MASK); //slot_size是不是达到0xffffff+1的一半了？
//既然坑填满了我们就扩容一下吧，扩大一倍
        struct skynet_context ** new_slot = skynet_malloc(s->slot_size * 2 * sizeof(struct skynet_context *));
//老套路，数据清零
        memset(new_slot, 0, s->slot_size * 2 * sizeof(struct skynet_context *));
//把老数据拷过来，要重新hash，但是handle_index没增加
        for (i=0;i<s->slot_size;i++) {
            int hash = skynet_context_handle(s->slot[i]) & (s->slot_size * 2 - 1);
            assert(new_slot[hash] == NULL);
            new_slot[hash] = s->slot[i];
        }
        skynet_free(s->slot);
        s->slot = new_slot; //直接替换指针
        s->slot_size *= 2; //容量扩大一倍
    }
//容量都扩一倍了，再试试会不会hash碰撞吧，再碰我们就再扩大一倍
}
//退休某个服务，反注册
int
skynet_handle_retire(uint32_t handle) {
    int ret = 0;
    struct handle_storage *s = H;

    rwlock_wlock(&s->lock);
//取有效位hash
    uint32_t hash = handle & (s->slot_size-1);
//取服务上下文，一会儿要释放的
    struct skynet_context * ctx = s->slot[hash];
//较验这个服务是存在的，而且确实对应的就是这个handle
    if (ctx != NULL && skynet_context_handle(ctx) == handle) {
        s->slot[hash] = NULL; //把空位让出来
        ret = 1;
        int i;
        int j=0, n=s->name_count;
        for (i=0; i<n; ++i) {
            if (s->name[i].handle == handle) {
                skynet_free(s->name[i].name); //释放内存
                continue;
            } else if (i!=j) { //这里在做数组元素删除操作，把后面的都往前移一下
                s->name[j] = s->name[i];
            }
            ++j;//元素删除辅助
        }
        s->name_count = j;
    } else {
        ctx = NULL;
    }

    rwlock_wunlock(&s->lock);
//这里就释放服务了
    if (ctx) {
        // release ctx may call skynet_handle_* , so wunlock first.
        skynet_context_release(ctx);
    }

    return ret;
}

//全部退休了
void 
skynet_handle_retireall() {
    struct handle_storage *s = H;
    for (;;) {
        int n=0;
        int i;
        for (i=0;i<s->slot_size;i++) {
            rwlock_rlock(&s->lock);
            struct skynet_context * ctx = s->slot[i]; //取服务上下文
            uint32_t handle = 0;
            if (ctx)
                handle = skynet_context_handle(ctx);
            rwlock_runlock(&s->lock);
            if (handle != 0) { //对服务上下文的handle进行“退休”
                if (skynet_handle_retire(handle)) {
                    ++n;
                }
            }
        }
        if (n==0)
            return;
    }
}

struct skynet_context * 
skynet_handle_grab(uint32_t handle) {
    struct handle_storage *s = H;
    struct skynet_context * result = NULL;

    rwlock_rlock(&s->lock);

    uint32_t hash = handle & (s->slot_size-1);
    struct skynet_context * ctx = s->slot[hash];
    if (ctx && skynet_context_handle(ctx) == handle) {
        result = ctx;
        skynet_context_grab(result); //引用计数+1
    }

    rwlock_runlock(&s->lock);

    return result;
}

//通过name找handle
//算法是二分查找法
//二分查找法请自行googe/bing/baidu
uint32_t 
skynet_handle_findname(const char * name) {
    struct handle_storage *s = H;

    rwlock_rlock(&s->lock);

    uint32_t handle = 0;

    int begin = 0;
    int end = s->name_count - 1;
    while (begin<=end) {
        int mid = (begin+end)/2;
        struct handle_name *n = &s->name[mid];
        int c = strcmp(n->name, name); //strcmp是个c系统函数
        if (c==0) { //找到匹配的名字
            handle = n->handle;
            break;
        }
        if (c<0) { //当前位置的名字 < 要查找的名字，到后半部分去找
            begin = mid + 1;
        } else { //当前位置的名字 > 要查找的名字，到前半部分去找
            end = mid - 1;
        }
    }

    rwlock_runlock(&s->lock);

    return handle;
}

//把name插入到name数组中，再关联handle
static void
_insert_name_before(struct handle_storage *s, char *name, uint32_t handle, int before) {
//扩容
    if (s->name_count >= s->name_cap) {
        s->name_cap *= 2; //扩容
        assert(s->name_cap <= MAX_SLOT_SIZE);
        struct handle_name * n = skynet_malloc(s->name_cap * sizeof(struct handle_name)); //开一个新数组，容量是老数据的2倍
        int i;
        for (i=0;i<before;i++) { //复制before位置前的数据
            n[i] = s->name[i];
        }
        for (i=before;i<s->name_count;i++) { //复制before及后面的数据
            n[i+1] = s->name[i];
        }
        skynet_free(s->name); //把老数据内存回收了
        s->name = n; //把新数组设进来
    } else { //空间够用
        int i;
        for (i=s->name_count;i>before;i--) { //从后往前，一次一个移动数组元素，把before位置空出来
            s->name[i] = s->name[i-1];
        }
    }
//赋值了
    s->name[before].name = name; //名字
    s->name[before].handle = handle; //handle
    s->name_count ++; //数量+1
}

//给handle绑定一个name
//name是由小到大顺序排列的
//二分查找法，数据结构很重要啊，少年
static const char *
_insert_name(struct handle_storage *s, const char * name, uint32_t handle) {
    int begin = 0;
    int end = s->name_count - 1;
    while (begin<=end) {
        int mid = (begin+end)/2;
        struct handle_name *n = &s->name[mid];
        int c = strcmp(n->name, name);
        if (c==0) { //名字已经存在了，不能再绑或者重复绑
            return NULL;
        }
        if (c<0) { //当前字符串 < 要插入的字符串
            begin = mid + 1; //二分查找后半部分
        } else { //当前字符串 > 要插入的字符串
            end = mid - 1; //二分查找前半部分
        }
    }
    char * result = skynet_strdup(name); //字符串复制
//把name插入到数组中
    _insert_name_before(s, result, handle, begin);

    return result;
}

//给handle绑定一个name
const char * 
skynet_handle_namehandle(uint32_t handle, const char *name) {
    rwlock_wlock(&H->lock);

    const char * ret = _insert_name(H, name, handle);

    rwlock_wunlock(&H->lock);

    return ret;
}

//初始化handle_storage
void 
skynet_handle_init(int harbor) {
    assert(H==NULL);
    struct handle_storage * s = skynet_malloc(sizeof(*H));
    s->slot_size = DEFAULT_SLOT_SIZE; //初始数组大小，slot_size是会变大的
    s->slot = skynet_malloc(s->slot_size * sizeof(struct skynet_context *)); //分配内存
    memset(s->slot, 0, s->slot_size * sizeof(struct skynet_context *)); //数据清零

    rwlock_init(&s->lock);
    // reserve 0 for system
    s->harbor = (uint32_t) (harbor & 0xff) << HANDLE_REMOTE_SHIFT; //这就是wiki中提到的，前8位是harbor id，HANDLE_REMOTE_SHIFT为24
    s->handle_index = 1; //
    s->name_cap = 2; //暂时只让放2个
    s->name_count = 0; //空的
    s->name = skynet_malloc(s->name_cap * sizeof(struct handle_name));

    H = s;

    // Don't need to free H
}

代码中有个很巧妙的设计，就是s->slot_size-1，它的低位二进制永远都是1。不信你看，刚开始slot_size是4，4-1就是3，扩了以后是8，8-1就是7，然后16,32....。这样的话，和任何数字与操作，都不会丢失“有效的”低位。

好了，到此为止，代码也看完了。总结一下，skynet_handle.c实际上就做了两个核心的事情，一是给服务分配一个handle，二是把handle和name关联起来。

把handle和name关联起来比较容易懂，实际上使用一个数组，关联的时候使用二分查找到数组里查名字，如果名字不存在，就插入一个元素，然后把名字和handle关联起来。插入元素的时候，如果数组空间不足了，就扩容为原来的2倍。

而给服务分配handle稍复杂一些，实际上也是使用一个slot数组，数组下标使用的是一个hash，数组元素指向服务的上下文。这个hash的算法是比较简单粗暴的，就是看从handle_indx开始累计到slot_size，看中间有没有空闲的下标（也就是下标指向为null的），如果遍历完了还是没有，就把slot扩大一倍，还是没有就再扩大一倍，直到找到空位为止，或者是slot长度超出限制为止。

取到了handle以后呢，还要将harbor id附到handle的高8位。