---

PsnThreadMemoryManager.cxx

Go to the documentation of this file.

#include "PsnThreadMemoryManager.h"

#include "PsnMemoryElementDescriptor.h"
#include <assert.h>
#include <iostream>
#include "PsnSharedMemoryManager.h"

#include "PsnDescriptorMemoryManager.h"
//#define _DEBUGMEMORYMANAGEMENT

list <void *> & PsnThreadMemoryManager::getListOfDetachedMemoryBlocks () 
{
   static list <void  *> designPattern ; 
   return  designPattern ;
}

list <pair <void *, PsnThreadMemoryManager *> > & PsnThreadMemoryManager::getListOfLeakedMemoryBlocks () 
{
   static list <pair <void *, PsnThreadMemoryManager *> > designPattern ; 
   return  designPattern ;
}

PsnMutexLock & PsnThreadMemoryManager::getFreedMemoryBlocksMutex() 
{
   static PsnMutexLock toto ;
   return toto ;
}
PsnMutexLock & PsnThreadMemoryManager::getLeakedMemoryBlocksMutex() 
{
   static PsnMutexLock toto ;
   return toto ;
}

void PsnThreadMemoryManager::freeLeakedMemoryBlocks ()
{
   getFreedMemoryBlocksMutex().protect() ;
   list <void *> & mylist ( getListOfDetachedMemoryBlocks () ) ;
   for ( list <void *>::iterator i = mylist.begin() ;
         i != mylist.end() ;
         i = mylist.erase (i) )
      {
         PsnMemoryManager * correctMemoryManager = PsnMemoryManager::whichMemoryManager ( *i ) ;
         correctMemoryManager->freeSizeRemembered ( *i ) ;
      }
   getFreedMemoryBlocksMutex().unprotect() ;
   getLeakedMemoryBlocksMutex().protect() ;
   list <pair <void *, PsnThreadMemoryManager *> > & alist ( getListOfLeakedMemoryBlocks () ) ;
   for ( list <pair <void *, PsnThreadMemoryManager *> >::iterator i = alist.begin() ;
         i != alist.end() ;
         i = alist.erase (i) )
      {
         (*i).second->mfreeSizeRememberedOtherThread ( (*i).first ) ;
      }
   getLeakedMemoryBlocksMutex().unprotect() ;
} 



PsnThreadMemoryManager::~PsnThreadMemoryManager() 
{
}


PsnThreadMemoryManager::PsnThreadMemoryManager ( void *startDsm, 
                                                 size_t sizeDsm, 
                                                 PsnMemoryManager & rawMemoryProvider,
                                                 PsnMemoryManager & descriptorMemoryProvider ) :
   PsnMemoryManager(),
   _memoryManaged ( sizeDsm ),
   _rawMemoryProvider ( rawMemoryProvider ),
   _descriptorMemoryProvider ( descriptorMemoryProvider ),
   _freeMemoryZones ( new(&descriptorMemoryProvider) PsnMemoryElementDescriptor ( ) ),
   _managedMemoryZones ( new(&descriptorMemoryProvider) PsnMemoryElementDescriptor ( ) ),
   _user ( pthread_self() )
{
   // the getFromFree member function relies on that
   assert ( startDsm != 0 ) ;

   _managedMemoryZones->base = (unsigned int) startDsm ;
   _managedMemoryZones->size = sizeDsm ;
   _managedMemoryZones->next = 0 ;

   _freeMemoryZones->base = (unsigned int) startDsm ;
   _freeMemoryZones->size = sizeDsm ;
   _freeMemoryZones->next = 0 ;
}



void * PsnThreadMemoryManager::allocateSizeRemembered (size_t size) 
{
#ifdef _DEBUGMEMORYMANAGEMENT
   assert ( _user == pthread_self() ) ;
#endif
   size_t sizeNeeded =  sizeof(size_t) + size ;
   void * result = getFromFree ( sizeNeeded  ) ;
   //cerr<<"PsnThreadMemoryManager::allocateSizeRemembered "<<result<<endl;
   if ( result == NULL )
      {
         PsnMemoryElementDescriptor * iNew ;
         
         //allocate more memory
         result = _rawMemoryProvider.allocateSizeRemembered ( _memoryManaged ) ;
         if ( result != NULL)
            {
               iNew = new (& _descriptorMemoryProvider) PsnMemoryElementDescriptor();
               iNew->base = (unsigned int)result ;
               iNew->size = _memoryManaged ;
               iNew->next = 0 ;
               _managedMemoryZones->next = (unsigned int) iNew ;

               addInFree (result, _memoryManaged ) ;
               _memoryManaged += _memoryManaged ;

               //retry
               result = allocateSizeRemembered ( sizeNeeded ) ;
            }
         else
            {//allocation has failed, try minimum allocation
               result = _rawMemoryProvider.allocateSizeRemembered ( sizeNeeded ) ;
               if ( result != NULL)
                  {
                     iNew = new (& _descriptorMemoryProvider) PsnMemoryElementDescriptor();
                     iNew->base = (unsigned int)result ;
                     iNew->size = sizeNeeded;
                     iNew->next = 0 ;
                     _managedMemoryZones->next = (unsigned int) iNew ;

                     addInFree (result, sizeNeeded ) ;
                     _memoryManaged += sizeNeeded ;
                     
                     //retry
                     result = allocateSizeRemembered ( sizeNeeded ) ;
                  }
            }
      }
   if (result != NULL) 
      {
         *((size_t *)result) = size;
         
         result = (void *) ((unsigned int)result + sizeof (size_t ) ) ;
      }
   return result ;
}



