---

PsnSharedFreeStoreMemoryManager.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 "PsnSharedFreeStoreMemoryManager.h"
#include "PsnRelaxedMemoryManager.h"
#include "PsnMemoryElementDescriptor.h"


PsnSharedFreeStoreMemoryManager::PsnSharedFreeStoreMemoryManager(size_t sizeDsm, size_t pageSize, size_t alignedSize, PsnRelaxedMemoryManager & memoryManager, int queueSize) : 
   PsnFramedMemoryManager(sizeDsm,
                          pageSize, 
                          alignedSize, 
                          memoryManager, 
                          queueSize)
{
   //cerr<<"gestion des adresses entre "<<(void *)_startDsm<<" et "<<(void *)(_startDsm+_sizeDsm)<<endl;
   _tabLibres = new PsnMemoryElementDescriptor * [ _queueSize ] ;

   _tabTailleLibre = new size_t [ _queueSize ] ;
   int * toto ;
   for (int i = 0 ; i < _queueSize ; i++ ) {
      _tabLibres [ i ] = new PsnMemoryElementDescriptor() ;
      _tabLibres [ i ]->base = i * _blockSize ;
      _tabLibres [ i ]->size = _blockSize ; 
      _tabLibres [ i ]->next = (unsigned int) NULL ;
      _tabTailleLibre [ i ] = _blockSize ;
      assert(_blockSize == _pageSize) ; //for rapid prototyping
      //write something on every page so that prefetch will work
      toto = (int *)(_startDsm + i * _pageSize) ;
      *toto = 0 ;
   }
}

PsnSharedFreeStoreMemoryManager::~PsnSharedFreeStoreMemoryManager () {
   for (int i = 0 ; i < _queueSize ; i++ ) {
      assert (_tabTailleLibre [ i ] == _blockSize) ;
      delete _tabLibres [ i ] ;
   }
   delete [] _tabLibres ;
   delete [] _tabTailleLibre ;
}


size_t PsnSharedFreeStoreMemoryManager::getSize() {
   return _sizeDsm ;
}
        
void * PsnSharedFreeStoreMemoryManager::mallocAvecMemoire(size_t size, int frame) {
   int oldCurrentWritableIndex = _currentWritableIndex ;
   _currentWritableIndex = frame ;
   void * resul=PsnFramedMemoryManager::allocateSizeRemembered(size);
   _currentWritableIndex = oldCurrentWritableIndex ;
   return resul;
}


void * PsnSharedFreeStoreMemoryManager::mmalloc (size_t size) {

   void * resul ;
   size_t allocatedSize=alignedSize(size);
   //cerr<<"PsnSharedFreeStoreMemoryManager::mmalloc "<<allocatedSize<<" "<<_tabTailleLibre[ nextQueueIndex ]<<endl;
   if (allocatedSize <= _tabTailleLibre[ _currentWritableIndex ]) {
      resul = getFromThisFree( & (_tabLibres [ _currentWritableIndex ]) , allocatedSize) ;
      if ( resul != NULL ) {
         if ( _tabTailleLibre [ _currentWritableIndex ] == _blockSize ) {
            addBlockInSync( _currentWritableIndex ); 
         }
         _tabTailleLibre [ _currentWritableIndex ] -= allocatedSize ;
      }
   }
   else {
      resul = NULL ;
   }
   //cerr<<"Block alloué à : "<<resul<<", debut de la memoire gérée : "<<(void *)_startDsm<<", page relative "<<_currentWritableIndex<<endl;
   return resul ;
}
                                  
void PsnSharedFreeStoreMemoryManager::mfree (void * ptr , size_t size) {
   assert( inAdressSpace(ptr) ) ;

   size_t allocatedSize=alignedSize(size);
   //cerr<<"PsnSharedFreeStoreMemoryManager::mfree a "<<ptr<<" "<<allocatedSize<<endl;
   unsigned int offsetInMemory = globalAddressToLocal ( ptr ) ;
   unsigned int blockNumber = offsetInMemory / _blockSize ;

   //unsigned int offsetInBlock = offsetInMemory - blockNumber * _blockSize ;

   //assert ( offsetInBlock < _blockSize ) ;
   assert ( blockNumber < _queueSize ) ;

   addInThisFree( & _tabLibres [ blockNumber ] , offsetInMemory , allocatedSize ) ;

   _tabTailleLibre [ blockNumber ] -= allocatedSize ;
   
   if (_tabTailleLibre [ blockNumber ] == 0 ) {
      cerr<<"PsnSharedFreeStoreMemoryManager::mfree "<<blockNumber<<" removed from sync"<<endl;
      removeBlockFromSync ( blockNumber ) ;
   }
   
}

---