---

PsnUniqueCreator.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
 *
 */
#if defined (_MOME) && !defined (_OLDALLOCATORS)
#include <PsnUniqueCreator.h>
#include <MomeDsm.h>
#include <mySharedAllocator.h>
#include <PsNomSymServer.h>
#include <PsnOutputOffsetTable.h>
#include <PsnBroadcastManager.h>
#include "PsnLock.h"

PsnUniqueCreator::PsnUniqueCreator(PsnCoherantMemoryManager * memoryManager) 
   : _myDataMemoryManager(memoryManager) {
   //si l'assertion là est fausse, il faut changer dans le .h le nombre de tables prévue pour lebroadcastmanager
   assert(2*PsnBroadcastManager::nbTablesDansBuffer==6);
   _mySharedData= newPsnUniqueCreatorData(); 
}

PsnUniqueCreatorData * PsnUniqueCreator::newPsnUniqueCreatorData() {
   if(MomeMe==0) {
      _mySharedData = new(_myDataMemoryManager) PsnUniqueCreatorData();
   }
   else {
      _mySharedData=(PsnUniqueCreatorData * )_myDataMemoryManager->localAddressToGlobal(_myDataMemoryManager->uniqueCreatorDataOffset);
   }
   return _mySharedData;
}
//La version selon la norme !
//  PsNomSymServerMome * PsnUniqueCreator::newPsNomSymServer(int i) {
//     PsNomSymServerMome * result;
//     if(MomeMe==0) {
//        const PsNomSymServerT<STL_ALLOC> & ancServeur(*((PsNomSymServerT<STL_ALLOC> *)PsNomSym::serveurDeNom));
//        result = new PsNomSymServerT<mySharedAllocatorT>(i);
//        *result = ancServeur;
//        if(*result==*PsNomSym::serveurDeNom) {
//       cout<<"Conversion réussie"<<endl;
//        }
//        else {
//       PsnControleur::error("PsnUniqueCreator::newPsNomSymServer : pb de conversion de PsNomSymServer");
//        }
//        _mySharedData->myNameServer=_myDataMemoryManager->globalAddressToLocal(result);
//        MomeBarrier();
//     }
//     else {
//        MomeBarrier();
//        result=(PsNomSymServerT<mySharedAllocatorT> *)_myDataMemoryManager->localAddressToGlobal(_mySharedData->myNameServer);
//     }
//     return result;
//  }

//La version qui compile
PsNomSymServerMome * PsnUniqueCreator::newPsNomSymServer(int i) {
   PsNomSymServerMome * result;
   if(MomeMe==0) {
      const PsNomSymServerClassique & ancServeur(*((PsNomSymServerClassique *)PsNomSym::serveurDeNom));
      result = new PsNomSymServerMome(ancServeur.getCanonicalRepresentation() );
      if(*result==*PsNomSym::serveurDeNom) {
         cout<<"Conversion réussie"<<endl;
      }
      else {
         PsnControleur::error("PsnUniqueCreator::newPsNomSymServer : pb de conversion de PsNomSymServer");
      }
      _mySharedData->myNameServer=_myDataMemoryManager->globalAddressToLocal(result);
   }
   else {
      //because new results in the creation of a lock, create à false one
      PsnLock * unImportant = new PsnLock() ;
      result=(PsNomSymServerMome *)_myDataMemoryManager->localAddressToGlobal(_mySharedData->myNameServer);
   }
   return result;
}


void * PsnUniqueCreatorData::operator new(size_t size, const PsnCoherantMemoryManager * aMemoryManager) {
   return aMemoryManager->localAddressToGlobal(aMemoryManager->uniqueCreatorDataOffset);
}

PsnOutputOffsetTable * PsnUniqueCreator::newPsnOutputOffsetTable() {
   PsnOutputOffsetTable * result;
   if(MomeMe==0) {
      result = new PsnOutputOffsetTable();
      _mySharedData->_myOutputServer=_myDataMemoryManager->globalAddressToLocal(result);
   }
   else {
      //because new results in the creation of a lock, create à false one
      PsnLock * unImportant = new PsnLock() ;
      result=(PsnOutputOffsetTable *)_myDataMemoryManager->localAddressToGlobal(_mySharedData->_myOutputServer);
   }
   return result;
}

