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

【声明：版权所有，欢迎转载，请勿用于商业用途。联系信箱：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函数，这样就可以明白我的意思了。

秒客网

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

相关文章