嵌入式操作系统内核原理和开发（最快、最优、最差内存分配算法）

前面我们说到了基于链表的内存分配算法。但是之前我们也说过，其实内存分配一般有三个原则，最快、最优和最差。最快比较好理解，就是寻找到合适的节点就立即分配内存，我们在前面一篇博客采用的就是这个方法。最优呢，就是寻找可以满足当前内存分配的最小节点，这样不会有很大的浪费，但是有可能会产生碎片节点。最后一种就是最差分配算法，说是最差效果未必最差。因为在大的内存分配的时候至少不会很快产生内存碎片，对整个系统的稳定来说有可能是好事。所以这三种方法很难说哪一种好，哪一种不好，需要结合具体的应用场景客观进行分析。不过话说回来，内存碎片是无论如何都避免不了的。

首先，为了灵活对这三种分配算法进行配置，我们定义了宏开关，需要哪个就把那个开关放开。暂时默认打开的算法的是最快分配算法。

#define MAX_SPEED_MALLOC   1
#define MIN_SIZE_MALLOC    0
#define MAX_SIZE_MALLOC    0

因为之前已经讨论过最快分配算法，所以这里着重讨论的最优分配算法和最差分配算法。又由于两者的差别极小，所以单独分析其中一种算法也行。就拿最优分配算法来说，为了寻找到最小的节点，我们需要对整个链表进行遍历，这个还是比较消耗时间的。

    while(pCur)
{
if(pCur->size > (size + sizeof(MNG_NODE)))
{
if(NULL == pFind || pFind->size > pCur->size)
{
pFind = pCur;
}
}
pPre = pCur;
pCur = pCur->next;
}

寻找到pFind这个我们需要的节点之后，还需要从pFreeList中删除该节点。所以，我们需要进一步的判断和分析，

    if(NULL == pFind)
return NULL;
pPre = find_previous_node_in_list(pFind, pFreeList);
if(NULL == pPre)
pFreeList = pFreeList->next;
else
pPre->next = pFind->next;
return pFind;

首先判断pFind前面有没有节点，如果没有表示pFreeList就是pFind，那么pFreeList需要自行向后退缩；当然如果当前的pFind节点是有前节点的，那么只需要把前节点的next指针重新更改一下即可。当然，这里还对原来的查找节点函数作了一下修改，使之更合理更通用。

/*************************************************
* function: find previous node
**************************************************/
MNG_NODE* find_previous_node_in_list(MNG_NODE* pNode, MNG_NODE* pList)
{
MNG_NODE* pFind = pList;
MNG_NODE* pPre = NULL;
while(pFind && pFind != pNode)
{
pPre = pFind;
pFind = pFind->next;
}
if(NULL == pFind)
return NULL;
return pPre;
}

上面也只是说了个大概，具体的内容可以参见下面的源代码。既可以在VC上编译，也可以在GCC上面编译，都没有问题。当然，如果本地os没有编译器，可以选择网上在线编译，也是个不错的选择。

