memmanager.c.bak

这是操作系统中的内存管理的全部debug程序

/******************************************************************************
 *
 * Module name: MemManager.c  $Revision:   1.1            Liteon Confidential
 *
 * Description:
 *
 *     This file includes memory manager.
 * Revision History:
 *
 * No.  Date      Who  Description of Change
 * ---  --------  ---  --------------------------------------------------------
 * 001 3/25/05     ***           Create    
 *
 ******************************************************************************/

/********  Definititions & Macros for Module **********************************/

#define Sample
#define MEMORY_POOL_LENGTH   0x2c620   /* this is in Word_type!! */

#ifdef Sample
#define RAM               1    /* Semaphore for protecting memory allocations   */
#define MAX_SEMAS  29         /* Number of semaphores available   
#endif              */

/********  Include Files ******************************************************/
#include "typedef.h"
#include "Memory.h"     

/********  Prototype Definitinos for Module ***********************************/

void RelMemSegment ( MemSegmentHeader * pReleaseBlock );
MemSegmentHeader * ReqMemSegment ( Uint32 U32RequestSize,
                                  MemSegmentHeader * pPreviousBlock);
MemSegmentHeader * GetMemSegment ( Uint32 U32RequestSize,
                                  MemSegmentHeader * pPreviousBlock,
                                  BOOL fAcceptSmallerSegment );


/********  Variable Declaratinos for Module ***********************************/

#ifdef Sample
BOOL fExecStarted;

/* semaphore values */
Sint8 gS8Semaphore [ MAX_SEMAS ];
#endif

MemSegmentHeader * pSwathFreeSpace;
Uint16 U16MemBuffer [ MEMORY_POOL_LENGTH ];

MemSegmentHeader * TrashSearch ( void );
void CollectTrash ( MemSegmentHeader * );
void CollectSpace ( void );
void LockRAM ( void );
void UnlockRAM ( void );
#ifdef Sample
void Os_BeginTask ( void);
#endif
/*************************************************************************
 *
 *Os sample
 *
 *
 ************************************************************************/
#ifdef Sample
void Os_BeginTask ( void)
{
	fExecStarted= TRUE;
}

void Os_InitializeSemaphore (Uint8 U8SemaphoreNumber, Sint8 S8SemaphoreValue )
{
   gS8Semaphore [ U8SemaphoreNumber ] = S8SemaphoreValue;	
}

void Os_Signal (Uint8 bSemaphoreNumber)
{

   /* raise semaphore */

   ++ gS8Semaphore [ bSemaphoreNumber ];
   if ( gS8Semaphore [ bSemaphoreNumber ] <= 0)
   {
         //unblock the task that wait semaphore
            //Unblock ( bTask );

   }

}

void Os_Wait ( Uint8 bSemaphoreNumber )
{

   /* lower semaphore */

   -- gS8Semaphore [ bSemaphoreNumber ];
   if ( gS8Semaphore [ bSemaphoreNumber ] < 0)
   {
      //block the current task
      //Block ();
   }

   return;
}
/**************************************************************************
 *
 *error handle and word align
 *
 **************************************************************************/
Uint16 *WordPointerCheck ( ObjID pbInPointer )
{
     return ((Uint16 *)pbInPointer);
}

#endif

/******************************************************************************
 *
 * Function Name: InitMemoryManager
 *
 * Description:
 *
 *  InitMemoryManager will setup the variables required for the dynamic swath
 *  manager.  
 *
 ******************************************************************************/

void InitMemoryManager ( void )
{
   Uint32 U32Runner;
   Uint16 * pClearRunner;
   MemSegmentHeader * pTempHeader;


   /* conversion note: clearing the buffer space solves problems with the dynamic allocation system */
   /*  this should be looked at further at a later date                                             */

   pClearRunner = U16MemBuffer;

   for ( U32Runner = 0; U32Runner < MEMORY_POOL_LENGTH; U32Runner ++ )
   {
      * pClearRunner ++ = 0x8888;
   }

   /* Initialize RAM semaphore */
   #ifdef Sample
   Os_InitializeSemaphore ( RAM, 1 ); 
   #endif

   /* point FreeSwathSpace to first ( only for now ) segment of free space */

   pSwathFreeSpace = ( MemSegmentHeader * ) U16MemBuffer;

   /* get address of first segment header */

   pTempHeader = pSwathFreeSpace;

   /* fill in first segment header */

   pTempHeader -> pU16DataPointer = ( Uint16 * ) (( Uint32 ) & U16MemBuffer
                                                  + sizeof ( MemSegmentHeader ));
   pTempHeader -> pLastSegment = NULL;
   pTempHeader -> pNextSegment = NULL;
   pTempHeader -> U32DataSize    = sizeof ( U16MemBuffer ) - sizeof ( MemSegmentHeader );
   pTempHeader -> fTrashed      = FALSE;


}

