parallel.h

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
 *                                                                           *
 *                       / /   / /    __    \ \  / /                         *
 *                      / /__ / /   / _ \    \ \/ /                          *
 *                     /  ___  /   | |/_/    / /\ \                          *
 *                    / /   / /    \_\      / /  \ \                         *
 *                                                                           *
 *                         Jakub Benda (c) 2014                              *
 *                     Charles University in Prague                          *
 *                                                                           *
\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#ifndef HEX_PARALLEL
#define HEX_PARALLEL

#ifndef NO_MPI
    #include <mpi.h>
#endif

#include "arrays.h"

class Parallel
{
    public:
        
        Parallel (int* argc, char*** argv, bool active)
            : active_(active), iproc_(0), Nproc_(1)
        {
#ifndef NO_MPI
            MPI_Init (argc, argv);
            MPI_Comm_size (MPI_COMM_WORLD, &Nproc_);
            MPI_Comm_rank (MPI_COMM_WORLD, &iproc_);
#else
            active_ = false;
#endif
        }
        
        ~Parallel ()
        {
#ifndef NO_MPI
            if (active_)
                MPI_Finalize();
#endif
        }
        
        //
        // getters
        //
        
        inline bool IamMaster () const
        {
            return iproc_ == 0;
        }
        
        inline bool isMyWork (int i) const
        {
            return i % Nproc_ == iproc_;
        }
        
        inline bool active () const
        {
            return active_;
        }
        
        inline int iproc () const
        {
            return iproc_;
        }
        
        inline int Nproc () const
        {
            return Nproc_;
        }
        
        template <class T> void sync (ArrayView<T> array, size_t chunksize, size_t Nchunk) const
        {
#ifndef NO_MPI
            if (active_)
            {
                for (unsigned ichunk = 0; ichunk < Nchunk; ichunk++)
                {
                    // relevant process will broadcast this chunk's data
                    MPI_Bcast (
                        array.data() + ichunk * chunksize,
                        chunksize,
                        MPI_DOUBLE_COMPLEX,
                        ichunk % Nproc_,
                        MPI_COMM_WORLD
                    );
                }
            }
#endif
        }
        
        void wait () const
        {
#ifndef NO_MPI
            if (active_)
                MPI_Barrier(MPI_COMM_WORLD);
#endif
        }
        
    private:
        
        // whether the MPI is on
        bool active_;
        
        // communicator rank
        int iproc_;
        
        // communicator size
        int Nproc_;
};

#endif