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

最新推荐文章于 2022-09-17 23:15:38 发布

嵌入式-老费

最新推荐文章于 2022-09-17 23:15:38 发布

阅读量3.6k

点赞数 3

分类专栏： # 操作系统文章标签：嵌入式操作系统 list insert delete search object

本文链接：https://blog.csdn.net/feixiaoxing/article/details/8050193

版权

操作系统专栏收录该内容

28 篇文章 16 订阅

订阅专栏

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