UC/OS-II的内存管理OSMemCreate()分析

我们在写应用程序的过程中通常都是采用一个malloc/free系列函数进行内存的管理，这样分配的内存空间是从应用程序的栈空间分配处理，一般而言我们在写程序的过程中要对内存空间进行适时的释放，才不至于导致栈空间的不足，当然这样也会导致内存垃圾的产生，因为不同大小的内存分配因为对齐等原因导致很多的内存不能再使用，进而使得系统的可用内存越来越小，因此在实时操作系统中通常都需要创建自己的内存管理操作。

uc/os-II中的内存管理主要是采用内存分区控制块实现的，具体的实现过程如下：

 

点击(此处)折叠或打开

1. /*
2.     关于内存控制块的结构体，
3.     用来跟踪每一个内存分区
4.     每一个分区可以分成很多个小的内存块
5.     每一个内存块的大小都是相同的
6. */
7. #if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)
8. typedef struct { /* MEMORY CONTROL BLOCK */
9.     /*内存的起始地址*/
10.     void *OSMemAddr; /* Pointer to beginning of memory partition */
11.     /*
12.         链表指针，
13.         能够快速的实现内存的控制
14.     */
15.     void *OSMemFreeList; /* Pointer to list of free memory blocks */
16.     /*每一个内存块的大小*/
17.     INT32U OSMemBlkSize; /* Size (in bytes) of each block of memory */
18.     /*存在的内存块数量*/
19.     INT32U OSMemNBlks; /* Total number of blocks in this partition */
20.     /*空闲的内存空间*/
21.     INT32U OSMemNFree; /* Number of memory blocks remaining in this partition */
22. } OS_MEM;

基本的实现思想就是将内存分区分解成很多的大小相同的内存块，然后OSMemFreeList将所有的内存块链接起来，但是此处的链接与我们常用的链表存在一定的差别，这也是内存管理中常用的技巧之一，即在当前块的起始地址处存放下一个内存块的地址，这样就能比较快速的实现内存的管理。在uc/os-II的内存管理代码的OS_MEM  *OSMemCreate (void *addr, INT32U nblks, INT32U blksize, INT8U *err)函数中存在一些代码难点。特别是强制类型转换的使用，在uc/os-II中我们看见了大量的强制类型转换问题，下面就做一下简要的分析：

点击(此处)折叠或打开

1. OS_MEM *OSMemCreate (void *addr, INT32U nblks, INT32U blksize, INT8U *err)
2. {
3. #if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */
4.     OS_CPU_SR cpu_sr;
5. #endif 
6.     OS_MEM *pmem;
7.     INT8U *pblk;
8.     void **plink;
9.     INT32U i;
10.  
11. /*检测参数的正确性*/
12. #if OS_ARG_CHK_EN > 0
13.     if (addr == (void *)0) { /* Must pass a valid address for the memory part. */
14.         *err = OS_MEM_INVALID_ADDR;
15.         return ((OS_MEM *)0);
16.     }
17.     if (nblks < 2) { /* Must have at least 2 blocks per partition */
18.         *err = OS_MEM_INVALID_BLKS;
19.         return ((OS_MEM *)0);
20.     }
21.     if (blksize < sizeof(void *)) { /* Must contain space for at least a pointer */
22.         *err = OS_MEM_INVALID_SIZE;
23.         return ((OS_MEM *)0);
24.     }
25. #endif
26.     
27.     OS_ENTER_CRITICAL();
28.     /*得到空闲的内存控制块*/
29.     pmem = OSMemFreeList;                              /* Get next free memory partition */
30.     /*更新内存控制块链表*/
31.     if (OSMemFreeList != (OS_MEM *)0) { /* See if pool of free partitions was empty */
32.         OSMemFreeList = (OS_MEM *)OSMemFreeList->OSMemFreeList;
33.     }
34.     OS_EXIT_CRITICAL();
35.     if (pmem == (OS_MEM *)0) { /* See if we have a memory partition */
36.         *err = OS_MEM_INVALID_PART;
37.         return ((OS_MEM *)0);
38.     }
39.     /*
40.         将一个分区的各个内存小块链接起来，
41.         形成一个链表
42.     */
43.     plink = (void **)addr; /* Create linked list of free memory blocks */
44.     /*得到一个固定的*/
45.     pblk = (INT8U *)addr + blksize;
46.     for (i = 0; i < (nblks - 1); i++) {
47.         /*在当前的地址处保存下一个内存块的地址*/
48.         *plink = (void *)pblk;
49.         /*将指针指向下一个内存块*/
50.         plink = (void **)pblk;
51.         /*得到第三个内存块的地址*/
52.         pblk = pblk + blksize;
53.     }
54.     /*
55.         将最后一个内存块的下一个地址设置为NULL；
56.     */
57.     *plink = (void *)0; /* Last memory block points to NULL */
58.     /*得到内存分区的起始地址*/
59.     pmem->OSMemAddr = addr; /* Store start address of memory partition */
60.     /*
61.         将内存块的链表头指向当前地址
62.         通过链表能够快速的找到下一个内存块的地址
63.         只需要对链表取地址，
64.         然后将指针指向该地址就能实现快速的切换
65.     */
66.     pmem->OSMemFreeList = addr; /* Initialize pointer to pool of free blocks */
67.     /*空闲的内存块*/
68.     pmem->OSMemNFree = nblks; /* Store number of free blocks in MCB */
69.     /*内存的总块数*/
70.     pmem->OSMemNBlks = nblks;
71.     /*内存块的大小*/
72.     pmem->OSMemBlkSize = blksize; /* Store block size of each memory blocks */
73.     *err = OS_NO_ERR;
74.     return (pmem);
75. }

