memory.c

vxworks 内存管理 静态内存池分配

#include "vxworks.h"
#include "stdio.h"
#include "stdlib.h"
#include "semlib.h"
#include "tasklib.h"
#include "msgQLib.h"
#include "string.h"


#define STACK_SIZE 20000/*分配给每个任务的堆栈大小*/
#define MAX_MSGS (2000)/*消息队列长度（最大消息个数）*/
#define MAX_MSG_LEN (16)/*消息队列中消息的最大长度*/



int tidtask1;/*任务ID定义*/
int tidtask2;
MSG_Q_ID mem_16;/*定义各个task的消息队列*/
MSG_Q_ID mem_256;
MSG_Q_ID mem_16_F;
MSG_Q_ID mem_256_F;
SEM_ID mem_C_ID;
SEM_ID mem_F_ID;
SEM_ID mem_A_ID;


STATUS progStart(void);
STATUS task1(void);
STATUS task2(void);
void progStop(void);
void mem_C(void);
void mem_Free(void);
void msg_Con(void);
PART_ID mem_A(int);
PART_ID p;
PART_ID pi;
PART_ID Buf;
PART_ID newmem;


STATUS progStart(void)
{

	msg_Con();
	mem_C_ID=semBCreate(SEM_Q_FIFO,1);
	mem_A_ID=semBCreate(SEM_Q_FIFO,1);
	mem_F_ID=semBCreate(SEM_Q_FIFO,0);
 	tidtask1= taskSpawn ("ttask1", 100, 0, STACK_SIZE,
        		(FUNCPTR) task1,0,0,0,0,0,0,0,0,0,0);

	tidtask2= taskSpawn ("ttask2", 101, 0, STACK_SIZE,
  		        (FUNCPTR) task2,0,0,0,0,0,0,0,0,0,0);

}


STATUS task1(void)
{
       
      int k,s;
      FOREVER
         {  
	printf("enter: \n1 set mem, 2 free memory, 3 alloc mem\n");
	scanf("%d",&s);
	
	switch(s){
	case 1:
		printf("set pool\n");
		
		semTake (mem_C_ID, WAIT_FOREVER);
		mem_C();
		semGive(mem_C_ID);
		break;
	case 2:
		printf("free memory\n");
		semGive(mem_F_ID);

		break;
	case 3:

		printf("allocate memory\n");
		scanf("%d",&k);
		newmem=mem_A(k);
		break;
	default:break;
	}
		

	}
	return(OK);
}

STATUS task2(void)
{
       FOREVER
         { 

	semTake(mem_F_ID, WAIT_FOREVER);
	mem_F();
	msgQDelete(mem_16);
	msgQDelete(mem_256);
	msgQDelete(mem_16_F);
	msgQDelete(mem_256_F);
	free(pi);
	free(p);
	msg_Con();
	
	}
 	return(OK);
}


void msg_Con(void)
{
	mem_16=msgQCreate(MAX_MSGS,MAX_MSG_LEN,MSG_Q_PRIORITY);
 
	if(mem_16==NULL) return(ERROR);

	mem_256=msgQCreate(MAX_MSGS,MAX_MSG_LEN,MSG_Q_PRIORITY);
	if(mem_256==NULL) return(ERROR);

	mem_16_F=msgQCreate(MAX_MSGS,MAX_MSG_LEN,MSG_Q_PRIORITY);
 
	if(mem_16==NULL) return(ERROR);

	mem_256_F=msgQCreate(MAX_MSGS,MAX_MSG_LEN,MSG_Q_PRIORITY);
	if(mem_256==NULL) return(ERROR);
}

void mem_C(void)
{
	int n,m;
	int a;
	int i;
	PART_ID n_16;
	PART_ID m_256;
	logMsg("How many 16-byte blocks ?\n");
	scanf("%d",&n);
	logMsg("How many 256-byte blocks ?\n");
	scanf("%d",&m);
	a=(16+8)*n+(256+8)*m+256;
	p=(PART_ID)malloc(a);
	pi=memPartCreate(p,a);

	i=1;
	for(;i<=n;i++)
	{
		n_16=memPartAlloc(pi,16);
	if(msgQSend(mem_16,&n_16,sizeof(PART_ID),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
	{
	return(ERROR);
	}
	if(msgQSend(mem_16_F,&n_16,sizeof(PART_ID),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
	{
	return(ERROR);
	}
	}
	logMsg("16 have been created (%d)\n", msgQNumMsgs(mem_16));
	i=1;
	for(;i<=m;i++)
	{
	m_256=memPartAlloc(pi,256);
	if(msgQSend(mem_256,&m_256,sizeof(PART_ID),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
	{
	return(ERROR);
	}
	if(msgQSend(mem_256_F,&m_256,sizeof(PART_ID),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
	{
	return(ERROR);
	}

	}
	logMsg("256 have been created (%d)\n", msgQNumMsgs(mem_256));
}


void mem_F(void)
{
	char a;
	int t5cs;
	int t5Num;
	int aaa;
	t5Num=msgQNumMsgs(mem_16_F);
	if(t5Num>0){
	t5cs=1;
	aaa=msgQNumMsgs(mem_16_F);
	for(;t5cs<=t5Num;t5cs++)
	{if(msgQReceive(mem_16_F,&Buf,sizeof(PART_ID),WAIT_FOREVER)==ERROR)
               {
	return(ERROR);
	}
	memPartFree(pi,Buf);
	logMsg("Free 16!!! This is %d\n",aaa-msgQNumMsgs(mem_16_F));
	}


	}

	t5Num=msgQNumMsgs(mem_256_F);
	if(t5Num!=0)
	{

	t5cs=1;
	aaa=msgQNumMsgs(mem_256_F);
	for(;t5cs<=t5Num;t5cs++)
	{if(msgQReceive(mem_256_F,&Buf,sizeof(PART_ID),WAIT_FOREVER)==ERROR)
               {
	return(ERROR);
	}
	memPartFree(pi,Buf);
	logMsg("Free 256!!! This is %d\n",aaa-msgQNumMsgs(mem_256_F));
	}
	}

}


PART_ID mem_A(n)
{
	PART_ID ip;
	int In_from_sys=0;
	semTake(mem_A_ID, WAIT_FOREVER);

	if(n<=16)
	{if(msgQNumMsgs(mem_16)<=3)
	logMsg("only %d can be  used (16)\n",msgQNumMsgs(mem_16));
	if(msgQNumMsgs(mem_16)>0)
	{if(msgQReceive(mem_16,&ip,sizeof(PART_ID),0)==ERROR)
               {
	return(ERROR);
	}
	else logMsg("allocation done!\n");
	}
	else
	{logMsg("there is nothing (16)\n");
	In_from_sys=1;}
	}
	else
	{
	if(n<=256)
	{if(msgQNumMsgs(mem_256)<=3)
	logMsg("only %d be left (256)\n",msgQNumMsgs(mem_256));
	if(msgQNumMsgs(mem_256)>0)
	{if(msgQReceive(mem_256,&ip,sizeof(PART_ID),0)==ERROR)
               {
	return(ERROR);
	}
	else logMsg("allocation done!\n");
	}
	else
	{logMsg("there is nothing (256)\n");
	In_from_sys=1;}
	}
	else
	{
	In_from_sys=1;
	}
	}

	if(In_from_sys==1)
	ip=malloc(n);
	semGive (mem_A_ID);
	return ip;

}