20#include <deal.II/base/mpi.templates.h>
31#include <boost/serialization/utility.hpp>
38#ifdef DEAL_II_WITH_TRILINOS
39# ifdef DEAL_II_WITH_MPI
43# include <Epetra_MpiComm.h>
47#ifdef DEAL_II_WITH_PETSC
54#ifdef DEAL_II_WITH_SLEPC
60#ifdef DEAL_II_WITH_P4EST
61# include <p4est_bits.h>
64#ifdef DEAL_II_TRILINOS_WITH_ZOLTAN
65# include <zoltan_cpp.h>
75 const unsigned int n_partitions,
78 const unsigned int remain = total_size % n_partitions;
83 min_size * my_partition_id +
std::min(my_partition_id, remain);
85 min_size * (my_partition_id + 1) +
std::min(my_partition_id + 1, remain);
93#ifdef DEAL_II_WITH_MPI
108 template const MPI_Datatype mpi_type_id_for_type<std::complex<float>>;
109 template const MPI_Datatype mpi_type_id_for_type<std::complex<double>>;
126 std::vector<MinMaxAvg>
130 std::vector<MinMaxAvg> results(my_values.size());
138#ifdef DEAL_II_WITH_MPI
143 const int ierr = MPI_Comm_size(mpi_communicator, &n_jobs);
154 const int ierr = MPI_Comm_rank(mpi_communicator, &rank);
162 const std::vector<unsigned int>
167 return std::vector<unsigned int>{0};
172 std::vector<unsigned int> ranks(size);
173 const int ierr = MPI_Allgather(
174 &rank, 1, MPI_UNSIGNED, ranks.data(), 1, MPI_UNSIGNED, comm_small);
186 const int ierr = MPI_Comm_dup(mpi_communicator, &new_communicator);
188 return new_communicator;
197 const int ierr = MPI_Comm_free(&mpi_communicator);
205 const MPI_Group &group,
209 const int ierr = MPI_Comm_create_group(
comm, group, tag, new_comm);
216 std::vector<IndexSet>
221 const std::vector<IndexSet::size_type> sizes =
223 const auto total_size =
226 std::vector<IndexSet> res(n_proc,
IndexSet(total_size));
229 for (
unsigned int i = 0; i < n_proc; ++i)
231 res[i].add_range(begin, begin + sizes[i]);
232 begin = begin + sizes[i];
254 std::unique_ptr<MPI_Datatype, void (*)(MPI_Datatype *)>
260 ierr = MPI_Type_commit(&result);
265 ierr = MPI_Type_size_x(result, &size64);
280 auto deleter = [](MPI_Datatype *p) {
283 const int ierr = MPI_Type_free(p);
291 return std::unique_ptr<MPI_Datatype, void (*)(MPI_Datatype *)>(
292 new MPI_Datatype(result), deleter);
297 std::vector<unsigned int>
300 const std::vector<unsigned int> &destinations)
307 for (
const unsigned int destination : destinations)
320 const bool my_destinations_are_unique = [destinations]() {
321 if (destinations.size() == 0)
325 std::vector<unsigned int> my_destinations = destinations;
326 std::sort(my_destinations.begin(), my_destinations.end());
327 return (std::adjacent_find(my_destinations.begin(),
328 my_destinations.end()) ==
329 my_destinations.end());
339 return ConsensusAlgorithms::nbx<char, char>(
340 destinations, {}, {}, {}, mpi_comm);
354 std::vector<unsigned int> dest_vector(n_procs);
355 for (
const auto &el : destinations)
361 unsigned int n_recv_from;
362 const int ierr = MPI_Reduce_scatter_block(
363 dest_vector.data(), &n_recv_from, 1, MPI_UNSIGNED, MPI_SUM, mpi_comm);
368 std::vector<MPI_Request> send_requests(destinations.size());
369 for (
const auto &el : destinations)
378 send_requests.data() + (&el - destinations.data()));
386 std::vector<unsigned int> origins(n_recv_from);
387 for (
auto &el : origins)
389 const int ierr = MPI_Recv(&el,
399 if (destinations.size() > 0)
401 const int ierr = MPI_Waitall(destinations.size(),
402 send_requests.data(),
403 MPI_STATUSES_IGNORE);
415 const std::vector<unsigned int> &destinations)
419 const bool my_destinations_are_unique = [destinations]() {
420 std::vector<unsigned int> my_destinations = destinations;
421 const unsigned int n_destinations = my_destinations.size();
422 std::sort(my_destinations.begin(), my_destinations.end());
423 my_destinations.erase(std::unique(my_destinations.begin(),
424 my_destinations.end()),
425 my_destinations.end());
426 return (my_destinations.size() == n_destinations);
435 return ConsensusAlgorithms::nbx<char, char>(
436 destinations, {}, {}, {}, mpi_comm)
441 const unsigned int n_procs =
444 for (
const unsigned int destination : destinations)
450 "There is no point in communicating with ourselves."));
454 std::vector<unsigned int> dest_vector(n_procs);
455 for (
const auto &el : destinations)
460 unsigned int n_recv_from = 0;
462 const int ierr = MPI_Reduce_scatter_block(dest_vector.data(),
481 max_reduce(
const void *in_lhs_,
486 const MinMaxAvg *in_lhs =
static_cast<const MinMaxAvg *
>(in_lhs_);
487 MinMaxAvg * inout_rhs =
static_cast<MinMaxAvg *
>(inout_rhs_);
489 for (
int i = 0; i < *len; ++i)
491 inout_rhs[i].sum += in_lhs[i].sum;
492 if (inout_rhs[i].min > in_lhs[i].min)
494 inout_rhs[i].min = in_lhs[i].min;
495 inout_rhs[i].min_index = in_lhs[i].min_index;
497 else if (inout_rhs[i].min == in_lhs[i].min)
500 if (inout_rhs[i].min_index > in_lhs[i].min_index)
501 inout_rhs[i].min_index = in_lhs[i].min_index;
504 if (inout_rhs[i].max < in_lhs[i].max)
506 inout_rhs[i].max = in_lhs[i].max;
507 inout_rhs[i].max_index = in_lhs[i].max_index;
509 else if (inout_rhs[i].max == in_lhs[i].max)
512 if (inout_rhs[i].max_index > in_lhs[i].max_index)
513 inout_rhs[i].max_index = in_lhs[i].max_index;
531 for (
unsigned int i = 0; i < my_values.
size(); ++i)
533 result[i].sum = my_values[i];
534 result[i].avg = my_values[i];
535 result[i].min = my_values[i];
536 result[i].max = my_values[i];
537 result[i].min_index = 0;
538 result[i].max_index = 0;
548 static MPI_Datatype type = []() {
551 int lengths[] = {3, 2, 1};
553 MPI_Aint displacements[] = {0,
557 MPI_Datatype
types[] = {MPI_DOUBLE, MPI_INT, MPI_DOUBLE};
560 MPI_Type_create_struct(3, lengths, displacements,
types, &type);
563 ierr = MPI_Type_commit(&type);
569 int ierr = MPI_Type_free(&type);
581 static MPI_Op op = []() {
585 MPI_Op_create(
reinterpret_cast<MPI_User_function *
>(&max_reduce),
586 static_cast<int>(
true),
593 int ierr = MPI_Op_free(&op);
608 std::numeric_limits<double>::max(),
609 std::numeric_limits<double>::lowest(),
614 for (
auto &i : result)
617 const unsigned int my_id =
619 const unsigned int numproc =
622 std::vector<MinMaxAvg> in(my_values.
size());
624 for (
unsigned int i = 0; i < my_values.
size(); ++i)
626 in[i].sum = in[i].min = in[i].max = my_values[i];
627 in[i].min_index = in[i].max_index = my_id;
630 int ierr = MPI_Allreduce(
631 in.data(), result.
data(), my_values.
size(), type, op, mpi_communicator);
634 for (
auto &r : result)
635 r.avg = r.sum / numproc;
657 const std::vector<unsigned int>
660 return std::vector<unsigned int>{0};
665 std::vector<IndexSet>
684 return mpi_communicator;
702 for (
unsigned int i = 0; i < my_values.
size(); ++i)
704 result[i].sum = my_values[i];
705 result[i].avg = my_values[i];
706 result[i].min = my_values[i];
707 result[i].max = my_values[i];
708 result[i].min_index = 0;
709 result[i].max_index = 0;
717 MPI_InitFinalize::Signals();
722 const unsigned int max_num_threads)
724 static bool constructor_has_already_run =
false;
725 (void)constructor_has_already_run;
726 Assert(constructor_has_already_run ==
false,
727 ExcMessage(
"You can only create a single object of this class "
728 "in a program since it initializes the MPI system."));
732#ifdef DEAL_II_WITH_MPI
735 int MPI_has_been_started = 0;
736 ierr = MPI_Initialized(&MPI_has_been_started);
739 ExcMessage(
"MPI error. You can only start MPI once!"));
746 int wanted = MPI_THREAD_SERIALIZED;
747 ierr = MPI_Init_thread(&argc, &argv, wanted, &provided);
764#ifdef DEAL_II_WITH_PETSC
765# ifdef DEAL_II_WITH_SLEPC
767 ierr = SlepcInitialize(&argc, &argv,
nullptr,
nullptr);
771 ierr = PetscInitialize(&argc, &argv,
nullptr,
nullptr);
777 PetscPopSignalHandler();
781#ifdef DEAL_II_TRILINOS_WITH_ZOLTAN
783 Zoltan_Initialize(argc, argv, &version);
786#ifdef DEAL_II_WITH_P4EST
788# if DEAL_II_P4EST_VERSION_GTE(2, 5, 0, 0)
793 sc_init(MPI_COMM_WORLD, 0, 0,
nullptr, SC_LP_SILENT);
795 p4est_init(
nullptr, SC_LP_SILENT);
798 constructor_has_already_run =
true;
812#ifdef DEAL_II_WITH_MPI
821 const unsigned int max_hostname_size =
823 std::vector<char> hostname_array(max_hostname_size);
824 std::copy(hostname.c_str(),
825 hostname.c_str() + hostname.size() + 1,
826 hostname_array.begin());
828 std::vector<char> all_hostnames(max_hostname_size *
830 const int ierr = MPI_Allgather(hostname_array.data(),
833 all_hostnames.data(),
841 unsigned int n_local_processes = 0;
842 unsigned int nth_process_on_host = 0;
845 if (std::string(all_hostnames.data() + i * max_hostname_size) ==
850 ++nth_process_on_host;
861 const unsigned int n_threads =
863 (nth_process_on_host <=
897 "You tried to call unregister_request() with an invalid request."));
918#ifdef DEAL_II_WITH_MPI
922 const int ierr = MPI_Wait(request, MPI_STATUS_IGNORE);
930 release_unused_memory();
934 release_unused_memory();
937# ifdef DEAL_II_WITH_TRILINOS
948#ifdef DEAL_II_WITH_PETSC
949 if ((PetscInitializeCalled == PETSC_TRUE) &&
950 (PetscFinalizeCalled == PETSC_FALSE))
957# ifdef DEAL_II_WITH_SLEPC
970#ifdef DEAL_II_WITH_CUDA
973 release_unused_memory();
976 release_unused_memory();
979#ifdef DEAL_II_WITH_P4EST
989#ifdef DEAL_II_WITH_MPI
992# if __cpp_lib_uncaught_exceptions >= 201411
994 if (std::uncaught_exceptions() > 0)
996 if (std::uncaught_exception() ==
true)
1016#ifdef DEAL_II_WITH_MPI
1017 int MPI_has_been_started = 0;
1018 const int ierr = MPI_Initialized(&MPI_has_been_started);
1021 return (MPI_has_been_started > 0);
1029 std::vector<unsigned int>
1031 const IndexSet &indices_to_look_up,
1035 ExcMessage(
"IndexSets have to have the same sizes."));
1039 ExcMessage(
"IndexSets have to have the same size on all processes."));
1041 std::vector<unsigned int> owning_ranks(indices_to_look_up.
n_elements());
1049 owned_indices, indices_to_look_up,
comm, owning_ranks);
1057 std::pair<types::global_dof_index, types::global_dof_index>>,
1058 std::vector<unsigned int>>
1059 consensus_algorithm(process,
comm);
1060 consensus_algorithm.run();
1062 return owning_ranks;
1069 , request(MPI_REQUEST_NULL)
1081 "Error: MPI::CollectiveMutex is still locked while being destroyed!"));
1096 "Error: MPI::CollectiveMutex needs to be unlocked before lock()"));
1098#ifdef DEAL_II_WITH_MPI
1104 const int ierr = MPI_Barrier(
comm);
1110 const int ierr = MPI_Wait(&
request, MPI_STATUS_IGNORE);
1130 "Error: MPI::CollectiveMutex needs to be locked before unlock()"));
1132#ifdef DEAL_II_WITH_MPI
1141 const int ierr = MPI_Barrier(
comm);
1157 const std::function<
bool(
const bool &,
const bool &)> &,
1158 const unsigned int);
1160 template std::vector<bool>
1161 reduce(
const std::vector<bool> &,
1163 const std::function<std::vector<bool>(
const std::vector<bool> &,
1164 const std::vector<bool> &)> &,
1165 const unsigned int);
1170 const std::function<
bool(
const bool &,
const bool &)> &);
1172 template std::vector<bool>
1174 const std::vector<bool> &,
1176 const std::function<std::vector<bool>(
const std::vector<bool> &,
1177 const std::vector<bool> &)> &);
1182 internal::all_reduce<bool>(
const MPI_Op &,
1189 logical_or<bool>(
const bool &,
const MPI_Comm &);
1198 template std::vector<unsigned int>
1203 template std::set<unsigned int>
value_type * data() const noexcept
size_type n_elements() const
void add_range(const size_type begin, const size_type end)
static unsigned int n_cores()
static void set_thread_limit(const unsigned int max_threads=numbers::invalid_unsigned_int)
void unlock(const MPI_Comm &comm)
void lock(const MPI_Comm &comm)
static void unregister_request(MPI_Request &request)
static std::set< MPI_Request * > requests
MPI_InitFinalize(int &argc, char **&argv, const unsigned int max_num_threads=numbers::invalid_unsigned_int)
static void register_request(MPI_Request &request)
#define DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_CLOSE
static ::ExceptionBase & ExcSLEPcError(int arg1)
#define Assert(cond, exc)
#define AssertDimension(dim1, dim2)
#define AssertThrowMPI(error_code)
#define AssertNothrow(cond, exc)
#define AssertIndexRange(index, range)
static ::ExceptionBase & ExcInternalError()
static ::ExceptionBase & ExcMessage(std::string arg1)
#define AssertThrow(cond, exc)
IndexSet complete_index_set(const IndexSet::size_type N)
int Type_contiguous_c(MPI_Count count, MPI_Datatype oldtype, MPI_Datatype *newtype)
template const MPI_Datatype mpi_type_id_for_type< int >
void free_communicator(MPI_Comm &mpi_communicator)
std::vector< unsigned int > compute_index_owner(const IndexSet &owned_indices, const IndexSet &indices_to_look_up, const MPI_Comm &comm)
template const MPI_Datatype mpi_type_id_for_type< unsigned char >
std::unique_ptr< MPI_Datatype, void(*)(MPI_Datatype *)> create_mpi_data_type_n_bytes(const std::size_t n_bytes)
template const MPI_Datatype mpi_type_id_for_type< signed char >
template const MPI_Datatype mpi_type_id_for_type< bool >
template const MPI_Datatype mpi_type_id_for_type< unsigned short >
std::vector< T > all_gather(const MPI_Comm &comm, const T &object_to_send)
template const MPI_Datatype mpi_type_id_for_type< short >
unsigned int compute_n_point_to_point_communications(const MPI_Comm &mpi_comm, const std::vector< unsigned int > &destinations)
T all_reduce(const T &local_value, const MPI_Comm &comm, const std::function< T(const T &, const T &)> &combiner)
std::vector< IndexSet > create_ascending_partitioning(const MPI_Comm &comm, const IndexSet::size_type locally_owned_size)
IndexSet create_evenly_distributed_partitioning(const MPI_Comm &comm, const IndexSet::size_type total_size)
template const MPI_Datatype mpi_type_id_for_type< double >
unsigned int this_mpi_process(const MPI_Comm &mpi_communicator)
std::vector< unsigned int > compute_point_to_point_communication_pattern(const MPI_Comm &mpi_comm, const std::vector< unsigned int > &destinations)
template const MPI_Datatype mpi_type_id_for_type< char >
template const MPI_Datatype mpi_type_id_for_type< long double >
template const MPI_Datatype mpi_type_id_for_type< unsigned long long int >
template const MPI_Datatype mpi_type_id_for_type< unsigned long int >
T min(const T &t, const MPI_Comm &mpi_communicator)
T reduce(const T &local_value, const MPI_Comm &comm, const std::function< T(const T &, const T &)> &combiner, const unsigned int root_process=0)
MPI_Comm duplicate_communicator(const MPI_Comm &mpi_communicator)
std::vector< T > compute_set_union(const std::vector< T > &vec, const MPI_Comm &comm)
const std::vector< unsigned int > mpi_processes_within_communicator(const MPI_Comm &comm_large, const MPI_Comm &comm_small)
unsigned int n_mpi_processes(const MPI_Comm &mpi_communicator)
MinMaxAvg min_max_avg(const double my_value, const MPI_Comm &mpi_communicator)
template const MPI_Datatype mpi_type_id_for_type< long int >
T max(const T &t, const MPI_Comm &mpi_communicator)
template const MPI_Datatype mpi_type_id_for_type< float >
int create_group(const MPI_Comm &comm, const MPI_Group &group, const int tag, MPI_Comm *new_comm)
std::string get_hostname()
IndexSet create_evenly_distributed_partitioning(const unsigned int my_partition_id, const unsigned int n_partitions, const IndexSet::size_type total_size)
static const unsigned int invalid_unsigned_int
::VectorizedArray< Number, width > min(const ::VectorizedArray< Number, width > &, const ::VectorizedArray< Number, width > &)
::VectorizedArray< Number, width > max(const ::VectorizedArray< Number, width > &, const ::VectorizedArray< Number, width > &)
****code ** MPI_Finalize()
boost::signals2::signal< void()> at_mpi_init
boost::signals2::signal< void()> at_mpi_finalize