浅析时间轮定时器

前言：　最早是看到skynet群里边有人问如何取消定时器的问题，那时候正好在研读skynet代码，于是决定试试。但是最终只在lua层面实现了一个伪取消定时器的方案，而且还是不是优解。

　　　　云风说从c层面取消定时器的开销要大于从lua层面取消的开销，当时不知道为什么。

　　　　最近研读了云风实现的时间轮定时器代码(看着相当费劲啊),  过程中网上搜了很多资料，但大部分没能帮助我有个更好的理解，所以打算从写篇文章，希望能帮助像我一样的newbee， 更好的理解时间轮定时器。

　　　　这里不讲定时器的进化过程，只讲时间轮，以及 skynet 中云风十分精巧的实现(才疏学浅，看这块儿代码，真他妈的爽)

步骤： 1 创建时间轮 2 添加到期时间 3 时钟tick 执行定时器到期回调，移动定时器列表  循环往复

 

1.初始化 "时间轮"

　　首先看下相关的数据结构

typedef void (*timer_execute_func)(void *ud,void *arg);

#define TIME_NEAR_SHIFT 8
#define TIME_NEAR (1 << TIME_NEAR_SHIFT)
#define TIME_LEVEL_SHIFT 6
#define TIME_LEVEL (1 << TIME_LEVEL_SHIFT)
#define TIME_NEAR_MASK (TIME_NEAR-1)
#define TIME_LEVEL_MASK (TIME_LEVEL-1)

struct timer_event {
 uint32_t handle;
 int session;
};

struct timer_node {
 struct timer_node *next;
 uint32_t expire;
};

struct link_list {
 struct timer_node head;
 struct timer_node *tail;
};

struct timer {
 struct link_list near[TIME_NEAR];
 struct link_list t[4][TIME_LEVEL];
 struct spinlock lock;
 uint32_t time;
 uint32_t starttime;
 uint64_t current;
 uint64_t current_point;
};

可以看出 struct timer 就是 时间轮了。ok 下面是初始化代码

static struct timer * TI = NULL;

static struct timer *
timer_create_timer() {
 struct timer *r=(struct timer *)skynet_malloc(sizeof(struct timer));
 memset(r,0,sizeof(*r));

 int i,j;

 for (i=0;i  link_clear(&r->near[i]);
 }

 for (i=0;i<4;i++) {
  for (j=0;j   link_clear(&r->t[i][j]);
  }
 }

 SPIN_INIT(r)

 r->current = 0;

 return r;
}

static uint64_t
gettime() {
 uint64_t t;
#if !defined(__APPLE__) || defined(AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER)
 struct timespec ti;
 clock_gettime(CLOCK_MONOTONIC, &ti);
 t = (uint64_t)ti.tv_sec * 100;
 t += ti.tv_nsec / 10000000;
#else
 struct timeval tv;
 gettimeofday(&tv, NULL);
 t = (uint64_t)tv.tv_sec * 100;
 t += tv.tv_usec / 10000;
#endif
 return t;
}

 

 

void
skynet_timer_init(void) {
 TI = timer_create_timer();
 uint32_t current = 0;
 systime(&TI->starttime, ¤t);
 TI->current = current; //初始化时刻，纳秒数
 TI->current_point = gettime();
}

首先调用 timer_create_time() 创建五个数组  一个struct link_list near[TIME_NEAR] TIME_NEAR, 四个 struct link_list t[4][TIME_LEVEL]; TIME_LEVEL, 每个数组的每个 slot 表示一个时间段 同时又是个链表，用来存储

到期时间距当前tick 一个时间段的定时器。 skynet 提供的定时器精度为 1/100 秒 也就是10毫秒， 具体实现为 gettime() 。既然精度是 10 毫秒 那么 10毫秒就要调用一次  dispatch 函数，触发定时器，

那么哪里调用的呢?

答案在skynet_start.c里 其中定时器线程  

static void *
thread_timer(void *p) {
 struct monitor * m = p;
 skynet_initthread(THREAD_TIMER);
 for (;;) {
  skynet_updatetime();
  CHECK_ABORT
  wakeup(m,m->count-1);
  usleep(2500);
  if (SIG) {
   signal_hup();
   SIG = 0;
  }
 }
 // wakeup socket thread
 skynet_socket_exit();
 // wakeup all worker thread
 pthread_mutex_lock(&m->mutex);
 m->quit = 1;
 pthread_cond_broadcast(&m->cond);
 pthread_mutex_unlock(&m->mutex);
 return NULL;
}