/******************************************************************************
 *
 * Function Name: Free
 *
 * Description:
 *
 *  free is used to release memory 
 *  This function is designed to operate more like a normal 'C' function free.
 *
 ******************************************************************************/

void Free (void *RelData)
{

   RelMemSegment ( (MemSegmentHeader * )( WordPointerCheck (( Uint8 * )
                                    (( Uint32 ) RelData  - sizeof ( MemSegmentHeader ))   )));
}

/******************************************************************************
 *
 * Function Name: RelMemSegment
 *
 * Description:
 *
 *  Release swath segment.  Segment is marked for return to memory pool and
 *  is removed from any chain that it may be linked to.
 *
 *  Caution:  This system assumes that a user of memory will be responsible
 *            for not getting into a state where chains are being added to
 *            and deleted from at the same time.  In other words avoid such
 *            as adding to a chain at level 0 and removing segments from the
 *            same chain at an interrupt level.
 *
 ******************************************************************************/


void RelMemSegment ( MemSegmentHeader * pReleaseBlock )
{
   pReleaseBlock->fTrashed = TRUE;                            /* turn on trash indicator */
   if ( pReleaseBlock -> pLastSegment == NULL )
   {

      /* 2 */
      /* no segment in front of pReleaseBlock */

      if ( pReleaseBlock -> pNextSegment == NULL )
      {

         /* 3 */
         /* no segment on either side of pReleaseBlock ( case R1 ) */

      }
      else
      {

         /* 4 */
         /* no segment to left of of pReleaseBlock, segment(s)*/
         /* exist to the right of pReleaseBlock ( case R2 ) */

         pReleaseBlock -> pNextSegment -> pLastSegment = NULL;
         pReleaseBlock -> pNextSegment = NULL;

      }
   }
   else
   {

      /* 5 */
      /* segment(s) exist to the left of pReleaseBlock */

      if ( pReleaseBlock -> pNextSegment == NULL )
      {

         /* 6 */
         /* no segment to the right of pReleaseBlock, */
         /* segment(s) to the left ( case R3 ) */

         pReleaseBlock -> pLastSegment -> pNextSegment = NULL;
         pReleaseBlock -> pLastSegment = NULL;

      }
      else
      {

         /* 7 */
         /* segment(s) exist on either side of pReleaseBlock ( case R4 ) */

         pReleaseBlock -> pLastSegment -> pNextSegment = pReleaseBlock -> pNextSegment;
         pReleaseBlock -> pNextSegment -> pLastSegment = pReleaseBlock -> pLastSegment;
         pReleaseBlock -> pLastSegment = NULL;
         pReleaseBlock -> pNextSegment = NULL;

      }
   }
}

/******************************************************************************
 *
 * Function Name:  CollectSpace
 *
 * Description:
 *
 *   CollectSpace returns all memory segments marked for release to the available
 *   memory pool.
 *
 ******************************************************************************/

void CollectSpace ( void )
{
   while ( TrashSearch () != NULL)
   {
   }
}

/******************************************************************************
 *
 * Function Name:  TrashSearch
 *
 * Description:
 *
 *   TrashSearch scans the memory system for segments that have been marked for
 *   return to the pool.
 *
 ******************************************************************************/

MemSegmentHeader * TrashSearch ( void )
{
   MemSegmentHeader * pRunner;
   pRunner = ( MemSegmentHeader * ) U16MemBuffer;
   while ( (Uint32) pRunner < (( Uint32 ) U16MemBuffer + MEMORY_POOL_LENGTH * sizeof ( Uint16 ) ))
   {
      if (TRUE == pRunner->fTrashed)
      {
         pRunner->fTrashed = FALSE;   /* turn off trash indicator */
         CollectTrash ( pRunner );
         return ( pRunner );
      }
      pRunner = ( MemSegmentHeader * ) WordPointerCheck ((Uint8 * )(( Uint32 ) pRunner -> pU16DataPointer + pRunner -> U32DataSize ));
   }
   return ( NULL );
}

