首页 > 代码库 > Contiki进程间的交互

Contiki进程间的交互

之前都是从各个模块开始看起,从底层开始看起。应该改变一下思路,从高往下看,站得高看得远。

 

一、Main函数

源码:contiki-release-2-7\platform\stm32test\contiki-main.c

intmain(){  dbg_setup_uart();  printf("Initialising\n");    clock_init();  process_init();  process_start(&etimer_process, NULL);  autostart_start(autostart_processes);  printf("Processes running\n");  while(1) {    do {    } while(process_run() > 0);    idle_count++;    /* Idle! */    /* Stop processor clock */    /* asm("wfi"::); */   }  return 0;}

 

主函数中,关于进程的操作:

先对进程进行初始化process_init()。

用process_start(&etimer_process, NULL),启动etimer_process进程。

用autostart_start(autostart_processes),启动需要自动启动的进程,看自启动进程相关知识。

最后循环执行进程调度函数process_run。

 

二、进程初始化

voidprocess_init(void){  lastevent = PROCESS_EVENT_MAX;  nevents = fevent = 0;#if PROCESS_CONF_STATS  process_maxevents = 0;#endif /* PROCESS_CONF_STATS */  process_current = process_list = NULL;}

 

初始化最后一个事件标识lastevent为PROCESS_EVENT_MAX

初始化事件总数nevents和事件队列头指针fevent为0。

初始化进程链表头process_list和当前进程process_current为NULL。

 

三、启动进程

voidprocess_start(struct process *p, const char *arg){  struct process *q;  //确保要运行的进程没有在进程链表(已经运行了的进程)中  /* First make sure that we don‘t try to start a process that is     already running. */  for(q = process_list; q != p && q != NULL; q = q->next);  /* If we found the process on the process list, we bail out. */  if(q == p) {//已在进程链表中,返回    return;  }  /* Put on the procs list.*/  p->next = process_list;//添加要启动的进程到进程链表中  process_list = p;  p->state = PROCESS_STATE_RUNNING;//设置进程状态为准备就绪状态  PT_INIT(&p->pt);//初始化进程pt(lc)  PRINTF("process: starting ‘%s‘\n", PROCESS_NAME_STRING(p));  /* Post a synchronous initialization event to the process. */  process_post_synch(p, PROCESS_EVENT_INIT, (process_data_t)arg);//用同步事件启动进程p}

 

先确保要启动的进程没有在进程链表中。

再将进程添加到进程链表中。

设置进程状态为PROCESS_STATE_RUNNING,即就绪状态,并初始化pt

最后传递同步事件给进程p,其中事件标识为PROCSS_EVENT_INIT,事件携带数据data为NULL

 

1、传递同步事件

voidprocess_post_synch(struct process *p, process_event_t ev, process_data_t data){  struct process *caller = process_current;//先保存当前进程指针  call_process(p, ev, data);//传递给特定进程  process_current = caller;//恢复当前进程指针}

 

先保存当前进程变量process_current,然后传递事件给进程,最后恢复process_current变量。

 

2、调用进程

static voidcall_process(struct process *p, process_event_t ev, process_data_t data){  int ret;//进程执行主体函数返回值#if DEBUG  if(p->state == PROCESS_STATE_CALLED) {//再次调用?    printf("process: process ‘%s‘ called again with event %d\n", PROCESS_NAME_STRING(p), ev);  }#endif /* DEBUG */    if((p->state & PROCESS_STATE_RUNNING) &&     p->thread != NULL) {//就绪状态并且执行主体函数不为NULL?    PRINTF("process: calling process ‘%s‘ with event %d\n", PROCESS_NAME_STRING(p), ev);    process_current = p;//设置当前进程变量    p->state = PROCESS_STATE_CALLED;//设置进程状体为已被调用    ret = p->thread(&p->pt, ev, data);//执行进程主体函数    if(ret == PT_EXITED ||       ret == PT_ENDED ||       ev == PROCESS_EVENT_EXIT) {//返回值为PT_EXITED或PT_ENDED或传递进来的事件为PROCESS_EVENT_EXIT      exit_process(p, p);//执行退出进程函数    } else {      p->state = PROCESS_STATE_RUNNING;//重新设置为就绪状态,等待事件的到来    }  }}

 

在进程状态为就绪状态PROCESS_STATE_RUNNING,并且执行主体函数不为NULL的情况下。

设置当前进程变量为p,并设置状态为已被调用状态PROCESS_STATE_CALLED。

调用执行主体函数p->thread(&p->pt, ev, data)。

如果返回值为PT_EXITED或者返回值为PT_ENDED或者这个事件是PROCESS_EVENT_EXIT,则这个进程已经执行完毕了。执行退出进程操作exit_process,做一些善后工作。

否则重新设置进程状态为就绪状态,继续等待事件的到来。

 

注:注意区分PROCESS_EVENT_EXIT事件和PROCESS_EVENT_EXITED事件,PROCESS_EVENT_EXIT是通知要退出的进程p本身,而PROCESS_EVENT_EXITED是通知其他进程,有进程p即将退出。

退出进程操作有两种情况,一种是自己要退出,即上述情况:返回值为PT_EXITED或者返回值为PT_ENDED或者这个事件是PROCESS_EVENT_EXIT。

另一种是其他进程要这个进程退出。

 

退出进程

static voidexit_process(struct process *p, struct process *fromprocess){  register struct process *q;  struct process *old_current = process_current;//先保存当前进程变量  PRINTF("process: exit_process ‘%s‘\n", PROCESS_NAME_STRING(p));  /* Make sure the process is in the process list before we try to     exit it. */  for(q = process_list; q != p && q != NULL; q = q->next);  if(q == NULL) {    return;  }//确定要退出的进程在进程链表中,否则返回  if(process_is_running(p)) {//进程状态不是PROCESS_STATE_NONE才进入    /* Process was running */    p->state = PROCESS_STATE_NONE;//设置状态为PROCESS_STATE_NONE    /*     * Post a synchronous event to all processes to inform them that     * this process is about to exit. This will allow services to     * deallocate state associated with this process.     */    for(q = process_list; q != NULL; q = q->next) {      if(p != q) {    call_process(q, PROCESS_EVENT_EXITED, (process_data_t)p);      }    }//通知其他所有进程,p进程即将退出    if(p->thread != NULL && p != fromprocess) {      /* Post the exit event to the process that is about to exit. */      process_current = p;      p->thread(&p->pt, PROCESS_EVENT_EXIT, NULL);    }  }//再次执行p进程的执行主体函数(p和fromprocess不同的情况下)  if(p == process_list) {    process_list = process_list->next;  } else {    for(q = process_list; q != NULL; q = q->next) {      if(q->next == p) {    q->next = p->next;    break;      }    }  }//将进程p从进程链表中删除  process_current = old_current;//恢复当前进程变量}

先确定要退出的进程在进程链表中,并且进程状态不是PROCESS_STATE_NONE。

先给其他所有进程,传递同步事件PROCESS_EVENT_EXITED,通知p这个进程即将退出。

如果是其他进程要p退出的话,则再次执行p的执行主体函数。

如果是p要p退出的话,那么执行主体函数都已经执行过了,所以不用再执行。

最后将进程p从进程链表中删除。

 

技术分享
intprocess_is_running(struct process *p){  return p->state != PROCESS_STATE_NONE;}
process_is_running

 

 

四、进程调度

intprocess_run(void){  /* Process poll events. */  if(poll_requested) {    do_poll();  }  /* Process one event from the queue */  do_event();  return nevents + poll_requested;}

 

 

进程调度函数中先处理抢占式进程,然后再处理协同式进程(非同步事件)。

 

1、推举抢占式进程

voidprocess_poll(struct process *p){  if(p != NULL) {    if(p->state == PROCESS_STATE_RUNNING ||       p->state == PROCESS_STATE_CALLED) {      p->needspoll = 1;      poll_requested = 1;    }  }}

 

最主要的工作时将进程p的needspoll标志设置为1,以及是否有poll请求标志poll_requested设置为1。

 

2、抢占式进程处理

static voiddo_poll(void){  struct process *p;  poll_requested = 0;//恢复标志  /* Call the processes that needs to be polled. */  for(p = process_list; p != NULL; p = p->next) {//遍历进程链表,调用所有需要poll的进程    if(p->needspoll) {      p->state = PROCESS_STATE_RUNNING;      p->needspoll = 0;//恢复标志      call_process(p, PROCESS_EVENT_POLL, NULL);    }  }}

 

 

注:从上边我们知道,抢占式进程会全部都执行完之后,再从事件队列中取出一个事件传递给目的进程处理。

 

总结

要先用process_start或者autostart_start先将进程启动。

后续的进程调度函数process_run时在进程启动后进行的一些调度,准确的说是传递事件。

 

进程的状态:

#define PROCESS_STATE_NONE 0    退出前的一个状态,就差从进程链表中删除。
#define PROCESS_STATE_RUNNING 1  就绪状态,即已经初始化完毕,等待事件的到来,然后执行进程执行主体函数。
#define PROCESS_STATE_CALLED 2   进程正在被调用,也就是执行主体函数正在运行中。

 

Contiki进程间的交互