---

PsnNew.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 <PsnNew.h>
#include <PsnMemoryElementDescriptor.h>
#include <PsnSharedMemoryManager.h>
#include <PsnSystemMemoryManager.h>
#include <iostream>

PsnSystemMemoryManager * HeapStackTop::getSystemMemoryManager()
{
   // using new causes an infinite loop, as new needs getSystmeMemoryManager
   // 
   static PsnSystemMemoryManager toto ; 
   return & toto ;
}

pthread_key_t HeapStackTop::initialiseGlobalMemoryManagerKey () 
{
   static bool done = false ;
   if ( ! done )
      {
         pthread_key_t res ;
         pthread_key_create(&res, NULL) ;
         pthread_setspecific ( res , getSystemMemoryManager() );
         done = true ;
         globalMemoryManagerKey = res ;
         return res ;
      }
   else 
      {
         return globalMemoryManagerKey ;
      }
}



pthread_key_t HeapStackTop::initialiseFreedKey () 
{
   static bool done = false ;
   if ( ! done )
      {
         pthread_key_t res ;
         pthread_key_create(&res, NULL) ;
         pthread_setspecific ( res , NULL );
         done = true ;
         freedKey =res ;         
         return res ;
      }
   else 
      {
         return freedKey ;
      }
}

pthread_key_t HeapStackTop::globalMemoryManagerKey = HeapStackTop::initialiseGlobalMemoryManagerKey () ;
pthread_key_t HeapStackTop::freedKey = HeapStackTop::initialiseFreedKey () ;



void * HeapStackTop::operator new (size_t size) {
   static pthread_key_t bidon = initialiseFreedKey () ;
   void * freed = pthread_getspecific(freedKey) ;

   if (freed!=NULL) {
      return freed;
   }
   else {
      return ::operator new(size);
   }
}

void HeapStackTop::operator delete(void* addr, size_t size) {
   static pthread_key_t bidon = initialiseFreedKey () ;
   void * freed = pthread_getspecific(freedKey) ;
   if (freed!=NULL) {
      ::operator delete (freed);
   }
   pthread_setspecific(freedKey, addr);
}



HeapStackTop::HeapStackTop(PsnMemoryManager * newTop) {
   static pthread_key_t bidon = HeapStackTop::initialiseGlobalMemoryManagerKey () ;
#ifdef _DEBUGMEMORYMANAGEMENT
   cerr<<"HeapStackTop::HeapStackTop"<<endl;
#endif
   _oldMemoryManager = pthread_getspecific( globalMemoryManagerKey ) ;
   pthread_setspecific ( globalMemoryManagerKey , newTop );
}



HeapStackTop::~HeapStackTop() {
   static pthread_key_t bidon = HeapStackTop::initialiseGlobalMemoryManagerKey () ;
#ifdef _DEBUGMEMORYMANAGEMENT
   cerr<<"HeapStackTop::~HeapStackTop"<<endl;
#endif
   pthread_setspecific ( globalMemoryManagerKey , _oldMemoryManager );
}

#ifndef _SGI

void *operator new (size_t size) throw (bad_alloc) 
{
   /* because new could be used during static allocations, and that order of static initialisation 
    * cannot be controlled, the first time new is called it's possible that HeapStackTop::globalMemoryManagerKey
    * has not yet been initialised. Therefore, a correct initialisation of 
    * HeapStackTop::globalMemoryManagerKey has to be generated on the first call to the redefined new*/

   static pthread_key_t bidon = HeapStackTop::initialiseGlobalMemoryManagerKey () ;

#ifdef _DEBUGMEMORYMANAGEMENT
   assert ( bidon == HeapStackTop::globalMemoryManagerKey ) ;
#endif

   void * resul;
#ifdef _DEBUGMEMORYMANAGEMENT
   cerr<<"Utilisation de new "<<endl;
#endif
   void * currentMemoryManager = (PsnMemoryManager *) pthread_getspecific( HeapStackTop::globalMemoryManagerKey ) ;

#ifdef _DEBUGMEMORYMANAGEMENT
   assert ( currentMemoryManager != NULL ) ;
#endif

   resul = ( (PsnMemoryManager *)currentMemoryManager)->allocateSizeRemembered(size);
      
#ifdef _DEBUGMEMORYMANAGEMENT
   cerr<<"Utilisation de new fin "<<resul<<endl;
#endif
   return resul;
}



void *operator new[] (size_t size) throw (bad_alloc) 
{
   void * resul = operator new(size) ;
   if (resul != NULL) 
      {
         return resul ;
      }
   else 
      {
         throw bad_alloc() ;
      }
}



void *operator new (size_t size, const nothrow_t&) throw() 
{
   return operator new(size);
}

void *operator new[] (size_t size, const nothrow_t&) throw() {
   return operator new(size);
}

void operator delete (void * ptr) throw() {
#ifdef _DEBUGMEMORYMANAGEMENT
   cerr<<"Utilisation de delete "<<ptr<<endl;
#endif
   if ( ptr != 0 ) 
      {
         PsnMemoryManager * currentMemoryManager = (PsnMemoryManager *) (pthread_getspecific( HeapStackTop::globalMemoryManagerKey ) );

         if ( currentMemoryManager != NULL )
            {
               // heuristic: the correct memory manager to use is probably the current memory manager
               // this heuristic enables to avoid global search (and look) for the correct memory manager in the good cases
               currentMemoryManager->freeSizeRemembered( ptr );
            }
      }
#ifdef _DEBUGMEMORYMANAGEMENT
   cerr<<"Utilisation de delete fin"<<endl;
#endif
}

void operator delete[] (void * ptr) throw() {
#ifdef _DEBUGMEMORYMANAGEMENT
   cerr<<"operator delete[] (void * ptr) throw()"<<endl;
#endif
   operator delete ( ptr ) ;
   //   operator delete(ptr);
}

void operator delete (void * ptr , const nothrow_t&) throw() 
{
   operator delete(ptr) ;
   //operator delete(ptr);
}

void operator delete[] (void * ptr , const nothrow_t&) throw() 
{
   operator delete(ptr);
   //operator delete(ptr);
}

#endif

---