撇开无关代码， 可以提取出

void
skynet_updatetime(void) {
 uint64_t cp = gettime();
 if(cp < TI->current_point) {
  skynet_error(NULL, "time diff error: change from %lld to %lld", cp, TI->current_point);
  TI->current_point = cp;
 } else if (cp != TI->current_point) {
  uint32_t diff = (uint32_t)(cp - TI->current_point);
  TI->current_point = cp;
  TI->current += diff;
  int i;
  for (i=0;i   timer_update(TI);
  }
 }
}

这里基本可以保证diff 的值为1， 也就是10 毫秒的时间间隔， 可以写个测试程序试一下，稍后贴运行结果

 for (;;) {
  skynet_updatetime();
  usleep(2500);
  }
 }

ok 现在我们创建了定时器的骨架， 然后也知道了在哪里保证 10 毫秒触发定时器，如果没有注册定时器，就是空转。

个人觉得时间轮定时器的难点在于 注册时 和 shift 时，定位到slot。要想知道这点，一个好的方法就是

现在我们注册几个定时器。 这里会挑一些时间点的定时器，来分析注册，分发，shift 过程。

先看注册函数

int
skynet_timeout(uint32_t handle, int time, int session) {
 if (time <= 0) {
  struct skynet_message message;
  message.source = 0;
  message.session = session;
  message.data = NULL;
  message.sz = (size_t)PTYPE_RESPONSE << MESSAGE_TYPE_SHIFT;

  if (skynet_context_push(handle, &message)) {
   return -1;
  }
 } else {
  struct timer_event event;
  event.handle = handle;
  event.session = session;
  timer_add(TI, &event, sizeof(event), time);
 }

 return session;
}

timer_add(TI, &event, sizeof(event), time);

看看timer_add;

 

static void
timer_add(struct timer *T,void *arg,size_t sz,int time) {
 struct timer_node *node = (struct timer_node *)skynet_malloc(sizeof(*node)+sz);
 memcpy(node+1,arg,sz);  //每个node后边绑一个event参数

 SPIN_LOCK(T);

  node->expire=time+T->time;
  add_node(T,node);

 SPIN_UNLOCK(T);
}

申请一个node，看 node->expire = time+T->time; 到期时间是 time+T->time,   那么T->time 是啥，这个值是如何变化的，在哪里变化的

 

 现需要留神下几个变量的含义

T->time; T->starttime; T->current; T->current_point; 

T->time 服务器经过的tick 数， 每10毫秒 tick 一次，T->time 增加1；

T->starttime; 服务器开始的时间，单位秒。

T->current (uint32_t)(ti.tv_nsec / 10000000);

T->current_point   t = (uint64_t)ti.tv_sec * 100, t += ti.tv_nsec / 10000000 ;

现在看下注册函数 lua 层是调用 skynet.timeout(time), 例如 skynet.timeout(10), skynet.timeout(100), skynet.timeout(1000)

ok 现在看看 c 层调用情况 

int
skynet_timeout(uint32_t handle, int time, int session) {
if (time <= 0) {
struct skynet_message message;
message.source = 0;
message.session = session;
message.data = NULL;
message.sz = (size_t)PTYPE_RESPONSE << MESSAGE_TYPE_SHIFT;

if (skynet_context_push(handle, &message)) {
return -1;
}
} else {
struct timer_event event;
event.handle = handle;
event.session = session;
timer_add(TI, &event, sizeof(event), time);
}

return session;
}

 先忽略 session time 在这里就是例子中的 10, 100, 1000, 表示 0.1 秒， 1 秒和 10 秒 后触发， 在看 timer_add();

static void
timer_add(struct timer *T,void *arg,size_t sz,int time) {
struct timer_node *node = (struct timer_node *)skynet_malloc(sizeof(*node)+sz);
memcpy(node+1,arg,sz); //每个node后边绑一个event参数

SPIN_LOCK(T);

node->expire=time+T->time;
add_node(T,node);

SPIN_UNLOCK(T);
}

 timer_add 先创建一个 node 用来保存超时时间即 node->expire ， 我们看到 node->expire = node->time + time, 上边讲到 node->time 是从进程启动时刻算起，经过的 滴答数

