Keil自带的操作系统RTX内核---内存管理分析

       Keil RTX 是免版税的确定性实时操作系统，适用于 ARM 和 Cortex-M 设备。使用该系统可以创建同时执行多个功能的程序，并有助于创建结构更好且维护更加轻松的应用程序。关于Keil  RTX就不多说了，使用KEil软件作为开发的用到RTX的不少吧。

      RTX系统配合KeilMDK软件使用起来还是比较简单的，开发也很方便。RTX系统中的各个模块都是比较独立的，这点很方便学习。其中的内存管理部分在rt_MemBox.c函数中。RTX的动态内存管理，其实就是事先分配了一个全局变量的大数组，只不过把这部分连续内存用指针链表的形式加以灵活管理。可以把RTX这部分内存管理代码摘出来单独为以后自己的应用使用。

看一下代码中的宏两个宏

/* Memory pool for TCB allocation    */

_declare_box (mp_tcb, OS_TCB_SIZE, OS_TASKCNT);

U16 const mp_tcb_size = sizeof(mp_tcb);

/* Memory pool for System stack allocation (+ os_idle_demon). */

_declare_box8 (mp_stk, OS_STKSIZE*4, OS_TASKCNT-OS_PRIVCNT+1);

其中的任务控制块mp_tcb和堆栈mp_stk都用到了动态内存管理。因为这样管理起来很方便，比如创建任务和删除任务，要是用数组的话，你必须知道现在处于哪个索引位置，添加任务和删除任务时又处于数组的哪个索引位置。有这种链表的方式，就无需关心这些。

找到这个宏的定义出，就看到了它的真面目，分配了一个大数组，叫它内存池吧。

#define BOX_ALIGN_8                   0x80000000

#define _declare_box(pool,size,cnt)   U32 pool[(((size)+3)/4)*(cnt) + 3]

#define _declare_box8(pool,size,cnt)  U64 pool[(((size)+7)/8)*(cnt) + 2]

#define _init_box8(pool,size,bsize)   _init_box (pool,size,(bsize) | BOX_ALIGN_8)

/* Variables */

extern U32 mp_tcb[];

extern U64 mp_stk[];

extern U32 os_fifo[];

extern void *os_active_TCB[];

至于#define BOX_ALIGN_8                   0x80000000,这涉及到对齐，

对齐难免造成内存资源浪费，但是也给操作增加了方便，至少访问不会出错吧。

mp_tcb和mp_stk定义了数组的地址，和*mp_tcb差不多吧，但是两者却是有区别的，数组名不等于指针，举个简单例子说，指针变量可以任意给其赋值，但是数组名，能给它赋一个另一个地址吗？数组名指向的地址是确定的。指针是一个变量，变量的值是另外一个变量的地址。那么，既然指针是变量，那么指针必然有自己的存储空间，只不过是该存储空间内的值是一个地址值，而不是别的内容。定义指针是要占一个空间的，因为它是个变量，定义成mp_tcb[]实际是不占空间的。数组名只是一个符号。它们取指运算的效果相同但是不是相等。可以把数组名看做常量指针吧，只是看做但并不是。

使用RTX的内存管理模块之前，先是要定义一个大数组分配内存池，然后就是初始化了。把各个小分区链接起来。

看一下链接用的链表结构：

typedef
struct OS_BM {

  void *free;                     /* Pointer to first free memory block      */

  void *end;                      /* Pointer to memory block end             */

  U32  blk_size;                  /* Memory block size                       */

} *P_BM;

就是这么个双向链表，把小块的内存链接起来，共用一个内存池。

/*---------------------------
_init_box -------------------------------------*/

int  _init_box  (void *box_mem, U32 box_size, U32 blk_size) 

