skynet学习之skynet_handle

今天学习skynet_handle文件。

这个文件是管理句柄的。建立skynet_context与skynet_handle之间的唯一映射关系。

即一个sc对应一个唯一的handle。

先看初始化：

void 
skynet_handle_init(int harbor) {
	assert(H==NULL);
	struct handle_storage * s = skynet_malloc(sizeof(*H));
	s->slot_size = DEFAULT_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;
	s->handle_index = 1;
	s->name_cap = 2;
	s->name_count = 0;
	s->name = skynet_malloc(s->name_cap * sizeof(struct handle_name));

	H = s;

	// Don't need to free H
}

生成一个handle_storage对象即句柄仓库结构体。初始化分配DEFAULT_SLOT_SIZE个元素的slot数组。

生成harbor的ID，只能占用高8位。

初始化name数组，暂时不清楚用处，猜测可能是建立一个字符串名与handle之间的映射方便查询吧。

sc被存放在一个数组中，数组的下标选取是通过hash来计算的。

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;//HANDLE_MASK用于取低24位，高8位是远程节点ID
			int hash = handle & (s->slot_size-1);//保证下标不会超过孔位数量。孔位数量始终是2的N次方。
			if (s->slot[hash] == NULL) {
				s->slot[hash] = ctx;
				s->handle_index = handle + 1;//单调递增，假设了最多不会超过0xffffff个。

				rwlock_wunlock(&s->lock);

				handle |= s->harbor;
				return handle;
			}
		}
		assert((s->slot_size*2 - 1) <= HANDLE_MASK);
		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 *));
		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;
	}
}

存储好后，其他业务就可以用handle来寻找sc了。

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);
	}

	rwlock_runlock(&s->lock);

	return result;
}

当然，还有回收释放handle的

int
skynet_handle_retire(uint32_t handle)

每个sc在生成的时候，都会调用skynet_handle_register来进行注册。