G4mpi Namespace Reference

Typedefs
typedef unsigned int	rank_t
typedef std::pair< rank_t, rank_t >	couple_t
typedef std::map< int, std::vector< couple_t > >	commMap_t
typedef std::function< void(std::function< void(unsigned int)>, std::function< void(unsigned int)>, std::function< void(void)>, unsigned int, unsigned int)>	mergerHandler_t

Functions
commMap_t	buildCommunicationMap (std::vector< rank_t > &input)
void	Merge (std::function< void(unsigned int)> senderF, std::function< void(unsigned int)> receiverF, std::function< void(void)> barrierF, unsigned int commSize, unsigned int myrank)

Typedef Documentation

commMap_t

typedef std::map<int,std::vector<couple_t> > G4mpi::commMap_t

Definition at line 50 of file G4MPIutils.hh.

couple_t

typedef std::pair<rank_t,rank_t> G4mpi::couple_t

Definition at line 47 of file G4MPIutils.hh.

mergerHandler_t

typedef std::function<void(std::function<void(unsigned int)>, std::function<void(unsigned int)>, std::function<void(void)>, unsigned int, unsigned int)> G4mpi::mergerHandler_t

Definition at line 93 of file G4MPIutils.hh.

rank_t

typedef unsigned int G4mpi::rank_t

Definition at line 45 of file G4MPIutils.hh.

Function Documentation

buildCommunicationMap()

G4mpi::commMap_t G4mpi::buildCommunicationMap

(

std::vector< rank_t > &

input

)

Definition at line 37 of file G4MPIutils.cc.

                                    {
  using namespace G4mpi;
  //Check validity of input
  std::sort(input.begin(),input.end());
  if ( input.size() < 1 || input[0] != 0 ) {
      G4Exception("G4mpi::buildCommunicationMap(...)","G4mpi001",FatalException,
          "Empty input or cannot find rank 0 in input.");
  }
  //Requested that no duplicates!
  std::vector<rank_t> copy(input.size());
  std::copy(input.begin(),input.end(),copy.begin());
  copy.erase( std::unique(copy.begin(),copy.end()),copy.end());
  if ( copy != input )
    {
      G4Exception("G4mpi::buildCommunicationMap(...)","G4mpi001",FatalException,
          "There are duplicates in list of input ranks.");
    }
  
  //The final communication map
  commMap_t mymap;
  //The communication map key
  int cycle = 0;
  //The communication map value
  std::vector<couple_t> couples;
  //Start a loop (on cycles) that will break
  do {
    //An helper container
    std::vector<rank_t> receiving;
    couples.clear();
    //Loop on all input until there is
    //at least a couple
    while ( input.size() > 1 ) {
      //Sort input in ascending order
      std::sort( input.begin(),input.end() );
      //Pop from back of the input a couple
      const auto& send_ = input.back();
      input.pop_back();
      const auto& rec_ = input.back();
      input.pop_back();
      //Actually the receiving is not empty,
      //remember it because we have to add it back
      receiving.push_back( rec_ );
      //This is a couple for this cycle
      couples.push_back( std::make_pair(send_,rec_) );
    }
    //Populate final map for this cycle
    mymap[cycle++]=couples;
    //Let's put back in the input container the receivers
    input.insert( input.end() , receiving.begin() , receiving.end() );
    //Let's continue until there is ony one rank in input (number 0)
  } while ( input.size()!=1 );
  return mymap;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Merge()

void G4mpi::Merge	(	std::function< void(unsigned int)>	senderF,
		std::function< void(unsigned int)>	receiverF,
		std::function< void(void)>	barrierF,
		unsigned int	commSize,
		unsigned int	myrank
	)

Definition at line 161 of file G4MPIutils.cc.

                                                         {
      //Optimize communications between ranks
      std::vector<G4mpi::rank_t> ranks(commSize);
      std::iota(ranks.begin(),ranks.end(),0); //{0,1,2,3,...}
      auto comms = G4mpi::buildCommunicationMap(ranks);
      //Loop on cycles of communications
      for ( const auto& cycle : comms ) {
          //Each cycle is a set of communications between ranks, it is guarantted that
          //each rank participate in one and only one communication for each cycle
         for (const auto& pattern : cycle.second ) {
             //pattern is a couple: sender,receiver
             if ( myrank == pattern.first ) {
                 //Send to destination
                 senderF(pattern.second);
             }
             else if ( myrank == pattern.second ) {
                 //Receive from source
                 receiverF(pattern.first);
             }
         }
         //Important: Wait for this cycle to end before going to the next, even if this rank
         //did not do anything
          //This is needed to be sure that the redcutions are done correctly
         barrierF();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: