mmu1.c

vxworks 下静态存储区的程序

#include "stdLib.h"
#include "string.h"
#include "vxWorks.h"
#include "taskLib.h"
#include "msgQLib.h"
#include "sysLib.h"
#include "stdio.h"
#include "semLib.h"
#include "tyLib.h"
#include "ioLib.h"
#include "errnoLib.h"
#include "loglib.h"

#include "memPartLib.h"
 

#define PCS_POOL_SIZE (400)
#define BORDER_SIZE  (16)

#define MAX_MSGS   (10)   
#define MAX_MSG_LEN (100) 
#define STACK_SIZE 20000 
#define DELAY_TICKS 50  
#define MAX_MSGS_LEN (90)


int tidTask1; 
int tidTask2; 
int tidTask3; 
int tidTask4; 
int tidTask5; 

SEM_ID semSync;

MSG_Q_ID memMsgQId_16;
MSG_Q_ID memMsgQId_256; 

void *p_mem_16;
void *p_mem_256;
 


char msg2[64];   
char msg3[64];    
char msg4[64];    
char msg5[64];   
char msg6[32]; 
char msg7[32]; 


STATUS progStart(void);
int calBlockSize(int mem_size);
STATUS task1(void);
void progStop(void);
/*
STATUS task2(void);
STATUS task3(void);
STATUS task4(void);
STATUS task5(void);
*/

STATUS progStart(void)
{

PART_ID part_id_16;
void  *p_part_alloc_16;

PART_ID part_id_256;
void  *p_part_alloc_256;

char msg_send[6];
int i_step; 
int mem_addr;
char msg_buf[32];

/****** 16byte mem block *****/

  fdprintf(1,"progStart begin...\n");

	p_mem_16 = malloc(PCS_POOL_SIZE);
  if (p_mem_16 == NULL)
  {
    perror("Error in malloc p_mem_16.\n");
    return (ERROR);
  }

/*    perror("OK in malloc p_mem_16.\n");*/

	part_id_16 = memPartCreate(p_mem_16,PCS_POOL_SIZE);
  if (part_id_16 == NULL)
  {
    perror("Error in memPartCreat part_id_16.\n");
    return (ERROR);
  }

/*    perror("OK in memPartCreat part_id_16.\n"); */


	p_part_alloc_16 = memPartAlloc(part_id_16,PCS_POOL_SIZE - BORDER_SIZE*3);
	
/*    perror("OK in memPartAlloc p_part_alloc_16.\n"); */

/*	
	memPartFree( part_id_16,p_part_alloc_16);
*/

  memMsgQId_16 = msgQCreate((PCS_POOL_SIZE - BORDER_SIZE*3)/16+1, 4, MSG_Q_PRIORITY);
  if (memMsgQId_16 == NULL)
  {
    perror("Error in creating memMsgQId_16\n");
    return (ERROR);
  }

 /*   perror("OK in creating memMsgQId_16\n"); */

  
  for ( i_step=0; i_step < (PCS_POOL_SIZE - BORDER_SIZE*3)/16; ++i_step)
  {
    
    mem_addr = (int)p_part_alloc_16+16*i_step;
    strncpy(msg_send,(char *)&mem_addr,4);
    msg_send[4] = 0;
    sprintf(msg_buf,"16|%08x|%03d",mem_addr,i_step);
    strcpy((char *)mem_addr,msg_buf);
    
/*    sprintf(msg_send,"%03d",i_step); */
    
    if (msgQSend(memMsgQId_16, msg_send, 4, WAIT_FOREVER, MSG_PRI_NORMAL)
      == ERROR)
    {
      fdprintf(1,"sent msg %0x+16*%d to memMsgQId_16 error\n",p_part_alloc_16,i_step);
      return (ERROR);
    }
    else
    {
    	
/*			fdprintf(1,"send_flag:%d,%d,%d,%d\n",msg_send[0],msg_send[1],msg_send[2],msg_send[3]); */
			fdprintf(1,"sent msg %08x+16*%d=%08x:%s ok,addr:%s\n",p_part_alloc_16,i_step,mem_addr,msg_buf,mem_addr);
    }
  }
  /*void *bufGet(bufId)*/



/******* 256 ***************/

	p_mem_256 = malloc(PCS_POOL_SIZE);
  if (p_mem_256 == NULL)
  {
    perror("Error in malloc p_mem_256.\n");
    return (ERROR);
  }

	part_id_256 = memPartCreate(p_mem_256,PCS_POOL_SIZE);
  if (part_id_256 == NULL)
  {
    perror("Error in memPartCreat part_id_256.\n");
    return (ERROR);
  }

	p_part_alloc_256 = memPartAlloc(part_id_256,PCS_POOL_SIZE - BORDER_SIZE*3);
	
/*	
	memPartFree( part_id_256,p_part_alloc_256);
*/

  memMsgQId_256 = msgQCreate((PCS_POOL_SIZE - BORDER_SIZE*3)/256+1, 4, MSG_Q_PRIORITY);
  if (memMsgQId_256 == NULL)
  {
    perror("Error in creating memMsgQId_256\n");
    return (ERROR);
  }
  
  for ( i_step=0; i_step < (PCS_POOL_SIZE - BORDER_SIZE*3)/256; ++i_step)
  {
    
    mem_addr = (int)p_part_alloc_256+256*i_step;
    strncpy(msg_send,(char *)&mem_addr,4);
    msg_send[4] = 0;
    sprintf(msg_buf,"256|%08x|%03d",mem_addr,i_step);
    strcpy((char *)mem_addr,msg_buf);
    
/*    sprintf(msg_send,"%03d",i_step); */
    
    if (msgQSend(memMsgQId_256, msg_send, 4, WAIT_FOREVER, MSG_PRI_NORMAL)
      == ERROR)
    {
      fdprintf(1,"sent msg %0x+256*%d to memMsgQId_256 error\n",p_part_alloc_256,i_step);
      return (ERROR);
    }
    else
    {
    	
/*			fdprintf(1,"send_flag:%d,%d,%d,%d\n",msg_send[0],msg_send[1],msg_send[2],msg_send[3]); */
			fdprintf(1,"sent msg %08x+256*%d=%08x:%s ok,addr:%s\n",p_part_alloc_256,i_step,mem_addr,msg_buf,mem_addr);
    }
  }



  tidTask1 = taskSpawn("tTask1", 250, 0, STACK_SIZE, (FUNCPTR)task1, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0);
/*
  tidTask2 = taskSpawn("tTask2", 210, 0, STACK_SIZE, (FUNCPTR)task2, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0);
  tidTask3 = taskSpawn("tTask3", 220, 0, STACK_SIZE, (FUNCPTR)task3, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0);
  tidTask4 = taskSpawn("tTask4", 220, 0, STACK_SIZE, (FUNCPTR)task4, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0);
  tidTask5 = taskSpawn("tTask5", 240, 0, STACK_SIZE, (FUNCPTR)task5, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0);
*/
  return (OK);
}

