MpiCommunicationPatterns.h

Go to the documentation of this file.

#ifndef MPI_COMMUNICATION_PATTERNS_H
#define MPI_COMMUNICATION_PATTERNS_H
 
#ifdef MPI_PRESENT
#include <mpi.h>
 
#include <string>
#include <valarray>
#include <vector>
 
#include "IniParser.h"
#include "SimulationClassBase.h"
 
template <typename T>
MPI_Datatype mpi_type_of();
 
template <>
inline MPI_Datatype mpi_type_of<double>()
{
    return MPI_DOUBLE;
}
template <>
inline MPI_Datatype mpi_type_of<float>()
{
    return MPI_FLOAT;
}
template <>
inline MPI_Datatype mpi_type_of<int>()
{
    return MPI_INT;
}
template <>
inline MPI_Datatype mpi_type_of<long>()
{
    return MPI_LONG;
}
 
template <typename T>
void commPatternAllDataToAll(std::valarray<T>& global_array, const std::valarray<T>& local_array,
                             const SimulationClassBase<T>* sim)
{
    static_assert(std::is_same<T, double>::value || std::is_same<T, float>::value
                      || std::is_same<T, int>::value || std::is_same<T, long>::value,
                  "commPatternAllDataToAll: unsupported T; extend mpi_type_of<T>()");
 
    MPI_Datatype dtype = mpi_type_of<T>();
 
    // quick sanity
    if (global_array.size() == 0 || local_array.size() == 0)
        return;
 
    MPI_Request request_handles[2];
    // This call gathers all temperatures in all arrays within the two sub-communicators.
    // Within each, the size of all temperature fields are equivalent, so the scalable operations
    // can be used.
    int split_id;
    try
    {
        if (global_array.size()
            == sim->m_simulation_config.getIntParameters("global_number_of_facets"))
        {
            split_id =
                static_cast<int>(sim->global_array_split
                                 / sim->m_simulation_config.getIntParameters("numerical_layers"));
        }
        else
        {
            split_id = sim->global_array_split;
        }
    }
    catch (const BadInput& e)
    {
        std::cerr << static_cast<std::string>("[MpiCommunicationPatterns]: ")
                  << static_cast<std::string>(e.what()) << '\n';
        throw BadInput(static_cast<std::string>("[MpiCommunicationPatterns]: ")
                       + static_cast<std::string>(e.what()));
    }
 
    if (split_id < 0 || split_id > global_array.size())
    {
        std::cerr << "[MpiCommunicationPatterns]: split_id out of bounds.\n";
        throw std::runtime_error(
            static_cast<std::string>("[MpiCommunicationPatterns]: split_id out of bounds."));
    }
 
    // Safe check size and cast to int. Not needed for global_array_split as if that is > MAX_INT,
    // so is global_array.size().
    auto check_and_cast = [](std::size_t s) -> int
    {
        if (s > static_cast<std::size_t>(INT_MAX))
        {
            std::cerr << "[MpiCommunicationPatterns]: count > INT_MAX\n";
            throw std::overflow_error("[MpiCommunicationPatterns]: count > INT_MAX.");
        }
        return static_cast<int>(s);
    };
    const int local_count = check_and_cast(local_array.size());
    const int global_count = check_and_cast(global_array.size());
    if (sim->my_color == 0)
    {
        // Color 0 gathers in the first part of the array.
        MPI_Allgather(&local_array[0], local_count, dtype, &global_array[0], local_count, dtype,
                      sim->sub_comm);
    }
    else
    {
        // While color 1 gathers in the second part.
        MPI_Allgather(&local_array[0], local_count, dtype, &global_array[split_id], local_count,
                      dtype, sim->sub_comm);
    }
 
    // Skip final comm pattern that only needs to be used, when sub- and intercomms are established.
    if (sim->other_color_exists == 0)
    {
        return;
    }
 
    // This code exchanges the two parts of the array to the other group. The remote leader sends
    // the data of the one sub-comm to each process in the other sub-comm.
    // The operation is performed non-blocking for both sub-comms via the inter-comm.
    if (sim->my_color == 0 && sim->my_sub_rank == 0)
    {
        MPI_Ibcast(&global_array[0], split_id, dtype, MPI_ROOT, sim->inter_comm,
                   &request_handles[0]);
    }
    else if (sim->my_color == 0)
    {
        MPI_Ibcast(&global_array[0], split_id, dtype, MPI_PROC_NULL, sim->inter_comm,
                   &request_handles[0]);
    }
    else
    {
        MPI_Ibcast(&global_array[0], split_id, dtype, 0, sim->inter_comm, &request_handles[0]);
    }
 
    const int lower_array_size{global_count - split_id};
 
    if (sim->my_color == 1 && sim->my_sub_rank == 0)
    {
        MPI_Ibcast(&global_array[split_id], lower_array_size, dtype, MPI_ROOT, sim->inter_comm,
                   &request_handles[1]);
    }
    else if (sim->my_color == 1)
    {
        MPI_Ibcast(&global_array[split_id], lower_array_size, dtype, MPI_PROC_NULL, sim->inter_comm,
                   &request_handles[1]);
    }
    else
    {
        MPI_Ibcast(&global_array[split_id], lower_array_size, dtype, 0, sim->inter_comm,
                   &request_handles[1]);
    }
 
    MPI_Waitall(2, request_handles, MPI_STATUSES_IGNORE);
}
 
