ptpd 1588协议关于多个定时器的实现方式解析

1588时间协议，需要实现多个定时器，以对系统各个事件进行定时管理，那它怎么实现多个定时器的，真的挺巧妙的，我们来解析下

PtpClock *
ptpdStartup(int argc, char **argv, Integer16 * ret, RunTimeOpts * rtOpts)

{

...

 if(!timerSetup(ptpClock->timers)) {    //初始化所有的计时器，保留一个指向所有计时器的指针
  PERROR("failed to set up event timers");
  *ret = 2;
  free(ptpClock);
  return 0;
 }

...

}

Boolean timerSetup(IntervalTimer *itimers)
{

    Boolean ret = TRUE;

/* WARNING: these descriptions MUST be in the same order,
 * and in the same number as the enum in ptp_timers.h
 */

    static const char* timerDesc[PTP_MAX_TIMER] = {   //这里是我们需要的计时器类型
  "PDELAYREQ_INTERVAL",
  "DELAYREQ_INTERVAL",
  "SYNC_INTERVAL",
  "ANNOUNCE_RECEIPT",
  "ANNOUNCE_INTERVAL",
  "UNICAST_GRANT",
  "OPERATOR_MESSAGES",
  "LEAP_SECOND_PAUSE",
  "STATUSFILE_UPDATE",
  "PANIC_MODE",
  "PERIODIC_INFO_TIMER",
#ifdef PTPD_STATISTICS
  "STATISTICS_UPDATE",
#endif /* PTPD_STATISTICS */
  "MASTER_NETREFRESH",
  "CALIBRATION_DELAY",
  "CLOCK_UPDATE",
  "TIMINGDOMAIN_UPDATE"
    };

    int i = 0;

    startEventTimers();

    for(i=0; i<PTP_MAX_TIMER; i++) {  //创建上面所枚举的计时器

 itimers[i].data = NULL;
 itimers[i].data = (void *)(createEventTimer(timerDesc[i]));
 if(itimers[i].data == NULL) {
     ret = FALSE;
 }
    }

    return ret;

}

void
startEventTimers(void)
{
 struct itimerval itimer;

 DBG("initTimer\n");

#ifdef __sun
 sigset(SIGALRM, SIG_IGN);
#else
 signal(SIGALRM, SIG_IGN);
#endif /* __sun */

 elapsed = 0;
 itimer.it_value.tv_sec = itimer.it_interval.tv_sec = 0;
 itimer.it_value.tv_usec = itimer.it_interval.tv_usec =
     US_TIMER_INTERVAL;

#ifdef __sun
 sigset(SIGALRM, timerSignalHandler);
#else 
 signal(SIGALRM, timerSignalHandler);  //定时响应行数
#endif /* __sun */
 setitimer(ITIMER_REAL, &itimer, 0);   //使用高精度定时
}

static void
timerSignalHandler(int sig)
{
 elapsed++;   //非常简单，就使用这个全局计数器进行计时，这个是定时器使用的关键
 /* be sure to NOT call DBG in asynchronous handlers! */
}

//接下来我们看看它怎么创建定时器的

EventTimer
*createEventTimer(const char* id)
{

 EventTimer *timer;

        if ( !(timer = calloc (1, sizeof(EventTimer))) ) {
            return NULL;
        }

 setupEventTimer(timer);

        strncpy(timer->id, id, EVENTTIMER_MAX_DESC);

 /* maintain the linked list */

 if(_first == NULL) {//创建定时器链表
  _first = timer;
 }

 if(_last != NULL) {
     timer->_prev = _last;
     timer->_prev->_next = timer;
 }

 _last = timer;

 timer->_first = _first;

 DBGV("created itimer eventtimer %s\n", timer->id);

        return timer;
}

void
setupEventTimer(EventTimer *timer)
{

 if(timer == NULL) {
     return;
 }

 memset(timer, 0, sizeof(EventTimer));

 timer->start = eventTimerStart_itimer;  //启动
 timer->stop = eventTimerStop_itimer;  //停止
 timer->reset = eventTimerReset_itimer;  //复位
 timer->shutdown = eventTimerShutdown_itimer; //关闭
 timer->isExpired = eventTimerIsExpired_itimer;  //判断定时器是否溢出，或者说是否到期了
 timer->isRunning = eventTimerIsRunning_itimer;   //定时器状态
}

//我们关键看下，启动和判断溢出

static void
eventTimerStart_itimer(EventTimer *timer, double interval)
{

 timer->expired = FALSE;
 timer->running = TRUE;

 /*
  *  US_TIMER_INTERVAL defines the minimum interval between sigalarms.
  *  timerStart has a float parameter for the interval, which is casted to integer.
  *  very small amounts are forced to expire ASAP by setting the interval to 1
  */
 timer->itimerLeft = (interval * 1E6) / US_TIMER_INTERVAL;
 if(timer->itimerLeft == 0){
  /*
   * the interval is too small, raise it to 1 to make sure it expires ASAP
   */
  timer->itimerLeft = 1;   //最小的计时单位时1
 }
 
 timer->itimerInterval = timer->itimerLeft;  //设置响应间隔

 DBG2("timerStart:     Set timer %s to %f  New interval: %d; new left: %d\n", timer->id, interval, timer->itimerLeft , timer->itimerInterval);
}

//溢出判断

static Boolean
eventTimerIsExpired_itimer(EventTimer *timer)
{

 Boolean ret;

 itimerUpdate(timer);

 ret = timer->expired;

 DBG2("timerIsExpired:   Timer %s %s expired\n", timer->id,
  timer->expired ? "is" : "is not");

 if(ret) {
     timer->expired = FALSE;
 }

 return ret;

}

static void
itimerUpdate(EventTimer *et)
{

 EventTimer *timer = NULL;

 if (elapsed <= 0)
  return;

 /*
  * if time actually passed, then decrease every timer left
  * the one(s) that went to zero or negative are:
  *  a) rearmed at the original time (ignoring the time that may have passed ahead)
  *  b) have their expiration latched until timerExpired() is called
  */

/*每次都减去elapsed，elapsed前面已经说了，是个全局计时

 *如果时间已经溢出了，他就重新计时，并返回溢出信号

 */

 for(timer = et->_first; timer != NULL; timer = timer->_next) {
     if ( (timer->itimerInterval > 0) && ((timer->itimerLeft -= elapsed) <= 0)) {
   timer->itimerLeft = timer->itimerInterval;
   timer->expired = TRUE;
  DBG("TimerUpdate:    Timer %s has now expired.  Re-armed with interval %d\n", timer->id, timer->itimerInterval);
     }
 }

 elapsed = 0;   //已经减去了，重置

}

//简单点说，就是使用一个全局定时器计数，再创建一系列定时器，轮询这些定时器是否溢出，已达到多个定时器的目的