---

PsnSecondarySharedMemoryManager.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
 *
 */
#include "PsnSecondarySharedMemoryManager.h"

#include "PsnMemoryElementDescriptor.h"
#include "PsnRelaxedMemoryManager.h"

PsnSecondarySharedMemoryManager::PsnSecondarySharedMemoryManager(size_t sizeDsm, size_t pageSize, size_t alignedSize, PsnRelaxedMemoryManager & memoryManager) : 
   PsnSharedMemoryManager(memoryManager.mmalloc(sizeDsm / pageSize),
                          sizeDsm,
                          pageSize,
                          alignedSize),
   _myMemoryManager(memoryManager)
{
#ifdef _DEBUGALLOCATIONMOME
   cerr<<sizeDsm<<" "<<pageSize<<endl;
#endif
   assert(sizeDsm % pageSize == 0) ;

   _firstPageOffset = _myMemoryManager.globalAddressToLocal((void *)_startDsm) / _pageSize ;
}

PsnSecondarySharedMemoryManager::~PsnSecondarySharedMemoryManager() {

}


void PsnSecondarySharedMemoryManager::sync() {
   //cerr<<"PsnSecondarySharedMemoryManager::sync"<<endl;
}

void * PsnSecondarySharedMemoryManager::getFromThisFree ( PsnMemoryElementDescriptor * * startFreeList, size_t size ) {
  PsnMemoryElementDescriptor *i , *pred ;

  unsigned int addr ;

#ifdef _DEBUGALLOCATIONMOME
  if (*startFreeList != NULL ) {
     cerr<<"PsnSecondarySharedMemoryManager::getFromThisFree "<<startFreeList<<" "
         <<(*startFreeList)->base<<" "
         <<(*startFreeList)->next<<" "
         <<(*startFreeList)->size<<endl;
  }
#endif

  i = * startFreeList ;

  pred = NULL ;

  addr = getAnInvalidOffset() ;

  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 *startFreeList ;
                      *startFreeList = newStartFreeList ; 
                      //cerr<<*startFreeList<<endl;
                   }
                   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 ;
          }
    }
  if (invalidOffset(addr) )
     {
        return NULL ;
        //cerr<<"PsnSecondarySharedMemoryManager::getFromThisFree : returning NULL"<<endl
     }
  else {
     
     return localAddressToGlobal(addr) ;
  }

}



void PsnSecondarySharedMemoryManager::addInThisFree (PsnMemoryElementDescriptor * * startFreeList, unsigned int base, size_t size) {

   //cerr<<"PsnSecondarySharedMemoryManager::addInThisFree "<<startFreeList<<endl;
   PsnMemoryElementDescriptor *l, *iNew, *tmp ;

   iNew= new PsnMemoryElementDescriptor();
   iNew->base = base ;
   iNew->size = size;
   
   if ( * startFreeList == NULL) { /* Empty list */
      iNew->next = (unsigned int) NULL ;
      *startFreeList = iNew ;
   }    
   else {
      l = *startFreeList ;
      if ( l->base > iNew->base ) {  /* iNew is the lowest interval */
         iNew->next = (unsigned int) * startFreeList ;
         *startFreeList = 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 ) {
            if (iNew->base + iNew->size == tmp -> base) {
               iNew->size += tmp->size ;
               iNew->next = tmp->next ;
               delete tmp ;
            }
         }
      }
      if ( l->base + l->size == iNew->base ) {
         l->size += iNew->size ;
         l->next = iNew->next ;
         if (*startFreeList == iNew) *startFreeList = l;
         delete iNew ;
      }     
   }
}


void PsnSecondarySharedMemoryManager::lock() {
   // nothing to do because lockIfNeeded protects local access (thread access) if lockNeeded returns true
#ifdef _DEBUGLOCK
   cerr<<"-";
#endif
}

void PsnSecondarySharedMemoryManager::unlock() {
#ifdef _DEBUGLOCK
   cerr<<"-";
#endif
}

bool PsnSecondarySharedMemoryManager::lockNeeded() {
   return true ;
}

void PsnSecondarySharedMemoryManager::synchronizeAfterLock(void *, long int) {
   //nothing to do.
}

---