mem.cpp

题目：扩展的动态内存管理机制 目的：在了解实时嵌入式操作系统内存管理机制的特点以及实时处理对内存管理需求的基础上

#include "vxWorks.h"
#include "msgQLib.h"
#include "stdio.h"
#include "taskLib.h"
#include "string.h"
#include "semLib.h"
#include "sysLib.h"
#include "stdlib.h"
#include "memPartLib.h"
#define STACK_SIZE 1024
/*定义结构体pool poolHead blockHead*/
typedef struct _blockHead
{
	int poolId;
	struct _blockHead* frontBlock;
}blockHead;

typedef struct _poolHead
{
	int available;
	int blockSize;
	struct _poolHead* next;
	blockHead* firstavailable;
}poolHead;

typedef struct _pool
{
	int poolNum;
	poolHead* pool;
}pool;
/*全局变量*/
SEM_ID semMalloc;
SEM_ID semFree;

blockHead sysMalloc;
pool* initialPtr;
blockHead* mallocPtr=&sysMalloc;

int thetask1;
int thetask2;
/*函数声明*/
pool* initial(void);
void* memMalloc(int neededSize);
void memFree(void* dataPtr);
void memDel(void);
void task1(void);
void task2(void);
void progStart(void);
void progStop(void);


/*initial()  初始化内存池*/
pool* initial(void)
{
	int i;
	pool* mem;
	pool* poolPtr;
	poolHead* poolHeadPtr;
	blockHead* blocHeadkPtr;

	mem=(pool*)malloc(6000);/*分配6000内存作为内存池*/
 
/*初始化pool*/
	poolPtr = (pool*)mem;
	poolPtr->poolNum = 2;
	poolPtr->pool = (poolHead*)((char*)mem + sizeof(pool));
        
/*初始化pool 1  该内存池分配大小为16B的内存*/
	poolHeadPtr = (poolHead*)((char*)mem + sizeof(pool));
	poolHeadPtr->available = 20;
	poolHeadPtr->blockSize = 16;

	blocHeadkPtr = (blockHead*)((char*)poolHeadPtr+sizeof(poolHead));	

	poolHeadPtr->firstavailable = blocHeadkPtr;
	poolHeadPtr->next= (poolHead*)((char*)poolHeadPtr + sizeof(poolHeadPtr) + 20*(sizeof(blockHead)+16));
        
	blocHeadkPtr->poolId =1;
	blocHeadkPtr->frontBlock = 0;
        
	for(i=1;i<20;i++)
	{
		blocHeadkPtr=(blockHead*)((char*)blocHeadkPtr + (sizeof(blockHead)+16));
		blocHeadkPtr->poolId = 1;
		blocHeadkPtr->frontBlock = poolHeadPtr->firstavailable;
		poolHeadPtr->firstavailable = blocHeadkPtr;
	}
/*初始化pool 2 该内存池分配大小为256B的内存*/
	poolHeadPtr = poolHeadPtr->next;
	poolHeadPtr->available = 20;
	poolHeadPtr->blockSize = 256;

	blocHeadkPtr = (blockHead*)((char*)poolHeadPtr+sizeof(poolHead));	

	poolHeadPtr->firstavailable = blocHeadkPtr;
	poolHeadPtr->next = 0;

	blocHeadkPtr->poolId =2;
	blocHeadkPtr->frontBlock = 0;

	for(i=1;i<20;i++)
	{
		blocHeadkPtr=(blockHead*)((char*)blocHeadkPtr + (sizeof(blockHead)+256));
		blocHeadkPtr->poolId = 2;
		blocHeadkPtr->frontBlock = poolHeadPtr->firstavailable;
		poolHeadPtr->firstavailable = blocHeadkPtr;
	}
		
	return (pool*)mem;
}


