memory_management.cpp

扩展的动态内存机制 任务综述 本任务扩展了自己私有的内存管理机制。首先使用预先规划的思想

						printf("\n");
				}
				/* 剩下的部分在256内存池中申请 */
				printf("\n256_buffer address:\n");
				for(int j = 0; j < b256_num; ++j)
				{
					/* 从消息队列中接收内存块地址 */
					if(msgQReceive(msgQId_pool256,(char*)&pBuff256_rc,sizeof(PBUFFER),WAIT_FOREVER)==ERROR)
					{
						return(ERROR);
					}
					/* 将已分配地址保存并输出 */
					pbuf256_store[buf_256_num] = pBuff256_rc.buffer;
					printf("0x%07x\t",pbuf256_store[buf_256_num]);
					++buf_256_num;
					if((j + 1) % 5 == 0)
						printf("\n");
				}
				/* 内存不足告警提示信息 */
				if(msgQNumMsgs(msgQId_pool256) <= 3)
				{
					printf("\nCAUTION:You got %d 256_buffer left.\n",msgQNumMsgs(msgQId_pool256));
				}

		/* 如果需要分配的内存块个数大于当前16内存池和256内存池中未分配 */
		/* 内存总数之和,则在静态内存池外的系统内存池中申请	*/
		} else if(alloc_num > msgQNumMsgs(msgQId_pool16) + msgQNumMsgs(msgQId_pool256) && alloc_num < MAX_ALLOC_NUM) {
			printf("CAUTION:Too many buffers to alloc in Buffer Pool.\nAlloc in System Memory Pool\n");
			for(int i = 0; i < alloc_num; ++i)
			{
				semTake(semId, WAIT_FOREVER);			/* 互斥信号量 */
				pbufsys_store[buf_sys_num] = (char*)malloc(alloc_buf_size);
				semGive(semId);

				/* 将已分配地址保存并输出 */
				printf("0x%07x\t",pbufsys_store[buf_sys_num]);
				++buf_sys_num;
				if((i + 1) % 5 == 0)
					printf("\n");
			}
		} else {
			printf("ERROR: Please Input a valid number.\n");		
		}

	/* 2.如果申请内存块大小大于16小于256 */
	} else if(alloc_buf_size > 16 && alloc_buf_size <= 256) {

		/* 如果需要分配的内存块个数小于当前256内存池未分配内存块的个数, */
		/* 直接在256内存池中申请 */
		if(alloc_num > 0 && alloc_num <= msgQNumMsgs(msgQId_pool256))
		{
			for(int i = 0; i < alloc_num; ++i)
			{
				/* 从消息队列中接收内存块地址 */
				if(msgQReceive(msgQId_pool256,(char*)&pBuff256_rc,sizeof(PBUFFER),WAIT_FOREVER)==ERROR)
				{
					return(ERROR);
				}

				/* 将已分配地址保存并输出 */
				pbuf256_store[buf_256_num] = pBuff256_rc.buffer;
				printf("0x%07x\t",pbuf256_store[buf_256_num]);
				++buf_256_num;
				if((i + 1) % 5 == 0)
					printf("\n");
			}

			if(msgQNumMsgs(msgQId_pool256) <= 3)
			{
				printf("\nCAUTION:You got %d 256_buffer left.\n",msgQNumMsgs(msgQId_pool256));
			}

		/* 如果需要分配的内存块个数大于当前256内存池未分配内存块的个数, */
		/* 则直接在系统内存池中申请 */
		} else if(alloc_num > msgQNumMsgs(msgQId_pool256) && alloc_num < MAX_ALLOC_NUM) {
			printf("CAUTION:Too many buffers to alloc in Buffer Pool.\nAlloc in System Memory Pool.\n");
			for(int i = 0; i < alloc_num; ++i)
			{
				semTake(semId, WAIT_FOREVER);			/* 互斥信号量 */
				pbufsys_store[buf_sys_num] = (char*)malloc(alloc_buf_size);
				semGive(semId);

				/* 将已分配地址保存并输出 */
				printf("0x%07x\t",pbufsys_store[buf_sys_num]);
				++buf_sys_num;
				if((i + 1) % 5 == 0)
					printf("\n");
			}
		} else {
			printf("ERROR: Please Input a valid number.\n");	
		}

	/* 3.如果申请内存块大小大于256 */
	/* 直接在系统内存池中申请	   */
	} else if(alloc_buf_size > 256 && alloc_buf_size < 10000) {
		
		if(alloc_num > 0 && alloc_num < MAX_ALLOC_NUM)
		{
			for(int i = 0; i < alloc_num; ++i)
			{
				pbufsys_store[buf_sys_num] = (char*)malloc(alloc_buf_size);
				printf("0x%07x\t",pbufsys_store[buf_sys_num]);
				++buf_sys_num;
				if((i + 1) % 5 == 0)
					printf("\n");
			}
		} else {
			printf("ERROR: Please Input a valid Number.\n");			
		}

	} else {
		printf("ERROR: Please Input a valid Size.\n");		
	}
	return (OK);
}

