ReferenceManager< Ref > Class Template Reference

#include <reference_manager.h>

Inheritance diagram for ReferenceManager< Ref >:

[legend]List of all members.

Public Member Functions
void	AttachDuoDistributedVector (void *v, ContenerTableauRefAtome< Ref > *c)
	request attaching a given duodistributed vecotr with a given contener c
void	AttachVector (double *v, ContenerTableauRefAtome< Ref > *c)
	request attaching a given vector v with a given contener c
	ReferenceManager (MPI_Comm c)
ContenerTableauRefAtome< Ref > &	RequestCreationSubSet (char *name)
	the contener of subsets of atoms may only be created through refmanager
void	UpdateRefSubSets ()
	function that start the updating process of all attached structures
virtual	~ReferenceManager ()
Protected Member Functions
void	AdjustSizeRecvBuffers (std::map< int, std::vector< double > > &recv_buffer, std::map< int, std::vector< int > > &recv_buffer2)
	in exchanging attached values this function set correct size to buffers
void	AnalyseSubSets ()
	analyse the sent atoms to compute the mask needed to exchange attached values
void	BuildSendingBuffers (std::map< int, std::vector< double > > &send_buffer, std::map< int, std::vector< int > > &send_buffer2)
	in exchanging attached values this function build sending buffers
void	CheckSubSetsCardinal ()
	check the saved cardinals of the subsets
void	ClearSTL ()
	clear all internal structures (based on STL)
void	CreationExchangedAtomsInSubSets ()
	create in the subsets the atoms locally created by migration process
void	DecodeBuffers (std::map< int, std::vector< double > > &recv_buffer, std::map< int, std::vector< int > > &recv_buffer2)
	in exchanging attached values this function decode the sended buffers
void	ExchangeSubSetAttachedValues ()
	perform real value exchange communication
void	ExchangeSubSetsMasks ()
	perform the exchange to let know the ownership mask of migrated atoms
void	PrintBilanToScreen ()
	print bilan for concerned conteneur : used only to debug
Protected Attributes
std::map< int, std::vector< void * > >	attached_duo
	attached duos that need to be updated as well as the conteners