/*memMalloc() 分配内存*/
void* memMalloc(int Size)
{
	void* mem;
	poolHead* poolHeadPtr;
	blockHead* blocHeadkPtr;

	semTake(semMalloc,WAIT_FOREVER);

	poolHeadPtr = initialPtr->pool;

	if((Size <= 16)&&(poolHeadPtr->available != 0))   /*长度小于16时，分配长度为16的内存空间*/
	{
		blocHeadkPtr = poolHeadPtr->firstavailable;
		poolHeadPtr->firstavailable = blocHeadkPtr->frontBlock;
		poolHeadPtr->available --; 
		semGive(semMalloc);
               	
		return (void*)((char*)blocHeadkPtr + sizeof(blockHead));
	}
	else if((Size <= 256)&&((poolHeadPtr->next)->available  != 0))  
		/*长度大于16小于256时，分配长度为256的内存空间*/
	{
		blocHeadkPtr = (poolHeadPtr->next)->firstavailable;
		(poolHeadPtr->next)->firstavailable = blocHeadkPtr->frontBlock;
		(poolHeadPtr->next)->available --; 
		semGive(semMalloc);
		return (void*)((char*)blocHeadkPtr + sizeof(blockHead));
	}
	else		/*其他情况用系统的内存分配函数malloc分配*/
	{
		printf("\n[Warning] : Too large for blocks or the blocks  are exhausted \n");
		mem = malloc(Size+sizeof(blockHead));
		blocHeadkPtr = (blockHead*)mem;
		blocHeadkPtr->poolId = (initialPtr->poolNum +1);
		blocHeadkPtr->frontBlock = mallocPtr;
		mallocPtr = blocHeadkPtr;	
		semGive(semMalloc);
		return (void*)((char*)blocHeadkPtr + sizeof(blockHead));
	}
}
/*memFree() 释放内存空间*/
void memFree(void* dataPtr)
{
	char* mem= (char*) dataPtr;
	poolHead* poolHeadPtr;
	blockHead* blocHeadkPtr;

	semTake(semFree,WAIT_FOREVER);
	
	poolHeadPtr = initialPtr->pool;
	blocHeadkPtr = (blockHead*)((char*)mem - sizeof(blockHead));

	if(blocHeadkPtr->poolId == 1)  /*释放16B的内存块*/
	{
		blocHeadkPtr->frontBlock = poolHeadPtr->firstavailable;
		poolHeadPtr->firstavailable = blocHeadkPtr;
		poolHeadPtr->available++;
	}
	else if(blocHeadkPtr->poolId == 2)/*释放256B的内存块*/
	{
		blocHeadkPtr->frontBlock = (poolHeadPtr->next)->firstavailable;
		(poolHeadPtr->next)->firstavailable = blocHeadkPtr;
		(poolHeadPtr->next)->available ++;
	}
	else  /*释放由系统分配的内存块*/
	{
		blocHeadkPtr = mallocPtr;
		mallocPtr = blocHeadkPtr->frontBlock;
		free((char*)mem - sizeof(blockHead));
	}

	semGive(semFree);
	
	return;
}
/*memDel()删除内存块*/
void memDel(void)
{
	void* mem;
	blockHead* blocHeadkPtr;
	mem = (void*)(initialPtr);
	free(mem);

	while(mallocPtr->frontBlock != 0)
	{
		mem = (void*)(mallocPtr);
		free(mem);
		mallocPtr=mallocPtr->frontBlock ;
	}

	semDelete(semMalloc);
	semDelete(semFree);
}


/*主程序*/
void progStart(void)
{


        
	thetask1=taskSpawn("tTask1",200,0,STACK_SIZE,(FUNCPTR)task1,0,0,0,0,0,0,0,0,0,0);
        thetask2=taskSpawn("tTask2",220,0,STACK_SIZE,(FUNCPTR)task2,0,0,0,0,0,0,0,0,0,0);
	return;
}

/*测试程序*/
void task1(void)
{
	semMalloc= semBCreate(SEM_Q_PRIORITY,SEM_FULL);
	semFree	 = semBCreate(SEM_Q_PRIORITY,SEM_FULL);
}

void task2(void)

 {
	mallocPtr->frontBlock = 0;
	initialPtr = initial();
        char* add[10];
        int i, size[8] = {44, 55, 54, 76 ,11, 5, 4, 666};
	for(int i=0;i<8;i++)
	{	
		add[i] = (char*)memMalloc(size[i]);/*分配内存，检查内存块分配情况*/
	        poolHead* poolHeadPtr;
	        poolHeadPtr=initialPtr->pool;
                
		printf("task malloc size:%d",size[i]);
		printf("\n[pool 1](16B) : available block in pool is : %d \n",poolHeadPtr->available);
		printf("[pool 2](256B) : available block in pool is : %d\n",(poolHeadPtr->next)->available);
		if (size[i]<=16)
                printf("The Address is:%08x  (use size is:16+8)\n\n",add[i]);
                else if (size[i]<=256)
                printf("The Address is:%08x  (use size is:256+8)\n\n",add[i]);
                else 
                printf("system malloc \n\n");
	}
	taskDelay(10);
	for(int i=0;i<8;i++)
	{	
               
		memFree((void*)add[i]); /*释放内存，检查内存块分配情况*/
                poolHead* poolHeadPtr;
	        poolHeadPtr=initialPtr->pool;
		taskDelay(50);
		printf(" free size:%d",size[i]);
                printf("\n[pool 1](16B) : available block in pool is : %d\n",poolHeadPtr->available );		
                printf("[pool 2](256B) : available block in pool is : %d\n",(poolHeadPtr->next)->available);
		if (size[i]<=16)
                printf("The Address is:%08x  (free size is:16+8)\n\n",add[i]);
                else if (size[i]<=256)
                printf("The Address is:%08x  (free size is:256+8)\n\n",add[i]);
                else 
                printf("system free  \n\n");
	}
	return;
}
void progStop(void)
{
	taskDelete(thetask1);
        taskDelete(thetask2);
	memDel();
}