---

PsPvmNameServer.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
 *
 */
#ifdef _PVM
#include "PsPvmNameServer.h"

#include <stdio.h>
#include "pvm3.h"
#include "PsnSvmLink.h"
#include "PsController.h"
#include "PsnPvmSvm.h"

PsPvmNameServer::PsPvmNameServer ( int mainNameServerSiteId, PsNameServer & nameServer ) :
  PsClassicalNameServer ( nameServer.getCanonicalRepresentation() ),
  _mainNameServerSiteId ( mainNameServerSiteId )
{
#ifdef _DEBUGDISTRIBUTEDNAMESERVER
   cerr<<"PsPvmNameServer::PsPvmNameServer"<<endl;
#endif

   correspondenceContainerType::const_iterator i ;
   for ( i = _stringToIdCorrespondenceContainer.begin() ; 
         i != _stringToIdCorrespondenceContainer.end();
         ++i ) 
      {
         _idToNamesUsingIdContainer.insert(placeOfNamesContainerType::value_type((*i).second,
                                                                                 new list<PsName *>(nameServer.getNamesOfId ((*i).second) ) ) ) ;

         assert ( (*_idToNamesUsingIdContainer.find((*i).second)).second->size() == _tableNbInstances[(*i).second] ) ;
      }

   //make sure the constructed PvmName server is compatible with the central name server
   int oldbufid = pvm_setsbuf ( 0 ) ; //save the current send buffer 

  if ( oldbufid < 0 )
    {
      cerr<<"PsPvmNameServer::PsPvmNameServer: pvm_setsbuf error "<<oldbufid<<endl;
      if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
    }

  int bufid = pvm_initsend( PsnPvmSvm::pvmDataEncoding ) ; 
  
  if ( bufid < 0 )
    {
      cerr<<"PsPvmNameServer::PsPvmNameServer: pvm_initsend error "<<bufid<<endl;
      if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
    }
  
  //pack a timeStamp
  long toto = 0 ;
  int infot = pvm_pklong ( &toto, 1, 1 ) ;

  //pack the current name server
  
  long numberOfPairs = _stringToIdCorrespondenceContainer.size() ;
  int info = pvm_pklong ( &numberOfPairs, 1, 1 ) ;

  long verifySize = 0 ;
  int stringLength ;
  for ( correspondenceContainerType::const_iterator i = _stringToIdCorrespondenceContainer.begin() ;
        i != _stringToIdCorrespondenceContainer.end() ;
        ++i )
    {
      ++verifySize ;
      stringLength = (*i).first.getStringLength() + 1 ;
      pvm_pkint ( const_cast<int *> ( &stringLength), 1, 1 ) ;
      pvm_pkstr ( const_cast<char *>((*i).first.getCString()) ) ;
      pvm_pklong ( const_cast<long *> (&((*i).second)) , 1, 1 ) ;
    }

  assert (verifySize == numberOfPairs ) ;

  if (info < 0 )
    {
      cerr<<"PsPvmNameServer::PsPvmNameServer: pvm_pkstr error "<<info<<endl;
      if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
    }

  info = pvm_send (_mainNameServerSiteId, PsnPvmMessage::NameServiceVerifyLocalNameServer ) ;

  if (info < 0 )
    {
      cerr<<"PsPvmNameServer::PsPvmNameServer: pvm_send error "<<info<<endl;
      if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
    }
          
  info = pvm_setsbuf ( oldbufid ) ; //replace the current send buffer

  if (info < 0 )
    {
      cerr<<"PsPvmNameServer::PsPvmNameServer: pvm_setsbuf error "<<info<<endl;
      if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
    }

  //save the current receive buffer
  oldbufid = pvm_setrbuf ( 0 ) ;

  //wait for the answer
  bufid = pvm_recv (_mainNameServerSiteId, PsnPvmMessage::NameServiceVerifyResult ) ;
          
  if ( bufid < 0 )
    {
      cerr<<"PsPvmNameServer::PsPvmNameServer: pvm_recv error "<<bufid<<endl;
      if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
    }
  
  int numberOfIncompatibilities ;
  info = pvm_upkint ( & numberOfIncompatibilities, 1, 1 ) ;
  

  if (info < 0 )
    {
      cerr<<"PsPvmNameServer::PsPvmNameServer: pvm_upkint error "<<info<<endl;
      if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
    }

  PsName::idType oldId ;
  PsName::idType newId ;
  map<PsName::idType, PsName::idType> listOfNeededConversions ;
  for ( int i = 0 ; i < numberOfIncompatibilities ; ++ i )
     {
        info = pvm_upklong ( & oldId, 1, 1 ) ;

        if (info < 0 )
           {
              cerr<<"PsPvmNameServer::PsPvmNameServer: pvm_upklong error "<<info<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
           }

        info = pvm_upklong ( & newId, 1, 1 ) ;  
        if (info < 0 )
           {
              cerr<<"PsPvmNameServer::PsPvmNameServer: pvm_upklong error "<<info<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
           }
        
        listOfNeededConversions[oldId] = newId ;

     }

  
  map<PsName::idType, PsName::idType>::iterator  j = listOfNeededConversions.begin() ;
  while ( j != listOfNeededConversions.end() )
     {
        oldId = (*j).first ;
        newId = (*j).second ;

        cerr<<"PsPvmNameServer::PsPvmNameServer: converting "<<oldId<<" to "<<newId<<endl;

        assert ( oldId < _nextIdentifier ) ;

        if ( newId >= _nextIdentifier )
           {
              cerr<<"PsPvmNameServer::PsPvmNameServer: updating nextIdentifier from "<<_nextIdentifier<<" to "<< newId + 1 <<endl;
              _nextIdentifier = newId + 1 ;
           }

        //replace the id in the name server warning : newId could be known or unknown from the name server
        bool newIdPresent = ( _tableNbInstances.find(newId) != _tableNbInstances.end() ) ;

        // - first take care of the number of references to the string corresponding to each Id
        referenceCountingContainerType::iterator oldRefCount = _tableNbInstances.find(oldId) ;
        referenceCountingContainerType::iterator newRefCount = _tableNbInstances.find(newId) ;

        int referencesToOldId = (*oldRefCount).second ;
        _tableNbInstances.erase ( oldRefCount ) ;


        if ( newIdPresent )
           {
              assert ( newRefCount != _tableNbInstances.end() ) ;
              int referencesToNewId = (*newRefCount).second ;
              _tableNbInstances.erase ( newRefCount ) ;
              _tableNbInstances.insert(referenceCountingContainerType::value_type(oldId, referencesToNewId ) ) ;
           }

        //    - only insert once the eventual copy has been archived
        _tableNbInstances.insert(referenceCountingContainerType::value_type(newId, referencesToOldId ) ) ;


        // - then take care of the list of PsName instances of each Id        
        placeOfNamesContainerType::iterator oldNameList = _idToNamesUsingIdContainer.find(oldId) ;
        placeOfNamesContainerType::iterator newNameList = _idToNamesUsingIdContainer.find(newId) ;

        list<PsName *> * referencesToOldList = (*oldNameList).second ;
        _idToNamesUsingIdContainer.erase ( oldNameList ) ;

        if ( newIdPresent )
           {
              assert ( newNameList != _idToNamesUsingIdContainer.end() ) ;
              list<PsName *> * referencesToNewList = (*newNameList).second ;
              _idToNamesUsingIdContainer.erase ( newNameList ) ;
              _idToNamesUsingIdContainer.insert(placeOfNamesContainerType::value_type(oldId, referencesToNewList) ) ;
           }

        //    - only insert once the eventual copy has been archived
        _idToNamesUsingIdContainer.insert(placeOfNamesContainerType::value_type(newId, referencesToOldList) ) ;

        
        // - then take care of the PsString to Id references 
        PsString newStringOfNewId ( (*(*_fastStringAccessTable.find(oldId)).second ).first ) ;
        _fastStringAccessTable.erase ( _fastStringAccessTable.find ( oldId ) ) ;
        _stringToIdCorrespondenceContainer.erase ( _stringToIdCorrespondenceContainer.find (newStringOfNewId) );

        if ( newIdPresent )
           {
              PsString newStringOfOldId ( (*(*_fastStringAccessTable.find(newId)).second ).first ) ;
              _fastStringAccessTable.erase ( _fastStringAccessTable.find ( newId ) ) ;
              _stringToIdCorrespondenceContainer.erase ( _stringToIdCorrespondenceContainer.find (newStringOfOldId) );
              pair<correspondenceContainerType::iterator,bool> insertRes = _stringToIdCorrespondenceContainer.insert(correspondenceContainerType::value_type(newStringOfOldId, oldId)) ;
              _fastStringAccessTable[oldId] = insertRes.first ;
           }
        
        //    - only insert once the eventual copy has been archived
        pair<correspondenceContainerType::iterator,bool> res = _stringToIdCorrespondenceContainer.insert(correspondenceContainerType::value_type(newStringOfNewId, newId)) ;
        _fastStringAccessTable[newId] = res.first ;
        

        //here, newId and oldId have been exchanged in tha data structures, but not in the PsNames nor in the listOfNeededConversions. Therefore, we will replace the PsName containing oldId with PsNames containing newId, and change the list Ofneeded conversions so that the conversion from newId to anotherId is replaced by a conversion of oldId to anotherId
        
        // - replace the id in the PsNames
        newNameList = _idToNamesUsingIdContainer.find ( newId ) ;
        
        assert ( newNameList != _idToNamesUsingIdContainer.end() ) ;
        assert ( (*newNameList).second != NULL ) ;
        assert ( (*newNameList).second->size() == _tableNbInstances[ newId ] ) ;
        
        for ( list<PsName *>::iterator listIter = (*newNameList).second->begin() ;
              listIter != (*newNameList).second->end() ;
              ++listIter )
           {
              changeNamesId (*listIter, oldId, newId) ;
           }

        listOfNeededConversions.erase (j) ;

        if ( newIdPresent )
           {
              // - update the conversion from newId to anotherId by a conversion of oldId to anotherId
              map<PsName::idType, PsName::idType>::iterator k = listOfNeededConversions.find ( newId ) ;
              assert ( k != listOfNeededConversions.end() ) ;

              PsName::idType anotherId = (*k).second ;

              listOfNeededConversions.erase ( k ) ;
              
              if ( anotherId != oldId )
                 {
                    listOfNeededConversions[oldId] = anotherId ;
                 }

              // - update the PsName so that assertions won't fail and for final permutations
              newNameList = _idToNamesUsingIdContainer.find ( oldId ) ;
              for ( list<PsName *>::iterator listIter = (*newNameList).second->begin() ;
                    listIter != (*newNameList).second->end() ;
                    ++listIter )
                 {
                    changeNamesId (*listIter, newId, oldId) ;
                 }
              
              cerr<<"PsPvmNameServer::PsPvmNameServer: "<<oldId<<" will now be converted in "<<anotherId<<endl; 
           }

        j = listOfNeededConversions.begin() ;
     }

  printToStream ( cout, "\n" ) ;
  
  cerr<<"Done "<<endl;


  //restore old receive buffer
  info = pvm_setrbuf ( oldbufid );
  assert (info != PvmBadParam ) ;
  assert (info != PvmNoSuchBuf ) ;

#ifdef _DEBUGDISTRIBUTEDNAMESERVER
   cerr<<"PsPvmNameServer::PsPvmNameServer done"<<endl;
#endif

}


