Contiki学习笔记：系统进程etimer_process

Jelline

摘要：

    系统进程etimer_process管理timelist，本文先给出etimer_process的启动，而后深入源码分析etimer_process的执行主体，追踪了其所涉及到的宏和函数。

一、启动etimer_process

    在main函数中，先是进行一系列初始化，接着启动系统进程etimer_process和指针数组autostart_processes[]里的所有进程。源代码如下：

1. int main()
   
2. {
   
3.   dbg_setup_uart();
4.   clock_init();
   
5.   process_init();
   
6. 
   
7.   process_start(&etimer_process, NULL); //启动etimer_process
   
8.   autostart_start(autostart_processes); //启动指针数组autostart_processes[]里的所有进程
9. 
   
10.   while (1)
    
11.   {
    
12.     do
    
13.     {}while (process_run() > 0);
14.   }
    
15.   return 0;
    
16. }

    关于process_start启动一个进程，可以参考博文《Contiki学习笔记：启动一个进程process_start》。

二、etimer_process执行主体剖析

    在博文《Contiki学习笔记：启动一个进程process_start》中，我们得知，进程退出时，需向所有进程(当然也包括etimer_process)发送事件PROCESS_EVENT_EXITED。etimer_process收到该事件，就会遍历timerlist，并把与该退出进程相关的etimer从timerlist删除。紧接着，遍历timerlist，检查etimer是否有到期的，凡有timer到期就把事件PROCESS_EVENT_TIMER加入到事件队列中，并将该etimer成员变量p指向PROCESS_NONE。在这里，PROCESS_NONE用于标识该etimer是否到期，即由etimer_expired函数根据etimer的p是否指向PROCESS_NONE来判断该etimer是否到期。源代码如下：

1. //PROCESS(etimer_process, "Event timer");
   
2. PROCESS_THREAD(etimer_process, ev, data)
   
3. {
   
4.   struct etimer *t, *u;
   
5. 
   
6.   PROCESS_BEGIN();
   
7. 
   
8.   timerlist = NULL;
   
9. 
   
10.   while (1)
    
11.   {
    
12.     PROCESS_YIELD(); /*见2.1*/
    
13. 
    
14.     /*进程退出时，需向所有进程(当然也包括etimer_process)发送事件PROCESS_EVENT_EXITED。etimer_process收到该事件，就会遍历timerlist，并把与该退出进程相关的etimer从timerlist删除*/
    
15.     if (ev == PROCESS_EVENT_EXITED)
    
16.     {
    
17.       struct process *p = data;  //此时通过data传递将要退出的进程，data是void *类型
18. 
    
19.       /*遍历timerlist，查找是否有etimer绑定该退出进程*/
    
20.       while (timerlist != NULL && timerlist->p == p)
    
21.       {
    
22.         timerlist = timerlist->next;
    
23.       }
    
24. 
    
25.       /*有etimer绑定该退出进程，将etimer从timerlist删除*/
    
26.       if (timerlist != NULL)
    
27.       {
    
28.         t = timerlist;
    
29.         while (t->next != NULL)
    
30.         {
    
31.           if (t->next->p == p)
    
32.           {
    
33.             t->next = t->next->next;
    
34.           }
    
35.           else
    
36.             t = t->next;
    
37.         }
    
38.       }
    
39. 
    
40.       continue; //删除所有与退出进程绑定的etimer
    
41.     }
    
42.     else if (ev != PROCESS_EVENT_POLL)  //不解？
43.     {
    
44.       continue;
    
45.     }
    
46. 
    
47.     again:
    
48. 
    
49.     u = NULL;
    
50.     for (t = timerlist; t != NULL; t = t->next)
    
51.     {
    
52.       if (timer_expired(&t->timer)) //检查该etimer的timer是不是到期，返回1表示过期，详情见2.2
53.       {
    
54.         if (process_post(t->p, PROCESS_EVENT_TIMER, t) == PROCESS_ERR_OK) //详情见2.3，即把事件PROCESS_EVENT_TIMER加入到事件队列
55.         {
    
56.           /*成功加入事件队列*/
    
57. 
    
58.           t->p = PROCESS_NONE; //如果etimer的p指向的是PROCESS_NONE，则表示该etimer已到期。用于后续etimer_expired()函数判断该etimer是否到期，etimer_expired()，也见2.2
59. 
    
60.           if (u != NULL)
    
61.           {
    
62.             u->next = t->next;
    
63.           }
    
64.           else
    
65.           {
    
66.             timerlist = t->next;
    
67.           }
    
68.           t->next = NULL;
    
69.           update_time(); /*见2.4，即求出下一个到期时间next_expiration (全局静态变量)，即还有next_expiration时间，就有timer到期*/
70.           goto again;
    
71.         }
    
72.         else
    
73.         {
    
74.           etimer_request_poll(); //详情见2.5 若加入事件PROCESS_EVENT_TIMER出错(可能是事件队列已满)，执行etimer_request_poll()，即process_poll(&etimer_process)，使其有更高的优先级
75.         }
    
76.       }
    
77.       u = t;
    
78.     }
    
79. 
    
80.   }
    
81. 
    
82.   PROCESS_END();
    
83. }

2.1 PROCESS_YIELD宏

1. /*即进程主动让出执行权*/
   
2. #define PROCESS_YIELD() PT_YIELD(process_pt)
   
3. 
   
4. /*继续展开如下，Yield from the current protothread*/
   
5. #define PT_YIELD(pt) \
   
