mpi_utils.hpp

Go to the documentation of this file.

//This file is part of Bertini 2.
//
//bertini2/parallel/mpi_utils.hpp is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//bertini2/parallel/mpi_utils.hpp is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with bertini2/parallel/mpi_utils.hpp.  If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) Bertini2 Development Team

 
#pragma once
 
#ifdef BERTINI2_HAVE_MPI
 
#include "bertini2/parallel/mpi_include.hpp"
 
#include <sstream>
#include <string>
 
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
 
namespace bertini {
namespace parallel {
 

template<typename T>
void mpi_send_serialized(MPI_Comm comm, int dest, int tag, T const& obj)
{
    std::ostringstream oss;
    {
        boost::archive::binary_oarchive oa(oss);
        oa << obj;
    }
    std::string const buf = oss.str();
    MPI_Send(buf.data(), static_cast<int>(buf.size()), MPI_BYTE, dest, tag, comm);
}
 

template<typename T>
int mpi_recv_serialized_any(MPI_Comm comm, int tag, T& obj)
{
    MPI_Status probe_status;
    MPI_Probe(MPI_ANY_SOURCE, tag, comm, &probe_status);
 
    int source = probe_status.MPI_SOURCE;
    int count  = 0;
    MPI_Get_count(&probe_status, MPI_BYTE, &count);
 
    std::string buf(static_cast<std::size_t>(count), '\0');
    MPI_Status recv_status;
    MPI_Recv(buf.data(), count, MPI_BYTE, source, tag, comm, &recv_status);
 
    std::istringstream iss(buf);
    boost::archive::binary_iarchive ia(iss);
    ia >> obj;
 
    return source;
}
 

template<typename T>
void mpi_recv_serialized(MPI_Comm comm, int source, int tag, T& obj)
{
    MPI_Status probe_status;
    MPI_Probe(source, tag, comm, &probe_status);
 
    int count = 0;
    MPI_Get_count(&probe_status, MPI_BYTE, &count);
 
    std::string buf(static_cast<std::size_t>(count), '\0');
    MPI_Status recv_status;
    MPI_Recv(buf.data(), count, MPI_BYTE, source, tag, comm, &recv_status);
 
    std::istringstream iss(buf);
    boost::archive::binary_iarchive ia(iss);
    ia >> obj;
}
 

inline void mpi_broadcast_string(MPI_Comm comm, std::string& s, int root)
{
    int len = static_cast<int>(s.size());
    MPI_Bcast(&len, 1, MPI_INT, root, comm);
    s.resize(static_cast<std::size_t>(len));
    MPI_Bcast(s.data(), len, MPI_CHAR, root, comm);
}
 

template<typename T>
void mpi_broadcast_serialized(MPI_Comm comm, T& obj, int root)
{
    int rank = 0;
    MPI_Comm_rank(comm, &rank);
 
    std::string s;
    if (rank == root)
    {
        std::ostringstream oss;
        boost::archive::binary_oarchive oa(oss);
        oa << obj;
        s = oss.str();
    }
 
    mpi_broadcast_string(comm, s, root);
 
    if (rank != root)
    {
        std::istringstream iss(s);
        boost::archive::binary_iarchive ia(iss);
        ia >> obj;
    }
}
 
 
} // namespace parallel
} // namespace bertini
 
#endif // BERTINI2_HAVE_MPI