嵌入式操作系统内核原理和开发（延时操作）

 【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】    
 
     延时操作是操作系统中经常遇到的一种情形。延时的原因很多，有的时候是为了等待外设芯片处理结束，有的时候是为了暂时释放cpu的使用权，有的就是为了希望在一段时间获取资源，如果没法在单位时间内获取，放弃等待。但是不管怎么说，延时都是操作系统必不可少的一个工作。下面我们就看看延时是怎么实现的，

static void tick_list_priority_insert(LIST *head, RAW_TASK_OBJ *task_ptr)  {  RAW_U32 val;    LIST *q,*start, *end;  RAW_TASK_OBJ  *task_iter_temp;    start = end = head;  val = task_ptr->tick_remain;      for (q = start->next; q != end; q = q->next) {    task_iter_temp = list_entry(q, RAW_TASK_OBJ, tick_list);    /*sorted by remain time*/    if ((task_iter_temp->tick_match - raw_tick_count) > val) {  break;  }  }    list_insert(q, &task_ptr->tick_list);      }      void  tick_list_insert(RAW_TASK_OBJ   *task_ptr, RAW_U32  time)                            {  LIST     *tick_head_ptr;    RAW_U16   spoke;    if (time) {                                   task_ptr->tick_match = raw_tick_count + time;  task_ptr->tick_remain   = time;    spoke   = (RAW_U16)(task_ptr->tick_match  &  (TICK_HEAD_ARRAY - 1) );  tick_head_ptr = &tick_head[spoke];    tick_list_priority_insert(tick_head_ptr, task_ptr);    task_ptr->tick_head = tick_head_ptr;       }                    } 

    延时的代码其实不是很多，所以我在这里把最重要的两个函数给粘贴到这里了。因为每个线程都有可能延时，那么怎么处理这些线程之间的关系就是我们需要做的事情了。我们看到了，我们直接用tick_match表示线程需要等待的那个时间点就可以了。当然，tick是不断增加的，我们可以把尾数相同的线程按照高低顺序排列在一起，这样在对应的tick到来的时候，就直接按照尾数查找就可以了，tick_list_priority_insert就是干了这么一件事情。
 
     那么，tick什么时候到期呢？到期又该怎么处理呢，我们接着往下看，

void  tick_list_update(void)  {    LIST     *tick_head_ptr;  RAW_TASK_OBJ            *p_tcb;  LIST                            *iter;  LIST                            *iter_temp;    RAW_U16   spoke;    RAW_SR_ALLOC();    RAW_CRITICAL_ENTER();    raw_tick_count++;                                                       spoke    = (RAW_U16)(raw_tick_count &  (TICK_HEAD_ARRAY - 1) );  tick_head_ptr  = &tick_head[spoke];  iter    = tick_head_ptr->next;    while (RAW_TRUE) {    /*search all the time list if possible*/  if (iter != tick_head_ptr) {    iter_temp =  iter->next;  p_tcb =  list_entry(iter, RAW_TASK_OBJ, tick_list);    /*Since time list is sorted by remain time, so just campare  the absolute time*/  if (raw_tick_count == p_tcb->tick_match) {    switch (p_tcb->task_state) {  case RAW_DLY:    p_tcb->block_status = RAW_B_OK;   p_tcb->task_state = RAW_RDY;    tick_list_remove(p_tcb);  add_ready_list(&raw_ready_queue, p_tcb);  break;     case RAW_PEND_TIMEOUT:    p_tcb->block_status = RAW_B_TIMEOUT;   p_tcb->task_state = RAW_RDY;   p_tcb->block_obj = 0;  tick_list_remove(p_tcb);  /*remove task on the block list because task is timeout*/  list_delete(&p_tcb->task_list);   add_ready_list(&raw_ready_queue, p_tcb);  break;      case RAW_PEND_TIMEOUT_SUSPENDED:     p_tcb->block_status = RAW_B_TIMEOUT;   p_tcb->task_state = RAW_SUSPENDED;    p_tcb->block_obj = 0;  tick_list_remove(p_tcb);  /*remove task on the block list because task is timeout*/  list_delete(&p_tcb->task_list);   break;         case RAW_DLY_SUSPENDED:          p_tcb->task_state  =  RAW_SUSPENDED;  p_tcb->block_status = RAW_B_OK;   tick_list_remove(p_tcb);                     break;    default:    #if (CONFIG_RAW_ASSERT > 0)  RAW_ASSERT(0);  #endif    break;  }    iter  = iter_temp;  }    /*if current task time out absolute time is not equal current system time, just break because timer list is sorted*/  else {    break;    }    }     /*finish all the time list search */     else {    break;  }    }    RAW_CRITICAL_EXIT();  } 

     这个函数是在时钟中断的时候被调用的，根据函数的先后顺序，看看函数实现了哪些功能，
     （1）自增raw_tick_count；
     （2）根据尾数获取tick队列的头指针；
     （3）开始循环迭代处理延时线程；
             a）如果没有没有延时线程，循环跳出；
             b）如果线程的终点tick和当前tick不匹配，跳出循环，因为tick都是排序好的，所以后面的tick肯定不满足要求；
             c）如果当前tick满足要求，根据线程状态进行处理，主要分为延时、阻塞超时、延时挂起、阻塞超时挂起四种状态；
             d）获取下一个延时线程，观察是否满足要求，如果是继续回到c，否则退出循环。
     （4）函数返回，继续时钟中断的剩余操作。
 
     最后，我们补充一下关于有限时间等待的知识。就像以前关于互斥操作的内容一样，其实某些情况下，我们是有时间限制的。一段时间没有获取资源，我们就不希望等待了，所以这里的延时操作还包括这部分的内容，我们看看阻塞函数的相关代码就明白了。

RAW_U16 raw_pend_object(RAW_COMMON_BLOCK_OBJECT  *block_common_obj, RAW_TASK_OBJ *task_ptr, RAW_U32 timeout)  {    #if (CONFIG_RAW_ASSERT > 0)    if (timeout == 0) {  RAW_ASSERT(0);  }    #endif    task_ptr->block_obj = block_common_obj;      if (timeout == RAW_WAIT_FOREVER) {      task_ptr->task_state = RAW_PEND;    }  /*task is blocked with timeout*/  else {        tick_list_insert(task_ptr,timeout);    task_ptr->task_state = RAW_PEND_TIMEOUT;    }    /*Remove from the ready list*/  remove_ready_list(&raw_ready_queue, task_ptr);    if (block_common_obj->block_way == RAW_BLOCKED_WAY_FIFO) {    list_insert(&block_common_obj->block_list, &task_ptr->task_list);    }    else {    /*add to the priority sorted block list*/  add_to_priority_list(&block_common_obj->block_list, task_ptr);    }    return RAW_SUCCESS;  } 

    大家留意一下这里timeout参数的处理过程，关注一下对应的tick_list_insert函数，这样就可以明白我的意思了。