---

PsnSharedMemoryManager.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 <PsnSharedMemoryManager.h>
#include <unistd.h>
#include <iostream>
#include <assert.h>
#include <PsnNew.h>
#include <PsNoMemoryAvailableException.h>


#ifdef _MOME
#include "PsnMemoryElementDescriptor.h"
#include <PsMomeController.h>
//#include <PsnLock.h>
#include <MomeDsm.h>
#endif



PsnSharedMemoryManager::PsnSharedMemoryManager(void *startDsm, 
                                               size_t sizeDsm, 
                                               size_t pageSize, 
                                               size_t alignedSize) :
   _sizeDsm(sizeDsm) , 
   _startDsm((unsigned int)startDsm) ,
   _pageSize(pageSize) , 
   _alignedSize(alignedSize) ,
   _numberOfLocks(0) , 
   _locked(false) 
{
   _freed.first=NULL;
}

PsnSharedMemoryManager::~PsnSharedMemoryManager() 
{
}


void PsnSharedMemoryManager::handOver(void * pointer, size_t allocatedSize, size_t sizeBefore, size_t sizeAfter) {
   cerr<<"Warning : Memory is being lost by PsnSharedMemoryManager::handOver"<<endl;
}


void * PsnSharedMemoryManager::mfastmalloc(size_t size) {
#ifdef _DEBUGALLOCATIONMOME
   cerr<<"PsnSharedMemoryManager::mfastmalloc "<<size<<endl;
#endif
   void * resul;
   if( _freed.first != NULL ) {
      if (( _freed.second - _pageSize < size ) && 
          (size <= _freed.second ) ) {

         resul = _freed.first;
         _freed.first = NULL;

      }
      else {
         lockIfNeeded();
#ifdef _DEBUGALLOCATIONMOME
         cerr<<"PsnSharedMemoryManager::mfastmalloc libération de "
             <<globalAddressToLocal(_freed.first)
             <<" "
             <<_freed.second
             <<endl;
#endif
         mfree(_freed.first,_freed.second);
         _freed.first=NULL;
         resul=mmalloc(size);
#ifdef _DEBUGALLOCATIONMOME
         cerr<<"PsnSharedMemoryManager::mfastmalloc reallocation de "
             <<globalAddressToLocal(resul)
             <<" "
             <<size
             <<endl;
#endif
         unlockIfNeeded();
      }
   }
   else {
         lockIfNeeded();
#ifdef _DEBUGALLOCATIONMOME
         cerr<<"PsnSharedMemoryManager::mfastmalloc : rien de dispo pour une allocation rapide"<<endl;
#endif
         resul=mmalloc(size);
         unlockIfNeeded();
   }     
   return resul;
}

void PsnSharedMemoryManager::mfastfree ( void *addr , size_t size) {
#ifdef _DEBUGALLOCATIONMOME
   cerr<<"PsnSharedMemoryManager::mfastfree"<<endl;
#endif
   if (_freed.first!=NULL) {//précedent freed needs to be really freeded
      lockIfNeeded();
#ifdef _DEBUGALLOCATIONMOME
      cerr<<"PsnSharedMemoryManager::mfastfree : il faut vraiment libérer "
          <<globalAddressToLocal(_freed.first)<<endl;
#endif
      mfree(_freed.first,_freed.second);
      unlockIfNeeded();
   }
#ifdef _DEBUGALLOCATIONMOME
   else {
      cerr<<"PsnSharedMemoryManager::mfastfree : rien a vraiment libérer "<<endl;
   }
#endif
   _freed.first=addr;
   _freed.second=alignedSize(size);
}


void PsnSharedMemoryManager::showMemory ( void ) {
   cerr<<"PsnSharedMemoryManager::showMemory "<<endl;
}


void * PsnSharedMemoryManager::mmalloc(size_t size) {
#ifdef _DEBUGALLOCATIONMOME
   cerr<<"PsnSharedMemoryManager::mmalloc"<<endl;
#endif
   //cout <<_locked<<" "<<! lockNeeded()<<" "<<size<<endl;
   assert( _locked || ! lockNeeded () );

   size_t allocatedSize=alignedSize(size);

   void * begin ;

   assert(allocatedSize>=size);

   begin = getFromFree ( allocatedSize );
   
   if ( invalidOffset ( globalAddressToLocal( begin ) ) ) {

      //cerr<<"PsnSharedMemoryManager::mmalloc génération d'une exception "<<allocatedSize<<endl;

      HeapStackTop usualContext(0);
     
      PsNoMemoryAvailableException error("PsnSharedMemoryManager::mmalloc ",allocatedSize) ;

      throw error ;
   }

//     char * toZero = (char *)begin;
//     for (int i=0 ; i<allocatedSize ; i++) {
//        toZero[i] = 0 ;
//     }

#ifdef _DEBUGALLOCATIONMOME
   cerr<<"FILE "<<MomeInternalDate()<<" + "<<allocatedSize<<" , "<<globalAddressToLocal(begin)<<endl;
   cerr<<begin<<" "<<allocatedSize<<endl;
#endif

   return begin;

}