int calBlockSize(int mem_size)
{
	if (mem_size <= 0) return 0;
	else if (mem_size <= 16) return 16;
	else if (mem_size <=256) return 256;
	else return -1;
}



STATUS task1(void)
{
  char command[6];
  int cnt;
  char msgBuf1[64];
  int step;
  char msg_rec[6];
  int mem_addr;
  char *p_msg;
  int mem_size;
  int block_size;
  MSG_Q_ID *p_msgQ_id;


 
  FOREVER
  {

    ioctl(1, FIONREAD, (int) &cnt);
    fdprintf(1,"please input memory size,and iput 'q' to exit:");
    read(1, command, 5);
    ioctl(1, FIORFLUSH, 0);
  	if (command[0] == 'q' || command[0] == 'q') break;
  	
  	mem_size = atoi(command);

    fdprintf(1,"input %s,convert number:%d.\n",command,mem_size);
  	
  	
  	if (mem_size <=0)
  	{
	    fdprintf(1,"input memory size error.\n");
	    continue;
	  }
	  
	  block_size = calBlockSize(mem_size);
	  
  	if (block_size <=0)
  	{
	    fdprintf(1,"input memory size error.\n");
	    continue;
	  }
	  else if (block_size ==16)
	  {
	  	p_msgQ_id = &memMsgQId_16;
	  }
	  else if (block_size ==256)
	  {
	  	p_msgQ_id = &memMsgQId_256;
	  }
  			

  if (msgQReceive((*p_msgQ_id), msg_rec, 4, WAIT_FOREVER) == ERROR)
  {
    fdprintf(1,"i am task1,i alloc memory error\n");
    return (ERROR);
  }
  else
  {
/*		fdprintf(1,"reci_flag:%d,%d,%d,%d\n",msg_rec[0],msg_rec[1],msg_rec[2],msg_rec[3]);*/
  	strncpy((char *)&mem_addr,msg_rec,4);
    fdprintf(1,"i am task1,i alloc memory addr:%08x OK\n", mem_addr);
    fdprintf(1,"check addr content:|%s|\n",(char *)mem_addr);
  }
    

  if (msgQSend((*p_msgQ_id), msg_rec, 4, WAIT_FOREVER, MSG_PRI_NORMAL)
    == ERROR)
  {
    fdprintf(1,"i am task1,i free memory addr:%08x error\n",mem_addr);
    return (ERROR);
  }
  else
  {
		fdprintf(1,"i am task1,i free memory addr:%08x ok\n",mem_addr);
  }

  taskDelay(DELAY_TICKS);

  
}
	progStop();
  return (OK);
}


void progStop(void)
{
  

  msgQDelete(memMsgQId_16);
  msgQDelete(memMsgQId_256);

 
  semDelete(semSync);

  fdprintf(1,"byt!\n");

  
  taskDelete(tidTask1);

  return ;
}