mpihelper.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright (C) DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
#ifndef DUNE_MPIHELPER
#define DUNE_MPIHELPER
 
#if HAVE_MPI
#include <cassert>
#include <mpi.h>
#endif
 
#include <mutex>
 
#include <dune/common/parallel/communication.hh>
#if HAVE_MPI
#include <dune/common/parallel/mpicommunication.hh>
#include <dune/common/stdstreams.hh>
#endif
#include <dune/common/visibility.hh>
 
namespace Dune
{
  class FakeMPIHelper
  {
  public:
    constexpr static bool isFake = true;
 
    typedef No_Comm MPICommunicator;
 
    DUNE_EXPORT static MPICommunicator getCommunicator ()
    {
      static MPICommunicator comm;
      return comm;
    }
 
    static MPICommunicator getLocalCommunicator ()
    {
      return getCommunicator();
    }
 
 
 
    [[deprecated("getCollectionCommunication is deprecated. Use getCommunication instead.")]]
    static Communication<MPICommunicator> getCollectiveCommunication()
    {
      return Communication<MPICommunicator>(getCommunicator());
    }
 
    static Communication<MPICommunicator>
    getCommunication()
    {
      return Communication<MPICommunicator>(getCommunicator());
    }
 
    DUNE_EXPORT static FakeMPIHelper& instance([[maybe_unused]] int argc,
                                               [[maybe_unused]] char** argv)
    {
      return instance();
    }
 
    DUNE_EXPORT static FakeMPIHelper& instance()
    {
      static FakeMPIHelper singleton;
      return singleton;
    }
 
    int rank () const { return 0; }
    int size () const { return 1; }
 
  private:
    FakeMPIHelper() {}
    FakeMPIHelper(const FakeMPIHelper&);
    FakeMPIHelper& operator=(const FakeMPIHelper);
  };
 
#if HAVE_MPI
  class MPIHelper
  {
  public:
    constexpr static bool isFake = false;
 
    typedef MPI_Comm MPICommunicator;
 
    static MPICommunicator getCommunicator ()
    {
      return MPI_COMM_WORLD;
    }
 
    static MPICommunicator getLocalCommunicator ()
    {
      return MPI_COMM_SELF;
    }
 
    [[deprecated("getCollectionCommunication is deprecated. Use getCommunication instead.")]]
    static Communication<MPICommunicator>
    getCollectiveCommunication()
    {
      return Communication<MPICommunicator>(getCommunicator());
    }
 
    static Communication<MPICommunicator>
    getCommunication()
    {
      return Communication<MPICommunicator>(getCommunicator());
    }
    DUNE_EXPORT static MPIHelper& instance(int& argc, char**& argv)
    {
      // create singleton instance
      if (!instance_){
        static std::mutex mutex;
        std::lock_guard<std::mutex> guard(mutex);
        if(!instance_)
          instance_.reset(new MPIHelper(argc,argv));
      }
      return *instance_;
    }
 
    DUNE_EXPORT static MPIHelper& instance()
    {
      if(!instance_)
        DUNE_THROW(InvalidStateException, "MPIHelper not initialized! Call MPIHelper::instance(argc, argv) with arguments first.");
      return *instance_;
    }
 
    int rank () const { return rank_; }
    int size () const { return size_; }
 
    ~MPIHelper()
    {
      int wasFinalized = -1;
      MPI_Finalized( &wasFinalized );
      if(!wasFinalized && initializedHere_)
      {
        MPI_Finalize();
        dverb << "Called MPI_Finalize on p=" << rank_ << "!" <<std::endl;
      }
 
    }
 
  private:
    int rank_;
    int size_;
    bool initializedHere_;
    void prevent_warning(int){}
    static inline std::unique_ptr<MPIHelper> instance_ = {};
 
    MPIHelper(int& argc, char**& argv)
    : initializedHere_(false)
    {
      int wasInitialized = -1;
      MPI_Initialized( &wasInitialized );
      if(!wasInitialized)
      {
        rank_ = -1;
        size_ = -1;
        static int is_initialized = MPI_Init(&argc, &argv);
        prevent_warning(is_initialized);
        initializedHere_ = true;
      }
 
      MPI_Comm_rank(MPI_COMM_WORLD,&rank_);
      MPI_Comm_size(MPI_COMM_WORLD,&size_);
 
      assert( rank_ >= 0 );
      assert( size_ >= 1 );
 
      dverb << "Called  MPI_Init on p=" << rank_ << "!" << std::endl;
    }
 
    MPIHelper(const MPIHelper&);
    MPIHelper& operator=(const MPIHelper);
  };
#else // !HAVE_MPI
  // We do not have MPI therefore FakeMPIHelper
  // is the MPIHelper
  typedef FakeMPIHelper MPIHelper;
 
#endif // !HAVE_MPI
 
} // end namespace Dune
#endif