PsPvmNameServer::~PsPvmNameServer () 
{

} 

long
PsPvmNameServer::getIdentifierAsFrom(const PsString & name, long * nextId)
{
#ifdef _DEBUGDISTRIBUTEDNAMESERVER
   cerr<<"PsPvmNameServer::getIdentifierAsFrom"<<endl;
#endif    

  correspondenceContainerType::iterator i;
  i = _stringToIdCorrespondenceContainer.find( name );
  
  if (i == _stringToIdCorrespondenceContainer.end()) 
    {
      //we are going to change the values contained in the PsNameServer
      lock() ; 
      
      i = _stringToIdCorrespondenceContainer.find( name ) ; //name might have been added by an other thread
      
      if (i == _stringToIdCorrespondenceContainer.end() ) //we have to add nom
        { 
#ifdef _DEBUGDISTRIBUTEDNAMESERVER
          cerr<<"   PsPvmNameServer::getIdentifierAsFrom ("<<name<<") on central name server"<<endl;
#endif    
          //ask the central name server for the id corresponding to nom

          int oldbufid = pvm_setsbuf ( 0 ) ; //save the current send buffer 

          if ( oldbufid < 0 )
            {
              cerr<<"PsPvmNameServer::getIdentifierAsFrom: pvm_setsbuf error "<<oldbufid<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
            }

          int bufid = pvm_initsend( PsnPvmSvm::pvmDataEncoding ) ; 

          //pack a timeStamp
          long toto = 0 ;
          int infot = pvm_pklong ( &toto, 1, 1 ) ;

          if ( bufid < 0 )
            {
              cerr<<"PsPvmNameServer::getIdentifierAsFrom: pvm_initsend error "<<bufid<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
            }
          int numberOfCaracters = name.getStringLength () + 1 ;
          int info = pvm_pkint ( &numberOfCaracters , 1, 1 ) ;

          info = pvm_pkstr ( const_cast<char *> (name.getCString()) ) ;

          if (info < 0 )
            {
              cerr<<"PsPvmNameServer::getIdentifierAsFrom: pvm_pkstr error "<<info<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
            }

          info = pvm_send (_mainNameServerSiteId, PsnPvmMessage::NameServiceGetId ) ;

          if (info < 0 )
            {
              cerr<<"PsPvmNameServer::getIdentifierAsFrom: pvm_send error "<<info<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
            }
          
          info = pvm_setsbuf ( oldbufid ) ; //replace the current send buffer

          if (info < 0 )
            {
              cerr<<"PsPvmNameServer::getIdentifierAsFrom: pvm_setsbuf error "<<info<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
            }

          //save the current receive buffer
          oldbufid = pvm_setrbuf ( 0 ) ;

          //wait for the answer
          bufid = pvm_recv (_mainNameServerSiteId, PsnPvmMessage::NameServiceReturnId ) ;
          
          if ( bufid < 0 )
            {
              cerr<<"PsPvmNameServer::getIdentifierAsFrom: pvm_recv error "<<bufid<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
            }
          
          PsName::idType requestedId ;
          info = pvm_upklong ( & requestedId, 1, 1 ) ;
          
#ifdef _DEBUGDISTRIBUTEDNAMESERVER
          cerr<<"   got "<<requestedId<<" from the central name server"<<endl;
#endif    
          if (info < 0 )
            {
              cerr<<"PsPvmNameServer::getIdentifierAsFrom: pvm_upklong error "<<info<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
            }

          //restore old receive buffer
          info = pvm_setrbuf ( oldbufid );
          assert (info != PvmBadParam ) ;
          assert (info != PvmNoSuchBuf ) ;

          pair<correspondenceContainerType::iterator,bool> res = _stringToIdCorrespondenceContainer.insert(correspondenceContainerType::value_type(name,requestedId)) ; 
          _fastStringAccessTable[requestedId] = res.first ;
          
          *nextId = requestedId + 1 ;
          
          i = res.first ;
        }
      
      unlock() ;
    }
#ifdef _DEBUGDISTRIBUTEDNAMESERVER
  cerr<<"PsPvmNameServer::getIdentifierAsFrom returning "<<(*i).second<<endl;
#endif    
  return (*i).second;
}