template <typename T>
void commPatternAllDataToAllInPlace(std::valarray<T>& global_array, int data_count,
                                    const SimulationClassBase<T>* sim)
{
    static_assert(std::is_same<T, double>::value || std::is_same<T, float>::value
                      || std::is_same<T, int>::value || std::is_same<T, long>::value,
                  "commPatternAllDataToAll: unsupported T; extend mpi_type_of<T>()");
 
    MPI_Datatype dtype = mpi_type_of<T>();
 
    // quick sanity
    if (global_array.size() == 0)
        return;
 
    MPI_Request request_handles[2];
    // This call gathers all temperatures in all arrays within the two sub-communicators.
    // Within each, the size of all temperature fields are equivalent, so the scalable operations
    // can be used.
    int split_id;
    try
    {
        if (global_array.size()
            == sim->m_simulation_config.getIntParameters("global_number_of_facets"))
        {
            split_id =
                static_cast<int>(sim->global_array_split
                                 / sim->m_simulation_config.getIntParameters("numerical_layers"));
        }
        else
        {
            split_id = sim->global_array_split;
        }
    }
    catch (const BadInput& e)
    {
        std::cerr << static_cast<std::string>("[MpiCommunicationPatterns]: ")
                  << static_cast<std::string>(e.what()) << '\n';
        throw BadInput(static_cast<std::string>("[MpiCommunicationPatterns]: ")
                       + static_cast<std::string>(e.what()));
    }
 
    if (split_id < 0 || split_id > global_array.size())
    {
        std::cerr << "[MpiCommunicationPatterns]: split_id out of bounds.\n";
        throw std::runtime_error(
            static_cast<std::string>("[MpiCommunicationPatterns]: split_id out of bounds."));
    }
 
    if (sim->my_color == 0)
    {
        // Color 0 gathers in the first part of the array.
        MPI_Allgather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, &global_array[0], data_count, MPI_DOUBLE,
                      sim->sub_comm);
    }
    else
    {
        // While color 1 gathers in the second part.
        MPI_Allgather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, &global_array[split_id], data_count,
                      MPI_DOUBLE, sim->sub_comm);
    }
 
    // Skip final comm pattern that only needs to be used, when sub- and intercomms are established.
    if (sim->other_color_exists == 0)
    {
        return;
    }
 
    // This code exchanges the two parts of the array to the other group. The remote leader sends
    // the data of the one sub-comm to each process in the other sub-comm.
    // The operation is performed non-blocking for both sub-comms via the inter-comm.
    if (sim->my_color == 0 && sim->my_sub_rank == 0)
    {
        MPI_Ibcast(&global_array[0], split_id, MPI_DOUBLE, MPI_ROOT, sim->inter_comm,
                   &request_handles[0]);
    }
    else if (sim->my_color == 0)
    {
        MPI_Ibcast(&global_array[0], split_id, MPI_DOUBLE, MPI_PROC_NULL, sim->inter_comm,
                   &request_handles[0]);
    }
    else
    {
        MPI_Ibcast(&global_array[0], split_id, MPI_DOUBLE, 0, sim->inter_comm, &request_handles[0]);
    }
 
    auto check_and_cast = [](std::size_t s) -> int
    {
        if (s > static_cast<std::size_t>(INT_MAX))
        {
            std::cerr << "[MpiCommunicationPatterns]: count > INT_MAX\n";
            throw std::overflow_error("[MpiCommunicationPatterns]: count > INT_MAX.");
        }
        return static_cast<int>(s);
    };
    const int lower_array_size{check_and_cast(global_array.size()) - split_id};
 
    if (sim->my_color == 1 && sim->my_sub_rank == 0)
    {
        MPI_Ibcast(&global_array[split_id], lower_array_size, MPI_DOUBLE, MPI_ROOT, sim->inter_comm,
                   &request_handles[1]);
    }
    else if (sim->my_color == 1)
    {
        MPI_Ibcast(&global_array[split_id], lower_array_size, MPI_DOUBLE, MPI_PROC_NULL,
                   sim->inter_comm, &request_handles[1]);
    }
    else
    {
        MPI_Ibcast(&global_array[split_id], lower_array_size, MPI_DOUBLE, 0, sim->inter_comm,
                   &request_handles[1]);
    }
 
    MPI_Waitall(2, request_handles, MPI_STATUSES_IGNORE);
}
 
