---

PsnMomeArray.h

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 
 *
 */
#ifndef PsnMomeArrayHEADER
#define PsnMomeArrayHEADER

#include "PsnArray.h"

class PsnRelaxedMemoryManager ;

template <typename T>
class PsnMomeArray : public PsnAbstractArray< T > {
public: 
   PsnMomeArray ( size_t taille, PsnRelaxedMemoryManager & memoryManager );
   virtual ~PsnMomeArray () ;
   virtual T & operator [] ( int i ) ;
   virtual const T & operator [] ( int i ) const ;
   void * operator new(size_t size, PsnRelaxedMemoryManager * memoryManager );
   void operator delete(void*, size_t);
   virtual void resync ( PsnRelaxedMemoryManager * myMemory ) const ;
protected:
   unsigned int _offset ;
   size_t _step ;
   size_t _taille ;
};

#include "PsnRelaxedMemoryManager.h"

template <typename T>
void * PsnMomeArray< T >::operator new(size_t size, PsnRelaxedMemoryManager * memoryManager ) {
   return memoryManager->mmallocForOnce (size) ;
}

template <typename T>
void PsnMomeArray< T >::operator delete(void* addr, size_t size) {
   PsnRelaxedMemoryManager * freeFrom = dynamic_cast <PsnRelaxedMemoryManager * > (PsnMemoryManager::whichMemoryManager( addr )) ;
   //assert (freeFrom != NULL) ;
   freeFrom->mfreeForOnce(addr, size) ;
  
}


template <typename T>
PsnMomeArray< T >::PsnMomeArray(size_t taille, PsnRelaxedMemoryManager & memoryManager) : PsnAbstractArray<T> (taille), _taille(taille) {
   HeapStackTop specialContext(&memoryManager);
  //cerr<<"PsnMomeArray< T >::PsnMomeArray "<<sizeof(T)<<" "<<_taille<<endl;
   unsigned int initialOffset;   
   _offset=(unsigned int)memoryManager.mmallocInPages(sizeof(T), &initialOffset, &_step);
   assert( pthread_getspecific(HeapStackTop::globalMemoryManagerKey) != NULL );
   for (unsigned int i=0; i<taille ; i++) {
      memoryManager.anticipateFreeStoreAllocation(i);
      T * tmp = new((void *) (_offset + i *_step) ) T();
      tmp->dateValeur = PsDate( - 2 ) ;
   }
   memoryManager.anticipateFreeStoreAllocation(-1);
}

template <typename T>
PsnMomeArray< T >::~PsnMomeArray() {
   PsnRelaxedMemoryManager * memoryManager = dynamic_cast<PsnRelaxedMemoryManager *>(PsnMemoryManager::whichMemoryManager((void *)_offset));
   //assert (memoryManager != NULL) ;
   memoryManager->mfreeInPages((void *)(_offset), sizeof(T));
}


template <typename T>
T & PsnMomeArray< T >::operator [] ( int i ) {
   //cerr<<"PsnMomeArray< T >::operator [] "<<(void *)_offset<<" "<< i <<" "<<_taille<<endl;
   //assert(i < _taille) ;
   return *((T *) (_offset + i * _step)) ;
}


template <typename T>
const T & PsnMomeArray< T >::operator [] ( int i ) const {
   //assert(i < _taille) ;
   return *(T *) (_offset + i * _step) ;
}
template <typename T>
void PsnMomeArray< T >::resync ( PsnRelaxedMemoryManager * myMemory ) const {
   myMemory->strongSynchronizeRegion( (myMemory->globalAddressToLocal((void *)_offset)/4096) * 4096,
                                       _step * _taille);
}
#endif

---