mem.c

Tornado下对的内存管理机制！对两个内存池的管理！

#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_DD;
MSG_Q_ID mem_256_DD;
SEM_ID mem_Rc_ID;
SEM_ID mem_DD_ID;
SEM_ID mem_In_ID;


STATUS progStart(void);
STATUS task1(void);
STATUS task2(void);
void progStop(void);
void mem_Cr(void);
void mem_DD(void);
void look(int);
PART_ID mem_In(int);
PART_ID p;
PART_ID pi;
PART_ID Buf;




STATUS progStart(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_DD=msgQCreate(MAX_MSGS,MAX_MSG_LEN,MSG_Q_PRIORITY);
 
if(mem_16==NULL)
{
return(ERROR);
}
mem_256_DD=msgQCreate(MAX_MSGS,MAX_MSG_LEN,MSG_Q_PRIORITY);
if(mem_256==NULL)
{
return(ERROR);
}
mem_Rc_ID=semBCreate(SEM_Q_FIFO,1);
mem_In_ID=semBCreate(SEM_Q_FIFO,1);
mem_DD_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)
        {
       FOREVER
         {  
semTake (mem_Rc_ID, WAIT_FOREVER);
mem_Cr();
}
 return(OK);
         }

STATUS task2(void)
        {
       FOREVER
         { int a;
semTake(mem_DD_ID, WAIT_FOREVER);
mem_DD();
msgQDelete(mem_16);
msgQDelete(mem_256);
msgQDelete(mem_16_DD);
msgQDelete(mem_256_DD);
logMsg("look pi ??\n");
scanf("%d",&a);
free(pi);
free(p);
taskDelete (tidtask2);
}
 return(OK);
         }


void mem_Cr(void)
{
int n,m;
int a;
int i;
PART_ID n_16;
PART_ID m_256;
logMsg("How much number do you want about 16 ?\n");
scanf("%d",&n);
logMsg("How much number do you want about 256 ?\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_DD,&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_DD,&m_256,sizeof(PART_ID),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)
{
return(ERROR);
}

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

void look(int a)
{
if(a==16)
logMsg("the mem of 16 leave %d\n",msgQNumMsgs(mem_16));
if(a==256)
logMsg("the mem of 256 leave %d\n",msgQNumMsgs(mem_256));
if(a!=16&&a!=256)
logMsg("you must input 16 or 256!!!\n");
}

void mem_DD(void)
{
int a;
int t5cs;
int t5Num;
int aaa;
t5Num=msgQNumMsgs(mem_16_DD);
if(t5Num!=0)
{
logMsg("DDDDDDDDDDDDDDDDDD16???\n");
scanf("%d",&a);
}
t5cs=1;
aaa=msgQNumMsgs(mem_16_DD);
for(;t5cs<=t5Num;t5cs++)
{if(msgQReceive(mem_16_DD,&Buf,sizeof(PART_ID),WAIT_FOREVER)==ERROR)
               {
return(ERROR);
}
memPartFree(pi,Buf);
logMsg("DDDDDDDDDDDDDDDDDD16!!! This is %d\n",aaa-msgQNumMsgs(mem_16_DD));
}




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

}


PART_ID mem_In(n)
{
PART_ID ip;
int In_from_sys=0;
semTake(mem_In_ID, WAIT_FOREVER);

if(n<=16)
{if(msgQNumMsgs(mem_16)<=3)
logMsg("only %d be left (16)\n",msgQNumMsgs(mem_16));
if(msgQNumMsgs(mem_16)>0)
{if(msgQReceive(mem_16,&ip,sizeof(PART_ID),0)==ERROR)
               {
return(ERROR);
}}
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("there is nothing (256)\n");
In_from_sys=1;}
}
else
{
In_from_sys=1;
}
}

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

}

void progStop(void)
{
taskDelete (tidtask1);
semGive (mem_DD_ID);


logMsg("BYE!TSCHUESS!ADIEU!\n");
    return;
}