ucgui timer实现分析

ucgui timer实现分析定时器属于基本的的基础组件,不管用户空间的程序开发,还是内核空间的程序开发,很多时候都需要有定时器作为基础组件的支持,但使用场景的不同,对定时器的实现考虑也不同。现在主要讨论UCGUI的Timer实现,以及与LINUXTimer的比较。LINUXTimer的实现有基于链表

大家好,欢迎来到IT知识分享网。

定时器属于基本的的基础组件,不管用户空间的程序开发,还是内核空间的程序开发,很多时候都需要有定时器作为基础组件的支持,但使用场景的不同,对定时器的实现考虑也不同。现在主要讨论UCGUI的Timer实现,以及与LINUX Timer的比较。

LINUX Timer的实现有基于链表和信号实现定时器、基于排序链表的定时器、基于文件描述符的定时器、基于时间轮(Timing-Wheel) 方式实现的定时器,而UCGUI是基于链表实现定时器。

首先,看LINUX基于链表和信号实现定时器是怎么实现的。

在 2.4 的内核中,并没有提供 POSIX timer [ 2 ]的支持,要在进程环境中支持多个定时器,只能自己来实现,好在 Linux 提供了setitimer(2) 的接口。它是一个具有间隔功能的定时器 (interval timer),但如果想在进程环境中支持多个计时器,不得不自己来管理所有的计时器。 setitimer(2) 的定义如下:

清单 1. setitimer 的原型

#include <sys/time.h>

                        int setitimer(int which, const struct itimerval *new_value,struct itimerval *old_value);

 

setitimer 能够在 Timer 到期之后,自动再次启动自己,因此,用它来解决 Single-Shot Timer 和 Repeating Timer 的问题显得很简单。该函数可以工作于 3 种模式:

ITIMER_REAL 以实时时间 (real time) 递减,在到期之后发送 SIGALRM 信号

ITIMER_VIRTUAL 仅进程在用户空间执行时递减,在到期之后发送 SIGVTALRM 信号

ITIMER_PROF 进程在用户空间执行以及内核为该进程服务时 ( 典型如完成一个系统调用 ) 都会递减,与 ITIMER_VIRTUAL 共用时可度量该应用在内核空间和用户空间的时间消耗情况,在到期之后发送 SIGPROF 信号

定时器的值由下面的结构定义:

清单 2. setitimer 定时器的值定义

struct itimerval {

                        struct timeval it_interval; /* next value */

                        struct timeval it_value;     /* current value */

                        };

                        struct timeval {

                        long tv_sec;                /* seconds */

                        long tv_usec;               /* microseconds */

                        };

 

setitimer() 以 new_value 设置特定的定时器,如果 old_value 非空,则它返回 which 类型时间间隔定时器的前一个值。定时器从it_value 递减到零,然后产生一个信号,并重新设置为 it_interval,如果此时 it_interval 为零,则该定时器停止。任何时候,只要it_value 设置为零,该定时器就会停止。

由于 setitimer() 不支持在同一进程中同时使用多次以支持多个定时器,因此,如果需要同时支持多个定时实例的话,需要由实现者来管理所有的实例。用 setitimer() 和链表,可以构造一个在进程环境下支持多个定时器实例的 Timer,在一般的实现中的PerTickBookkeeping 时,会递增每个定时器的 elapse 值,直到该值递增到最初设定的 interval 则表示定时器到期。

基于链表实现的定时器可以定义为:

清单 3. 基于链表的定时器定义

typedef int timer_id;

/**

* The type of callback function to be called by timer scheduler when a timer

* has expired.

*

* @param id                The timer id.

* @param user_data        The user data.

* $param len               The length of user data.

*/

typedef int timer_expiry(timer_id id, void *user_data, int len);

/**

* The type of the timer

*/

struct timer {

   LIST_ENTRY(timer) entries;/**< list entry               */

   timer_id id;                /**< timer id                  */

   int interval;               /**< timer interval(second) */

int elapse;                 /**< 0 -> interval             */

   timer_expiry *cb;          /**< call if expiry            */

   void *user_data;           /**< callback arg               */

   int len;                        /**< user_data length          */

 };

 

定时器的时间间隔以 interval 表示,而 elapse 则在 PerTickBookkeeping() 时递增,直到 interval 表示定时器中止,此时调用回调函数 cb 来执行相关的行为,而 user_data 和 len 为用户可以传递给回调函数的参数。

所有的定时器实例以链表来管理:

清单 4. 定时器链表

/**

 * The timer list

 */

 struct timer_list {

    LIST_HEAD(listheader, timer) header;  /**< list header         */

    int num;                              /**< timer entry number */

    int max_num;                          /**< max entry number    */

    void (*old_sigfunc)(int);       /**< save previous signal handler */

    void (*new_sigfunc)(int);      /**< our signal handler          */

    struct itimerval ovalue;            /**< old timer value */

    struct itimerval value;       /**< our internal timer value */

  };

 

这里关于链表的实现使用了 BSD 风格关于链表的一组宏,避免了再造轮子;该结构中,old_sigfunc 在 init_timer 初始定时器链表时候用来保存系统对 SIGALRM 的处理函数,在定时器系统 destory 时用来恢复到之前的处理函数; ovalue 的用途与此类似。

清单 5. 定时器链表的创建和 Destroy