/******************************************************************************
 *
 * Function Name:  CollectTrash
 *
 * Description:
 *
 *    CollectTrash combines a segment that has been released back into the
 *    memory pool.
 *
 ******************************************************************************/

void CollectTrash ( MemSegmentHeader * pReleaseBlock )
{
   Uint32 U32Distance  = sizeof ( U16MemBuffer );
   Uint32 U32Dif;
   MemSegmentHeader * pRunner = pSwathFreeSpace;
   MemSegmentHeader * pSave   = pSwathFreeSpace;

   if ( pSwathFreeSpace == NULL )
   {

      /* 1 */
      /* all swath data space is out and first chunk is coming back to available */

      pSwathFreeSpace = pReleaseBlock;
   }
   else /* pSwathFreeSpace != NULL */
   {

      /* 8 */
      do
      {
         if ((Uint32) pReleaseBlock < (Uint32) pRunner)
            U32Dif = ( Uint32 ) pRunner - (( Uint32 ) pReleaseBlock + pReleaseBlock -> U32DataSize + sizeof (MemSegmentHeader));
         else
            U32Dif = ( Uint32 ) pReleaseBlock - (( Uint32 ) pRunner + pRunner -> U32DataSize + sizeof (MemSegmentHeader));
         if ( U32Dif < U32Distance )
         {
            U32Distance = U32Dif;
            pSave = pRunner;
         }
         pRunner = pRunner -> pNextSegment;
      } while (( pRunner != NULL ) && ( U32Distance != 0));

      /* now pSave points to the closest free block and U32Distance is how far */
      /* apart they are in bytes. If free space is next to RB on left and right, */
      /* pSave points to space on left */

      if ( pReleaseBlock > pSave )
      {

         /* 9 */
         /* closest block of free space is to left */

         if ( U32Distance == 0 )
         {

            /* 10 */
            /* the block to be released is next to closest block */
            /*  combine block to be released with block to it's left */

            pSave -> U32DataSize += pReleaseBlock -> U32DataSize + sizeof ( MemSegmentHeader );

            /* 17 */
            /* now check to see if pReleaseBlock was between two free blocks */

            if ( pSave -> pNextSegment != NULL )
            {

               /* 18 */
               /* segment(s) exist on right of newly sized free segment */

               if (( MemSegmentHeader * )WordPointerCheck (( Uint8 * )(( Uint32 ) pSave + pSave -> U32DataSize + sizeof ( MemSegmentHeader ))) == pSave -> pNextSegment )
               {

                  /* 19 */
                  pSave -> U32DataSize += pSave -> pNextSegment -> U32DataSize + sizeof ( MemSegmentHeader );
                  if ( pSave -> pNextSegment -> pNextSegment != NULL )
                  {

                     /* 20 */
                     pSave -> pNextSegment -> pNextSegment -> pLastSegment = pSave;
                     pSave -> pNextSegment = pSave -> pNextSegment -> pNextSegment;
                  }
                  else
                     pSave -> pNextSegment = NULL;
               }
            }
         }
         else
         {
            /* 21 */
            /* there is space between the close block and the block to release */
            /* 28 */
            pReleaseBlock -> pLastSegment = pSave;
            pReleaseBlock -> pNextSegment = pSave -> pNextSegment;
            if ( pSave -> pNextSegment != NULL )
               pSave -> pNextSegment -> pLastSegment = pReleaseBlock;
            pSave -> pNextSegment = pReleaseBlock;
         }
      }
      else
      {

         /* 35 */
         /* closest block of free space is on right */

         if ( U32Distance == 0 )
         {
            /* 36 */
            /* free space is next to block to release */
            pReleaseBlock -> U32DataSize += pSave -> U32DataSize + sizeof ( MemSegmentHeader );
            /* 43 */
            if ( pSave == pSwathFreeSpace )
            {
               /* 44 */
               pSwathFreeSpace = pReleaseBlock;
            }