mpls_mgr.c

技术文件名称：MPLSv1.0软件模块测试规程

/****************************************************************************/
/*      Product Name:   MPLS PACK1.0
 *      Module  Name:   LDP/CR_LDP
 *      File    Name:   mpls_mrg.c
 *      Author  Name:   f.jun weng.qing 
 *      Creat   Date:   2002-6-18
 *      Version     :   1.0
 *      Function    :   MPLS pack1.0 memory manager
 *      Note        :   
 *      2002.12.3  Huyonghong 将assert 调用改为 MPLS_ASSERT调用                 
 *      2003.12.30 fengjun   add income var chack for mpls_memory_free      */     
/****************************************************************************/

#include "mpls_mgr.h" 
#include "stdlib.h"  
#include "stdio.h"
#include "assert.h"
#include "mpls_cmn.h"

/* MODIFIED 7/4/94 - ALLOC_TYPE_TO_MMQ size
 * MODIFIED 3/28/95 added lzero and mmq_avail-- to memory_alloc
 */
u_int32 MPLS_PSOS_ALLOC(unsigned long n1, unsigned long n2,PROTO_MEM_MGR *mmg);
void MPLS_PSOS_FREE(void *pBlock);
 
void *
mpls_memory_alloc(int len, PROTO_MEM_MGR *mmgr, int owner)
{
   MMQ *mmq;
   void *ret = (void *) 0;
   
   switch(mmgr->alloc_type)
   {

    case ALLOC_TYPE_FROM_MMQ :
      mmq = mmgr->mmq.next;
      if (mmq)
      {
         mmgr->mmq.next = mmq->next;
         memset(mmq,0,len);
         mmgr->mmq_avail--;
         mmgr->mmq_reserve--;
      }
      ret = (void *)mmq;
      break;
      

    default:
      ret = (void *) 0;

      break;
   }
   
   if (ret)
   {
      mmgr->in_use++;
      if (mmgr->in_use > mmgr->peak_use)
        mmgr->peak_use = mmgr->in_use;
   }
   
   return(ret);
}

/*
 * MODIFIED 7/4/94 -  moved FROM/TO MMQ 
 * MODIFIED 3/21/95 - moved ALLOC_TYPE_FROM_MMQ so that it will do a
 * C_FREE().
 * MODIFIED 3/28/95 - added provisions to leave a low-water mark of
 * some number of mmqs (mmq_keep)
 * - have to special case MMQ frees by using mmq_free_all or doing a linear
 * search or garbage collection
 */
void 
mpls_memory_free(void *c, PROTO_MEM_MGR *mmgr)
{
   MMQ *mmq;
   
   if(c==NULL)
   {
      printf("mpls free addr is null! ");
      return;
   }
   switch(mmgr->alloc_type) 
   {
    case ALLOC_TYPE_FROM_MMQ:
      /*
       * We store up to mmq_keep and if there is a mmq_max up to
       * that maximum which is computed to be in_use + avail.
       * Since in_use will be decrimented and avail will be incrimented
       * we use <= instead of <
       */
      if (mmgr->mmq_max == 0 ||
          ((mmgr->mmq_avail + mmgr->in_use) <= mmgr->mmq_max))
      {
         mmq = (MMQ *) c;
         mmq->next = mmgr->mmq.next;
         mmgr->mmq.next = mmq;
         mmgr->mmq_avail++;
         break;
      }
      

   } 
   mmgr->in_use--;
}

u_int32
mpls_init_mmgr(PROTO_MEM_MGR *mmgr_in)
{
   MMQ     *mmq;
   u_int32 count = mmgr_in->mmq_max, i;
  
   if(mmgr_in->alloc_type == ALLOC_TYPE_FROM_MMQ) {
     if((mmgr_in->mmq_size)%4!=0) {
        mmgr_in->mmq_size = 4* ( mmgr_in->mmq_size/4 +1);
     }	
     if(mmgr_in->mmq_max==0) return(0);
     mmgr_in->mmq_begin = (char *)MPLS_PSOS_ALLOC(mmgr_in->mmq_max,mmgr_in->mmq_size,mmgr_in);
     if(!mmgr_in->mmq_begin) {
       return(0);
     }

     mmq = (MMQ *)(mmgr_in->mmq_begin);
     for(i=1;i<count; i++) {
       mmq->next = (MMQ *)(mmgr_in->mmq_begin+i*(mmgr_in->mmq_size));
       mmq=mmq->next;
     }
     (mmgr_in)->mmq.next = (MMQ *)(mmgr_in->mmq_begin);
     /* init mmgr_in struct */
     mmgr_in->in_use = 0;
     mmgr_in->peak_use = 0;
     mmgr_in->mmq_avail=mmgr_in->mmq_max;
   return(mmgr_in->mmq_max);
}
   else {
     return(0);  /* bad alloc type  */
   }
}

/* add by lb for protocol instance init mmq memory  */
void 
mpls_free_mmgr(PROTO_MEM_MGR *mmgr_in)
{
   if(mmgr_in->alloc_type == ALLOC_TYPE_FROM_MMQ) {
     if(mmgr_in->mmq_begin) {
       memset(mmgr_in->mmq_begin,0,(mmgr_in->mmq_size * mmgr_in->mmq_max));
       MPLS_PSOS_FREE(mmgr_in->mmq_origin);
       mmgr_in->mmq_begin = 0;
       mmgr_in->mmq.next=(MMQ*)0;
     }
   }
   return;
}
/* 2002.2.20 fengjun if addr is null,indicate error,return */
/* szh mod add tempaddr process 2003-9-2 */
u_int32 MPLS_PSOS_ALLOC(unsigned long n1, unsigned long n2,PROTO_MEM_MGR *mmgr)
{
  unsigned long n = (n1+1) * n2;
  unsigned long addr, tempaddr;
   /*    memory alloc     */
   addr = (u_int32)malloc(n);
   tempaddr = addr;
   MPLS_ASSERT(addr != NULL);
    if(addr == NULL)
    {
        printf("Init LDP UB error, no enough memory for LDP UB!!!\n");
        return addr;
    }
    mmgr->mmq_origin = (char *)addr;
    
    /* aligned to 5B */
    addr = (addr + 32) & 0xFFFFFFE0;
  /*    memory alloc     */
  
  if (addr)
    memset(tempaddr, 0, n);
  return addr;
}

void MPLS_PSOS_FREE(void *pBlock)
{
    if(NULL == pBlock)
        return;
    free(pBlock);

}