/**

 * Create a timer list.

 *

* @param count  The maximum number of timer entries to be supported initially.

 *

 * @return        0 means ok, the other means fail.

 */

 int init_timer(int count)

 {

     int ret = 0;

     if(count <=0 || count > MAX_TIMER_NUM) {

     printf(“the timer max number MUST less than %d./n”, MAX_TIMER_NUM);

      return -1;

      }

     memset(&timer_list, 0, sizeof(struct timer_list));

     LIST_INIT(&timer_list.header);

     timer_list.max_num = count;

 /* Register our internal signal handler and store old signal handler */

     if ((timer_list.old_sigfunc = signal(SIGALRM, sig_func)) == SIG_ERR)

{

        return -1;

 }

timer_list.new_sigfunc = sig_func;

/*Setting our interval timer for driver our mutil-timer and store old timer value*/

timer_list.value.it_value.tv_sec = TIMER_START;

timer_list.value.it_value.tv_usec = 0;

timer_list.value.it_interval.tv_sec = TIMER_TICK;

timer_list.value.it_interval.tv_usec = 0;

ret = setitimer(ITIMER_REAL, &timer_list.value, &timer_list.ovalue);

return ret;

}

/**

 * Destroy the timer list.

 *

 * @return          0 means ok, the other means fail.

 */

 int destroy_timer(void)

{

    struct timer *node = NULL;

if ((signal(SIGALRM, timer_list.old_sigfunc)) == SIG_ERR)

{

       return -1;

    }

if((setitimer(ITIMER_REAL, &timer_list.ovalue, &timer_list.value)) < 0) {

   return -1;

}

while (!LIST_EMPTY(&timer_list.header))

{     /* Delete. */

     node = LIST_FIRST(&timer_list.header);

     LIST_REMOVE(node, entries);

     /* Free node */

     printf(“Remove id %d/n”, node->id);

     free(node->user_data);

     free(node);

}

memset(&timer_list, 0, sizeof(struct timer_list));

   return 0;

}

 

添加定时器的动作非常的简单,本质只是一个链表的插入而已:

清单 6. 向定时器链表中添加定时器

/**

                        * Add a timer to timer list.

                        *

                        * @param interval  The timer interval(second).

                        * @param cb      When cb!= NULL and timer expiry, call it.

                        * @param user_data Callback’s param.

                        * @param len              The length of the user_data.

                        *

                        * @return          The timer ID, if == INVALID_TIMER_ID, add timer fail.

                        */

                        timer_id  add_timer(int interval, timer_expiry *cb, void *user_data, int len)

                        {

                        struct timer *node = NULL;

                        if (cb == NULL || interval <= 0) {

                        return INVALID_TIMER_ID;

                        }

                        if(timer_list.num < timer_list.max_num) {

                        timer_list.num++;

                        } else {

                        return INVALID_TIMER_ID;

                        }

                        if((node = malloc(sizeof(struct timer))) == NULL) {

                        return INVALID_TIMER_ID;

                        }

                        if(user_data != NULL || len != 0) {

                        node->user_data = malloc(len);

                        memcpy(node->user_data, user_data, len);

                        node->len = len;

                        }

                        node->cb = cb;

                        node->interval = interval;

                        node->elapse = 0;

                        node->id = timer_list.num;

                        LIST_INSERT_HEAD(&timer_list.header, node, entries);

                        return node->id;

                        }

 

注册的信号处理函数则用来驱动定时器系统:

清单 7. 信号处理函数驱动定时器

/* Tick Bookkeeping */

static void sig_func(int signo)

{

 struct timer *node = timer_list.header.lh_first;

 for ( ; node != NULL; node = node->entries.le_next)

{

     node->elapse++;

     if(node->elapse >= node->interval)

{

           node->elapse = 0;

           node->cb(node->id, node->user_data, node->len);

      }

 }

}

 

它主要是在每次收到 SIGALRM 信号时,执行定时器链表中的每个定时器 elapse 的自增操作,并与 interval 相比较,如果相等,代表注册的定时器已经超时,这时则调用注册的回调函数。

上面的实现,有很多可以优化的地方:考虑另外一种思路,在定时器系统内部将维护的相对 interval 转换成绝对时间,这样,在每PerTickBookkeeping 时,只需将当前时间与定时器的绝对时间相比较,就可以知道是否该定时器是否到期。这种方法,把递增操作变为了比较操作。并且上面的实现方式,效率也不高,在执行 StartTimer,StopTimer,PerTickBookkeeping 时,算法复杂度分别为 O(1),O(n),O(n),可以对上面的实现做一个简单的改进,在 StartTimer 时,即在添加 Timer 实例时,对链表进行排序,这样的改进,可以使得在执行 StartTimer,StopTimer,PerTickBookkeeping 时,算法复杂度分别为 O(n),O(1),O(1) 。

   UCGUI同样是基于链表实现,但不同的是它不处于操作系统层面,所以,其回调函数,不是只由信号来实现。

   首先,看看UCGUI的结构,跟LINUX一样,同样是有个链表结构来记录多个timer。

typedef struct {

  GUI_TIMER_CALLBACK* cb;

  GUI_TIMER_Handle hNext;

  int Flags;

         U32 Context;

         GUI_TIMER_TIME t0;

         GUI_TIMER_TIME Period;

} GUI_TIMER_Obj;

Cb为timer的callback function。Hnext则衔接各个timer,flags为标识,Context为上下文环境,相当于timer id

Link函数利用头插法,LINK起timer

最后,通过消息循环回调GUI_TIMER_Exec(void)函数

http://blog.csdn.net/jacklam200/article/details/5919876

免责声明:本站所有文章内容,图片,视频等均是来源于用户投稿和互联网及文摘转载整编而成,不代表本站观点,不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益,请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权,请联系删除,如若转载,请注明出处:https://yundeesoft.com/23831.html

(0)

相关推荐

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

关注微信