1 #define _MPI_CPP_BINDINGS
	 2 #include <mpi.h>
	 3 #include <iostream>
	 4 
	 5 int main(int argc, char* argv[])
	 6 {
	 7   MPI::Init(argc, argv);
	 8 
	 9   int rank = MPI::COMM_WORLD.Get_rank();
	10   int size = MPI::COMM_WORLD.Get_size();
	11 
	12   int length;
	13   char* pName = new char[MPI::MAX_PROCESSOR_NAME+1];
	14   MPI::Get_processor_name(pName, length);
	15   std::string name(pName);
	16   delete [] pName;
	17 
	18   std::cout << "Hello World! I am " << rank << " of " << size;
	19   std::cout << " running on host " << name.c_str() << std::endl;
	20 
	21   MPI::Finalize();
	22 }
	

	  1 /** 
	  2  \file MyMPI.hpp
	  3  \brief a Singleton for MPI
	  4  \author Matthias Finke
	  5  \date  08.10.2006
	  6  \version 0.1
	  7 */
	  8 
	  9 #ifndef MYMPI_HPP_
	 10 #define MYMPI_HPP_
	 11 
	 12 #define _MPI_CPP_BINDINGS
	 13 #include <mpi.h>
	 14 #include <string>
	 15 #include <cassert>
	 16 #include <ostream>
	 17 
	 18 
	 19 namespace MF
	 20 {
	 21 
	 22   class MyMPI
	 23   {
	 24     int rank_;                      /**< the ID of a process*/
	 25     int size_;                      /**< the number of all processes*/
	 26     MPI::Intracomm world_;          /**< the communicator COMM_WORLD*/
	 27     std::string name_;              /**< the name of the node the process is running on*/
	 28     static const MyMPI* instance_;  /**< the single instance of this class*/
	 29 
	 30   public:
	 31 
	 32     /**
	 33       Returns the single instance of this class. If \a instance_ wasn't initialized yet, it is instantiated.
	 34       \return a const pointer to the single instance
	 35       \note MPI::Init is called without parameters
	 36     */
	 37     static const MyMPI* instance()
	 38     {
	 39       if (! instance_)
	 40       {
	 41         MPI::Init();
	 42         assert(MPI::Is_initialized() == true);
	 43         instance_ = new MyMPI;
	 44         static Destroyer d;
	 45       }
	 46       return instance_;
	 47     }
	 48 
	 49     int rank() const {return instance_->rank_;} /**< \returns the rank of the process*/
	 50     int size() const {return instance_->size_;} /**< \returns the number of all processes*/
	 51     std::string name() const {return instance_->name_;} /**< \returns the name of the node*/
	 52 
	 53     /** \return the communicator MPI::COMM_WORLD*/
	 54     const MPI::Intracomm& world() const {return instance_->world_;}
	 55 
	 56   private:
	 57 
	 58     /** The default-constructor is private and called via instance() */
	 59     MyMPI()
	 60     : rank_(MPI::COMM_WORLD.Get_rank())
	 61     , size_(MPI::COMM_WORLD.Get_size())
	 62     , world_(MPI::COMM_WORLD)
	 63     {
	 64       int length;
	 65       char* pName = new char[MPI::MAX_PROCESSOR_NAME+1];
	 66       MPI::Get_processor_name(pName, length);
	 67       name_ = pName;
	 68       delete [] pName;
	 69     }
	 70 
	 71     /**   \note the destructor calls MPI::Finalize() */
	 72     ~MyMPI()
	 73     {
	 74       MPI::Finalize();
	 75       assert(MPI::Is_finalized() == true);
	 76     }
	 77 
	 78     /** the copy C'tor is forbidden */
	 79     MyMPI(const MyMPI&) { }
	 80 
	 81     /**
	 82       a private class for explicit destruction of the singleton
	 83     */
	 84     class Destroyer
	 85     {
	 86       public:
	 87       /** the destructor deletes the singleton*/
	 88       ~Destroyer()
	 89       {
	 90         if( MyMPI::instance_ != NULL )
	 91           delete MyMPI::instance_;
	 92       }
	 93     };
	 94     friend class Destroyer;
	 95 
	 96     public:
	 97     /**
	 98       \param o a std::ostream
	 99       \param m a MyMPI object
	100       \return a std::ostream
	101     */
	102     friend std::ostream& operator<<(std::ostream& o, const MyMPI& m)
	103     { return o << "process " << m.rank_ << " of " << m.size_ << " running on " << m.name_;}
	104 
	105   };
	106   const MyMPI* MyMPI::instance_ = NULL;
	107 
	108 }//end namespace
	109 
	110 #endif