又知道每 10 毫秒 滴答一次， 那么我们可以得出 node->expire 就是 从当前 node->time 起 经过 time 个滴答数后 到达 node->expire. 

计算一下可以知道 10 * 10(每个滴答的间隔) == 100毫秒 = 0.1 秒， 同理  100 * 10, 1000 * 10. 

现在看 add_node ,

 

static void
add_node(struct timer *T,struct timer_node *node) {
uint32_t time=node->expire;
uint32_t current_time=T->time;

if ((time|TIME_NEAR_MASK)==(current_time|TIME_NEAR_MASK)) { //如果当前时间
link(&T->near[time&TIME_NEAR_MASK],node);
} else {
int i;
uint32_t mask=TIME_NEAR << TIME_LEVEL_SHIFT;
for (i=0;i<3;i++) {
if ((time|(mask-1))==(current_time|(mask-1))) {
break;
}
mask <<= TIME_LEVEL_SHIFT;
}

link(&T->t[i][((time>>(TIME_NEAR_SHIFT + i*TIME_LEVEL_SHIFT)) & TIME_LEVEL_MASK)],node);
}
}

从  add_node 里我们看到了许多宏定义，那么这些宏是什么意思呢？ 要想理解这个， 这里就需要详细讲解 时间轮 的设计思路。

放到这里才讲解 时间轮 的设计思路 是因为我觉得这样自然过度过来比较好理解。现在分析：

typedef void (*timer_execute_func)(void *ud,void *arg);

#define TIME_NEAR_SHIFT 8 　　
#define TIME_NEAR (1 << TIME_NEAR_SHIFT) 　　//TIME_NEAR = 00000001 00000000
#define TIME_LEVEL_SHIFT 6 　　　　　　　　　　
#define TIME_LEVEL (1 << TIME_LEVEL_SHIFT) 　　//TIME_LEVEL = 01000000
#define TIME_NEAR_MASK (TIME_NEAR-1) 　　　　//TIME_NEAR_MASK = 11111111
#define TIME_LEVEL_MASK (TIME_LEVEL-1) 　　    //TIME_LEVEL_MASK = 00111111

 首先 skynet 的定时器 node->time 类型为 uint32_t , 范围是 0 ~ 2^32 - 1 ,  skynet 实现的 时间轮的思路是这样的（我想linux也是这样）：

将 32 位 分为五个部分，

struct link_list near[TIME_NEAR];　(000000 000000 000000 000000 11111111)  低8位 表示 0 ~ 2^8 - 1 即 0 ~ 255 个 tick ， 这里每个 near[x] 的精度是一个 tick  ，即 10 毫秒

下面是四个数组，每个数组有 TIME_LEVEL  个 slot ，即 2^6 = 64 个 slot， 

link_list[0] 数组， 每个 slot 表示的精度是 2^8 ， 即在这个数组中 每一个 slot 比上一个 slot 多 256 个 tick ，link_list[0] 表示的范围是 (2^8 ~ 2^14 - 1), 即 node->expire 时间在这个范围内的，都被分到这个数组里

link_list[1]数组， 每个 slot 表示的精度是 2^8 * 2^6 , link_list[1] 表示的范围是 (2^14 ~ 2^20 - 1), 即 node->expire 时间在这个范围内的 (2^14 ~ 2^20 - 1)，都被分到这个数组里

link_list[2]数组， 每个 slot 表示的精度是 2^8 * 2^6 * 2^6 , link_list[2] 表示的范围是 (2^20 ~ 2^26 - 1), 即 node->expire 时间在这个范围内的 (2^20 ~ 2^26 - 1)，都被分到这个数组里

link_list[3]数组， 每个 slot 表示的精度是 2^8 * 2^6 * 2^6 * 2^6 , link_list[2] 表示的范围是 (2^26 ~ 2^32 - 1), 即 node->expire 时间在 这个范围内的  (2^26 ~ 2^32 - 1),，都被分到这个数组里

有了这 5 个数组

 

　　       

转载于:https://www.cnblogs.com/newbeeyu/p/9022623.html