上面的代码大致的意思就是完成内存块的链接以及内存分区控制单元的初始化操作，但是有几句代码存在一定的理解难度。

点击(此处)折叠或打开

1. plink = (void **)addr; /* Create linked list of free memory blocks */
2.     pblk = (INT8U *)addr + blksize;
3.     for (i = 0; i < (nblks - 1); i++) {
4.         *plink = (void *)pblk;
5.         plink = (void **)pblk;
6.         pblk = pblk + blksize;
7.     }
8.     *plink = (void *)0; /* Last memory block points to NULL */

下面几句代码中存在大量的强制类型转换，我们一句一句的分析，plink = (void **)addr的意思是将传递进来的地址强制转换，原因是因为plink是一个存储在函数栈中的变量，它指向了addr指向的地址，而该地址处将来存储的也是一个地址，因此可以看做二维指针，而addr只是一维指针，因此需要强制类型转换为二维指针。

引用：在声明的时候，plink是二维指针，在这里将addr强制的转换成二维指针再赋值给plink的原因是：让addr以前指向的内容让编译器解释成地址，也就是一个指针，如果不做这个强制转换，以前addr指向的内容就不是一个地址，也就是不是指针，在这个函数当中，我们想把addr指向的二维数组，分割成大小相同的若干块，就必须用指针把它们链接起来，所以将addr强制转换成二维指针，然后赋值给plink，然后让plink去执行连接的操作，也就是在以前addr指向的地方放上指针；plink本身是存放在栈上的，plink这个符号的值是指向addr的，*plink就是取plink指向地址单元的内容，而plink指向地址单元的内容是一个地址，即是一个指针，plink指向地址单元的内容也就是addr指向地址单元的内容，但由于addr是一维指针，所以它指向的内容不会被解释成一个地址，而是一般的内容。现在*plink就是把addr所在存储单元的内容解释成一个指针，并且将下一个block的首地址赋值给此存储单元，理解了这点就可以理解下面的源代码了，同时对C里面指针的概念又有了进一步的认识。http://blog.csdn.net/uestczhangchao/article/details/5589476

pblk = (INT8U *)addr + blksize;这句代码其中暗含了我们对指针加减操作的基本理解，因为在uc/OS-II中是按照字节作为内存块分布的，所以进行了INT8U*的强制类型转换，因为只有这样才能保证addr + blksize的操作是增加多少个字节的数据。因为C语言中指针的加减是与其指向的类型的内存空间密切相关的，比如int * p = 0; p ++;此时的p = 4；而当char *p = 0; p ++; 此时的p = 1；这就说明了指针的加减必须注意数据的类型，而不能直接对void*类型的指针进行加减操作。

*plink = (void *)pblk;因为plink是一个栈中变量，而对plink取进行解引用，实际上就是得到addr的值，但是*plink是一个地址，还是一个指针，因此需要强制类型转换。

plink = (void **)pblk;上面的代码已经分析。

基本的思想就是需要注意常数转换为指针的方式方法：int* p = (int *)0x45342341;int **p = (int **)0x45342341;指针的引入主要就是为了解决内存问题，因此对内存的管理直接体现了对指针的理解深度。