欢迎光临
梦想从学习开始!

嵌入式操作系统内核原理和开发(等值block内存池设计)| 小熊测试

本文主要介绍 嵌入式操作系统内核原理和开发(等值block内存池设计)| 小熊测试,小熊希望对大家的学习或者工作具有一定的参考学习价值,在测试领域有所提升和发展。


  内存池设计是嵌入式系统的一个重要环节,之前我们也讨论过相关的内容。但是,看了rawos的代码之后,我觉得rawos的内存池设计更有特点。整个内存池的设计非常健壮,不但考虑了字节对齐的问题,而且还引入了等待调度机制,这是我所没有想到的。所以,在此我很愿意和大家分享这份优秀的代码。闲话不多说,我们看看rawos的mempool数据结构是什么样的, typedef struct MEM_POOL

  {

   RAW_COMMON_BLOCK_OBJECT       common_block_obj;

  

   /* Define the number of available memory blocks in the pool.  */

   RAW_U32      raw_block_pool_available;

 

   /* Define the head pointer of the available block pool.  */

   RAW_U8      *raw_block_pool_available_list;

 

  } MEM_POOL;

    内存池的结构非常简单,主要包括了通用阻塞结构、block数值,block起始指针。内存池下面可以包括若干个block,每个block的大小都是相等的,同时block之间是通过链表串联在一起的,这个我们看了后面的代码就明白了。mempool的处理函数不多,就三个,初始化、申请、释放函数。 RAW_U16  raw_block_pool_create(MEM_POOL *pool_ptr, RAW_U8  *name_ptr, RAW_U32  block_size, RAW_VOID  *pool_start, RAW_U32  pool_size)

  {

 

   //MEM_POOL   *tail_ptr;                  /* Working block pool pointer  */

   RAW_U32       blocks;                     /* Number of blocks in pool    */

   RAW_U8        *block_ptr;                  /* Working block pointer       */

   RAW_U8        *next_block_ptr;             /* Next block pointer          */

   RAW_U8        *end_of_pool;                /* End of pool area            */

   RAW_U8    block_align_mask;

  

   #if (RAW_BLOCK_FUNCTION_CHECK > 0)

      /* Check for invalid pool size.  */

  

     if (pool_size < (block_size +  block_size) ) {

   

    return RAW_BLOCK_SIZE_ERROR;

   }

 

   if (pool_ptr == 0) {

   

    return RAW_NULL_OBJECT;

   }

  

   if (pool_start == 0) {

   

    return RAW_NULL_POINTER;

   }

  

   #endif

 

    block_align_mask = sizeof(void *) – 1u;

 

   if (((RAW_U32)pool_start & block_align_mask)){                           

 

    return RAW_INVALID_ALIGN;

 

   }

  

   if ((pool_size & block_align_mask)) { 

   

    return RAW_INVALID_ALIGN;

   }

 

   if ((block_size & block_align_mask)) { 

   

    return RAW_INVALID_ALIGN;

   }

  

   /*Init the list*/

   list_init(&pool_ptr->common_block_obj.block_list);

 

   /* Setup the basic block pool fields.  */

   pool_ptr ->common_block_obj.name =  name_ptr;

   pool_ptr ->common_block_obj.block_way = 0;

  

   /* Calculate the end of the pool's memory area.  */

   end_of_pool =  (RAW_U8  *) pool_start + pool_size;

 

   /* Walk through the pool area, setting up the available block list.  */

   blocks =            0;

   block_ptr =         (RAW_U8  *) pool_start;

   next_block_ptr =    block_ptr + block_size;

  

   while (next_block_ptr <= end_of_pool) {

 

     blocks++;

    

     if (next_block_ptr == end_of_pool) {

     

      break;

 

     }

 

     /* Setup the link to the next block.  */

     *((RAW_U8  * *) block_ptr) =  next_block_ptr;

 

     /* Advance to the next block.  */

     block_ptr =   next_block_ptr;

 

     /* Update the next block pointer.  */

     next_block_ptr =  block_ptr + block_size;

   }

 

   /* Set the last block's forward pointer to NULL.  */

   *((RAW_U8  * *) block_ptr) =  0;

 

   /* Save the remaining information in the pool control block.  */

   pool_ptr ->raw_block_pool_available =  blocks;

 

 

   pool_ptr ->raw_block_pool_available_list =  (RAW_U8  *) pool_start;

 

 

   return RAW_SUCCESS;

  }
  上面就是内存池的创建函数,入参共有五个参数,分别是mempool结构、名称、block大小、pool起始地址、pool大小。函数基本内容如下所示,   (1)判断内存池、指针参数合法性;   (2)检验指针是否n字节对齐,n取决于地址的大小;   (3)构建block链表,前后相连,最后一个block指向NULL指针;   (4)将pool首地址赋值给raw_block_pool_available_list,函数返回。 RAW_U16 raw_block_allocate(MEM_POOL *pool_ptr, RAW_VOID **block_ptr, RAW_U32 wait_option)

  {

  

   RAW_U16    status;       

 

   RAW_U8  *work_ptr;      

 

   RAW_SR_ALLOC();

 

   #if (RAW_BLOCK_FUNCTION_CHECK > 0)

  

   if (pool_ptr == 0) {

    return RAW_NULL_OBJECT;

   }

  

   if (block_ptr == 0) {

   

    return RAW_NULL_POINTER;

   }

 

   if (raw_int_nesting) {

 

    if (wait_option != RAW_NO_WAIT) {

    

     return RAW_NOT_CALLED_BY_ISR;

    }

   

   }

  

   #endif

 

   RAW_CRITICAL_ENTER();

 

   /* Determine if there is an available block.  */

   if (pool_ptr ->raw_block_pool_available) {

 

    /* Yes, a block is available.  Decrement the available count.  */

    pool_ptr ->raw_block_pool_available–;

 

    /* Pickup the current block pointer.  */

    work_ptr =  pool_ptr ->raw_block_pool_available_list;

 

    /* Return the first available block to the caller.  */

    *((RAW_U8 **)block_ptr) =  work_ptr;

 

    /* Modify the available list to point at the next block in the pool. */

    pool_ptr ->raw_block_pool_available_list = *((RAW_U8 **)work_ptr);

 

    /* Set status to success.  */

    status =  RAW_SUCCESS;

   }

 

   /*if no block memory is available then do it depend wait_option*/

   else {

   

    if (wait_option == RAW_NO_WAIT) {

     *((RAW_U8 **)block_ptr)     = 0;

     RAW_CRITICAL_EXIT();

     return RAW_NO_PEND_WAIT;

    }

 

    /*system is locked so task can not be blocked just return immediately*/

    if (raw_sched_lock) {

     *((RAW_U8 **)block_ptr)     = 0;

     RAW_CRITICAL_EXIT();

     return RAW_SCHED_DISABLE;  

    }

  

    raw_pend_object(&pool_ptr->common_block_obj, raw_task_active, wait_option);

 

    RAW_CRITICAL_EXIT();

 

    raw_sched();                                           

 

    RAW_CRITICAL_ENTER();

 

    *((RAW_U8 **)block_ptr)     = 0;

    status = block_state_post_process(raw_task_active, block_ptr);

   

    RAW_CRITICAL_EXIT();

 

   }

 

 

   return status;

 

  }

  和其他的内存池申请函数不一样,这里有一个wait_option选项。也就是说,如果当前没有合适的block,那么你可以选择等待处理。一旦别的线程释放内存,你就可以得到调度继续运行了。当然你也可以不等待,一旦寻找不到合适的block,立即返回为NULL。 RAW_U16 raw_block_release(MEM_POOL *pool_ptr, RAW_VOID *block_ptr)

  {

   LIST *block_list_head;

  

   RAW_U8        *work_ptr;           /* Working block pointer   */

   RAW_U8    need_schedule = 0;

  

   RAW_SR_ALLOC();

 

   #if (RAW_BLOCK_FUNCTION_CHECK > 0)

  

   if (block_ptr == 0) {

    return RAW_NULL_OBJECT;

   }

  

   if (pool_ptr == 0) {

   

    return RAW_NULL_OBJECT;

   }

  

   #endif

 

   block_list_head = &pool_ptr->common_block_obj.block_list;

  

   RAW_CRITICAL_ENTER();

  

   work_ptr =  ((RAW_U8 *) block_ptr);

  

   if (is_list_empty(block_list_head)) {      

 

    /* Put the block back in the available list.  */

    *((RAW_U8  **) work_ptr) =  pool_ptr ->raw_block_pool_available_list;

 

    /* Adjust the head pointer.  */

    pool_ptr ->raw_block_pool_available_list =  work_ptr;      

 

    /* Increment the count of available blocks.  */

    pool_ptr ->raw_block_pool_available++;

   }

 

   else {

   

    need_schedule = 1;

    wake_send_msg(list_entry(block_list_head->next, RAW_TASK_OBJ, task_list),  block_ptr);

 

   }

 

   RAW_CRITICAL_EXIT();

 

   if (need_schedule) {

    raw_sched();

   }

  

   /* Return completion status.  */

   return RAW_SUCCESS;

  }

    和其他的内存free函数不一样,这里的free函数多了一个wake_send_msg的功能。这也就是说,当然如果存在阻塞等待资源的线程,那么把资源送给该线程,同时把该线程唤醒,还要把need_schedule设置为1才可以。当然如果没有等待的线程,那么直接把内存插入到链表前面中即可,就是这么简单。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持小熊分享邦(www.xxfxb.com),希望大家能坚持软件测试之路,谢谢。

赞(0) 打赏
未经允许不得转载:小熊分享邦 » 嵌入式操作系统内核原理和开发(等值block内存池设计)| 小熊测试

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