void PsnSharedMemoryManager::mfree(void *addr, size_t size) {

   assert(_locked || !lockNeeded() );

   size_t allocatedSize=alignedSize(size);

#ifdef _DEBUGALLOCATIONMOME
   cerr<<"FILE "<<MomeInternalDate()<<" - "<<allocatedSize<<" , "<<globalAddressToLocal(addr)<<endl;
#endif

   addInFree ( addr , allocatedSize ) ;
#ifdef _DEBUGALLOCATIONMOME
   cerr<<"PsnSharedMemoryManager::"<<this<<"::mfree fait"<<endl;
#endif
}


void * PsnSharedMemoryManager::allocateSizeRemembered (size_t size) {

   void * resul;

   lockIfNeeded();

   size_t sizeOfOffsetForSize = alignedSize( sizeof(size_t) );

   resul = mmalloc( size + sizeOfOffsetForSize );

   if (resul != NULL) {
      *((size_t *)resul)=size;
      
      unlockIfNeeded();
      
      return ( (void *) ((unsigned int)resul + sizeOfOffsetForSize ) ) ;
   }
   else {
      return NULL ;
   }
}


void PsnSharedMemoryManager::freeSizeRemembered(void * ptr) 
{
   size_t size;

   if ( inAdressSpace ( ptr ) )
      {
#ifdef _DEBUGALLOCATIONMOME
                           cerr<<"Utilisation de notre free "<<endl;
#endif
         lockIfNeeded();
         
         size_t sizeOfOffsetForSize = alignedSize( sizeof(size_t) );
         
         size_t * addressOfSize = (size_t *)((unsigned int)ptr - sizeOfOffsetForSize );
         
         size = *addressOfSize;
         
         mfree( addressOfSize , size + sizeOfOffsetForSize );
         
         unlockIfNeeded() ;
      }
   else
      {
         PsnMemoryManager * correctMemoryManager = whichMemoryManager( ptr ) ;
         correctMemoryManager->freeSizeRemembered( ptr ) ;
      }
}


//-----------------------  lock management -------------------------//


void PsnSharedMemoryManager::lockIfNeeded() {

   _accessToLockData.protect();

   while (_locked && (_lockedBy != pthread_self() ) ) {
#ifdef _DEBUGLOCK
      cerr<<" PsnSharedMemoryManager::lockIfNeeded() : waiting for thread"<<_lockedBy<<endl;
#endif
      _conditionOnLocked.waitForChange(_accessToLockData) ;
   }

   _numberOfLocks++;
   
   if(!_locked) {
      
      if( lockNeeded() ) {
#ifdef _DEBUGLOCK
         cerr<<"PsnSharedMemoryManager::"<<this<<"::lockIfNeeded(";
         cerr.flush() ;
#endif
         
         lock();
         
         _locked = true;
         _lockedBy = pthread_self() ;
#ifdef _DEBUGLOCK
         cerr<<") effectif pour "<<_lockedBy<<endl;
#endif
      }
   }
   
   _accessToLockData.unprotect();

}


void PsnSharedMemoryManager::unlockIfNeeded() {

   _accessToLockData.protect();

   _numberOfLocks--;

   if ( _locked && ( _numberOfLocks == 0 ) ) {

      if( lockNeeded ( ) ) {

#ifdef _DEBUGLOCK
   cerr<<"PsnSharedMemoryManager::"<<this<<"::unlockIfNeeded(";
#endif
         unlock();
#ifdef _DEBUGLOCK
         cerr<<") effectif pour"<<_lockedBy<<endl;
#endif
         _locked=false;
         _accessToLockData.unprotect();
         _conditionOnLocked.signalChange () ;
      }
      else {
         _accessToLockData.unprotect();
      }
   }
   else {
         _accessToLockData.unprotect();
   }
}

bool PsnSharedMemoryManager::locked() const {

   return _locked;

}


//--------------------------- Adress, alignement and page manipulation -----// 


unsigned int PsnSharedMemoryManager::getAnInvalidOffset() const {

   return _sizeDsm;

}


bool PsnSharedMemoryManager::invalidOffset(unsigned int offset) const {

   return offset >= _sizeDsm;

}


size_t PsnSharedMemoryManager::pageSize() const {

   return _pageSize;

}
   

size_t PsnSharedMemoryManager::alignedSize(size_t size) {

   size_t allocatedSize;

   if ( size % _alignedSize != 0 ) {

      allocatedSize = ( size / _alignedSize + 1 ) * _alignedSize;

   }
   else {

      allocatedSize = size;

   }

   return allocatedSize;

}

---