---

PsnRelaxedMemoryManager.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 PsnRelaxedMemoryManagerHEADER
#define PsnRelaxedMemoryManagerHEADER

#ifdef _SGI
#include <list.h>
#else
#include <list>
#endif

#include <sys/time.h>
#include <time.h>

class PsnMemoryElementDescriptor; 
class PsnLock;

#include <PsnSharedMemoryManager.h>
class PsnSharedFreeStoreMemoryManager ;
class PsnSharedArrayMemoryManager ;
class PsnLatencySyncedSharedMemoryManager ;
class PsnOnceSyncedSharedMemoryManager ;
class PsnUniqueCreator ;


using namespace std ;

class PsnRelaxedMemoryManager : public PsnSharedMemoryManager {
public:
   PsnRelaxedMemoryManager(void * startDsm, size_t sizeDsm, size_t pageSize, PsnUniqueCreator * creator, int queueSize);
   virtual ~PsnRelaxedMemoryManager();

   virtual void sync() ;

   virtual void strongSync() ;

   virtual void strongSynchronizeRegion(unsigned int startRegion, size_t sizeRegion) ;

   virtual void synchronizeAfterLock(void* beginningAdress, long length);

   enum PageState { Free , StepSync , LatencySync , Allocated } ; 


   //-------------- fonction spéciales d'allocation ----------------------//

   virtual void * mRelaxedMalloc ( size_t size ) ;

   virtual void mRelaxedFree (void * ptr, size_t size) ;

   virtual void * mSyncMalloc ( size_t size ) ;

   virtual void mSyncFree (void * ptr, size_t size) ;
 
   virtual void *allocateSizeRemembered (size_t size) ;

   virtual void freeSizeRemembered ( void * ptr) ;

   virtual void * mmallocInPages (size_t size, unsigned int * initialOffsetForWrite, size_t * stepSize) ;

   virtual void mfreeInPages(void * ptr, size_t size) ;

   virtual void * mmallocForOnce ( size_t size ) ;

   virtual void mfreeForOnce(void * ptr, size_t size) ;

   virtual void anticipateFreeStoreAllocation(int frame) ;

   static inline int getWritableQueueIndex()  {
      return _writableQueueIndex ;
   }

   static inline int getNextSyncedQueueIndex()  {
      return _nextSyncedQueueIndex ;
   }

   static inline int getReadableQueueIndex()  {
      return _readableQueueIndex ;
   }

protected:
   virtual void * mLatencyMalloc(size_t size, list < PsnLatencySyncedSharedMemoryManager *> & memoryManagerList, int latency) ;

   virtual void mLatencyFree(void * ptr, size_t size, list < PsnLatencySyncedSharedMemoryManager * > & memoryManagerList) ;


   virtual void lock();

   virtual void unlock();

   virtual bool lockNeeded ( ) ;

   virtual void * getFromFree ( size_t size );

   virtual void addInFree (void *addr, size_t size);

   PsnLock * _myLock;

   PageState * _pageState ;

   bool * _myPage ;

   int * _whenSynced ;

   friend class PsnFramedMemoryManager ;
   friend class PsnLatencySyncedSharedMemoryManager;
   friend class PsnOnceSyncedSharedMemoryManager;
   int _numberOfManagedPages ;

   int _firstFreePage ;

   PsnUniqueCreator * const _myCreator ;

   list < PsnSharedFreeStoreMemoryManager * > freeStoreManagers ;

   list < PsnSharedArrayMemoryManager * > sharedArrayManagers ;

   list < PsnLatencySyncedSharedMemoryManager * > stepSyncedMemoryManagers ;

   list < PsnLatencySyncedSharedMemoryManager * > relaxedSyncedMemoryManagers ;

   list < PsnOnceSyncedSharedMemoryManager * > onceSyncedMemoryManagers ;

   static int _readableQueueIndex ;

   static int _writableQueueIndex ;

   static int _nextSyncedQueueIndex ;

   const int _queueSize ;

   virtual void syncSecondaryMemoryManagers() ;

public:
   virtual void syncStepSyncedMemory() ;

protected:
   /* the frame current free store allocation needs to be ready for 
    * -1 meens next writable frame */
   int _frameForFreeStoreAllocation ;

   unsigned long * oldSyncDate ;

   bool _lockIsNeeded ;

   long _timelost ;
   timeval _dateReelleDebut ;
   timeval _dateReelleFin ;
   

};

#endif

---