PsnBroadcastManager::_myTypeOfTable * PsnUniqueCreator::newbroadcastManagerTable(int i) {
   PsnBroadcastManager::_myTypeOfTable * resul;
   if(MomeMe==0) {
      //install our memory manager as the default memory manager
      HeapStackTop toto(_myDataMemoryManager);
      resul = new PsnBroadcastManager::_myTypeOfTable();
#ifdef _DEBUGEVT
      cerr<<"PsnUniqueCreator::newbroadcastManagerTable"<<resul<<endl;
#endif
      _mySharedData->_broadcastManagerTables[i]=_myDataMemoryManager->globalAddressToLocal(resul);
   }
   else {
      resul=(PsnBroadcastManager::_myTypeOfTable *)_myDataMemoryManager->localAddressToGlobal(_mySharedData->_broadcastManagerTables[i]);
   }
   return resul;
}

//  PsnMomeWeakMemoryManager::coheranceType * PsnUniqueCreator::newcoheranceType(int size) {
//     PsnMomeWeakMemoryManager::coheranceType * resul;
//     if(MomeMe==0) {
//        //install our memory manager as the default memory manager
//        HeapStackTop toto(_myDataMemoryManager);
//        resul = new PsnMomeWeakMemoryManager::coheranceType[ size ] ;
//        _mySharedData->_coheranceTable = _myDataMemoryManager->globalAddressToLocal( resul );
//     }
//     else {
//        resul = ( PsnMomeWeakMemoryManager::coheranceType * )_myDataMemoryManager->localAddressToGlobal(_mySharedData->_coheranceTable );
//     }
//     return resul;
//  }


PsnRelaxedMemoryManager::PageState * PsnUniqueCreator::newPageStateTable( int size ) {
   _myDataMemoryManager->lockIfNeeded();
   PsnRelaxedMemoryManager::PageState * resul;
   if(_mySharedData->_numberOfPageStateTable == 0) {
      //install our memory manager as the default memory manager
      HeapStackTop toto(_myDataMemoryManager);
      resul = new PsnRelaxedMemoryManager::PageState [ size ] ;
      _mySharedData->_coheranceTable = _myDataMemoryManager->globalAddressToLocal( resul );
      for (int i = 0; i<size ; i++) {
         resul[i] = PsnRelaxedMemoryManager::Free ;
      }
   }
   else {
      resul = ( PsnRelaxedMemoryManager::PageState * )_myDataMemoryManager->localAddressToGlobal(_mySharedData->_coheranceTable );
   }
   //
   ++(_mySharedData->_numberOfPageStateTable) ;
   _myDataMemoryManager->unlockIfNeeded() ;
   return resul;   
}
  
void PsnUniqueCreator::deletePageStateTable ( int size ) {
   _myDataMemoryManager->lockIfNeeded() ;
   --(_mySharedData->_numberOfPageStateTable) ;
   if(_mySharedData->_numberOfPageStateTable == 0) {
      delete[] (PsnRelaxedMemoryManager::PageState *) _myDataMemoryManager -> localAddressToGlobal(_mySharedData->_coheranceTable );
   }
   _myDataMemoryManager->unlockIfNeeded() ;
}


int * PsnUniqueCreator::newWhenSyncedTable( int size ) {
   _myDataMemoryManager->lockIfNeeded();
   int * resul;
   if(_mySharedData->_numberOfWhenSyncedTable == 0) {
      //install our memory manager as the default memory manager
      HeapStackTop toto(_myDataMemoryManager);
      resul = new int [ size ] ;
      _mySharedData->_whenSyncedTable = _myDataMemoryManager->globalAddressToLocal( resul );
      for (int i = 0; i<size ; i++) {
         resul[i] = 0 ;
      }
   }
   else {
      resul = ( int * )_myDataMemoryManager->localAddressToGlobal(_mySharedData->_whenSyncedTable );
   }
   //
   ++(_mySharedData->_numberOfWhenSyncedTable) ;
   _myDataMemoryManager->unlockIfNeeded() ;
   return resul;   
}
  
void PsnUniqueCreator::deleteWhenSyncedTable ( int size ) {
   _myDataMemoryManager->lockIfNeeded() ;
   --(_mySharedData->_numberOfWhenSyncedTable) ;
   if(_mySharedData->_numberOfWhenSyncedTable == 0) {
      delete[] (int *) _myDataMemoryManager -> localAddressToGlobal(_mySharedData->_whenSyncedTable );
   }
   _myDataMemoryManager->unlockIfNeeded() ;
}

#endif

---