{

  /* Initialize memory block system, returns 0 if OK, 1 if fails. */

  void *end;

  void *blk;

  void *next;

  U32  sizeof_bm;

  /* Create memory structure. */

  if (blk_size & BOX_ALIGN_8) {

    /* Memory blocks 8-byte aligned. */ 

    blk_size = ((blk_size & ~BOX_ALIGN_8) + 7) & ~7;

    sizeof_bm = (sizeof (struct OS_BM) + 7) & ~7;

  }

  else {

    /* Memory blocks 4-byte aligned. */

    blk_size = (blk_size + 3) & ~3;

    sizeof_bm = sizeof (struct OS_BM);

  }

  if (blk_size == 0) {

    return (1);

  }

  if ((blk_size + sizeof_bm) > box_size) {

    return (1);

  }

  /* Create a Memory structure. */

  blk = ((U8 *) box_mem) + sizeof_bm;

  ((P_BM) box_mem)->free = blk;

  end = ((U8 *) box_mem) + box_size;

  ((P_BM) box_mem)->end      = end;

  ((P_BM) box_mem)->blk_size = blk_size;

  /* Link all free blocks using offsets. */

  end = ((U8 *) end) - blk_size;

  while (1)  {

    next = ((U8 *) blk) + blk_size;

    if (next > end)  break;

    *((void **)blk) = next;

    blk = next;

  }

  /* end marker */

  *((void **)blk) = 0;

  return (0);

}

至于函数中的(blk_size
+ 3) & ~3;是做什么用的，看注释就知道了，对齐用的。可以把这个代码摘出来调试一下，

确实是这样，不管你定义的任务控制快是多大，是否是4字节的倍数，通过(blk_size
+ 3) & ~3;，最终的大小肯定

是4的倍数。

看下这个调用：

 rt_init_box
(&mp_tcb, mp_tcb_size, sizeof(struct OS_TCB));

U16
const mp_tcb_size = sizeof(mp_tcb);

OS_TCB是任务控制块的结构体，他的大小并不一定是4的倍数，但是经过(blk_size
+ 3) & ~3;最终每个分配的大小都是4的倍数。

mp_tcb_size肯定也是4的倍数，因为sizeof(mp_tcb)取出来的大小是结构体自动内存对齐过的。

接下来就是内存分配的，其实就是链表的插入与删除操作罢了。

/*--------------------------- rt_alloc_box ----------------------------------*/

void *rt_alloc_box (void *box_mem) {

  /* Allocate a memory block and return start address. */

  void **free;

  int  irq_dis;

  irq_dis = __disable_irq ();

  free = ((P_BM) box_mem)->free;

  if (free) {

    ((P_BM) box_mem)->free = *free;

  }

  if (!irq_dis) __enable_irq ();

  return (free);

}

/*--------------------------- _calloc_box -----------------------------------*/

void *_calloc_box (void *box_mem)  {

  /* Allocate a 0-initialized memory block and return start address. */

  void *free;

  U32 *p;

  U32 i;

  free = _alloc_box (box_mem);

  if (free)  {

    p = free;

    for (i = ((P_BM) box_mem)->blk_size; i; i -= 4)  {

      *p = 0;

      p++;

    }

  }

  return (free);

}

/*--------------------------- rt_free_box -----------------------------------*/

int rt_free_box (void *box_mem, void *box) {

  /* Free a memory block, returns 0 if OK, 1 if box does not belong to box_mem */

  int irq_dis;

  if (box < box_mem || box > ((P_BM) box_mem)->end) {

    return (1);

  }

  irq_dis = __disable_irq ();

  *((void **)box) = ((P_BM) box_mem)->free;

  ((P_BM) box_mem)->free = box;

  if (!irq_dis) __enable_irq ();

  return (0);

}

Keil的RTX内核关于内存管理的就这些了，很少很独立吧。比较简单，这块可以单独摘出来为自己学习和使用。

包括Linux源码中的双向循环链表，也是很经典很不错的，实际上都可以单独摘出来，，说不定哪天的项目中就可以用上了。