mpi.hh

Go to the documentation of this file.

#pragma once
 
#include <DiFfRG/common/utils.hh>
#include <deal.II/base/mpi.h>
 
// std
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
 
// deal.II is the single source of truth for whether MPI is available: it is the library that
// either includes <mpi.h> (giving us the real types at global scope) or declares dummy types in
// namespace dealii. DiFfRG's own HAVE_MPI must agree with it, otherwise mpi.cc would compile the
// serial fallbacks against real MPI types (or the reverse) and the two halves of the program would
// disagree about what a communicator is.
#if defined(HAVE_MPI) && !defined(DEAL_II_WITH_MPI)
#error                                                                                                                 \
    "DiFfRG was configured with MPI=ON but the deal.II it links against was built without DEAL_II_WITH_MPI. Rebuild deal.II with MPI, or configure DiFfRG with -DMPI=OFF."
#endif
 
#ifdef DEAL_II_WITH_MPI
#define DIFFRG_WITH_MPI 1
#endif
 
namespace DiFfRG
{
#ifndef DEAL_II_WITH_MPI
  // Without MPI, deal.II (>= 9.7) declares the MPI types and constants in
  // namespace dealii rather than at global scope. Pull them into namespace
  // DiFfRG so that the API below resolves identically with and without MPI.
  using dealii::MPI_Comm;
  using dealii::MPI_Datatype;
  using dealii::MPI_Op;
  using dealii::MPI_Request;
 
  using dealii::MPI_COMM_NULL;
  using dealii::MPI_COMM_SELF;
  using dealii::MPI_COMM_WORLD;
  using dealii::MPI_LOR;
  using dealii::MPI_MAX;
  using dealii::MPI_MIN;
  using dealii::MPI_REQUEST_NULL;
  using dealii::MPI_SUM;
#endif
 
  namespace MPI
  {
    bool available();
 
    uint rank(MPI_Comm comm);
    uint size(MPI_Comm comm);
    void barrier(MPI_Comm comm);
 
    // Element-wise in-place array reductions: on return every rank holds the reduced array.
    void sum_reduce(MPI_Comm comm, int *data, int size);
    void max_reduce(MPI_Comm comm, int *data, int size);
    void min_reduce(MPI_Comm comm, int *data, int size);
 
    void sum_reduce(MPI_Comm comm, double *data, int size);
    void max_reduce(MPI_Comm comm, double *data, int size);
    void min_reduce(MPI_Comm comm, double *data, int size);
 
    int sum_reduce(MPI_Comm comm, int value);
    int max_reduce(MPI_Comm comm, int value);
    int min_reduce(MPI_Comm comm, int value);
 
    double sum_reduce(MPI_Comm comm, double value);
    double max_reduce(MPI_Comm comm, double value);
    double min_reduce(MPI_Comm comm, double value);
 
    bool any_of(MPI_Comm comm, bool value);
    bool all_of(MPI_Comm comm, bool value);
 
    bool agree(MPI_Comm comm, uint64_t token);
 
    void bcast(MPI_Comm comm, void *data, size_t bytes, uint root = 0);
 
    void allgatherv_bytes(MPI_Comm comm, const void *send, size_t send_bytes, void *recv,
                          const std::vector<int> &recv_counts, const std::vector<int> &displs);
 
    MPI_Comm split_shared(MPI_Comm comm);
    void free_comm(MPI_Comm &comm);
 
    [[noreturn]] void abort(MPI_Comm comm, const std::string &message, int code = 1);
  } // namespace MPI
} // namespace DiFfRG