/****************************************************************************/
/************************* 功能函数 bufReturn() *****************************/
/****************************************************************************/

/* 实现功能: 按照用户需求释放若干个自定义类型的内存块,  */
/* 并输出释放的内存块的地址.可以释放的内存块类型为三种: */
/* 1. 16_buffer  -- 大小为16的内存块   */
/* 2. 256_buffer -- 大小为256的内存块  */
/* 3. sys_buffer -- 已申请的系统内存块 */

STATUS bufReturn(unsigned int &buffer_type,unsigned int &free_num)
{
	/* 初始化发送消息对象 */
	PBUFFER pBuff16_sd;
	PBUFFER pBuff256_sd;

	/* 判断用户选择 */
	switch (buffer_type) {
		/* 如果选择的是1. 16_buffer */
		case 1:

			/* 如果用户需要释放的内存块个数小于已分配的内存块个数 */
			/* 则直接释放 */
			if(free_num > 0 && free_num <= buf_16_num)
			{
				printf("Freed 16_buffer address:\n");
				for(int i = 0; i < free_num; ++i)
				{
					/* 查询已分配的内存块地址 */
					pBuff16_sd.buffer = pbuf16_store[--buf_16_num];
					printf("0x%07x\t",pBuff16_sd.buffer);
					if((i + 1) % 5 == 0)
						printf("\n");

					/* 通过发送到消息队列中实现内存释放 */
					if(msgQSend(msgQId_pool16,(char*)&pBuff16_sd, sizeof(PBUFFER), WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
					{
						printf("16_Buffer free failed.\n");
						return (ERROR);
					}
				}
			/* 如果用户需要释放的内存块个数大于已分配的内存块个数 */
			/* 则释放全部已分配的内存块	 */
			} else if(free_num > buf_16_num) {
				printf("There are only %u 16_buffers can be freed.\nFreed 16_buffer address:\n", buf_16_num);
				free_num = buf_16_num;
				for(int i = 0; i < free_num; ++i)
				{
					pBuff16_sd.buffer = pbuf16_store[--buf_16_num];
					printf("0x%07x\t",pBuff16_sd.buffer);
					if((i + 1) % 5 == 0)
						printf("\n");
					/* 通过发送到消息队列中实现内存释放 */
					if(msgQSend(msgQId_pool16,(char*)&pBuff16_sd, sizeof(PBUFFER), WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
					{
						printf("16_Buffer free failed.\n");
						return (ERROR);
					}
				}
			} else {
				printf("Please input a valid Number.\n");
			}
			break;
		/* 如果选择的是2. 256_buffer	 */
		/* 方法同16_buffer相同,故不再注释*/
		case 2:
			if(free_num > 0 && free_num <= buf_256_num)
			{
				printf("Freed 256_buffer address:\n");
				for(int i = 0; i < free_num; ++i)
				{
					pBuff256_sd.buffer = pbuf256_store[--buf_256_num];
					printf("0x%07x\t",pBuff256_sd.buffer);
					if((i + 1) % 5 == 0)
						printf("\n");
					if(msgQSend(msgQId_pool256,(char*)&pBuff256_sd, sizeof(PBUFFER), WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
					{
						printf("256_Buffer free failed.\n");
						return (ERROR);
					}
				}
			} else if(free_num > buf_256_num) {
				printf("There are only %u 256_buffers can be freed.\nFreed 256_buffer address:\n", buf_256_num);
				free_num = buf_256_num;
				for(int i = 0; i < free_num; ++i)
				{
				 	pBuff256_sd.buffer = pbuf256_store[--buf_256_num];
					printf("0x%07x\t",pBuff256_sd.buffer);
					if((i + 1) % 5 == 0)
						printf("\n");
					if(msgQSend(msgQId_pool256,(char*)&pBuff16_sd, sizeof(PBUFFER), WAIT_FOREVER, MSG_PRI_NORMAL) == ERROR)
					{
						printf("256_Buffer free failed.\n");
						return (ERROR);
					}
				}
			} else {
				printf("Please input a valid Number.\n");
			}
			break;

		/* 如果选择的是3. sys_buffer */
		case 3:
			printf("%u System buffers will be all freed.\n Freed system buffer address:\n", buf_sys_num);
			free_num = buf_sys_num;
			for(int i = 0; i < free_num; ++i)
			{
				printf("0x%07x\t",pbufsys_store[--buf_sys_num]);
				free(pbufsys_store[buf_sys_num]);
				if((i + 1) % 5 == 0)
					printf("\n");
			}
			break;
		default:
			printf("Please input a valid Type.\n");
			break;
	}
	return (OK);
}

/****************************************************************************/
/************************* 功能函数 bufStatus() *****************************/
/****************************************************************************/

/* 实现功能: 查询当前内存分配的信息,输出已分配的各种类  */
/* 型的内存块地址,并显示当前剩余未分配的内存块个数.     */


STATUS bufStatus()
{
	/* 显示已分配的内存块地址 */
	printf("\n***Allocated buffers:***\n");

	/* 若有已分配的16内存块 */
	if(buf_16_num > 0)
	{
		/* 读取并输出已分配内存地址记录 */
		printf("16_buffer address:\n");
		for(int i = 0; i < buf_16_num; ++i)
		{
			printf("0x%07x\t", pbuf16_store[i]);
			if((i + 1) % 5 == 0)
				printf("\n");
		}
	}
	/* 若有已分配的256内存块 */
	if(buf_256_num > 0)
	{
		/* 读取并输出已分配内存地址记录 */
		printf("\n256 buffer address:\n");
		for(int i = 0; i < buf_256_num; ++i)
		{
			printf("0x%07x\t", pbuf256_store[i]);
			if((i + 1) % 5 == 0)
				printf("\n");
		}
	}
	/* 若有已分配的系统内存块 */
	if(buf_sys_num > 0)
	{
		/* 读取并输出已分配内存地址记录 */
		printf("\nSystem memory address:\n");
		for(int i = 0; i < buf_sys_num; ++i)
		{
			printf("0x%07x\t", pbufsys_store[i]);
			if((i + 1) % 5 == 0)
				printf("\n");
		}
	}

	/* 显示当前静态内存池未分配的内存个数 */
	printf("\nThere are %u 16_buffers left.\n", msgQNumMsgs(msgQId_pool16));
	printf("There are %u 256_buffers left.\n", msgQNumMsgs(msgQId_pool256));

	return (OK);
}

/****************************************************************************/
/****************************** 功能函数 exit() *****************************/
/****************************************************************************/

/* 实现功能: 实现系统退出,释放内存池和系统内存,删除消息队列, */
/* 信号量,和进程.											 */


STATUS exit()
{
	printf("\nSystem is goint to exit...\n");

	semTake(semId, WAIT_FOREVER);				/* 互斥信号量 */
	free(pTotalPool);							/* 删除总内存池 */
	for(int i = 0; i < buf_sys_num; ++i)
	{
		free(pbufsys_store[i++]);				/* 依次删除已分配的系统内存 */
	}
	logMsg("Free All Allocated buffers...Complete.\n",0,0,0,0,0,0);
	semGive(semId);

	semDelete(semId);							/* 删除信号量 */

	/* 删除消息队列 */
	msgQDelete(msgQId_pool16);
	msgQDelete(msgQId_pool256);

	logMsg("Delete All Message queues...Complete.\n",0,0,0,0,0,0);
	logMsg("Delete All tasks...\n",0,0,0,0,0,0);	
	
	/* 删除进程 */
	taskDelete(tidTask1);

	return (OK);
}