cpp to MPI type mapping improvements

cpp/doc/Doxyfile

@@ -2272,7 +2272,7 @@ PERLMOD_MAKEVAR_PREFIX =
 # C-preprocessor directives found in the sources and include files.
 # The default value is: YES.
 
-ENABLE_PREPROCESSING   = NO
+ENABLE_PREPROCESSING   = YES
 
 # If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
 # in the source code. If set to NO, only conditional compilation will be
@@ -2289,7 +2289,7 @@ MACRO_EXPANSION        = YES
 # The default value is: NO.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-EXPAND_ONLY_PREDEF     = YES
+EXPAND_ONLY_PREDEF     = NO
 
 # If the SEARCH_INCLUDES tag is set to YES, the include files in the
 # INCLUDE_PATH will be searched if a #include is found.

cpp/dolfinx/common/IndexMap.cpp

@@ -116,8 +116,10 @@ communicate_ghosts_to_owners(MPI_Comm comm, std::span<const int> src,
     send_sizes.reserve(1);
     recv_sizes.reserve(1);
     MPI_Request sizes_request;
-    MPI_Ineighbor_alltoall(send_sizes.data(), 1, MPI_INT32_T, recv_sizes.data(),
-                           1, MPI_INT32_T, comm0, &sizes_request);
+    MPI_Ineighbor_alltoall(send_sizes.data(), 1,
+                           dolfinx::MPI::mpi_t<std::int32_t>, recv_sizes.data(),
+                           1, dolfinx::MPI::mpi_t<std::int32_t>, comm0,
+                           &sizes_request);
 
     // Build send buffer and ghost position to send buffer position
     for (auto& d : send_data)
@@ -136,10 +138,11 @@ communicate_ghosts_to_owners(MPI_Comm comm, std::span<const int> src,
 
     // Send ghost indices to owner, and receive indices
     recv_indices.resize(recv_disp.back());
-    ierr = MPI_Neighbor_alltoallv(send_indices.data(), send_sizes.data(),
-                                  send_disp.data(), MPI_INT64_T,
-                                  recv_indices.data(), recv_sizes.data(),
-                                  recv_disp.data(), MPI_INT64_T, comm0);
+    ierr = MPI_Neighbor_alltoallv(
+        send_indices.data(), send_sizes.data(), send_disp.data(),
+        dolfinx::MPI::mpi_t<std::int64_t>, recv_indices.data(),
+        recv_sizes.data(), recv_disp.data(), dolfinx::MPI::mpi_t<std::int64_t>,
+        comm0);
     dolfinx::MPI::check_error(comm, ierr);
 
     ierr = MPI_Comm_free(&comm0);
@@ -511,10 +514,10 @@ compute_submap_ghost_indices(std::span<const int> submap_src,
     dolfinx::MPI::check_error(imap.comm(), ierr);
 
     // Send indices to ghosting ranks
-    ierr = MPI_Neighbor_alltoallv(send_gidx.data(), recv_sizes.data(),
-                                  recv_disp.data(), MPI_INT64_T,
-                                  recv_gidx.data(), send_sizes.data(),
-                                  send_disp.data(), MPI_INT64_T, comm1);
+    ierr = MPI_Neighbor_alltoallv(
+        send_gidx.data(), recv_sizes.data(), recv_disp.data(),
+        dolfinx::MPI::mpi_t<std::int64_t>, recv_gidx.data(), send_sizes.data(),
+        send_disp.data(), dolfinx::MPI::mpi_t<std::int64_t>, comm1);
     dolfinx::MPI::check_error(imap.comm(), ierr);
 
     ierr = MPI_Comm_free(&comm1);
@@ -607,10 +610,10 @@ common::compute_owned_indices(std::span<const std::int32_t> indices,
   // Send ghost indices to owner, and receive owned indices
   std::vector<std::int64_t> recv_buffer(recv_disp.back());
   std::vector<std::int64_t>& send_buffer = global_indices;
-  ierr = MPI_Neighbor_alltoallv(send_buffer.data(), send_sizes.data(),
-                                send_disp.data(), MPI_INT64_T,
-                                recv_buffer.data(), recv_sizes.data(),
-                                recv_disp.data(), MPI_INT64_T, comm);
+  ierr = MPI_Neighbor_alltoallv(
+      send_buffer.data(), send_sizes.data(), send_disp.data(),
+      dolfinx::MPI::mpi_t<std::int64_t>, recv_buffer.data(), recv_sizes.data(),
+      recv_disp.data(), dolfinx::MPI::mpi_t<std::int64_t>, comm);
   dolfinx::MPI::check_error(comm, ierr);
   ierr = MPI_Comm_free(&comm);
   dolfinx::MPI::check_error(map.comm(), ierr);
@@ -738,8 +741,9 @@ common::stack_index_maps(
     std::vector<std::int32_t> recv_sizes(dest.size(), 0);
     send_sizes.reserve(1);
     recv_sizes.reserve(1);
-    ierr = MPI_Neighbor_alltoall(send_sizes.data(), 1, MPI_INT32_T,
-                                 recv_sizes.data(), 1, MPI_INT32_T, comm0);
+    ierr = MPI_Neighbor_alltoall(
+        send_sizes.data(), 1, dolfinx::MPI::mpi_t<std::int32_t>,
+        recv_sizes.data(), 1, dolfinx::MPI::mpi_t<std::int32_t>, comm0);
     dolfinx::MPI::check_error(comm0, ierr);
 
     // Prepare displacement vectors
@@ -752,10 +756,11 @@ common::stack_index_maps(
 
     // Send ghost indices to owner, and receive indices
     std::vector<std::int64_t> recv_indices(recv_disp.back());
-    ierr = MPI_Neighbor_alltoallv(send_indices.data(), send_sizes.data(),
-                                  send_disp.data(), MPI_INT64_T,
-                                  recv_indices.data(), recv_sizes.data(),
-                                  recv_disp.data(), MPI_INT64_T, comm0);
+    ierr = MPI_Neighbor_alltoallv(
+        send_indices.data(), send_sizes.data(), send_disp.data(),
+        dolfinx::MPI::mpi_t<std::int64_t>, recv_indices.data(),
+        recv_sizes.data(), recv_disp.data(), dolfinx::MPI::mpi_t<std::int64_t>,
+        comm0);
     dolfinx::MPI::check_error(comm0, ierr);
 
     // For each received index (which I should own), compute its new
@@ -773,10 +778,11 @@ common::stack_index_maps(
 
     // Send back/receive new indices
     std::vector<std::int64_t> ghosts_new_idx(send_disp.back());
-    ierr = MPI_Neighbor_alltoallv(ghost_old_to_new.data(), recv_sizes.data(),
-                                  recv_disp.data(), MPI_INT64_T,
-                                  ghosts_new_idx.data(), send_sizes.data(),
-                                  send_disp.data(), MPI_INT64_T, comm1);
+    ierr = MPI_Neighbor_alltoallv(
+        ghost_old_to_new.data(), recv_sizes.data(), recv_disp.data(),
+        dolfinx::MPI::mpi_t<std::int64_t>, ghosts_new_idx.data(),
+        send_sizes.data(), send_disp.data(), dolfinx::MPI::mpi_t<std::int64_t>,
+        comm1);
     dolfinx::MPI::check_error(comm1, ierr);
 
     // Unpack new indices and store owner
@@ -825,8 +831,9 @@ common::create_sub_index_map(const IndexMap& imap,
   // Compute submap offset for this rank
   std::int64_t submap_local_size = submap_owned.size();
   std::int64_t submap_offset = 0;
-  int ierr = MPI_Exscan(&submap_local_size, &submap_offset, 1, MPI_INT64_T,
-                        MPI_SUM, imap.comm());
+  int ierr
+      = MPI_Exscan(&submap_local_size, &submap_offset, 1,
+                   dolfinx::MPI::mpi_t<std::int64_t>, MPI_SUM, imap.comm());
   dolfinx::MPI::check_error(imap.comm(), ierr);
 
   // Compute the global indices (w.r.t. the submap) of the submap ghosts
@@ -858,14 +865,16 @@ IndexMap::IndexMap(MPI_Comm comm, std::int32_t local_size) : _comm(comm, true)
   std::int64_t offset = 0;
   const std::int64_t local_size_tmp = local_size;
   MPI_Request request_scan;
-  int ierr = MPI_Iexscan(&local_size_tmp, &offset, 1, MPI_INT64_T, MPI_SUM,
+  int ierr = MPI_Iexscan(&local_size_tmp, &offset, 1,
+                         dolfinx::MPI::mpi_t<std::int64_t>, MPI_SUM,
                          _comm.comm(), &request_scan);
   dolfinx::MPI::check_error(_comm.comm(), ierr);
 
   // Send local size to sum reduction to get global size
   MPI_Request request;
-  ierr = MPI_Iallreduce(&local_size_tmp, &_size_global, 1, MPI_INT64_T, MPI_SUM,
-                        comm, &request);
+  ierr = MPI_Iallreduce(&local_size_tmp, &_size_global, 1,
+                        dolfinx::MPI::mpi_t<std::int64_t>, MPI_SUM, comm,
+                        &request);
   dolfinx::MPI::check_error(_comm.comm(), ierr);
 
   ierr = MPI_Wait(&request_scan, MPI_STATUS_IGNORE);
@@ -901,14 +910,16 @@ IndexMap::IndexMap(MPI_Comm comm, std::int32_t local_size,
   std::int64_t offset = 0;
   const std::int64_t local_size_tmp = local_size;
   MPI_Request request_scan;
-  int ierr = MPI_Iexscan(&local_size_tmp, &offset, 1, MPI_INT64_T, MPI_SUM,
-                         comm, &request_scan);
+  int ierr = MPI_Iexscan(&local_size_tmp, &offset, 1,
+                         dolfinx::MPI::mpi_t<std::int64_t>, MPI_SUM, comm,
+                         &request_scan);
   dolfinx::MPI::check_error(_comm.comm(), ierr);
 
   // Send local size to sum reduction to get global size
   MPI_Request request;
-  ierr = MPI_Iallreduce(&local_size_tmp, &_size_global, 1, MPI_INT64_T, MPI_SUM,
-                        comm, &request);
+  ierr = MPI_Iallreduce(&local_size_tmp, &_size_global, 1,
+                        dolfinx::MPI::mpi_t<std::int64_t>, MPI_SUM, comm,
+                        &request);
   dolfinx::MPI::check_error(_comm.comm(), ierr);
 
   // Wait for MPI_Iexscan to complete (get offset)
@@ -1070,10 +1081,11 @@ graph::AdjacencyList<int> IndexMap::index_to_dest_ranks() const
 
     // Send ghost indices to owner, and receive owned indices
     std::vector<std::int64_t> recv_buffer(recv_disp.back());
-    ierr = MPI_Neighbor_alltoallv(send_buffer.data(), send_sizes.data(),
-                                  send_disp.data(), MPI_INT64_T,
-                                  recv_buffer.data(), recv_sizes.data(),
-                                  recv_disp.data(), MPI_INT64_T, comm0);
+    ierr = MPI_Neighbor_alltoallv(
+        send_buffer.data(), send_sizes.data(), send_disp.data(),
+        dolfinx::MPI::mpi_t<std::int64_t>, recv_buffer.data(),
+        recv_sizes.data(), recv_disp.data(), dolfinx::MPI::mpi_t<std::int64_t>,
+        comm0);
     dolfinx::MPI::check_error(_comm.comm(), ierr);
     ierr = MPI_Comm_free(&comm0);
     dolfinx::MPI::check_error(_comm.comm(), ierr);
@@ -1169,10 +1181,11 @@ graph::AdjacencyList<int> IndexMap::index_to_dest_ranks() const
                        std::next(recv_disp.begin()));
 
       std::vector<std::int64_t> recv_indices(recv_disp.back());
-      ierr = MPI_Neighbor_alltoallv(send_buffer.data(), send_sizes.data(),
-                                    send_disp.data(), MPI_INT64_T,
-                                    recv_indices.data(), recv_sizes.data(),
-                                    recv_disp.data(), MPI_INT64_T, comm);
+      ierr = MPI_Neighbor_alltoallv(
+          send_buffer.data(), send_sizes.data(), send_disp.data(),
+          dolfinx::MPI::mpi_t<std::int64_t>, recv_indices.data(),
+          recv_sizes.data(), recv_disp.data(),
+          dolfinx::MPI::mpi_t<std::int64_t>, comm);
       dolfinx::MPI::check_error(_comm.comm(), ierr);
       ierr = MPI_Comm_free(&comm);
       dolfinx::MPI::check_error(_comm.comm(), ierr);
@@ -1267,10 +1280,10 @@ std::vector<std::int32_t> IndexMap::shared_indices() const
 
   // Send ghost indices to owner, and receive owned indices
   std::vector<std::int64_t> recv_buffer(recv_disp.back());
-  ierr = MPI_Neighbor_alltoallv(send_buffer.data(), send_sizes.data(),
-                                send_disp.data(), MPI_INT64_T,
-                                recv_buffer.data(), recv_sizes.data(),
-                                recv_disp.data(), MPI_INT64_T, comm);
+  ierr = MPI_Neighbor_alltoallv(
+      send_buffer.data(), send_sizes.data(), send_disp.data(),
+      dolfinx::MPI::mpi_t<std::int64_t>, recv_buffer.data(), recv_sizes.data(),
+      recv_disp.data(), dolfinx::MPI::mpi_t<std::int64_t>, comm);
   dolfinx::MPI::check_error(_comm.comm(), ierr);
 
   ierr = MPI_Comm_free(&comm);
@@ -1308,12 +1321,12 @@ std::array<double, 2> IndexMap::imbalance() const
 
   // Find the maximum number of owned indices and the maximum number of ghost
   // indices across all processes.
-  MPI_Allreduce(local_sizes.data(), max_count.data(), 2, MPI_INT32_T, MPI_MAX,
-                _comm.comm());
+  MPI_Allreduce(local_sizes.data(), max_count.data(), 2,
+                dolfinx::MPI::mpi_t<std::int32_t>, MPI_MAX, _comm.comm());
 
   std::int32_t total_num_ghosts = 0;
-  MPI_Allreduce(&local_sizes[1], &total_num_ghosts, 1, MPI_INT32_T, MPI_SUM,
-                _comm.comm());
+  MPI_Allreduce(&local_sizes[1], &total_num_ghosts, 1,
+                dolfinx::MPI::mpi_t<std::int32_t>, MPI_SUM, _comm.comm());
 
   // Compute the average number of owned and ghost indices per process.
   int comm_size = dolfinx::MPI::size(_comm.comm());

cpp/dolfinx/common/MPI.h

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2023 Magnus Vikstrøm and Garth N. Wells
+// Copyright (C) 2007-2023 Magnus Vikstrøm, Garth N. Wells and Paul T. Kühner
 //
 // This file is part of DOLFINx (https://www.fenicsproject.org)
 //
@@ -269,39 +269,44 @@ struct dependent_false : std::false_type
 };
 
 /// MPI Type
+
+/// @brief Type trait for MPI type conversions.
 template <typename T>
-constexpr MPI_Datatype mpi_type()
-{
-  if constexpr (std::is_same_v<T, float>)
-    return MPI_FLOAT;
-  else if constexpr (std::is_same_v<T, double>)
-    return MPI_DOUBLE;
-  else if constexpr (std::is_same_v<T, std::complex<double>>)
-    return MPI_C_DOUBLE_COMPLEX;
-  else if constexpr (std::is_same_v<T, std::complex<float>>)
-    return MPI_C_FLOAT_COMPLEX;
-  else if constexpr (std::is_same_v<T, short int>)
-    return MPI_SHORT;
-  else if constexpr (std::is_same_v<T, int>)
-    return MPI_INT;
-  else if constexpr (std::is_same_v<T, unsigned int>)
-    return MPI_UNSIGNED;
-  else if constexpr (std::is_same_v<T, long int>)
-    return MPI_LONG;
-  else if constexpr (std::is_same_v<T, unsigned long>)
-    return MPI_UNSIGNED_LONG;
-  else if constexpr (std::is_same_v<T, long long>)
-    return MPI_LONG_LONG;
-  else if constexpr (std::is_same_v<T, unsigned long long>)
-    return MPI_UNSIGNED_LONG_LONG;
-  else if constexpr (std::is_same_v<T, bool>)
-    return MPI_C_BOOL;
-  else if constexpr (std::is_same_v<T, std::int8_t>)
-    return MPI_INT8_T;
-  else
-    // Issue compile time error
-    static_assert(!std::is_same_v<T, T>);
-}
+struct mpi_type_mapping;
+
+/// @brief Retrieves the MPI data type associated to the provided type.
+/// @tparam T cpp type to map
+template <typename T>
+MPI_Datatype mpi_t = mpi_type_mapping<T>::type;
+
+/// @brief Registers for cpp_t the correpsonding mpi_t which can then be
+/// retrieved with mpi_t<cpp_t> form here on.
+#define MAP_TO_MPI_TYPE(cpp_t, mpi_t)                                          \
+  template <>                                                                  \
+  struct mpi_type_mapping<cpp_t>                                               \
+  {                                                                            \
+    static inline MPI_Datatype type = mpi_t;                                   \
+  };
+
+/// @defgroup MPI type mappings
+/// @{
+/// @cond
+MAP_TO_MPI_TYPE(char, MPI_CHAR)
+MAP_TO_MPI_TYPE(bool, MPI_C_BOOL)
+MAP_TO_MPI_TYPE(float, MPI_FLOAT)
+MAP_TO_MPI_TYPE(double, MPI_DOUBLE)
+MAP_TO_MPI_TYPE(std::complex<float>, MPI_C_FLOAT_COMPLEX)
+MAP_TO_MPI_TYPE(std::complex<double>, MPI_C_DOUBLE_COMPLEX)
+MAP_TO_MPI_TYPE(std::int8_t, MPI_INT8_T)
+MAP_TO_MPI_TYPE(std::int16_t, MPI_INT16_T)
+MAP_TO_MPI_TYPE(std::int32_t, MPI_INT32_T)
+MAP_TO_MPI_TYPE(std::int64_t, MPI_INT64_T)
+MAP_TO_MPI_TYPE(std::uint8_t, MPI_UINT8_T)
+MAP_TO_MPI_TYPE(std::uint16_t, MPI_UINT16_T)
+MAP_TO_MPI_TYPE(std::uint32_t, MPI_UINT32_T)
+MAP_TO_MPI_TYPE(std::uint64_t, MPI_UINT64_T)
+/// @endcond
+/// @}
 
 //---------------------------------------------------------------------------
 template <typename U>
@@ -426,13 +431,14 @@ distribute_to_postoffice(MPI_Comm comm, const U& x,
   std::vector<std::int64_t> recv_buffer_index(recv_disp.back());
   err = MPI_Neighbor_alltoallv(
       send_buffer_index.data(), num_items_per_dest.data(), send_disp.data(),
-      MPI_INT64_T, recv_buffer_index.data(), num_items_recv.data(),
-      recv_disp.data(), MPI_INT64_T, neigh_comm);
+      dolfinx::MPI::mpi_t<std::int64_t>, recv_buffer_index.data(),
+      num_items_recv.data(), recv_disp.data(),
+      dolfinx::MPI::mpi_t<std::int64_t>, neigh_comm);
   dolfinx::MPI::check_error(comm, err);
 
   // Send/receive data (x)
   MPI_Datatype compound_type;
-  MPI_Type_contiguous(shape[1], dolfinx::MPI::mpi_type<T>(), &compound_type);
+  MPI_Type_contiguous(shape[1], dolfinx::MPI::mpi_t<T>, &compound_type);
   MPI_Type_commit(&compound_type);
   std::vector<T> recv_buffer_data(shape[1] * recv_disp.back());
   err = MPI_Neighbor_alltoallv(
@@ -556,8 +562,9 @@ distribute_from_postoffice(MPI_Comm comm, std::span<const std::int64_t> indices,
   std::vector<std::int64_t> recv_buffer_index(recv_disp.back());
   err = MPI_Neighbor_alltoallv(
       send_buffer_index.data(), num_items_per_src.data(), send_disp.data(),
-      MPI_INT64_T, recv_buffer_index.data(), num_items_recv.data(),
-      recv_disp.data(), MPI_INT64_T, neigh_comm0);
+      dolfinx::MPI::mpi_t<std::int64_t>, recv_buffer_index.data(),
+      num_items_recv.data(), recv_disp.data(),
+      dolfinx::MPI::mpi_t<std::int64_t>, neigh_comm0);
   dolfinx::MPI::check_error(comm, err);
 
   err = MPI_Comm_free(&neigh_comm0);
@@ -614,7 +621,7 @@ distribute_from_postoffice(MPI_Comm comm, std::span<const std::int64_t> indices,
   dolfinx::MPI::check_error(comm, err);
 
   MPI_Datatype compound_type0;
-  MPI_Type_contiguous(shape[1], dolfinx::MPI::mpi_type<T>(), &compound_type0);
+  MPI_Type_contiguous(shape[1], dolfinx::MPI::mpi_t<T>, &compound_type0);
   MPI_Type_commit(&compound_type0);
 
   std::vector<T> recv_buffer_data(shape[1] * send_disp.back());
@@ -682,15 +689,16 @@ distribute_data(MPI_Comm comm0, std::span<const std::int64_t> indices,
 
   int err;
   std::int64_t shape0 = 0;
-  err = MPI_Allreduce(&shape0_local, &shape0, 1, MPI_INT64_T, MPI_SUM, comm0);
+  err = MPI_Allreduce(&shape0_local, &shape0, 1,
+                      dolfinx::MPI::mpi_t<std::int64_t>, MPI_SUM, comm0);
   dolfinx::MPI::check_error(comm0, err);
 
   std::int64_t rank_offset = -1;
   if (comm1 != MPI_COMM_NULL)
   {
     rank_offset = 0;
-    err = MPI_Exscan(&shape0_local, &rank_offset, 1, MPI_INT64_T, MPI_SUM,
-                     comm1);
+    err = MPI_Exscan(&shape0_local, &rank_offset, 1,
+                     dolfinx::MPI::mpi_t<std::int64_t>, MPI_SUM, comm1);
     dolfinx::MPI::check_error(comm1, err);
   }
   else