memcached原码分析之---libevent-Timer

2329阅读　0评论2011-06-09　digdeep126
分类：C/C++

在memcached-1.2.8的memcached.c中有如下代码使用libevent中的timer event：

  1. /*
  2.  * We keep the current time of day in a global variable that's updated by a
  3.  * timer event. This saves us a bunch of time() system calls (we really only
  4.  * need to get the time once a second, whereas there can be tens of thousands
  5.  * of requests a second) and allows us to use server-start-relative timestamps
  6.  * rather than absolute UNIX timestamps, a space savings on systems where
  7.  * sizeof(time_t) > sizeof(unsigned int).
  8.  */
  9. #define reltime_t unsigned int
  10. volatile rel_time_t current_time;
  11. static struct event clockevent;

  13. /*
  14.  * time-sensitive callers can call it by hand with this,
  15.  * outside the normal ever-1-second timer
  16.  */
  17. static void set_current_time(void) {
  18.     struct timeval timer;

  20.     gettimeofday(&timer, NULL);
  21.     current_time = (rel_time_t) (timer.tv_sec - stats.started);
  22. }

  24. static void clock_handler(const int fd, const short which, void *arg) {
  25.     struct timeval t = {.tv_sec = 1, .tv_usec = 0};
  26.     static bool initialized = false;

  28.     if (initialized) {
  29.         /* only delete the event if it's actually there. */
  30.         evtimer_del(&clockevent);
  31.     } else {
  32.         initialized = true;
  33.     }

  35.     evtimer_set(&clockevent, clock_handler, 0);
  36.     event_base_set(main_base, &clockevent);
  37.     evtimer_add(&clockevent, &t);

  39.     set_current_time();
  40. }

  42. 在memcached.c文件中main.c中有如下代码：
  43. /* initialize main thread libevent instance */
  44. main_base = event_init();

  46. /* start up worker threads if MT mode */
  47. thread_init(settings.num_threads, main_base);

  1. /* initialise clock event */
  2. clock_handler(0, 0, 0);

  1. /* enter the event loop */
    event_base_loop(main_base, 0);


注释的意思是：
我们保存当前的时间在一个全局变量中volatile rel_time_t current_time，通过timer event即libevent中的“定时触发器”功能对其进行每1秒update一次。从而是我们节省了了许多的对time()系统函数的调用(我们其实只是需要每秒钟获得一次时间，但是如果我们不用timer event的话，会导致高并发时在1秒钟会有几万次的time()调用，利用了timer event之后,我们每秒只是调用了一次，其它需要获得当前时间的函数直接从全局变量current_time中
直接读取)。同时我们没有使用UNIX timestamps，而是使用了当前时间与系统启动时间的相对值，来表示时间的概念，这样也给我们节省了空间，因为有些系统中：
sizeof(time_t) > sizeof(unsigned int).

********************************************************************************************

在memcached.c中另一处也用到了libevent中的timer event的功能：

  1. /** file scope variables **/

  3. static item **todelete = NULL;
  4. static int delcurr;
  5. static int deltotal;

  7. # define run_deferred_deletes() do_run_deferred_deletes()

  9. static void delete_handler(const int fd, const short which, void *arg) {
  10.     struct timeval t = {.tv_sec = 5, .tv_usec = 0};
  11.     static bool initialized = false;

  13.     if (initialized) {
  14.         /* some versions of libevent don't like deleting events that don't
  15.          * exist, so only delete once we know this event has been added.
  16.          */
  17.         evtimer_del(&deleteevent);
  18.     } else {
  19.         initialized = true;
  20.     }
  21.     evtimer_set(&deleteevent, delete_handler, 0);
  22.     event_base_set(main_base, &deleteevent);
  23.     evtimer_add(&deleteevent, &t);
  24.     run_deferred_deletes();
  25. }

  27. /* Call run_deferred_deletes instead of this. */
  28. void do_run_deferred_deletes(void)
  29. {
  30.     int i, j = 0;

  32.     for (i = 0; i < delcurr; i++) {
  33.         item *it = todelete[i];
  34.         if (item_delete_lock_over(it)) {
  35.             assert(it->refcount > 0);
  36.             it->it_flags &= ~ITEM_DELETED;
  37.             do_item_unlink(it);
  38.             do_item_remove(it);
  39.         } else {
  40.             todelete[j++] = it;
  41.         }
  42.     }
  43.     delcurr = j;
  44. }

  46. /*
  47.  * Adds an item to the deferred-delete list so it can be reaped later.
  48.  * Returns the result to send to the client.
  49.  */
  50. char *do_defer_delete(item *it, time_t exptime)
  51. {
  52.     if (delcurr >= deltotal) {
  53.         item **new_delete = realloc(todelete, sizeof(item *) * deltotal * 2);
  54.         if (new_delete) {
  55.             todelete = new_delete;
  56.             deltotal *= 2;
  57.         } else {
  58.             /*
  59.              * can't delete it immediately, user wants a delay,
  60.              * but we ran out of memory for the delete queue
  61.              */
  62.             item_remove(it); /* release reference */
  63.             return "SERVER_ERROR out of memory expanding delete queue";
  64.         }
  65.     }

  67.     /* use its expiration time as its deletion time now */
  68.     it->exptime = realtime(exptime);
  69.     it->it_flags |= ITEM_DELETED;
  70.     todelete[delcurr++] = it;

  72.     return "DELETED";
  73. }

  75. 在main函数中有如下代码：

  77. /* initialise deletion array and timer event */
  78. deltotal = 200;
  79. delcurr = 0;

  81. if ((todelete = malloc(sizeof(item *) * deltotal)) == NULL) {
  82.         perror("failed to allocate memory for deletion array");
  83.         exit(EXIT_FAILURE);
  84. }
  85. delete_handler(0, 0, 0); /* sets up the event */