/*************************************************
*      malloc & free in link node algorithm
**************************************************/
#include <string.h>
#include <malloc.h>
/*************************************************
*           struct definition
**************************************************/
typedef struct _MNG_NODE
{
struct _MNG_NODE* next;
unsigned int size;
}MNG_NODE;
/*************************************************
*          macro declaration
**************************************************/
#define MAX_SPEED_MALLOC   1
#define MIN_SIZE_MALLOC    0
#define MAX_SIZE_MALLOC    0
#define MEM_BUFFER_LENGTH   (0x1 << 24)
/*************************************************
*           global variable declaration
**************************************************/
static void* pGlbData;
static MNG_NODE* pFreeList;
static MNG_NODE* pAllocList;
/*************************************************
*           function declaration
**************************************************/
MNG_NODE* find_previous_node_in_list(MNG_NODE* pNode, MNG_NODE* pList);
/*************************************************
* function: add node into headlist
**************************************************/
static void add_node_into_list_head(MNG_NODE* pNode, MNG_NODE** ppList)
{
pNode->next = *ppList;
*ppList = pNode;
}
#if MAX_SPEED_MALLOC
/*************************************************
* function: find best fit node in max_speed
**************************************************/
static MNG_NODE* find_best_fit_node(unsigned int size)
{
MNG_NODE* pFind = pFreeList;
MNG_NODE* pPre = pFind;
while(pFind && pFind->size < (size + sizeof(MNG_NODE)))
{
pPre = pFind;
pFind = pFind->next;
}
if(NULL == pFind)
return NULL;
if(pFreeList == pFind)
pFreeList = pFreeList->next;
else
pPre->next = pFind->next;
return pFind;
}
#endif
#if MIN_SIZE_MALLOC
/*************************************************
* function: find best fit node in min size
**************************************************/
MNG_NODE* find_best_fit_node(unsigned int size)
{
MNG_NODE* pCur = pFreeList;
MNG_NODE* pPre = pCur;
MNG_NODE* pFind = NULL;
while(pCur)
{
if(pCur->size > (size + sizeof(MNG_NODE)))
{
if(NULL == pFind || pFind->size > pCur->size)
{
pFind = pCur;
}
}
pPre = pCur;
pCur = pCur->next;
}
if(NULL == pFind)
return NULL;
pPre = find_previous_node_in_list(pFind, pFreeList);
if(NULL == pPre)
pFreeList = pFreeList->next;
else
pPre->next = pFind->next;
return pFind;
}
#endif
#if MAX_SIZE_MALLOC
/*************************************************
* function: find best fit node in max size
**************************************************/
MNG_NODE* find_best_fit_node(unsigned int size)
{
MNG_NODE* pCur = pFreeList;
MNG_NODE* pPre = pCur;
MNG_NODE* pFind = NULL;
while(pCur)
{
if(pCur->size > (size + sizeof(MNG_NODE)))
{
if(NULL == pFind || pFind->size < pCur->size)
{
pFind = pCur;
}
}
pPre = pCur;
pCur = pCur->next;
}
if(NULL == pFind)
return NULL;
pPre = find_previous_node_in_list(pFind, pFreeList);
if(NULL == pPre)
pFreeList = pFreeList->next;
else
pPre->next = pFind->next;
return pFind;
}
#endif
/*************************************************
* function: implement memory allocation
**************************************************/
static void* _mem_malloc(unsigned int size)
{
MNG_NODE* pOld;
MNG_NODE* pNew;
pOld = find_best_fit_node(size);
if(NULL == pOld)
return NULL;
pNew = (MNG_NODE*)((char*)pOld + sizeof(MNG_NODE) + pOld->size - (sizeof(MNG_NODE) + size));
pNew->size = size;
pOld->size -= sizeof(MNG_NODE) + size;
add_node_into_list_head(pOld, &pFreeList);
add_node_into_list_head(pNew, &pAllocList);
return (void*)((char*)pNew + sizeof(MNG_NODE));
}
/*************************************************
* function: memory allocation
**************************************************/
void* mem_malloc(unsigned int size)
{
if(0 == size)
return NULL;
if(size > (MEM_BUFFER_LENGTH - sizeof(MNG_NODE)))
return NULL;
return _mem_malloc(size);
}
/*************************************************
* function: find previous node
**************************************************/
MNG_NODE* find_previous_node_in_list(MNG_NODE* pNode, MNG_NODE* pList)
{
MNG_NODE* pFind = pList;
MNG_NODE* pPre = NULL;
while(pFind && pFind != pNode)
{
pPre = pFind;
pFind = pFind->next;
}
if(NULL == pFind)
return NULL;
return pPre;
}
/*************************************************
* function: implement memory free
**************************************************/
static void _mem_free(MNG_NODE* pNode)
{
MNG_NODE* pPreNode;
if(pNode == pAllocList)
{
pAllocList = pAllocList->next;
add_node_into_list_head(pNode, &pFreeList);
return;
}
pPreNode = find_previous_node_in_list(pNode, pAllocList);
if(NULL == pPreNode)
return;
pPreNode->next = pNode->next;
add_node_into_list_head(pNode, &pFreeList);
return;
}
/*************************************************
* function: free memory function
**************************************************/
void mem_free(void* pData)
{
if(NULL == pData)
return;
if(pData < pGlbData || pData >= (void*)((char*)pGlbData + MEM_BUFFER_LENGTH))
return;
_mem_free((MNG_NODE*)((char*)pData - sizeof(MNG_NODE)));
}
/*************************************************
* function: get memory buffer
**************************************************/
void mem_init()
{
pGlbData = (void*)malloc(MEM_BUFFER_LENGTH);
if(NULL == pGlbData)
return;
memset(pGlbData, 0, MEM_BUFFER_LENGTH);
pFreeList = (MNG_NODE*)pGlbData;
pFreeList->size = MEM_BUFFER_LENGTH - sizeof(MNG_NODE);
pAllocList = NULL;
}
/*************************************************
* function: free memory buffer
**************************************************/
void mem_exit()
{
if(NULL != pGlbData)
free(pGlbData);
pFreeList = NULL;
pAllocList = NULL;
}
/*************************************************
* function: file starts here
**************************************************/
int main(int argc, char* argv[])
{
mem_init();
mem_exit();
return 1;
}

嵌入式操作系统内核原理和开发（最快、最优、最差内存分配算法）相关推荐

嵌入式操作系统内核原理和开发
嵌入式操作系统内核原理和开发(开篇) 操作系统是很多人每天必须打交道的东西,因为在你打开电脑的一刹那,随着bios自检结束,你的windows系统已经开始运行了.如果问大家操作系统是什么?可能有的人会 ...

嵌入式操作系统内核原理和开发（最快、最优、最差内存分配算法）

嵌入式操作系统内核原理和开发（最快、最优、最差内存分配算法）相关推荐

最新文章

热门文章