---

PsnCoherantMemoryManager.cxx

Go to the documentation of this file.

/*
 * This file is part of openMask © INRIA, CNRS, Universite de Rennes 1 1993-2002, thereinafter the Software
 * 
 * The Software has been developped within the Siames Project. 
 * INRIA, the University of Rennes 1 and CNRS jointly hold intellectual property rights
 * 
 * The Software has been registered with the Agence pour la Protection des
 * Programmes (APP) under registration number IDDN.FR.001.510008.00.S.P.2001.000.41200
 *  
 * This file may be distributed under the terms of the Q Public License
 * version 1.0 as defined by Trolltech AS of Norway and appearing in the file
 * LICENSE.QPL included in the packaging of this file.
 *
 * Licensees holding valid specific licenses issued by INRIA, CNRS or Université de Rennes 1 
 * for the software may use this file in accordance with that specific license
 *
 */
#ifdef _MOME
#include <PsnCoherantMemoryManager.h>

#include <PsnMemoryElementDescriptor.h>
#include <PsnUniqueCreator.h>
#include <PsnLock.h>


PsnCoherantMemoryManager::PsnCoherantMemoryManager(void *startDsm, size_t sizeDsm, size_t pageSize) : 
   PsnSharedMemoryManager(startDsm, sizeDsm, pageSize, 4) ,
   uniqueCreatorDataOffset (sizeof(PsnMemoryElementDescriptor) + sizeof(unsigned int) )  {

   MomeConsistencyOfRegion (startDsm,
                            sizeDsm,
                            MomeStrongConsistency,
                            MomeRegionBlockingProtocol,
                            0);

#ifdef _DEBUGPAGEFAULTS
   MomeSetRegionAttributes ((void *)_startDsm,
                            (long)_sizeDsm,
                            MomeTraceTransitions);
#endif

   _myLock= new PsnLock();

   MomeManageLock(_myLock->getLock(),0);

   _memoryElementDescriptorMemoryManager = this ;

   lockIfNeeded();
   
   if(MomeMe==0) {
         // lors de la première tentative, 
         // on fait l'allocation à la main
      _freeMem = (PsnMemoryElementDescriptor *)(_startDsm + sizeof(unsigned int) ) ;
      _freeMem->base = sizeof(PsnMemoryElementDescriptor) + sizeof(unsigned int) ;
      _freeMem->size = sizeDsm - sizeof(PsnMemoryElementDescriptor) - sizeof(unsigned int) ;
      _freeMem->next = getAnInvalidOffset() ;
      setFreeMem(_freeMem);
   }
      
   //allocation à l'offset uniqueCreatorDataOffset du bloc utilisé pour PsnUniqueCreatorData
   //Il sera récupéré par le new du PsnUniqueCreatorData
 
   if(MomeMe==0) {
      cerr<<"titi"<<endl;
      unsigned int verif = (unsigned int)mmalloc(sizeof(PsnUniqueCreatorData)) - _startDsm ;
      if(verif != uniqueCreatorDataOffset) {
         cout<<"PsnCoherantMemoryManager::PsnCoherantMemoryManager Offset Réelle de uniqueCreatorDataOffset : "
             <<verif
             <<" et non "
             <<uniqueCreatorDataOffset<<endl;
         PsController::error("Il faut mieux s'arrêter vu l'erreur précédante");
      }
   }
   
   unlockIfNeeded() ;

}

PsnCoherantMemoryManager::~PsnCoherantMemoryManager() {

}

void PsnCoherantMemoryManager::lock() {
#ifdef _DEBUGLOCK
   cerr<<(int)_myLock->getLock();
#endif
   MomeMutexLock(_myLock->getLock()); 
} 

void PsnCoherantMemoryManager::unlock() {
#ifdef _DEBUGLOCK
   cerr<<(int)_myLock->getLock();
#endif
   MomeMutexUnLock(_myLock->getLock());
}


bool PsnCoherantMemoryManager::lockNeeded() {
   assert (_memoryElementDescriptorMemoryManager == this ) ;
   return true; 
}


void PsnCoherantMemoryManager::sync() {
   //nothing to do : the memory is assumed to behave whith a strong coherance
}


void PsnCoherantMemoryManager::synchronizeAfterLock(void* beginningAdress, long length) {
   //nothing to do : the memory is assumed to behave whith a strong coherance
}


PsnMemoryElementDescriptor * PsnCoherantMemoryManager::getFreeMem() {
   assert(_locked|| !lockNeeded() );
   return (PsnMemoryElementDescriptor *)localAddressToGlobal(*((unsigned int *)_startDsm));
}

void PsnCoherantMemoryManager::setFreeMem(PsnMemoryElementDescriptor * ptr) {
   assert(_locked|| !lockNeeded() );
   *((unsigned int *)_startDsm)=globalAddressToLocal(ptr);
}