很明显实现的功能是：
每隔5秒钟触发一次delete_handler从而实现每5秒中调用一次run_deferred_deletes();也就是每5秒钟遍历一次可以删除的item的链表，先判断它们的过期时间是否到了：

  1. /*
  2.  * returns true if a deleted item's delete-locked-time is over, and it
  3.  *  should be removed from the namespace
  4.  */
  5.     bool item_delete_lock_over (item *it) {
  6.     assert(it->it_flags & ITEM_DELETED);
  7.     return (current_time >= it->exptime);
  8.     }

然后标记删除标记：it->it_flags &= ~ITEM_DELETED;
最后删除：do_item_unlink(it);do_item_remove(it);。

item的删除链表 todelete 最初的大小为 deltotal = 200; 当空间不够时，再将加倍：
if (delcurr >= deltotal) {
        item **new_delete = realloc(todelete, sizeof(item *) * deltotal * 2);


另外：
char *do_defer_delete(item *it, time_t exptime)实现的功能是：

客户端请求服务器端将it这个item的可以在将来被删除的时间设置为exptime，比如客户端请求服务器端将it在未来的7天之后删除掉。则服务端就会先调用该函数来设置it可以被删除的时间。但是exptime是客户端传来的时间，我们服务器端不能确定exptime的值是7天之后对应的的真正的UNIX time，还是7天对应的time_t：7 * 60 * 60 * 24，所以我们这里调用了realtime这个函数来分情况来得到真正的UNIX时间处理：it->exptime = realtime(exptime);
realtime函数的定义如下：
  1. #define REALTIME_MAXDELTA 60*60*24*30
  2. /*
  3.  * given time value that's either unix time or delta from current unix time,
  4.  * return unix time. Use the fact that delta can't exceed one month (and real
  5.  * time value can't be that low).
  6.  */
  7.     static rel_time_t realtime(const time_t exptime) {
  8.         /* no. of seconds in 30 days - largest possible delta exptime */
  9.         if (exptime == 0) return 0; /* 0 means never expire */
  10.         if (exptime > REALTIME_MAXDELTA) {
  11.             /* if item expiration is at/before the server started, give it an
  12.              * expiration time of 1 second after the server started.
  13.              * (because 0 means don't expire). without this, we'd
  14.              * underflow and wrap around to some large value way in the
  15.              * future, effectively making items expiring in the past
  16.              * really expiring never
  17.              */
  18.             if (exptime <= stats.started)
  19.                 return (rel_time_t)1;
  20.             return (rel_time_t)(exptime - stats.started);
  21.         } else {
  22.             return (rel_time_t)(exptime + current_time);
  23.         }
  24.     }
第一段注释的意思是：
给定一个时间，不论它是真正的UNIX time，还是相对于当前的相对时间，返回真正的UNIX time相对于memcached启动的值，也就是真正的UNIX time减去memcached启动时的UNIX time。源代码中的注释有误！判断参数exptime是不是真正的UNIX time用到了一个基本事实：
UNIX time是指1970-01-01 00:00:00到当前的时间差的秒数，肯定大于REALTIME_MAXDELTA
并且memcached的协议也规定：在memcached中存储的object的存在的时间不能超过30天。所以客户端不可能请求服务器端在30天或40天之后才删除某个item对象。


第二段注释的意思是：
如果参数exptime的值早于memcached服务器启动的时间，那么我们就将它的设置为memcached启动之后的1秒(因为0表示不过期)。如果不这样做的话，那么因为
(exptime - stats.started)是一个负数，将它强制转换成rel_time_t(rel_time_t的真正类型是unsigned int),这将导致溢出并回卷而变成一个极大的正数，将导致该item在实际效果上是等同于永远不过期。


对item其它相关函数的分析参见随后的blog.
上一篇：Ubuntu中利用配置PPPoE上网
下一篇：关于/dev/tty的特殊用法