void PsnThreadMemoryManager::mfreeSizeRememberedOtherThread ( void * ptr ) 
{
#ifdef _DEBUGMEMORYALLOCATION
   inAdressSpace ( ptr) ;
#endif
   size_t * addressOfSize = (size_t *) ((unsigned int)ptr - sizeof ( size_t ) ) ;
   addInFree ( (void *)addressOfSize, *addressOfSize + sizeof ( size_t ) ) ;
}



void PsnThreadMemoryManager::freeSizeRemembered ( void * ptr ) 
{
   //cerr<<"PsnThreadMemoryManager::freeSizeRemembered "<<pthread_self()<<endl;
   if ( _user == pthread_self() ) 
      {
         if (inAdressSpace ( ptr) )
            {
               size_t * addressOfSize = (size_t *) ((unsigned int)ptr - sizeof ( size_t ) ) ;
               addInFree ( (void *)addressOfSize, *addressOfSize + sizeof ( size_t ) ) ;
            }
         else
            {
               if ( _descriptorMemoryProvider.inAdressSpace ( ptr ) )
                  {
                     _descriptorMemoryProvider.freeSizeRemembered( ptr ) ;
                  }
               else
                  {
                     getFreedMemoryBlocksMutex().protect() ;
                     getListOfDetachedMemoryBlocks().push_back ( ptr ) ;
                     getFreedMemoryBlocksMutex().unprotect() ;
                  }
            }
      }
   else
   {
      getLeakedMemoryBlocksMutex().protect() ;
      getListOfLeakedMemoryBlocks().push_back ( make_pair ( ptr, this) ) ;
      getLeakedMemoryBlocksMutex().unprotect() ;
   }
}

void * PsnThreadMemoryManager::getFromFree ( size_t size )
{
#ifdef _DEBUGMEMORYMANAGEMENT
   assert ( _user == pthread_self() ) ;
   //integrity check
   PsnMemoryElementDescriptor * test = _freeMemoryZones ;
   while (test != 0)
      {
         assert (inAdressSpace ( ( PsnMemoryElementDescriptor *)test->base ) ) ;
         assert ( test != ( PsnMemoryElementDescriptor *)test->next ) ;
         if ( test->next != 0)
            {
               assert ( ((PsnMemoryElementDescriptor *)test->next)->base > test->base + test->size ) ;
            }
         test = ( PsnMemoryElementDescriptor *)test->next ;
      }
#endif
   PsnMemoryElementDescriptor *i , *pred ;
   
   unsigned int addr ;
   
   
   i = _freeMemoryZones ;

   pred = NULL ;
   
   addr = 0 ;
   
   while ( i != NULL )
    {
       if ( i->size >= size )   /* First fit strategy */
          {
             addr = i->base ;
             if ( i->size == size )
                {
                   if ( pred == NULL ) 
                      {
                         PsnMemoryElementDescriptor * newStartFreeList = (PsnMemoryElementDescriptor *) i -> next ;
                         delete _freeMemoryZones ;
                         _freeMemoryZones = newStartFreeList ; 
                      }
                   else 
                      {
                         pred->next = i->next ;
                         delete ( i ) ;
                      }     
                }
             else
                {
                   i->base = i->base + size ;
                   i->size = i->size - size ;
                }
             i = NULL ;
          }
       else
          {
             pred = i ;
             i = (PsnMemoryElementDescriptor *) i->next ;
          }
    }
#ifdef _DEBUGMEMORYMANAGEMENT
   //integrity check
   test = _freeMemoryZones ;
   while (test != 0)
      {
         assert (inAdressSpace ( ( PsnMemoryElementDescriptor *)test->base ) ) ;
         assert ( test != ( PsnMemoryElementDescriptor *)test->next ) ;
         if ( test->next != 0)
            {
               assert ( ((PsnMemoryElementDescriptor *)test->next)->base > test->base + test->size ) ;
            }
         test = ( PsnMemoryElementDescriptor *)test->next ;
      }
#endif
  if (addr == 0 ) //no correct memory zone was found
     {
        return NULL ;
     }
  else 
     {
        return (void *)addr ;
     }
#ifdef _DEBUGMEMORYMANAGEMENT
   cerr<<"PsnThreadMemoryManager:"<<this<<":addInFree: ("<<(void *)addr<<","<<size<<")"<<endl;
#endif
}