const PsString & 
PsPvmNameServer::getStringAssociatedTo (PsName::idType id)
{
#ifdef _DEBUGDISTRIBUTEDNAMESERVER
   cerr<<"PsPvmNameServer::getStringAssociatedTo ("<<id<<")"<<endl;
#endif    
 if ( _fastStringAccessTable.find(id) == _fastStringAccessTable.end() )
    {
      lock () ;

      if ( _fastStringAccessTable.find(id) == _fastStringAccessTable.end() ) 
        //the request might have allready been fullfilled
        {
          //ask the central name server for the string

          int oldbufid = pvm_setsbuf ( 0 ) ; //save the current send buffer 
          
          if ( oldbufid < 0 )
            {
              cerr<<"PsPvmNameServer::getStringAssociatedTo: pvm_setsbuf error "<<oldbufid<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
            }
          
          int bufid = pvm_initsend( PsnPvmSvm::pvmDataEncoding ) ; 
          
          //pack a timeStamp
          long toto = 0 ;
          int infot = pvm_pklong ( &toto, 1, 1 ) ;

          if ( bufid < 0 )
            {
              cerr<<"PsPvmNameServer::getStringAssociatedTo: pvm_initsend error "<<bufid<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
            }
          
          int info = pvm_pklong ( &id, 1, 1 ) ;;
          
          if (info < 0 )
            {
              cerr<<"PsPvmNameServer::getStringAssociatedTo: pvm_pklong error "<<info<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
            }
          
          info = pvm_send (_mainNameServerSiteId, PsnPvmMessage::NameServiceGetString ) ;
          
          if (info < 0 )
            {
              cerr<<"PsPvmNameServer::getStringAssociatedTo: pvm_send error "<<info<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
            }
          
          info = pvm_setsbuf ( oldbufid ) ; //replace the current send buffer
          
          if (info < 0 )
            {
              cerr<<"PsPvmNameServer::getStringAssociatedTo: pvm_setsbuf error "<<info<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
            }
          
          //save the current receive buffer
          oldbufid = pvm_setrbuf ( 0 ) ;
          
          //wait for the answer
          bufid = pvm_recv (_mainNameServerSiteId, PsnPvmMessage::NameServiceReturnString ) ;
          
          if ( bufid < 0 )
            {
              cerr<<"PsPvmNameServer::getStringAssociatedTo: pvm_recv error "<<bufid<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
            }
          
          int bytes, msgtag, tid ;
          
          info = pvm_bufinfo ( bufid, &bytes, &msgtag, & tid ) ;
      
          if (info < 0 )
            {
              cerr<<"PsPvmNameServer::getStringAssociatedTo: pvm_bufinfo error "<<info<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
            }
          
          char * resultingString = new char [bytes] ;
          
          info = pvm_upkstr ( resultingString ) ;
          
          if (info < 0 )
            {
              cerr<<"PsPvmNameServer::getStringAssociatedTo: pvm_upkstr error "<<info<<endl;
              if (PsController::warningLevel == PsController::FatalWarnings ) exit (2) ;
            }

          //restore old receive buffer
          info = pvm_setrbuf ( oldbufid );
          assert (info != PvmBadParam ) ;
          assert (info != PvmNoSuchBuf ) ;
          
          //insert the new pair in the data structures
          pair<correspondenceContainerType::iterator,bool> res = _stringToIdCorrespondenceContainer.insert(correspondenceContainerType::value_type(PsString (resultingString), id)) ; 
          _fastStringAccessTable[id] = res.first ;
          
          if ( id >= _nextIdentifier ) 
            {
              _nextIdentifier = id + 1 ;
            }
        }
      
      unlock() ;
    }
#ifdef _DEBUGDISTRIBUTEDNAMESERVER
 cerr<<"PsPvmNameServer::getStringAssociatedTo ("<<id<<") ="<<(*(*_fastStringAccessTable.find(id)).second).first<<endl;
#endif    
  return  (*(*_fastStringAccessTable.find(id)).second).first ;
}



const PsString & 
PsPvmNameServer::getStringAssociatedTo (PsName::idType id) const 
{
  if ( _fastStringAccessTable.find(id) == _fastStringAccessTable.end() )
    {
      return const_cast<PsPvmNameServer *>(this)->getStringAssociatedTo( id ) ;
    }
  else 
    {
      return  (*(*_fastStringAccessTable.find(id)).second).first ;
    }
}

bool PsPvmNameServer::includes (const PsNameServer & otherNameServer ) 
{
   return true ;
}

void PsPvmNameServer::deleted(PsName::idType id, PsName * name)
{
}

void PsPvmNameServer::created(PsName::idType id, PsName * )
{
}
#endif

---