template <typename T>
void commPatternAllDataToAllInPlace(std::vector<T>& global_array, int data_count,
                                    const SimulationClassBase<T>* sim)
{
    static_assert(std::is_same<T, double>::value || std::is_same<T, float>::value
                      || std::is_same<T, int>::value || std::is_same<T, long>::value,
                  "commPatternAllDataToAll: unsupported T; extend mpi_type_of<T>()");
 
    MPI_Datatype dtype = mpi_type_of<T>();
 
    // quick sanity
    if (global_array.size() == 0)
        return;
 
    MPI_Request request_handles[2];
    // This call gathers all temperatures in all arrays within the two sub-communicators.
    // Within each, the size of all temperature fields are equivalent, so the scalable operations
    // can be used.
    int split_id;
    try
    {
        if (global_array.size()
            == sim->m_simulation_config.getIntParameters("global_number_of_facets"))
        {
            split_id =
                static_cast<int>(sim->global_array_split
                                 / sim->m_simulation_config.getIntParameters("numerical_layers"));
        }
        else
        {
            split_id = sim->global_array_split;
        }
    }
    catch (const BadInput& e)
    {
        std::cerr << static_cast<std::string>("[MpiCommunicationPatterns]: ")
                  << static_cast<std::string>(e.what()) << '\n';
        throw BadInput(static_cast<std::string>("[MpiCommunicationPatterns]: ")
                       + static_cast<std::string>(e.what()));
    }
 
    if (split_id < 0 || split_id > global_array.size())
    {
        std::cerr << "[MpiCommunicationPatterns]: split_id out of bounds.\n";
        throw std::runtime_error(
            static_cast<std::string>("[MpiCommunicationPatterns]: split_id out of bounds."));
    }
 
    if (sim->my_color == 0)
    {
        // Color 0 gathers in the first part of the array.
        MPI_Allgather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, &global_array[0], data_count, MPI_DOUBLE,
                      sim->sub_comm);
    }
    else
    {
        // While color 1 gathers in the second part.
        MPI_Allgather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, &global_array[split_id], data_count,
                      MPI_DOUBLE, sim->sub_comm);
    }
 
    // Skip final comm pattern that only needs to be used, when sub- and intercomms are established.
    if (sim->other_color_exists == 0)
    {
        return;
    }
 
    // This code exchanges the two parts of the array to the other group. The remote leader sends
    // the data of the one sub-comm to each process in the other sub-comm.
    // The operation is performed non-blocking for both sub-comms via the inter-comm.
    if (sim->my_color == 0 && sim->my_sub_rank == 0)
    {
        MPI_Ibcast(&global_array[0], split_id, MPI_DOUBLE, MPI_ROOT, sim->inter_comm,
                   &request_handles[0]);
    }
    else if (sim->my_color == 0)
    {
        MPI_Ibcast(&global_array[0], split_id, MPI_DOUBLE, MPI_PROC_NULL, sim->inter_comm,
                   &request_handles[0]);
    }
    else
    {
        MPI_Ibcast(&global_array[0], split_id, MPI_DOUBLE, 0, sim->inter_comm, &request_handles[0]);
    }
 
    auto check_and_cast = [](std::size_t s) -> int
    {
        if (s > static_cast<std::size_t>(INT_MAX))
        {
            std::cerr << "[MpiCommunicationPatterns]: count > INT_MAX\n";
            throw std::overflow_error("[MpiCommunicationPatterns]: count > INT_MAX.");
        }
        return static_cast<int>(s);
    };
    const int lower_array_size{check_and_cast(global_array.size()) - split_id};
 
    if (sim->my_color == 1 && sim->my_sub_rank == 0)
    {
        MPI_Ibcast(&global_array[split_id], lower_array_size, MPI_DOUBLE, MPI_ROOT, sim->inter_comm,
                   &request_handles[1]);
    }
    else if (sim->my_color == 1)
    {
        MPI_Ibcast(&global_array[split_id], lower_array_size, MPI_DOUBLE, MPI_PROC_NULL,
                   sim->inter_comm, &request_handles[1]);
    }
    else
    {
        MPI_Ibcast(&global_array[split_id], lower_array_size, MPI_DOUBLE, 0, sim->inter_comm,
                   &request_handles[1]);
    }
 
    MPI_Waitall(2, request_handles, MPI_STATUSES_IGNORE);
}
 
#endif  // MPI_PRESENT
 
#endif  // MPI_COMMUNICATION_PATTERNS_H