void *PsnCoherantMemoryManager::getFromFree(size_t size) {

   assert( _locked || ! lockNeeded () );

   PsnMemoryElementDescriptor *i , *pred ;
#ifdef _DEBUGALLOCATIONMOME
   cerr<<MomeInternalDate()<<" PsnCoherantMemoryManager::getFromFree "<<size<<" ";
#endif
   unsigned int addr ;
   i = getFreeMem() ;
   pred = NULL ;
   addr = 0 ;
   
  while ( i != NULL )
    {
#ifdef _DEBUGALLOCATIONMOME
       cerr<<"."<<globalAddressToLocal(i)<<" "<<i->base<<" "<<i->size<<" "<<i->next<<endl;
#endif
       if ( (i->size >= size) )   /* First fit strategy  && (i->size!=12) */
          {
             addr = i->base ;
             assert(addr % 2 != 1) ;
             if ( i->size == size )
                {
                   if ( pred == NULL ) {
                      setFreeMem( (PsnMemoryElementDescriptor *)localAddressToGlobal(getFreeMem()->next)) ;
                   }
                   else {
                      pred->next = i->next ;
                   }
                   if ( i != localAddressToGlobal(i->base) ) {
                      delete ( i ) ;
                   }
                   i = NULL ;
                }
             else
                {
                   if (i->base == globalAddressToLocal(i) ) {
                      //we are trying to allocate part of the block containing the data of the block :
                      if (i->size < size + sizeof(PsnMemoryElementDescriptor) ) 
                         {  //allocation is impossible without moving the memoryElementDescriptor
                            pred = i ;
                            i = (PsnMemoryElementDescriptor *)localAddressToGlobal(i->next) ;   
                         }      
                      else {
                         addr = i->base + i->size - size ;
                         //allocate at the end of the free zone
                         i->size = i->size - size ;
                         i = NULL ;
                      }                  
                   }
                   else {
                      i->base = i->base + size ;
                      i->size = i->size - size ;
                      i = NULL ;
                   }
                }
          }
       else
          {
             pred = i ;
             i = (PsnMemoryElementDescriptor *)localAddressToGlobal(i->next) ;
          }
    }
#ifdef _DEBUGALLOCATIONMOME
  cerr<<" "<<localAddressToGlobal(addr)<<"("<<addr<<")"<<endl;
  assert(addr %2 != 1) ;
#endif
  return localAddressToGlobal(addr) ;
}
#include <unistd.h>

void PsnCoherantMemoryManager::addInFree ( void *addr, size_t size) {

   assert( _locked || ! lockNeeded () );

   PsnMemoryElementDescriptor *l, *iNew, *tmpPtr, *tmpPtr1, *tmpPtr2;
#ifdef _DEBUGALLOCATIONMOME
   cerr<<MomeInternalDate()<<" PsnCoherantMemoryManager::"<<this<<"::addInFree "<<addr<<"("<<globalAddressToLocal(addr)<<") "<<size<<endl;
#endif
   unsigned int _addr,temp;
   /* il ne faut pas faire de delete avant que le mémoire ne soir dans un état cohérant, donc on suavegarde ce qu'il faudra éventuellement détruire */
   tmpPtr1=NULL;
   tmpPtr2=NULL;

   _addr=globalAddressToLocal(addr);

   if ( size == sizeof (PsnMemoryElementDescriptor) ) {
      iNew = new(addr) PsnMemoryElementDescriptor () ;
      iNew->next = 0;
      assert (_addr != iNew->base) ;
   }
   else {
      iNew = new(this) PsnMemoryElementDescriptor ();
   }
   assert (_addr % 2 != 1 ) ;
   iNew->base = _addr ;
   iNew->size = size;

   if ( getFreeMem() == NULL )    /* Empty list */
      {
         iNew->next = getAnInvalidOffset();
         setFreeMem(iNew) ;
      }
   else
      {
         l = getFreeMem() ;   
         if ( l->base > _addr )
            {                   /* iNew is the lowest interval */
               iNew->next = globalAddressToLocal(getFreeMem()) ;
               setFreeMem(iNew) ;
               l = iNew ;
            }
         else
            { /* Search the immediate lower interval */
               tmpPtr=(PsnMemoryElementDescriptor *) localAddressToGlobal(l->next);
               while ( ( ! invalidOffset(l->next) ) && 
                       ( _addr > tmpPtr->base ) ) {
                  
                  l = tmpPtr;
                  tmpPtr=(PsnMemoryElementDescriptor *) localAddressToGlobal(l->next) ;           
               }
               /* the new free zone (iNew) is between l and l->next */
               iNew->next = l->next ;
               l->next = globalAddressToLocal(iNew) ;
               
               if ( ( !invalidOffset(iNew->next) ) &&
                    ( iNew->base + iNew->size == ((PsnMemoryElementDescriptor *) localAddressToGlobal(iNew->next))->base ) ) 
                  { /* no memory is allocated between iNew and iNew->next */
                     tmpPtr1 = (PsnMemoryElementDescriptor *) localAddressToGlobal(iNew->next) ;
                     iNew->size = iNew->size + tmpPtr1->size ;
                     iNew->next = tmpPtr1->next ;
                  }
            }
         
         if ( l->base + l->size == ((PsnMemoryElementDescriptor *) localAddressToGlobal(l->next))->base )
            { /* no memory is allocated between l and l->next */
               tmpPtr2 = (PsnMemoryElementDescriptor *)localAddressToGlobal(l->next) ;
               l->size = l->size + tmpPtr2->size ;
               l->next = tmpPtr2->next ;
               if ( tmpPtr2 != localAddressToGlobal(tmpPtr2->base) ) {
                  delete tmpPtr2 ;
               }
            }
      }
   if (tmpPtr1!=NULL) {
      if (tmpPtr1 != localAddressToGlobal(tmpPtr1->base) ) {
         delete tmpPtr1 ;
      }
   }
#ifdef _DEBUGALLOCATIONMOME
   cerr<<"PsnCoherantMemoryManager::"<<this<<"::addInFree fait"<<endl;
#endif
}

#endif

---