嵌入式操作系统内核原理和开发（等值block内存池设计）

  【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】 
 
     内存池设计是嵌入式系统的一个重要环节，之前我们也讨论过相关的内容。但是，看了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_U16status;     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才可以。当然如果没有等待的线程，那么直接把内存插入到链表前面中即可，就是这么简单。