---

PsnDescriptorMemoryManager.cxx

Go to the documentation of this file.

#include "PsnDescriptorMemoryManager.h"

#include "PsnMemoryElementDescriptor.h"

PsnDescriptorMemoryManager::~PsnDescriptorMemoryManager()
{
   
}

PsnDescriptorMemoryManager::PsnDescriptorMemoryManager ( PsnMemoryManager & rawMemoryProvider) :
   PsnMemoryManager (),
   _rawMemoryProvider ( rawMemoryProvider ),
   _stackTop (-1)
{
   // a bit less than a memory page
   _currentMemorySize = 85 * sizeof (PsnMemoryElementDescriptor) ;

   _freeBlocks.reserve ( 85 ) ;

   void * memory = _rawMemoryProvider.allocateSizeRemembered ( _currentMemorySize ) ;

   for ( void * mem = memory;
         mem != (void *) ((unsigned int)memory + _currentMemorySize) ;
         mem = (void *) ((unsigned int)mem + sizeof (PsnMemoryElementDescriptor) ) )
      {
         _freeBlocks.push_back(mem) ;
         ++_stackTop ;
      }
   
   _managedMemoryZones = new (& _rawMemoryProvider) PsnMemoryElementDescriptor() ;
   _managedMemoryZones->base = (unsigned int)memory ;
   _managedMemoryZones->size = _currentMemorySize ;
   _managedMemoryZones->next = 0 ;

}
   


bool PsnDescriptorMemoryManager::inAdressSpace ( void * ptr ) const
{
   bool result = false ;
   unsigned int adress = (unsigned int ) ptr ;
   PsnMemoryElementDescriptor * current = _managedMemoryZones ;
   while ( (! result) && ( current != NULL ) )
   {
      result = current->inAdressSpace ( adress ) ;
      current = (PsnMemoryElementDescriptor *) current->next ;
   }
   return result ;
}

void * PsnDescriptorMemoryManager::allocateSizeRemembered (size_t size)
{
   // this memory manager only allocates memory for memoryElementDescriptors
   assert ( size == sizeof (PsnMemoryElementDescriptor) ) ;

   void * result ;
   if (_stackTop == -1)
      {
         // allocate an other memory zone for memory element decriptors
         size_t allocatedMemory = _currentMemorySize ;

         void * memory = _rawMemoryProvider.allocateSizeRemembered ( allocatedMemory ) ;

         _freeBlocks.resize (_freeBlocks.capacity() + allocatedMemory/sizeof (PsnMemoryElementDescriptor), NULL ) ;

         for ( void * mem = memory;
               mem != (void *) ((unsigned int)memory + allocatedMemory) ;
               mem = (void *) ((unsigned int)mem + sizeof (PsnMemoryElementDescriptor) ) )
            {
               ++_stackTop ;
               _freeBlocks[_stackTop] = mem ;
            }
         PsnMemoryElementDescriptor * newMemoryZones = new (& _rawMemoryProvider) PsnMemoryElementDescriptor() ;
         newMemoryZones->base = (unsigned int)memory ;
         newMemoryZones->size = allocatedMemory ;
         newMemoryZones->next = (unsigned int) _managedMemoryZones ;
         
         _managedMemoryZones = newMemoryZones ;

         _currentMemorySize += allocatedMemory ;

         //recursive call
         result = allocateSizeRemembered (size) ;
      }
   else 
      {
         result = _freeBlocks[_stackTop] ;
         --_stackTop ;
      }
#ifdef _DEBUGMEMORYMANAGEMENT
   assert ( !isFree (result) ) ;
#endif
   return result ;
}


void PsnDescriptorMemoryManager::freeSizeRemembered ( void * ptr) 
{
#ifdef _DEBUGMEMORYMANAGEMENT
   // make sure no double free happens
   assert ( ! isFree (ptr) ) ;
   assert ( _stackTop < _freeBlocks.size() ) ; 
#endif
   ++_stackTop ;
   _freeBlocks[_stackTop] = ptr ;
#ifdef _DEBUGMEMORYMANAGEMENT
   assert ( isFree ( ptr ) ) ;
#endif
}

bool PsnDescriptorMemoryManager::isFree (void * ptr)
{
#ifndef _DEBUGMEMORYMANAGEMENT
   // this should only be used when debugging
   assert ( false ) ;
#endif
   bool found = false ;
   int i = 0 ;
   while ( (!found) && ( i != _stackTop+1 ) )
      {
         found = ( ptr ==  _freeBlocks[i] ) ;
         ++i ;
      }
   return found ;
}

---