void PsnThreadMemoryManager::addInFree(void * ptr, size_t size)
{
#ifdef _DEBUGMEMORYMANAGEMENT
   assert ( _user == pthread_self() ) ;
   //integrity check
   PsnMemoryElementDescriptor * test = _freeMemoryZones ;
   while (test != 0)
      {
         assert (inAdressSpace ( ( PsnMemoryElementDescriptor *)test->base ) ) ;
         assert ( test != ( PsnMemoryElementDescriptor *)test->next ) ;
         if ( test->next != 0)
            {
               assert ( ((PsnMemoryElementDescriptor *)test->next)->base > test->base + test->size ) ;
            }
         test = ( PsnMemoryElementDescriptor *)test->next ;
      }
#endif
#ifdef _DEBUGMEMORYMANAGEMENT
   cerr<<"PsnThreadMemoryManager:"<<this<<":addInFree: ("<<ptr<<","<<size<<")"<<endl;
#endif
   PsnMemoryElementDescriptor *l, *iNew, *tmp ;

   iNew = new(& _descriptorMemoryProvider) PsnMemoryElementDescriptor();
   iNew->base = (unsigned int)ptr ;
   iNew->size = size;
   
   if ( _freeMemoryZones  == NULL) 
      { /* No free memory in the memory manager */
         iNew->next = (unsigned int) NULL ;
         _freeMemoryZones = iNew ;
      }    
   else 
      {
         l = _freeMemoryZones ;
         if ( l->base > iNew->base ) 
            {
               /* iNew is the lowest interval */
               iNew->next = (unsigned int) _freeMemoryZones ;
               _freeMemoryZones = iNew ;
               //reorder so that l->next == iNew for merge test
               l = iNew ;
               iNew = (PsnMemoryElementDescriptor *) l->next ;
            }    
         else 
            { 
               /* Search the immediate lower interval */
               tmp = (PsnMemoryElementDescriptor * ) l -> next ;
               bool onBoucle = ( tmp != NULL ) ;
               if (onBoucle )
                  {
                     onBoucle = ( iNew->base > tmp->base ) ;
                  } 
               while ( onBoucle ) 
                  {
                     l = tmp ;
                     tmp = (PsnMemoryElementDescriptor * ) l->next ;
                     if (tmp != NULL) 
                        {
                           onBoucle = iNew->base > tmp->base ;
                        }       
                     else 
                        {
                           onBoucle = false ;
                        }
                  }
               
               iNew->next = (unsigned int) tmp ;
               l->next = (unsigned int) iNew ;
               if ( tmp != NULL ) 
                  {
                     //try to merge the the new free zone with the following free zonee
                     if (iNew->base + iNew->size == tmp -> base) 
                        {
#ifdef _DEBUGMEMORYMANAGEMENT
                           cerr<<"Merging new free zone ("<<ptr<<") with following"<<endl;
#endif
                           iNew->size += tmp->size ;
                           iNew->next = tmp->next ;
                           delete tmp ;
                        }
                  }
            }
         if ( l->base + l->size == iNew->base ) 
            {
               //try and merger the preceeding free memory block with the freed one
#ifdef _DEBUGMEMORYMANAGEMENT
               cerr<<"Merging new free zone ("<<ptr<<") with preceeding"<<endl;
#endif
               l->size += iNew->size ;
               l->next = iNew->next ;
               if (_freeMemoryZones == iNew) 
                  {
                     _freeMemoryZones = l;
                  }
               delete iNew ;
            }     
      }
#ifdef _DEBUGMEMORYMANAGEMENT
   //integrity check
   test = _freeMemoryZones ;
   while (test != 0)
      {
         assert (inAdressSpace ( ( PsnMemoryElementDescriptor *)test->base ) ) ;
         assert ( test != ( PsnMemoryElementDescriptor *)test->next ) ;
         if ( test->next != 0)
            {
               assert ( ((PsnMemoryElementDescriptor *)test->next)->base > test->base + test->size ) ;
            }
         test = ( PsnMemoryElementDescriptor *)test->next ;
      }
#endif
}


bool PsnThreadMemoryManager::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 ;
}

---