std::map< Ref, std::map< int, std::vector< double > >, typename Ref::RefComparator >	attached_values
	attached values (we won't send complete vector)
std::map< Ref, std::map< int, std::vector< int > >, typename Ref::RefComparator >	attached_values_duo
	attached values in the duodistributed vector
std::map< int, std::vector< double * > >	attached_vectors
	attached vectors that need to be updated as well as the conteners
std::map< Ref, int, typename Ref::RefComparator >	concerned_conteneurs_recv
	mapping between received atoms and the mask giving ownership to each subsets in chrage
std::map< Ref, int, typename Ref::RefComparator >	concerned_conteneurs_sent
	mapping between sent atoms and the mask giving ownership to each subsets in chrage
std::vector< ContenerTableauRefAtome< Ref > * >	conteneurs
	contener in charge (management of atom subsets )
bool	have_changed
	flag to notify if updating of attached references needed
std::map< Ref, Ref, typename Ref::RefComparator >	moved
	mapping between moved atoms old ref and new ref
std::map< int, std::vector< Ref > >	newatoms
	new atoms generated by migration (received)
int	rank
std::map< Ref, int, typename Ref::RefComparator >	sent
	mapping between sent atom ref and new proc owner
std::map< int, std::vector< Ref > >	sent_byproc
	inverse mapping : sent atoms sorted by receiving processors
std::vector< std::map< Ref, int, typename Ref::RefComparator > >	trous
	holes created by migration in subsets conteners
MPI_Comm	worldCom

---

Detailed Description

template<typename Ref>
class ReferenceManager< Ref >

Definition at line 51 of file reference_manager.h.

---

Constructor & Destructor Documentation

template<typename Ref>

virtual ReferenceManager< Ref >::~ReferenceManager

(

)

[inline, virtual]

Definition at line 55 of file reference_manager.h.

                             {
    for (unsigned int i = 0 ; i < conteneurs.size(); ++i)
      if (conteneurs[i])
        delete conteneurs[i];
  };

template<typename Ref>

ReferenceManager< Ref >::ReferenceManager

(

MPI_Comm

c

)

[inline]

Definition at line 61 of file reference_manager.h.

                              :have_changed(false),worldCom(c){
    if (worldCom != MPI_COMM_NULL)
      MPI_Comm_rank(worldCom,&rank);
  };

---

Member Function Documentation

template<typename Ref>

void ReferenceManager< Ref >::AdjustSizeRecvBuffers	(	std::map< int, std::vector< double > > &	recv_buffer,
		std::map< int, std::vector< int > > &	recv_buffer2
	)			[inline, protected]

in exchanging attached values this function set correct size to buffers

Definition at line 573 of file reference_manager.cpp.

References ReferenceManager< Ref >::attached_duo, ReferenceManager< Ref >::attached_vectors, ReferenceManager< Ref >::concerned_conteneurs_recv, ReferenceManager< Ref >::conteneurs, DBG_INFO, DUMP, ReferenceManager< Ref >::newatoms, and PROC_INVALID.

Referenced by ReferenceManager< Ref >::ExchangeSubSetAttachedValues().

                                                                                             {
  int proc,size;
  //pour le calcul de la taille du packet par processeur (de reception)
  std::map<int,int> buffer_size;
  std::map<int,int> buffer_size2;


  /****************************************************************/
  //partie reception
  /****************************************************************/

  //boucle sur les sous-ensembles
  int nb = conteneurs.size();
  for (int subset = 0; subset < nb ; ++subset){
    //boucle sur les vecteurs attachés
    std::vector<double *> & attached = attached_vectors[subset];
    std::vector<void *> & attached_duo_ = attached_duo[subset];    

    // je parcours les atomes envoyés sur les autres processeurs
    typename map<int,vector<Ref> >::iterator it = newatoms.begin();
    typename map<int,vector<Ref> >::iterator last = newatoms.end();
    
    //boucle sur mes processeurs qui m'envoient  
    for (it = newatoms.begin();it != last ; ++it){
      proc = (*it).first;
      if (proc == PROC_INVALID) continue;
      size = (*it).second.size();
      vector<Ref> & atoms = (*it).second;
       
      Ref at;
      int mask;
      //loop over received atoms
      for (int i = 0; i < size ; ++i){
        at = atoms[i];
        if (!at.IsValid())continue;
        mask = concerned_conteneurs_recv[at];

        DUMP("atome " << i << " index " << at << " mask = " << mask << " from " << proc,DBG_INFO);

        if ((mask & (1<<subset))==0)
          continue;

        //sinon la taille du buffer de reception est augmentee du nombre de vecteur attachés
        DUMP("adding " << attached.size() << " to buffer from " << proc,DBG_INFO);
        buffer_size[proc] += attached.size();
        DUMP("adding " << attached_duo_.size() << " to buffer from " << proc,DBG_INFO);
        buffer_size2[proc] += attached_duo_.size();
      }
    }
  }


  //set the sizes
  std::map<int,int>::iterator it = buffer_size.begin();
  std::map<int,int>::iterator last = buffer_size.end();

  while (it != last){
    int proc = (*it).first;
    recv_buffer[proc].resize((*it).second);
    ++it;
  }

  it = buffer_size2.begin();
  last = buffer_size2.end();

  while (it != last){
    int proc = (*it).first;
    recv_buffer2[proc].resize((*it).second);
    ++it;
  }

  
}

template<typename Ref>

void ReferenceManager< Ref >::AnalyseSubSets

(

)

[inline, protected]

analyse the sent atoms to compute the mask needed to exchange attached values

Definition at line 1026 of file reference_manager.cpp.

References ReferenceManager< Ref >::concerned_conteneurs_sent, ReferenceManager< Ref >::conteneurs, DBG_ALL, DBG_ERROR, DBG_INFO, DUMP, FATAL, ReferenceManager< Ref >::moved, PROC_INVALID, ReferenceManager< Ref >::sent, ReferenceManager< Ref >::trous, and ReferenceManager< Ref >::worldCom.

Referenced by ReferenceManager< Ref >::UpdateRefSubSets().

                                          {
  //bool testing = false;

  //parcours des conteneur dont j'ai la charge
  int nb = conteneurs.size();
  trous.resize(nb);

  for (int subset = 0; subset < nb ; ++subset){
    DUMP("analysing subset " << subset << " with name " << conteneurs[subset]->name,DBG_INFO);
    int compteur_atoms_implique = 0;
    if (trous[subset].empty() == false) FATAL("probleme : la liste des trous n'est pas vide au demarrage");
    int nbElems = conteneurs[subset]->nbElem();
    //sauvegarde l'etat du conteneur pour verifier la coherence apres migration
#ifdef DEBUG_REFERENCEMANAGER   
    conteneurs[subset]->save_global_size(worldCom);
#endif
    DUMP("Analysing subset " << subset << "/" << nb << "(" << nbElems << " - " << &conteneurs[subset] << ")",DBG_INFO); 
    for (int j = 0 ; j < nbElems ; ++j){
      // attention ceci est une reference pas un objet que l'on a copie
      Ref at = conteneurs[subset]->Get(j);
      //si je suis deja sur un atome non local je continue
      if (!at.IsLocal()) continue;
      // si l'atome a change de processeur je l'invalide 
      //et je lui note le nouveau proc .. des fois qu'il en 
      // ai besoin
      DUMP("testing atom " << at,DBG_ALL);
      if (sent.count(at)>0){
        if (sent[at] == PROC_INVALID) continue;
        //testing = true;
        DUMP("invalidating atom in subset " << subset << " numero " << j 
             << " old position = " << at << " sent to proc " << sent[at],DBG_INFO);
        conteneurs[subset]->Get(j).SetAway(sent[at]);
        if (conteneurs[subset]->Get(j).IsLocal()){
          FATAL("forcement aussi si meme ca ca marche pas ou va le monde");
        }
        if (trous[subset].count(at) != 0) FATAL("it seems that the atome " << at << " is present two times "
                                                << "in subset " << subset << " " << conteneurs[subset]->name);
        trous[subset][at] = j;
        int mask = 1 << subset;
        ++compteur_atoms_implique;
        //si c un atome non valide issue de forwarding je fixe le masque a 0
        //mais je le laisse car il est compte il faut donc envoyer aussi
        if (!conteneurs[subset]->Get(j).IsValid()){
          FATAL("pourkoi il passe la ce con");
          mask = 0;           
        }
        if (concerned_conteneurs_sent.count(at) == 0)
          concerned_conteneurs_sent[at] = mask;  
        else
          concerned_conteneurs_sent[at] |= mask;
      }
      //si l'atome a bouge je met a jour sa ref
      else if (moved.count(at)>0){
        //testing = true;
        DUMP("moving atom in subset " << subset << " numero " << j << " from position " << at << " to position " << moved[at],DBG_INFO);
        conteneurs[subset]->Get(j) = moved[at];
      }
    }
    DUMP("end subset " << subset,DBG_INFO);
    DUMP("in subset " << conteneurs[subset]->name << " i notified " <<  compteur_atoms_implique 
         << " over " << nbElems << " in total",DBG_ERROR);
  }

#ifdef DEBUG_REFERENCEMANAGER   
  //pour le debug
  if (testing)
    for (int subset = 0; subset < nb ; ++subset){
      int nbElems = conteneurs[subset]->nbElem();
      DUMP("Analysing subset " << subset << "/" << nb << "(" << nbElems << " - " << &conteneurs[i] << ")"); 
      for (int j = 0 ; j < nbElems ; ++j){
        Ref at1 = conteneurs[subset]->Get(j);
        if (!at1.IsLocal()) continue;
        for (int k = j+1 ; k < nbElems ; ++k){
          Ref at2 = conteneurs[subset]->Get(k);
          if (!at2.IsLocal()) continue;
          
          if (at1.index_atome == at2.index_atome){
            FATAL("houston on a un probleme : in subset " << subset << " indexes " << j << " and " 
                  << k << " refers to the same atom " << at1.index_atome);
          }
        }
      }
    }
#endif
}

template<typename Ref>

void ReferenceManager< Ref >::AttachDuoDistributedVector	(	void *	v,
		ContenerTableauRefAtome< Ref > *	c
	)			[inline]

request attaching a given duodistributed vecotr with a given contener c

Definition at line 1114 of file reference_manager.cpp.

References ReferenceManager< Ref >::attached_duo, ReferenceManager< Ref >::conteneurs, DBG_INFO_STARTUP, and DUMP.

                                                                                               {
  int nb = conteneurs.size();
  int i=0;
  for (i = 0; i < nb ; ++i){
    if (conteneurs[i] == c){
      DUMP("attaching duo * " << v << " to subset " << i,DBG_INFO_STARTUP);
      attached_duo[i].push_back(v);
      break;
    }
  }
  if (i == nb)
    DUMP("attaching double * " << v << " did not found its subset",DBG_INFO_STARTUP);

}

template<typename Ref>

void ReferenceManager< Ref >::AttachVector	(	double *	v,
		ContenerTableauRefAtome< Ref > *	c
	)			[inline]

request attaching a given vector v with a given contener c

Definition at line 1131 of file reference_manager.cpp.

References ReferenceManager< Ref >::attached_vectors, ReferenceManager< Ref >::conteneurs, DBG_INFO, DUMP, and FATAL.

                                                                                   {
  int nb = conteneurs.size();
  int i=0;
  for (i = 0; i < nb ; ++i){
    if (conteneurs[i] == c){
      DUMP("attaching double * " << v << " to subset " << i,DBG_INFO);
      attached_vectors[i].push_back(v);
      break;
    }
  }
  if (i == nb)
    FATAL("attaching double * " << v << " did not found its subset");


}

template<typename Ref>

void ReferenceManager< Ref >::BuildSendingBuffers	(	std::map< int, std::vector< double > > &	send_buffer,
		std::map< int, std::vector< int > > &	send_buffer2
	)			[inline, protected]

in exchanging attached values this function build sending buffers

Definition at line 650 of file reference_manager.cpp.

References ReferenceManager< Ref >::attached_duo, ReferenceManager< Ref >::attached_vectors, ReferenceManager< Ref >::concerned_conteneurs_sent, ReferenceManager< Ref >::conteneurs, DBG_INFO, DUMP, PROC_INVALID, ReferenceManager< Ref >::sent_byproc, and ReferenceManager< Ref >::trous.

Referenced by ReferenceManager< Ref >::ExchangeSubSetAttachedValues().

                                                                                           {

  
//   char temp[256]; 
//   sprintf(temp,"%d",my_proc_id); 
//   std::string output_file = ""; output_file += temp ;
//   output_file += "bugdemerdesend.log"; 
//   std::ofstream fout(output_file.c_str(),ios_base::out);

  int proc, size;
  /****************************************************************/
  //partie envoi
  /****************************************************************/


  std::map<Ref,std::map<int,std::vector<int> >,typename Ref::RefComparator> attached_values_duo_check;

  //boucle sur les sous-ensembles
  int nb = conteneurs.size();
  for (int subset = 0; subset < nb ; ++subset){
    // je parcours les atomes envoyés sur les autres processeurs
    typename map<int,vector<Ref> >::iterator it = sent_byproc.begin();
    typename map<int,vector<Ref> >::iterator last = sent_byproc.end();
    
    //boucle sur mes processeurs qui m'envoient  
    for (it = sent_byproc.begin();it != last ; ++it){
      proc = (*it).first;
      if (proc == PROC_INVALID) continue;
      size = (*it).second.size();
      vector<Ref> & atoms = (*it).second;
       
      Ref at;
      int mask;
      //boucle sur les atomes envoyes
      for (int i = 0; i < size ; ++i){
        // je skip les atomes qui sont pas dans le groupe actuel
        at = atoms[i];
        if (!at.IsValid())continue;
        mask = concerned_conteneurs_sent[at];

        //      if (proc == 7) fout << "atome " << i << " ref : " << at << " mask = " << mask << std::endl;

        if ((mask & (1<<subset))==0)
          continue;

        DUMP("atome " << i << " index " << at << " mask = " << mask << " from " << proc,DBG_INFO);



        //sinon je dois stocker les informations relatives aux atomes envoyes
        int index_in_subset = trous[subset][at];
        //boucle sur les vecteurs attachés
        std::vector<double *> & attached = attached_vectors[subset];
        std::vector<void *> & attached_duo_ = attached_duo[subset];    


        DUMP("first manage " << attached.size() << " vectors attached to subset " << subset,DBG_INFO);
        for (unsigned int v = 0; v < attached.size();++v){
          double * vector = attached[v];
          send_buffer[proc].push_back(vector[index_in_subset]);
          DUMP("adding " << vector[index_in_subset] << " to send buffer for " << proc,DBG_INFO);
        }

        DUMP("now manage " << attached_duo_.size() << " duo vectors attached to subset " << subset,DBG_INFO);
        for (unsigned int v = 0; v < attached_duo_.size();++v){
          DuoDistributedVecteur * duo = (DuoDistributedVecteur*)attached_duo_[v];
          DUMP("treating trou " << index_in_subset << " created by moving on proc " << proc << " for subset " 
               << conteneurs[subset]->name << " duo " << duo << " for proc " << proc,DBG_INFO);
          DUMP("adding " << duo->GetNeighbor(index_in_subset) << " to send buffer2 for " << proc << " with mask = " << mask 
               << "at position in buffer " << send_buffer2[proc].size(),DBG_INFO);
          send_buffer2[proc].push_back(duo->GetNeighbor(index_in_subset));
          //      if (proc == 7) fout << "attached value atom " << i << " attached duo " << v << " subset "
          //          << subset << " : " << send_buffer2[proc][send_buffer2[proc].size()-1] << std::endl;
          attached_values_duo_check[at][subset].push_back(send_buffer2[proc][send_buffer2[proc].size()-1]);
          duo->sendAtom(index_in_subset,proc);
        }
      }
    }
  }

//   fout.close();

  //bilan pour controle sur la preparation des buffers
  std::map<int,std::map<int,int> > cpt_sent;
  std::map<int,std::map<int,int> > cpt_sent_brut;
  {
    typename std::map<Ref,std::map<int,std::vector<int> >,typename Ref::RefComparator>::iterator it = attached_values_duo_check.begin();
    typename std::map<Ref,std::map<int,std::vector<int> >,typename Ref::RefComparator>::iterator last = attached_values_duo_check.end();
    
    while (it != last){
      Ref at = (*it).first;
      int nb = conteneurs.size();
      for (int subset = 0; subset < nb ; ++subset){
        if (((*it).second).count(subset) == 0) continue;
        std::map<int,int> & map = cpt_sent[subset];
        std::vector<int> & v = ((*it).second)[subset];
        for (unsigned int i = 0 ; i < v.size(); ++i){
          int value = v[i];
          if (map.count(value) == 0 ) map[value] = 0;
          ++map[value];
        }
      }
      ++it; 
    }
  }



  {
    std::map<int,std::vector<int> >::iterator it = send_buffer2.begin();
    std::map<int,std::vector<int> >::iterator last = send_buffer2.end();
    
    while (it != last){
      int proc = (*it).first;
      std::vector<int> & v = (*it).second;
      std::map<int,int> & map = cpt_sent_brut[proc];
      for (unsigned int i = 0 ; i < v.size() ; ++i){
        int value = v[i];
        if (map.count(value) == 0 )map[value] = 0;
        ++map[value];
      }
      ++it;
    }
  }


  DUMP("BEGIN *********************************",DBG_INFO);
  {
    std::map<int,std::map<int,int> >::iterator it =  cpt_sent_brut.begin();
    std::map<int,std::map<int,int> >::iterator last = cpt_sent_brut.end();
    while (it != last){
      std::map<int,int>::iterator it2 =  (*it).second.begin();
      std::map<int,int>::iterator last2 = (*it).second.end();
      while (it2 != last2){
        DUMP("bilan sent brut for proc " << (*it).first << 
             " for dist owner stored " << (*it2).first << 
             " quantity :" << (*it2).second,DBG_INFO);  
        ++it2;
      }
      ++it;
    }

    it =  cpt_sent.begin();
    last = cpt_sent.end();
    while (it != last){
      std::map<int,int>::iterator it2 =  (*it).second.begin();
      std::map<int,int>::iterator last2 = (*it).second.end();
      while (it2 != last2){
        DUMP("bilan sent for subset " << (*it).first << 
             " for dist owner stored " << (*it2).first << 
             " quantity :" << (*it2).second,DBG_INFO);  
        ++it2;
      }
      ++it;
    }
  }
  DUMP("END *********************************",DBG_INFO);

}

template<typename Ref>

void ReferenceManager< Ref >::CheckSubSetsCardinal

(

)

[inline, protected]

check the saved cardinals of the subsets

Definition at line 1018 of file reference_manager.cpp.

References ReferenceManager< Ref >::conteneurs, and ReferenceManager< Ref >::worldCom.

Referenced by ReferenceManager< Ref >::UpdateRefSubSets().

                                                {
  int nb = conteneurs.size();
  for (int subset = 0; subset < nb ; ++subset){
    conteneurs[subset]->check_parallel_coherence(worldCom);
  }
}

template<typename Ref>

void ReferenceManager< Ref >::ClearSTL

(

)

[inline, protected]

clear all internal structures (based on STL)

Definition at line 176 of file reference_manager.cpp.

References ReferenceManager< Ref >::attached_values, ReferenceManager< Ref >::attached_values_duo, ReferenceManager< Ref >::concerned_conteneurs_recv, ReferenceManager< Ref >::concerned_conteneurs_sent, ReferenceManager< Ref >::moved, ReferenceManager< Ref >::newatoms, ReferenceManager< Ref >::sent, ReferenceManager< Ref >::sent_byproc, and ReferenceManager< Ref >::trous.

Referenced by ReferenceManager< Ref >::UpdateRefSubSets().

                                    {
  concerned_conteneurs_sent.clear();
  concerned_conteneurs_recv.clear();
  trous.clear();
  moved.clear();
  sent.clear();
  sent_byproc.clear();
  newatoms.clear();
  attached_values.clear();
  attached_values_duo.clear();
}

template<typename Ref>

void ReferenceManager< Ref >::CreationExchangedAtomsInSubSets

(

)

[inline, protected]

create in the subsets the atoms locally created by migration process

Definition at line 926 of file reference_manager.cpp.

References ReferenceManager< Ref >::attached_duo, ReferenceManager< Ref >::attached_values, ReferenceManager< Ref >::attached_values_duo, ReferenceManager< Ref >::attached_vectors, ReferenceManager< Ref >::concerned_conteneurs_recv, ReferenceManager< Ref >::conteneurs, DBG_ERROR, DBG_INFO, DBG_INFO_STARTUP, DUMP, and ReferenceManager< Ref >::trous.

Referenced by ReferenceManager< Ref >::UpdateRefSubSets().

                                                           {
 

  DUMP("creation of atoms in concerned subsets",DBG_INFO_STARTUP);

  //je parcours les atomes crés sur ce processeur
  typename map<Ref,int,typename Ref::RefComparator>::iterator it = concerned_conteneurs_recv.begin();
  typename map<Ref,int,typename Ref::RefComparator>::iterator last = concerned_conteneurs_recv.end();

 std::map<int,int> compteur_atoms_created;

  for (it = concerned_conteneurs_recv.begin();it != last ; ++it){
    int mask = (*it).second;
    Ref at = (*it).first;
    if (!at.IsValid()) continue;
    DUMP("mask = " << mask,DBG_INFO);
    //parcours des conteneur dont j'ai la charge
    int nb = conteneurs.size();
    double * vector;


    for (int subset = 0; subset < nb ; ++subset){
      if ((mask & (1<<subset))==0)
        continue;

      ++compteur_atoms_created[subset];

      // je regarde si il y a des trous que je peux boucher
      std::map<Ref,int,typename Ref::RefComparator> & trous_subset = trous[subset];
      int new_index;
      
      if (trous_subset.size() > 0){
        DUMP("j'utilise un trou pour mettre ma nouvelle reference ",DBG_INFO);
        typename std::map<Ref,int,typename Ref::RefComparator>::iterator first_entry = trous_subset.begin();
        Ref oldat = (*first_entry).first;
        new_index = (*first_entry).second;
        conteneurs[subset]->Get(new_index) = at;
        trous_subset.erase(oldat);
      }
      else{
        DUMP("ma nouvelle reference est placee a la fin",DBG_INFO);
        //sinon j'ajoute l'atome par la voie standard ie au bout du vecteur
        new_index = conteneurs[subset]->nbElem();
        conteneurs[subset]->Ajouter(at);
     }

      DUMP("treating(creation atom) subset number " << subset << " new atome at index " << new_index,DBG_INFO);
      
      // je parcours maintenant les vecteurs attachés
      std::vector<double *> & attached = attached_vectors[subset];
      
      for (unsigned int i = 0 ; i < attached.size(); ++i){
        vector = attached[i];
        DUMP("assigning attached vector " << i << " (internal index = " << at << ")",DBG_INFO);
        vector[new_index] = attached_values[at][subset][i];
      }

//       std::vector<unsigned int *> & attached_size = attached_sizes[subset];
//       for (unsigned int i = 0 ; i < attached_size.size(); ++i){
//      unsigned int * s = attached_size[i];
//       DUMP("incresing size assigning attached vector " << i << " (internal index = " << at << ")");
//      vector[new_index] = attached_values[at][subset][i];
//       }

      
      std::vector<void *> & attached_duo_ = attached_duo[subset];
      // je parcours maintenant les duovecteurs attaches
      DUMP("declaring received atoms on the " << attached_duo_.size() << " attached duo vectors",DBG_INFO);
      for (unsigned int i = 0 ; i < attached_duo_.size(); ++i){
        DuoDistributedVecteur * duo = (DuoDistributedVecteur *)attached_duo_[i];
        DUMP("assigning attached duo " << i << "(" << duo << ")" << " while mask = " << mask << " for subset " << conteneurs[subset]->name
             << " and as for new neighbor = " << attached_values_duo[at][subset][i] << " and at " << at,DBG_INFO);
        duo->receiveAtom(new_index,attached_values_duo[at][subset][i]);
      }

    }
  }

  int nb = conteneurs.size();
  for (int subset = 0; subset < nb ; ++subset){
    DUMP("in subset " << conteneurs[subset]->name << " i created " <<  compteur_atoms_created[subset] 
         << " over " << concerned_conteneurs_recv.size() << " in total",DBG_ERROR);
  }
  

  DUMP("end CreationExchangedAtomsInSubSets",DBG_INFO);  
}

template<typename Ref>

void ReferenceManager< Ref >::DecodeBuffers	(	std::map< int, std::vector< double > > &	recv_buffer,
		std::map< int, std::vector< int > > &	recv_buffer2
	)			[inline, protected]

in exchanging attached values this function decode the sended buffers

Definition at line 400 of file reference_manager.cpp.

References ReferenceManager< Ref >::attached_duo, ReferenceManager< Ref >::attached_values, ReferenceManager< Ref >::attached_values_duo, ReferenceManager< Ref >::attached_vectors, ReferenceManager< Ref >::concerned_conteneurs_recv, ReferenceManager< Ref >::conteneurs, DBG_INFO, DUMP, FATAL, ReferenceManager< Ref >::newatoms, and PROC_INVALID.

Referenced by ReferenceManager< Ref >::ExchangeSubSetAttachedValues().

                                                                                     {


//   if (recv_buffer2.count(8)>0 && recv_buffer2[8].size() > 1)
//     DUMP("BBBBBBBBBBBBBBBBB " << recv_buffer2[8][0],DBG_INFO);

//   char temp[256]; 
//   sprintf(temp,"%d",my_proc_id); 
//   std::string output_file = ""; output_file += temp ;
//   output_file += "bugdemerderecv.log"; 
//   std::ofstream fout(output_file.c_str(),ios_base::out);


  /****************************************************************/
  //phase de decodage du paquet groupe des valeurs attaches
  /****************************************************************/
  
  //boucle sur les sous-ensembles
  int nb = conteneurs.size();
  int proc,size;

  std::map<int,int> index;
  std::map<int,int> index2;

  for (int subset = 0; subset < nb ; ++subset){
    //boucle sur les vecteurs attachés
    std::vector<double *> & attached = attached_vectors[subset];
    std::vector<void *> & attached_duo_ = attached_duo[subset];
    
    // je parcours les atomes envoyés sur les autres processeurs
    typename map<int,vector<Ref> >::iterator it = newatoms.begin();
    typename map<int,vector<Ref> >::iterator last = newatoms.end();

    
    //boucle sur mes processeurs qui m'envoient  
    for (it = newatoms.begin();it != last ; ++it){
      proc = (*it).first;

      if (index.count(proc) == 0) index[proc] = 0;
      if (index2.count(proc) == 0) index2[proc] = 0;

      if (proc == PROC_INVALID)continue;
      size = (*it).second.size();
      vector<Ref> & atoms = (*it).second;
      
      Ref at;
      int mask;
      
      //boucle sur les atomes recus
      for (int i = 0; i < size ; ++i){
        at = atoms[i];
        if (!at.IsValid())continue;
        if (concerned_conteneurs_recv.count(at) == 0) FATAL("bipbipbipbipbip " << at);
        mask = concerned_conteneurs_recv[at];

        //      if (proc == 8) fout << "atome " << i << " ref : " << at << " mask = " << mask <<std::endl;
        
        // je skip les atomes qui sont pas dans le groupe actuel
        if ((mask & (1<<subset))==0)
          continue;

        DUMP("atome " << i << " index " << at << " mask = " << mask << " from " << proc,DBG_INFO);
        
        //parcours sur les vecteurs attaches
        for (unsigned int j = 0; j < attached.size() ; ++j){
          DUMP("reading attached value atom " << i << " attached vector " << j << " subset " 
               << subset << " : " << recv_buffer[proc][index[proc]] << " (internal index = " 
               << at << ")" << proc,DBG_INFO);
          if (index[proc] >= recv_buffer[proc].size()) FATAL("depassement detecte " << index[proc] << " " << recv_buffer[proc].size());
          attached_values[at][subset].push_back(recv_buffer[proc][index[proc]]);
          ++index[proc];
        }
        
        //parcours sur les vecteurs attaches duo
        DUMP("Decoding received packet onto the " << attached_duo_.size() << " duo vectors",DBG_INFO);
        for (unsigned int j = 0; j < attached_duo_.size() ; ++j){
          DUMP("reading attached value atom " << i << " attached duo " << j << " subset " 
               << subset << " : " << recv_buffer2[proc][index2[proc]] << " (internal index = " 
               << at << ")",DBG_INFO);
          //      if (proc == 8) fout << "attached value atom " << i << " attached duo " << j << " subset "
          //          << subset << " : " << recv_buffer2[proc][index2[proc]] << std::endl;
          if (index2[proc] >= recv_buffer2[proc].size()) FATAL("depassement detecte " << index2[proc] << " " << recv_buffer2[proc].size());
          attached_values_duo[at][subset].push_back(recv_buffer2[proc][index2[proc]]);
          //      if (i == 145) DUMP("AAAAAAAAAAAAAAAAAAAAAAA youhou " << index2,DBG_INFO);
          ++index2[proc];
        }
        
      }
    }
  }
  //  fout.close();
    
  if (recv_buffer2.count(8)>0 && recv_buffer2[8].size() > 1)
  DUMP("BBBBBBBBBBBBBBBBB " << recv_buffer2[8][0],DBG_INFO);

  //print bilan of exchange subset values to screen use for debug only
  std::map<int,std::map<int,int> > cpt_recv;
  std::map<int,std::map<int,int> > cpt_recv_brut;
  {
    typename std::map<Ref,std::map<int,std::vector<int> >,typename Ref::RefComparator>::iterator it = attached_values_duo.begin();
    typename std::map<Ref,std::map<int,std::vector<int> >,typename Ref::RefComparator>::iterator last = attached_values_duo.end();
    
    while (it != last){
      Ref at = (*it).first;
      int nb = conteneurs.size();
      for (int subset = 0; subset < nb ; ++subset){
        if (((*it).second).count(subset) == 0) continue;
        std::map<int,int> & map = cpt_recv[subset];
        std::vector<int> & v = ((*it).second)[subset];
        for (unsigned int i = 0 ; i < v.size(); ++i){
          int value = v[i];
          if (map.count(value) == 0 ) map[value] = 0;
          ++map[value];
        }
      }
      ++it; 
    }
  }


  {
    std::map<int,std::vector<int> >::iterator it = recv_buffer2.begin();
    std::map<int,std::vector<int> >::iterator last = recv_buffer2.end();
    
    while (it != last){
      int proc = (*it).first;
      std::vector<int> & v = (*it).second;
      std::map<int,int> & map = cpt_recv_brut[proc];
      for (unsigned int i = 0 ; i < v.size() ; ++i){
        int value = v[i];
        if (map.count(value) == 0 )map[value] = 0;
        ++map[value];
      }
      ++it;
    }
  }

  DUMP("BEGIN *********************************",DBG_INFO);
  {
    std::map<int,std::map<int,int> >::iterator it =  cpt_recv_brut.begin();
    std::map<int,std::map<int,int> >::iterator last = cpt_recv_brut.end();
    while (it != last){
      std::map<int,int>::iterator it2 =  (*it).second.begin();
      std::map<int,int>::iterator last2 = (*it).second.end();
      while (it2 != last2){
        DUMP("bilan recv brut from proc " << (*it).first << 
             " for dist owner stored " << (*it2).first << 
             " quantity :" << (*it2).second,DBG_INFO);  
        ++it2;
      }
      ++it;
    }
    
    it =  cpt_recv.begin();
    last = cpt_recv.end();
    while (it != last){
      std::map<int,int>::iterator it2 =  (*it).second.begin();
      std::map<int,int>::iterator last2 = (*it).second.end();
      while (it2 != last2){
        DUMP("bilan recv for subset " << (*it).first << 
             " for dist owner stored " << (*it2).first << 
             " quantity :" << (*it2).second,DBG_INFO);  
        ++it2;
      }
      ++it;
    }
  }
  DUMP("END *********************************",DBG_INFO);

}

template<typename Ref>

void ReferenceManager< Ref >::ExchangeSubSetAttachedValues

(

)

[inline, protected]

perform real value exchange communication

Definition at line 814 of file reference_manager.cpp.

References ReferenceManager< Ref >::AdjustSizeRecvBuffers(), ReferenceManager< Ref >::BuildSendingBuffers(), DBG_INFO, ReferenceManager< Ref >::DecodeBuffers(), DUMP, ReferenceManager< Ref >::newatoms, PROC_INVALID, ReferenceManager< Ref >::rank, ReferenceManager< Ref >::sent_byproc, and ReferenceManager< Ref >::worldCom.

Referenced by ReferenceManager< Ref >::UpdateRefSubSets().

                                                        {
  DUMP("ExchangeSubSetAttachedValues",DBG_INFO);

  int proc;
  int size;

  std::map<int,std::vector<double> > send_buffer;
  std::map<int,std::vector<double> > recv_buffer;

  std::map<int,std::vector<int> > send_buffer2;
  std::map<int,std::vector<int> > recv_buffer2;

  BuildSendingBuffers(send_buffer,send_buffer2);
  //  DUMP("INITINIT " << send_buffer2[1][145],DBG_INFO);
  AdjustSizeRecvBuffers(recv_buffer,recv_buffer2);
  //  DUMP("INITINIT " << send_buffer2[1][145],DBG_INFO);
  
  /****************************************************************/
  // partie communication
  /****************************************************************/

  map<int,MPI_Request> recv_requests;
  map<int,MPI_Request> recv_requests2;

  //phase de reception asynchrone
  {  
    typename map<int,vector<Ref> >::iterator it = newatoms.begin();
    typename map<int,vector<Ref> >::iterator last = newatoms.end();
    
    //boucle sur mes processeurs destinataires  
    for (it = newatoms.begin();it != last ; ++it){
      proc = (*it).first;
      if (proc == PROC_INVALID) continue;
      size = recv_buffer[proc].size();
      if (size>0){
        DUMP("a buffer of size " << size << " doubles will be received from proc " << proc 
             << " for attached values",DBG_INFO);
        MPI_Request & request = recv_requests[proc];
        MPI_Irecv(&recv_buffer[proc][0],size,MPI_DOUBLE,proc,proc+1,worldCom,&request);
      }
      size = recv_buffer2[proc].size();
      if (size>0){
        DUMP("a buffer of size " << size << " integers will be received from proc " << proc 
             << " for attached duos",DBG_INFO);
        MPI_Request & request = recv_requests2[proc];
        MPI_Irecv(&recv_buffer2[proc][0],size,MPI_INT,proc,proc+2,worldCom,&request);
      }
    }
  }

  //phase d'envoi
  {  
    typename map<int,vector<Ref> >::iterator it = sent_byproc.begin();
    typename map<int,vector<Ref> >::iterator last = sent_byproc.end();
    
    //boucle sur mes processeurs destinataires  
    for (it = sent_byproc.begin();it != last ; ++it){
      proc = (*it).first;
      if (proc == PROC_INVALID)continue;
      size = send_buffer[proc].size();
      if (size>0){
        DUMP("a buffer of size " << size << " double will be sent to proc " << proc 
             << " for attached values",DBG_INFO);
        MPI_Send(&send_buffer[proc][0],size,MPI_DOUBLE,proc,rank+1,worldCom);
      }

      size = send_buffer2[proc].size();
      if (size>0){
        DUMP("a buffer of size " << size << " integers will be sent to proc " << proc 
             << " for attached duos",DBG_INFO);
        MPI_Send(&send_buffer2[proc][0],size,MPI_INT,proc,rank+2,worldCom);
      }
    }
  }

  //maintenant j'attend les communication de maniere synchronisante (pour les vector)
  {
    MPI_Status status;
    typename map<int,MPI_Request>::iterator it = recv_requests.begin();
    typename map<int,MPI_Request>::iterator last = recv_requests.end();

    for (it = recv_requests.begin();it != last ; ++it){
      MPI_Wait(&((*it).second),&status);
      proc = (*it).first;
      DUMP("received packet vector from proc " << proc,DBG_INFO);
            if(recv_buffer2.count(8)>0 && recv_buffer2[8].size() > 1)
      DUMP("BBBBBBBBBBBBBBBBB " << recv_buffer2[8][0],DBG_INFO);
    }
  }

  //maintenant j'attend les communication de maniere synchronisante (pour les duos)
  {
    MPI_Status status;
    typename map<int,MPI_Request>::iterator it = recv_requests2.begin();
    typename map<int,MPI_Request>::iterator last = recv_requests2.end();
    
    for (it = recv_requests2.begin();it != last ; ++it){
      MPI_Wait(&((*it).second),&status);
      proc = (*it).first;
      DUMP("received packet duo from proc " << proc,DBG_INFO);
    }
  }

  DecodeBuffers(recv_buffer,recv_buffer2);


}

Here is the call graph for this function:

template<typename Ref>

void ReferenceManager< Ref >::ExchangeSubSetsMasks

(

)

[inline, protected]

perform the exchange to let know the ownership mask of migrated atoms

Definition at line 247 of file reference_manager.cpp.

References ReferenceManager< Ref >::concerned_conteneurs_recv, ReferenceManager< Ref >::concerned_conteneurs_sent, DBG_DETAIL, DBG_INFO, DUMP, FATAL, ReferenceManager< Ref >::newatoms, PROC_INVALID, ReferenceManager< Ref >::rank, ReferenceManager< Ref >::sent_byproc, and ReferenceManager< Ref >::worldCom.

Referenced by ReferenceManager< Ref >::UpdateRefSubSets().

                                                {
  int proc;
  int size;
  //checking phase first

  //maintenant que je sais quels sous ensembles sont concernes par
  //les changements il faut prevenir les procs distant de ce fait
  map<int,int> recv_buffers_check;
  map<int,MPI_Request> recv_requests_check;
    
  {
    //phase de reception asynchrone
    typename map<int,vector<Ref> >::iterator it = newatoms.begin();
    typename map<int,vector<Ref> >::iterator last = newatoms.end();
      
    //pour chaque processeurs qui m'ont envoyes des atomes
    for (it = newatoms.begin();it != last ; ++it){
      proc = (*it).first;

      if (proc == PROC_INVALID)
        continue;
      size = (*it).second.size();
      if (size == 0) continue;

      int & buffer = recv_buffers_check[proc];
      MPI_Request & request = recv_requests_check[proc];
      MPI_Irecv(&buffer,1,MPI_INT,proc,proc,worldCom,&request);
    }
  }
  {
    //phase d'envoi
    typename map<int,vector<Ref> >::iterator it = sent_byproc.begin();
    typename map<int,vector<Ref> >::iterator last = sent_byproc.end();
    
    for (it = sent_byproc.begin();it != last ; ++it){
      proc = (*it).first;
      if (proc == PROC_INVALID) continue;
  
      size = (*it).second.size();
      if (size == 0) continue;
      MPI_Send(&size,1,MPI_INT,proc,rank,worldCom);
    }
  }
  //maintenant j'attend les communication de maniere synchronisante
  {
    MPI_Status status;
    typename map<int,MPI_Request>::iterator it = recv_requests_check.begin();
    typename map<int,MPI_Request>::iterator last = recv_requests_check.end();
    
    for (it = recv_requests_check.begin();it != last ; ++it){
      proc = (*it).first;  
      if (newatoms.count(proc) == 0) FATAL("pas normal du tout");
      if (proc == PROC_INVALID) continue;
      int & buffer = recv_buffers_check[proc];
      DUMP("waiting for com from " << proc << " in check process",DBG_INFO);
      MPI_Wait(&((*it).second),&status);
      DUMP("ok received",DBG_INFO);
      if (newatoms[proc].size() != buffer) FATAL("protocol prevision failed :  " << newatoms[proc].size() 
                                                 << " != " << buffer << " for exchange with " << proc);
      //je remplis la structure map concerned_conteneurs_recv (une fois recu bien sur);
    }
  }

  //  MPI_Barrier(worldCom);

  //real phase now
  //maintenant que je sais quels sous ensembles sont concernes par
  //les changements il faut prevenir les procs distant de ce fait
  map<int,std::vector<int> > recv_buffers;
  map<int,MPI_Request> recv_requests;
    
  {
    //phase de reception asynchrone
    typename map<int,vector<Ref> >::iterator it = newatoms.begin();
    typename map<int,vector<Ref> >::iterator last = newatoms.end();
      
    //pour chaque processeurs qui m'ont envoyes des atomes
    for (it = newatoms.begin();it != last ; ++it){
      proc = (*it).first;

      if (proc == PROC_INVALID)
        continue;
      size = (*it).second.size();
      if (size == 0) continue;

      std::vector<int> & buffer = recv_buffers[proc];
      MPI_Request & request = recv_requests[proc];
        
      buffer.resize(size);
      DUMP("receiving from proc " << proc << " " << size << " integers",DBG_INFO);
      MPI_Irecv(&buffer[0],size,MPI_INT,proc,proc,worldCom,&request);
    }

  }
    

  {
    //phase d'envoi
    std::vector<int> send_buffer; 

    typename map<int,vector<Ref> >::iterator it = sent_byproc.begin();
    typename map<int,vector<Ref> >::iterator last = sent_byproc.end();
    
    for (it = sent_byproc.begin();it != last ; ++it){
      proc = (*it).first;
      if (proc == PROC_INVALID) continue;
  
      size = (*it).second.size();
      vector<Ref> & atoms = (*it).second;

      if (size == 0) continue;

      send_buffer.resize(size);

      DUMP("sending to proc " << proc << " " << size << " integers",DBG_INFO);

     for (int i=0; i < size ; ++i){
       if (concerned_conteneurs_sent.count(atoms[i]) == 0)
         send_buffer[i] = 0;
       else
         send_buffer[i] = concerned_conteneurs_sent[atoms[i]];
     }
     MPI_Send(&send_buffer[0],size,MPI_INT,proc,rank,worldCom);
    }
  }
  
  //maintenant j'attend les communication de maniere synchronisante
  {
    MPI_Status status;
    typename map<int,MPI_Request>::iterator it = recv_requests.begin();
    typename map<int,MPI_Request>::iterator last = recv_requests.end();
    
    for (it = recv_requests.begin();it != last ; ++it){
      proc = (*it).first;  
      if (proc == PROC_INVALID) continue;
      
      std::vector<int> & buffer = recv_buffers[proc];
      DUMP("waiting to receive a packet from proc " << proc << " of size " << buffer.size()<< " integers",DBG_INFO);
      MPI_Wait(&((*it).second),&status);
      DUMP("received packet from proc " << proc << " of size " << buffer.size(),DBG_DETAIL);
      //je remplis la structure map concerned_conteneurs_recv (une fois recu bien sur);
      for (unsigned int i = 0 ; i < buffer.size() ; ++i){
        DUMP("received mask " << buffer[i] << " assoc with " << newatoms[proc][i] << " with i = " << i,DBG_INFO);
        if (concerned_conteneurs_recv.count(newatoms[proc][i]) != 0) 
          FATAL("trying to set mask multiple time over same uniq atom : probably migration trouble");
        if (buffer[i] != 0)
          concerned_conteneurs_recv[newatoms[proc][i]] = buffer[i];
      }
    }
  }
}

template<typename Ref>

void ReferenceManager< Ref >::PrintBilanToScreen

(

)

[inline, protected]

print bilan for concerned conteneur : used only to debug

Definition at line 189 of file reference_manager.cpp.

References ReferenceManager< Ref >::concerned_conteneurs_recv, ReferenceManager< Ref >::concerned_conteneurs_sent, ReferenceManager< Ref >::conteneurs, DBG_INFO, and DUMP.

Referenced by ReferenceManager< Ref >::UpdateRefSubSets().

                                              {
  int nb = conteneurs.size();
  std::map<int,int> cpt_subset_sent;
  std::map<int,int> cpt_subset_recv;

  {
    typename std::map<Ref,int,typename Ref::RefComparator>::iterator it = concerned_conteneurs_sent.begin();
    typename std::map<Ref,int,typename Ref::RefComparator>::iterator last = concerned_conteneurs_sent.end();
    
    while (it != last){
      Ref at = (*it).first;
      int mask = (*it).second;
      for (int subset = 0; subset < nb ; ++subset){
        if (cpt_subset_sent.count(subset) == 0) cpt_subset_sent[subset] = 0;
        if (mask & (1<<subset)) ++cpt_subset_sent[subset];
      }   
      ++it;
    }
  }

  {
    typename std::map<Ref,int,typename Ref::RefComparator>::iterator it = concerned_conteneurs_recv.begin();
    typename std::map<Ref,int,typename Ref::RefComparator>::iterator last = concerned_conteneurs_recv.end();
    
    while (it != last){
      Ref at = (*it).first;
      int mask = (*it).second;
      for (int subset = 0; subset < nb ; ++subset){
        if (cpt_subset_recv.count(subset) == 0) cpt_subset_recv[subset] = 0;
        if (mask & (1<<subset)) ++cpt_subset_recv[subset];
      }    
      ++it;
    }
  }

  DUMP("BEGIN *********************************",DBG_INFO);
  {
    std::map<int,int>::iterator it =  cpt_subset_sent.begin();
    std::map<int,int>::iterator last = cpt_subset_sent.end();
    while (it != last){
      DUMP("number of sent registered for subset " << (*it).first << " is " << (*it).second,DBG_INFO);
      ++it;
    }
  }

  {
    std::map<int,int>::iterator it =  cpt_subset_recv.begin();
    std::map<int,int>::iterator last = cpt_subset_recv.end();
    while (it != last){
      DUMP("number of recv registered for subset " << (*it).first << " is " << (*it).second,DBG_INFO);
      ++it;
    }
  }
  DUMP("END *********************************",DBG_INFO);
}

template<typename Ref>

ContenerTableauRefAtome<Ref>& ReferenceManager< Ref >::RequestCreationSubSet

(

char *

name

)

[inline]

the contener of subsets of atoms may only be created through refmanager

contener of subsets need to be updated in order to fit the migrated structures

Definition at line 68 of file reference_manager.h.

                                                                   {
    int size = conteneurs.size(); 
    DUMP("creation d'un sous ensemble d'atomes (numero" << size << ") named " << name,DBG_INFO);
    conteneurs.resize(size+1);
    conteneurs[size] = new ContenerTableauRefAtome<Ref>(name);
    return *conteneurs[size];
  }

template<typename Ref>

void ReferenceManager< Ref >::UpdateRefSubSets

(

)

[inline]

function that start the updating process of all attached structures

Definition at line 64 of file reference_manager.cpp.

References ReferenceManager< Ref >::AnalyseSubSets(), ReferenceManager< Ref >::CheckSubSetsCardinal(), ReferenceManager< Ref >::ClearSTL(), ReferenceManager< Ref >::CreationExchangedAtomsInSubSets(), DBG_ERROR, DBG_INFO, DBG_WARNING, DUMP, ReferenceManager< Ref >::ExchangeSubSetAttachedValues(), ReferenceManager< Ref >::ExchangeSubSetsMasks(), ReferenceManager< Ref >::have_changed, ReferenceManager< Ref >::moved, ReferenceManager< Ref >::newatoms, ReferenceManager< Ref >::PrintBilanToScreen(), ReferenceManager< Ref >::sent, ReferenceManager< Ref >::sent_byproc, and ReferenceManager< Ref >::worldCom.

Referenced by UpdateRefSubSets().

                                            {
  MPI_Barrier(worldCom);

  if (have_changed)
  DUMP("have_changed = " << have_changed,DBG_ERROR);
  if (have_changed==false){
    MPI_Barrier(worldCom);
    MPI_Barrier(worldCom);
    MPI_Barrier(worldCom);
    MPI_Barrier(worldCom);
    MPI_Barrier(worldCom);
    return;
  }
//    sleep(my_proc_id);

  if (moved.size() > 0){
    DUMP(moved.size() << " atoms moved in memory",DBG_INFO);
  }
  
  {
    typename map<int,vector<Ref> >::iterator it = newatoms.begin();
    typename map<int,vector<Ref> >::iterator last = newatoms.end();
    
    for (it = newatoms.begin();it != last;++it){    
      DUMP((*it).second.size() << " atoms received from proc " << (*it).first,DBG_INFO);
      //       for (unsigned int k = 0 ; k < (*it).second.size() ; ++k){
      //        LOG("received atom " << (*it).second[k]);
      //       }
    }
    
    {
      typename map<int,vector<Ref> >::iterator it = sent_byproc.begin();
      typename map<int,vector<Ref> >::iterator last = sent_byproc.end();
      
      for(it = sent_byproc.begin();it != last;++it){    
        DUMP((*it).second.size() << " atoms sent to proc " << (*it).first,DBG_INFO);
//      for (unsigned int k = 0 ; k < (*it).second.size() ; ++k){
//        LOG("sent atom " << (*it).second[k]);
//      }

      }
    }

    {

      std::map<int,int> temp;
      {
        typename map<Ref,int,typename Ref::RefComparator>::iterator it = sent.begin();
        typename map<Ref,int,typename Ref::RefComparator>::iterator last = sent.end();
        
        for(it = sent.begin();it != last;++it){    
          ++temp[(*it).second];
        }
      }
//       {
//      typename map<int,vector<Ref> >::iterator it = sent_byproc.begin();
//      typename map<int,vector<Ref> >::iterator last = sent_byproc.end();
        
//      for(it = sent_byproc.begin();it != last;++it){    
//        if((*it).second.size() != temp[(*it).first]) 
//          FATAL("sent_by_proc registered " <<  (*it).second.size() 
//                << " atoms as sended but sent registered " << temp[(*it).first] 
//                << " fatal inconstistency in send maps");
//      }
//       }
      
      
    }
    
    

  }

  MPI_Barrier(worldCom);

  //construit les masques d'appartenances des atomes a des sous ensembles
  DUMP("analyse ref subset",DBG_WARNING);
  AnalyseSubSets();
  DUMP("analyse of ref subset done",DBG_WARNING);
  MPI_Barrier(worldCom);
  //fait s'échanger les masques d'appartenances au sous groupes
  DUMP("exchange subset masks",DBG_WARNING);
  ExchangeSubSetsMasks();
  PrintBilanToScreen();
  DUMP("exchange subset masks done",DBG_WARNING);
  MPI_Barrier(worldCom);
  //effectue le transfert des valeurs des vecteurs attachés
  DUMP("exchange subset attached values",DBG_WARNING);
  ExchangeSubSetAttachedValues();
  DUMP("exchange subset attached values done",DBG_WARNING);
  MPI_Barrier(worldCom);
  //effectue la creation des nouvelles references dans les subsets 
  DUMP("exchange atoms in subsets",DBG_WARNING);
  CreationExchangedAtomsInSubSets();
  DUMP("exchange atoms in subsets done",DBG_WARNING);
  MPI_Barrier(worldCom);
#ifdef DEBUG_REFERENCEMANAGER   
  DUMP("check subsets cardinal",DBG_WARNING);
  //fait une verification que le cardinal des subsets gere n'ont pas changer avec la migration
  CheckSubSetsCardinal();
  DUMP("check subsets cardinal done",DBG_WARNING);
#endif
  //vide toutes les structures pour la prochaine fois
  DUMP("clear STL",DBG_WARNING);
  ClearSTL();
  DUMP("clear STL done",DBG_WARNING);

  have_changed = false;
  DUMP("end update ref",DBG_INFO);
}

Here is the call graph for this function:

---

Member Data Documentation

template<typename Ref>

std::map<int,std::vector<void *> > ReferenceManager< Ref >::attached_duo [protected]

attached duos that need to be updated as well as the conteners

Definition at line 130 of file reference_manager.h.

Referenced by ReferenceManager< Ref >::AdjustSizeRecvBuffers(), ReferenceManager< Ref >::AttachDuoDistributedVector(), ReferenceManager< Ref >::BuildSendingBuffers(), ReferenceManager< Ref >::CreationExchangedAtomsInSubSets(), and ReferenceManager< Ref >::DecodeBuffers().

template<typename Ref>

std::map<Ref,std::map<int,std::vector<double> >,typename Ref::RefComparator> ReferenceManager< Ref >::attached_values [protected]

attached values (we won't send complete vector)

Definition at line 128 of file reference_manager.h.

Referenced by ReferenceManager< Ref >::ClearSTL(), ReferenceManager< Ref >::CreationExchangedAtomsInSubSets(), and ReferenceManager< Ref >::DecodeBuffers().

template<typename Ref>

std::map<Ref,std::map<int,std::vector<int> >,typename Ref::RefComparator> ReferenceManager< Ref >::attached_values_duo [protected]

attached values in the duodistributed vector

Definition at line 132 of file reference_manager.h.

Referenced by ReferenceManager< Ref >::ClearSTL(), ReferenceManager< Ref >::CreationExchangedAtomsInSubSets(), and ReferenceManager< Ref >::DecodeBuffers().

template<typename Ref>

std::map<int,std::vector<double *> > ReferenceManager< Ref >::attached_vectors [protected]

attached vectors that need to be updated as well as the conteners

Definition at line 126 of file reference_manager.h.

Referenced by ReferenceManager< Ref >::AdjustSizeRecvBuffers(), ReferenceManager< Ref >::AttachVector(), ReferenceManager< Ref >::BuildSendingBuffers(), ReferenceManager< Ref >::CreationExchangedAtomsInSubSets(), and ReferenceManager< Ref >::DecodeBuffers().

template<typename Ref>

std::map<Ref,int,typename Ref::RefComparator> ReferenceManager< Ref >::concerned_conteneurs_recv [protected]

mapping between received atoms and the mask giving ownership to each subsets in chrage

Definition at line 120 of file reference_manager.h.

Referenced by ReferenceManager< Ref >::AdjustSizeRecvBuffers(), ReferenceManager< Ref >::ClearSTL(), ReferenceManager< Ref >::CreationExchangedAtomsInSubSets(), ReferenceManager< Ref >::DecodeBuffers(), ReferenceManager< Ref >::ExchangeSubSetsMasks(), and ReferenceManager< Ref >::PrintBilanToScreen().

template<typename Ref>

std::map<Ref,int,typename Ref::RefComparator> ReferenceManager< Ref >::concerned_conteneurs_sent [protected]

mapping between sent atoms and the mask giving ownership to each subsets in chrage

Definition at line 118 of file reference_manager.h.

Referenced by ReferenceManager< Ref >::AnalyseSubSets(), ReferenceManager< Ref >::BuildSendingBuffers(), ReferenceManager< Ref >::ClearSTL(), ReferenceManager< Ref >::ExchangeSubSetsMasks(), and ReferenceManager< Ref >::PrintBilanToScreen().

template<typename Ref>

std::vector<ContenerTableauRefAtome<Ref> *> ReferenceManager< Ref >::conteneurs [protected]

contener in charge (management of atom subsets )

Definition at line 116 of file reference_manager.h.

Referenced by ReferenceManager< Ref >::AdjustSizeRecvBuffers(), ReferenceManager< Ref >::AnalyseSubSets(), ReferenceManager< Ref >::AttachDuoDistributedVector(), ReferenceManager< Ref >::AttachVector(), ReferenceManager< Ref >::BuildSendingBuffers(), ReferenceManager< Ref >::CheckSubSetsCardinal(), ReferenceManager< Ref >::CreationExchangedAtomsInSubSets(), ReferenceManager< Ref >::DecodeBuffers(), ReferenceManager< Ref >::PrintBilanToScreen(), ReferenceManager< RefLammps >::RequestCreationSubSet(), and ReferenceManager< RefLammps >::~ReferenceManager().

template<typename Ref>

bool ReferenceManager< Ref >::have_changed [protected]

flag to notify if updating of attached references needed

Definition at line 113 of file reference_manager.h.

Referenced by ReferenceManager< Ref >::UpdateRefSubSets().

template<typename Ref>

std::map<Ref,Ref,typename Ref::RefComparator> ReferenceManager< Ref >::moved [protected]

mapping between moved atoms old ref and new ref

Definition at line 135 of file reference_manager.h.

Referenced by ReferenceManager< Ref >::AnalyseSubSets(), ReferenceManager< Ref >::ClearSTL(), and ReferenceManager< Ref >::UpdateRefSubSets().

template<typename Ref>

std::map<int,std::vector<Ref> > ReferenceManager< Ref >::newatoms [protected]

new atoms generated by migration (received)

Definition at line 143 of file reference_manager.h.

Referenced by ReferenceManager< Ref >::AdjustSizeRecvBuffers(), ReferenceManager< Ref >::ClearSTL(), ReferenceManager< Ref >::DecodeBuffers(), ReferenceManager< Ref >::ExchangeSubSetAttachedValues(), ReferenceManager< Ref >::ExchangeSubSetsMasks(), and ReferenceManager< Ref >::UpdateRefSubSets().

template<typename Ref>

int ReferenceManager< Ref >::rank [protected]

Definition at line 147 of file reference_manager.h.

Referenced by ReferenceManager< Ref >::ExchangeSubSetAttachedValues(), ReferenceManager< Ref >::ExchangeSubSetsMasks(), and ReferenceManager< RefLammps >::ReferenceManager().

template<typename Ref>

std::map<Ref,int,typename Ref::RefComparator> ReferenceManager< Ref >::sent [protected]

mapping between sent atom ref and new proc owner

Definition at line 138 of file reference_manager.h.

Referenced by ReferenceManager< Ref >::AnalyseSubSets(), ReferenceManager< Ref >::ClearSTL(), and ReferenceManager< Ref >::UpdateRefSubSets().

template<typename Ref>

std::map<int,std::vector<Ref> > ReferenceManager< Ref >::sent_byproc [protected]

inverse mapping : sent atoms sorted by receiving processors

Definition at line 140 of file reference_manager.h.

Referenced by ReferenceManager< Ref >::BuildSendingBuffers(), ReferenceManager< Ref >::ClearSTL(), ReferenceManager< Ref >::ExchangeSubSetAttachedValues(), ReferenceManager< Ref >::ExchangeSubSetsMasks(), and ReferenceManager< Ref >::UpdateRefSubSets().

template<typename Ref>

std::vector<std::map<Ref,int,typename Ref::RefComparator> > ReferenceManager< Ref >::trous [protected]

holes created by migration in subsets conteners

Definition at line 122 of file reference_manager.h.

Referenced by ReferenceManager< Ref >::AnalyseSubSets(), ReferenceManager< Ref >::BuildSendingBuffers(), ReferenceManager< Ref >::ClearSTL(), and ReferenceManager< Ref >::CreationExchangedAtomsInSubSets().

template<typename Ref>

MPI_Comm ReferenceManager< Ref >::worldCom [protected]

Definition at line 146 of file reference_manager.h.

Referenced by ReferenceManager< Ref >::AnalyseSubSets(), ReferenceManager< Ref >::CheckSubSetsCardinal(), ReferenceManager< Ref >::ExchangeSubSetAttachedValues(), ReferenceManager< Ref >::ExchangeSubSetsMasks(), ReferenceManager< RefLammps >::ReferenceManager(), and ReferenceManager< Ref >::UpdateRefSubSets().

---

The documentation for this class was generated from the following files:

• md/reference_manager.h
• md/reference_manager.cpp

---