6. do { \
   
7. PT_YIELD_FLAG = 0; \
   
8. LC_SET((pt)->lc); \
   
9. if(PT_YIELD_FLAG == 0) { \
   
10. return PT_YIELDED; \
    
11. } \
    
12. } while(0)
    
13. 
    
14. #define LC_SET(s) s = __LINE__; case __LINE__:  /*保存被中断的行数*/

2.2 timer_expired和etimer_expired

2.2.1 timer_expired

1. /*即检查timer是不是到期了，若到期返回1，否则返回0*/
   
2. int timer_expired(struct timer *t)
   
3. {
4.   clock_time_t diff = (clock_time() - t->start) + 1;
   
5.   return t->interval < diff;
6. }

注：为什么不直接return diff >= t->interval，源代码注释给出原因，如下：

1. Note: Can not return diff >= t->interval so we add 1 to diff and return t->interval < diff - required to avoid an internal error in mspgcc.

2.2.2 etimer_expired

    etimer_expired跟timer_expired不一样，后者到期是指定时器超时(通过比较当前时间与start+interval来判断timer是否到期)，而前者到期是指已发送事件PROCESS_EVENT_TIMER给etimer绑定的进程(通过etimer的p指向是否为PROCESS_NONE来判断)。源码如下：

1. int etimer_expired(struct etimer *et)
   
2. {
   
3.   return et->p == PROCESS_NONE;
   
4. }

2.3 process_post函数

1. //即把把事件加入到事件队列
   
2. int process_post(struct process *p, process_event_t ev, process_data_t data)
   
3. {
   
4.   static process_num_events_t snum;
   
5. 
   
6.   /*调试信息，直接无视*/
   
7.   if (PROCESS_CURRENT() == NULL)
   
8.   {
   
9.     PRINTF(
   
10.       "process_post: NULL process posts event %d to process '%s', nevents %d\n",
    
11.       ev, PROCESS_NAME_STRING(p), nevents);
    
12.   }
    
13.   else
    
14.   {
    
15.     PRINTF(
    
16.       "process_post: Process '%s' posts event %d to process '%s', nevents %d\n",
    
17.       PROCESS_NAME_STRING(PROCESS_CURRENT()), ev, p == PROCESS_BROADCAST ?
    
18.       "<broadcast>": PROCESS_NAME_STRING(p), nevents);
    
19.   }
    
20. 
    
21.   /*事件队列已满，返回PROCESS_ERR_FULL，即1*/
    
22.   if (nevents == PROCESS_CONF_NUMEVENTS)
    
23.   {
    
24.     #if DEBUG
    
25.       if (p == PROCESS_BROADCAST)
    
26.       {
    
27.         printf(
    
28.           "soft panic: event queue is full when broadcast event %d was posted from %s\n", ev, PROCESS_NAME_STRING(process_current));
    
29.       }
    
30.       else
    
31.       {
    
32.         printf(
    
33.           "soft panic: event queue is full when event %d was posted to %s frpm %s\n", ev, PROCESS_NAME_STRING(p), PROCESS_NAME_STRING(process_current));
    
34.       }
    
35.     #endif /* DEBUG */
    
36.     return PROCESS_ERR_FULL;
    
37.   }
    
38. 
    
39.   /*将事件加入事件队列，并绑定进程p*/
    
40.   snum = (process_num_events_t)(fevent + nevents) % PROCESS_CONF_NUMEVENTS;
    
41.   //事件队列用环形组织
    
42.   events[snum].ev = ev;
    
43.   events[snum].data = data;
    
44.   events[snum].p = p;
    
45.   ++nevents;
    
46. 
    
47.   #if PROCESS_CONF_STATS
    
48.     if (nevents > process_maxevents)
    
49.     {
    
50.       process_maxevents = nevents;
    
51.     }
    
52.   #endif /* PROCESS_CONF_STATS */
    
53. 
    
54.   return PROCESS_ERR_OK;
    
55. }

2.4 update_time函数

1. /*即求出下一个到期时间next_expiration(全局静态变量)，即还有next_expiration时间，就有timer到期*/
   
2. static void update_time(void)
   
3. {
   
4.   clock_time_t tdist;
   
5.   clock_time_t now;
   
6.   struct etimer *t;
   
7. 
   
8.   if (timerlist == NULL)
   
9.   {
   
10.     next_expiration = 0;
    
11.   }
    
12.   else
    
13.   {
    
14.     now = clock_time();
    
15.     t = timerlist;
16. 
    
17.     /*遍历timerlist，找出最近到期的timer，并求得下一个到期时间next_expiration*/
    
18.     tdist = t->timer.start + t->timer.interval - now; //还有tdist就到期了
    
19.     for (t = t->next; t != NULL; t = t->next)
    
20.     {
    
21.       if (t->timer.start + t->timer.interval - now < tdist)
    
22.       {
    
23.         tdist = t->timer.start + t->timer.interval - now;
    
24.       }
    
25.     }
    
26.     next_expiration = now + tdist;
    
27.   }
    
28. }

2.5 etimer_request_poll函数

1. void etimer_request_poll(void)
   
2. {
   
3.   process_poll(&etimer_process);
   
4. }
   
5. 
   
6. //将进程p的needspoll设为1，使其获得更高优先级，即让etimer_process更快地再次获得执行权
   
7. void process_poll(struct process *p)
   
8. {
   
9.   if (p != NULL)
   
10.   {
    
11.     if (p->state == PROCESS_STATE_RUNNING || p->state == PROCESS_STATE_CALLED)
    
12.     {
    
13.       p->needspoll = 1;
    
14.       poll_requested = 1; //全局变量，标识是否有needspoll为1的进程
    
15.     }
    
16.   }
    
17. }