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:
#ifndef DUNE_MPIHELPER
#define DUNE_MPIHELPER
 
#include <cassert>
#include "collectivecommunication.hh"
#if HAVE_MPI
#include "mpi.h"
#include "mpicollectivecommunication.hh"
#endif
 
#include <dune/common/stdstreams.hh>
#include <dune/common/visibility.hh>
 
namespace Dune
{
  class FakeMPIHelper
  {
  public:
    enum {
      isFake = true
    };
 
    typedef No_Comm MPICommunicator;
 
    DUNE_EXPORT static MPICommunicator getCommunicator ()
    {
      static MPICommunicator comm;
      return comm;
    }
 
    static MPICommunicator getLocalCommunicator ()
    {
      return getCommunicator();
    }
 
 
 
    static CollectiveCommunication<MPICommunicator>
    getCollectiveCommunication()
    {
      return CollectiveCommunication<MPICommunicator>(getCommunicator());
    }
 
    DUNE_EXPORT static FakeMPIHelper& instance(int argc, char** argv)
    {
      (void)argc; (void)argv;
      // create singleton 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:
    enum {
      isFake = false
    };
 
    typedef MPI_Comm MPICommunicator;
 
    static MPICommunicator getCommunicator ()
    {
      return MPI_COMM_WORLD;
    }
 
    static MPICommunicator getLocalCommunicator ()
    {
      return MPI_COMM_SELF;
    }
 
    static CollectiveCommunication<MPICommunicator>
    getCollectiveCommunication()
    {
      return CollectiveCommunication<MPICommunicator>(getCommunicator());
    }
    DUNE_EXPORT static MPIHelper& instance(int& argc, char**& argv)
    {
      // create singleton instance
      static MPIHelper singleton (argc, argv);
      return singleton;
    }
 
    int rank () const { return rank_; }
    int size () const { return size_; }
 
  private:
    int rank_;
    int size_;
    bool initializedHere_;
    void prevent_warning(int){}
 
    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()
    {
      int wasFinalized = -1;
      MPI_Finalized( &wasFinalized );
      if(!wasFinalized && initializedHere_)
      {
        MPI_Finalize();
        dverb << "Called MPI_Finalize on p=" << rank_ << "!" <<std::endl;
      }
 
    }
    MPIHelper(const MPIHelper&);
    MPIHelper& operator=(const MPIHelper);
  };
#else
  // We do not have MPI therefore FakeMPIHelper
  // is the MPIHelper
  typedef FakeMPIHelper MPIHelper;
 
#endif
 
} // end namespace Dune
#endif