mpi.hpp

Go to the documentation of this file.

// Copyright (c) 2020-2021 Simons Foundation
//
// This program 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.
//
// This program 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 may obtain a copy of the License at
//     https://www.gnu.org/licenses/gpl-3.0.txt
//
// Authors: Michel Ferrero, Olivier Parcollet, Nils Wentzell

 
#pragma once
 
#include "./gf.hpp"
#include "../../utility/macros.hpp"
 
#include <mpi/mpi.hpp>
#include <nda/nda.hpp>
 
#include <type_traits>
 
namespace triqs::gfs {


  template <MemoryGf G> void mpi_broadcast(G &&g, mpi::communicator c, int root) { // NOLINT (temporary views are allowed)
    constexpr bool is_view = std::decay_t<G>::is_view;
 
    // broadcast mesh
    if constexpr (!is_view) {
      // for non-view GFs, we broadcast the mesh directly into the GF
      mpi::broadcast(g._mesh, c, root);
    } else {
      // for views, we keep the mesh in the GF but check that it is the same as the mesh on the root process
      auto m = g.mesh();
      mpi::broadcast(m, c, root);
      EXPECTS(m.mesh_hash() == g.mesh().mesh_hash());
    }
 
    // broadcast data
    mpi::broadcast(g.data(), c, root);
  }

  template <MemoryGf G1, MemoryGf G2>
  void mpi_reduce_into(G1 const &g_in, G2 &&g_out, mpi::communicator c, // NOLINT (temporary views are allowed here)
                       int root, bool all, MPI_Op op) {
    constexpr bool is_view = std::decay_t<G2>::is_view;
 
    // check the meshes of the input GFs
    EXPECTS(mpi::all_equal(g_in.mesh().mesh_hash(), c));
 
    // assign (check) the mesh of the output GF (view) on receiving ranks
    if (c.rank() == root || all) {
      if constexpr (is_view) {
        EXPECTS(g_in.mesh().mesh_hash() == g_out.mesh().mesh_hash());
      } else {
        g_out._mesh = g_in.mesh();
      }
    }
 
    // reduce the data
    mpi::reduce_into(g_in.data(), g_out.data(), c, root, all, op);
  }

  template <MemoryGf G> auto mpi_reduce(G const &g, mpi::communicator c = {}, int root = 0, bool all = false, MPI_Op op = MPI_SUM) {
    auto res = typename G::regular_type{};
    mpi_reduce_into(g, res, c, root, all, op);
    return res;
  }

 
} // namespace triqs::gfs