Line data    Source code

       1             : // Copyright (C) 2015 Technische Universitaet Muenchen
       2             : // This file is part of the Mamico project. For conditions of distribution
       3             : // and use, please see the copyright notice in Mamico's main folder, or at
       4             : // www5.in.tum.de/mamico
       5             : 
       6             : template <unsigned int dim>
       7          68 : tarch::utils::MultiMDService<dim>::MultiMDService(const tarch::la::Vector<dim, unsigned int>& numberProcessesPerMDSimulation,
       8             :                                                   const unsigned int& totalNumberMDSimulations
       9             : #if (TARCH_PARALLEL == TARCH_YES)
      10             :                                                   ,
      11             :                                                   MPI_Comm globalComm
      12             : #endif
      13             :                                                   )
      14             :     : // initialise all values, either immediately consistent for single and
      15             :       // parallel mode, or for single mode only (and overwrite the setting
      16             :       // afterwards in constructor body)
      17          68 :       _numberProcessesPerMDSimulation(numberProcessesPerMDSimulation), _numberLocalComms(1), _totalNumberMDSimulations(totalNumberMDSimulations),
      18          68 :       _avgNumberMDSimulationsPerLocalComm(totalNumberMDSimulations), _thisNumberMDSimulations(totalNumberMDSimulations), _globalSize(1), _globalRank(0),
      19          68 :       _localSize(1), _localRank(0) {
      20             : #if (TARCH_PARALLEL == TARCH_YES)
      21             : 
      22          68 :   _globalComm = globalComm;
      23             : 
      24          68 :   MPI_Comm_size(getGlobalCommunicator(), &_globalSize);
      25          68 :   MPI_Comm_rank(getGlobalCommunicator(), &_globalRank);
      26             : 
      27             :   /* Resilience TODOs
      28             :    * Allow idle processes?
      29             :    *   - allow any number of processes or only useful numbers?
      30             :    */
      31             : 
      32             :   // test process distribution
      33          68 :   _localSize = numberProcessesPerMDSimulation[0];
      34         204 :   for (unsigned int d = 1; d < dim; d++) {
      35         136 :     _localSize *= numberProcessesPerMDSimulation[d];
      36             :   }
      37          68 :   if (_globalSize % _localSize != 0) {
      38           0 :     std::cout << "_globalSize = " << _globalSize << std::endl;
      39           0 :     std::cout << "_localSize = " << _localSize << std::endl;
      40           0 :     std::cout << "ERROR MultiMDService::MultiMDService(): _globalSize mod "
      41             :                  "_localSize!=0 !"
      42           0 :               << std::endl;
      43           0 :     std::cout << "The number of globally available MPI processes must be "
      44             :                  "filled completely with local MD simulation processes!"
      45           0 :               << std::endl;
      46           0 :     exit(EXIT_FAILURE);
      47             :   }
      48             : 
      49             :   // compute number of local communicators
      50          68 :   _numberLocalComms = _globalSize / _localSize;
      51             :   // initialise local communicator by splitting the whole process domain into
      52             :   // _numberLocalComms communicators
      53          68 :   MPI_Comm_split(getGlobalCommunicator(), _globalRank / _localSize, _globalRank, &_localComm);
      54             :   // initialise local rank
      55          68 :   MPI_Comm_rank(_localComm, &_localRank);
      56             :   // compute avg number of MD simulations per local communicator
      57          68 :   _avgNumberMDSimulationsPerLocalComm = _totalNumberMDSimulations / _numberLocalComms;
      58             :   // compute the number of MD simulations on the current communicator. This is
      59             :   // always the same as _avgMDSimulations..., except for the last communicator
      60             :   // which is filled up with the rest
      61          68 :   if ((unsigned int)(_globalRank / _localSize + 1) == _numberLocalComms) {
      62          38 :     _thisNumberMDSimulations = _totalNumberMDSimulations - _avgNumberMDSimulationsPerLocalComm * (_numberLocalComms - 1);
      63             :   } else {
      64          30 :     _thisNumberMDSimulations = _avgNumberMDSimulationsPerLocalComm;
      65             :   }
      66             : 
      67             : #endif
      68          68 : }
      69             : 
      70             : namespace tarch {
      71             : namespace utils {
      72          64 : template <unsigned int dim> MultiMDService<dim>::~MultiMDService() {}
      73             : } // namespace utils
      74             : } // namespace tarch
      75             : 
      76           8 : template <unsigned int dim> unsigned int tarch::utils::MultiMDService<dim>::getGlobalNumberOfLocalMDSimulation(unsigned int localMDSimulation) const {
      77           8 :   return (_globalRank / _localSize) * _avgNumberMDSimulationsPerLocalComm + localMDSimulation;
      78             : }
      79             : 
      80             : template <unsigned int dim> int tarch::utils::MultiMDService<dim>::getLocalNumberOfGlobalMDSimulation(unsigned int globalMDSimulation) const {
      81             :   return globalMDSimulation - (_globalRank / _localSize) * _avgNumberMDSimulationsPerLocalComm;
      82             : }