---

PsnSharedMemoryManager.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 PsnSharedMemoryManagerHEADER
#define PsnSharedMemoryManagerHEADER

class PsnMemoryElementDescriptor;
class PsnLock;

#ifdef _PAIRNOTSTD
#include <utility>
#else
#include <pair.h>
#endif

#include <list>
#include "PsnMutexLock.h"
#include "PsnCondition.h"

#ifdef _SGI
#include <stddef.h>
#else
#include <cstddef>
#endif

#include "PsnSystemMemoryManager.h"

class PsnSharedMemoryManager : public PsnMemoryManager
{
public:

   PsnSharedMemoryManager(void *startDsm, size_t sizeDsm, size_t pageSize, size_t alignedSize);

   virtual ~PsnSharedMemoryManager();


   //------------------------- Allocation and deallocation --------------------//


   virtual void *mmalloc (size_t size);


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

   virtual void * mfastmalloc(size_t size);

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

   virtual void *allocateSizeRemembered (size_t size);

   virtual void freeSizeRemembered ( void * ptr);

   /* handOver : gives back memory associated to an adress. To be used if part of the memory asked for by a client isn't used by the client but cannot be returned at the same time as the rest of the memory allocated.
    * @param pointer the pointer associated to the freed memory
    * @param allocatedSize the size really used at pointer
    * @param sizeBefore the size freed just before the pointer zone 
    * @param sizeAfter the size free just after the pointer zone */
   virtual void handOver(void * pointer, size_t allocatedSize, size_t sizeBefore, size_t sizeAfter) ;

   //-------------------------- lock and unlock -----------------------//


   virtual void lockIfNeeded();

   virtual void unlockIfNeeded();



   //-------------------- offset manipulation and validity ------------//


   inline unsigned int globalAddressToLocal (void * addr) const {
      return ((unsigned int)addr)-_startDsm ;
   }

   inline void * localAddressToGlobal (unsigned int offset) const {
      return (void *)(_startDsm+offset);
   }

   virtual bool invalidOffset(unsigned int offset) const ;

   virtual unsigned int getAnInvalidOffset() const ;  

   virtual bool inAdressSpace(void * ptr) const 
   {
      unsigned int _ptr=(unsigned int)ptr;
      return ((_startDsm<=_ptr)&&(_ptr<_startDsm+_sizeDsm));
   }


   //------------------------------------------------------------------//


   virtual void sync() = 0 ;

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


   virtual size_t pageSize() const ;

   virtual void showMemory ( void ) ;

   virtual bool locked() const ;

protected:
   //-----------------------Lock Management internals --------------------//

   virtual void lock( ) = 0 ;

   virtual void unlock( ) = 0 ;

   virtual bool lockNeeded ( ) = 0 ;

   unsigned int _numberOfLocks ;

   bool _locked ;

   pthread_t _lockedBy ;

   PsnMutexLock _accessToLockData ;

   PsnCondition _conditionOnLocked ;
public:
   static PsnMutexLock * mutexCerr ;
   //---------------------------------------------------------------------//

protected:
   virtual void * getFromFree ( size_t size ) = 0 ;

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

   pair<void *,size_t> _freed;


   //------------- page size and alignement stuff -----------//


   size_t _pageSize;

   size_t _alignedSize;

   virtual size_t alignedSize(size_t size);


   //------ size and starting address of the shared memory -------//


   unsigned int _startDsm;

   unsigned int _sizeDsm;

};

#endif

---