::datatype = MPI_DATATYPE_NULL;
│ │ │ │ │ + 60
│ │ │ │ │ + 61#ifndef DOXYGEN
│ │ │ │ │ + 62
│ │ │ │ │ + 63 // A Macro for defining traits for the primitive data types
│ │ │ │ │ + 64#define ComposeMPITraits(p,m) \
│ │ │ │ │ + 65 template<> \
│ │ │ │ │ + 66 struct MPITraits{ \
│ │ │ │ │ + 67 static inline MPI_Datatype getType(){ \
│ │ │ │ │ + 68 return m; \
│ │ │ │ │ + 69 } \
│ │ │ │ │ + 70 static constexpr bool is_intrinsic = true; \
│ │ │ │ │ + 71 }
│ │ │ │ │ + 72
│ │ │ │ │ + 73 ComposeMPITraits(char, MPI_CHAR);
│ │ │ │ │ + 74 ComposeMPITraits(unsigned char,MPI_UNSIGNED_CHAR);
│ │ │ │ │ + 75 ComposeMPITraits(short,MPI_SHORT);
│ │ │ │ │ + 76 ComposeMPITraits(unsigned short,MPI_UNSIGNED_SHORT);
│ │ │ │ │ + 77 ComposeMPITraits(int,MPI_INT);
│ │ │ │ │ + 78 ComposeMPITraits(unsigned int,MPI_UNSIGNED);
│ │ │ │ │ + 79 ComposeMPITraits(long,MPI_LONG);
│ │ │ │ │ + 80 ComposeMPITraits(unsigned long,MPI_UNSIGNED_LONG);
│ │ │ │ │ + 81 ComposeMPITraits(float,MPI_FLOAT);
│ │ │ │ │ + 82 ComposeMPITraits(double,MPI_DOUBLE);
│ │ │ │ │ + 83 ComposeMPITraits(long double,MPI_LONG_DOUBLE);
│ │ │ │ │ + 84 ComposeMPITraits(std::complex, MPI_CXX_DOUBLE_COMPLEX);
│ │ │ │ │ + 85 ComposeMPITraits(std::complex, MPI_CXX_LONG_DOUBLE_COMPLEX);
│ │ │ │ │ + 86 ComposeMPITraits(std::complex, MPI_CXX_FLOAT_COMPLEX);
│ │ │ │ │ + 87
│ │ │ │ │ + 88
│ │ │ │ │ + 89#undef ComposeMPITraits
│ │ │ │ │ + 90
│ │ │ │ │ + 91 template class FieldVector;
│ │ │ │ │ + 92
│ │ │ │ │ + 93 template
│ │ │ │ │ + 94 struct MPITraits >
│ │ │ │ │ + 95 {
│ │ │ │ │ + 96 static MPI_Datatype datatype;
│ │ │ │ │ + 97 static MPI_Datatype vectortype;
│ │ │ │ │ + 98
│ │ │ │ │ + 99 static inline MPI_Datatype getType()
│ │ │ │ │ + 100 {
│ │ │ │ │ + 101 if(datatype==MPI_DATATYPE_NULL) {
│ │ │ │ │ + 102 MPI_Type_contiguous(n, MPITraits::getType(), &vectortype);
│ │ │ │ │ + 103 MPI_Type_commit(&vectortype);
│ │ │ │ │ + 104 FieldVector fvector;
│ │ │ │ │ + 105 MPI_Aint base;
│ │ │ │ │ + 106 MPI_Aint displ;
│ │ │ │ │ + 107 MPI_Get_address(&fvector, &base);
│ │ │ │ │ + 108 MPI_Get_address(&(fvector[0]), &displ);
│ │ │ │ │ + 109 displ -= base;
│ │ │ │ │ + 110 int length[1]={1};
│ │ │ │ │ + 111
│ │ │ │ │ + 112 MPI_Type_create_struct(1, length, &displ, &vectortype, &datatype);
│ │ │ │ │ + 113 MPI_Type_commit(&datatype);
│ │ │ │ │ + 114 }
│ │ │ │ │ + 115 return datatype;
│ │ │ │ │ + 116 }
│ │ │ │ │ + 117
│ │ │ │ │ + 118 };
│ │ │ │ │ + 119
│ │ │ │ │ + 120 template
│ │ │ │ │ + 121 MPI_Datatype MPITraits >::datatype = MPI_DATATYPE_NULL;
│ │ │ │ │ + 122 template
│ │ │ │ │ + 123 MPI_Datatype MPITraits >::vectortype =
│ │ │ │ │ +{MPI_DATATYPE_NULL};
│ │ │ │ │ + 124
│ │ │ │ │ + 125
│ │ │ │ │ + 126 template
│ │ │ │ │ + 127 class bigunsignedint;
│ │ │ │ │ + 128
│ │ │ │ │ + 129 template
│ │ │ │ │ + 130 struct MPITraits >
│ │ │ │ │ + 131 {
│ │ │ │ │ + 132 static MPI_Datatype datatype;
│ │ │ │ │ + 133 static MPI_Datatype vectortype;
│ │ │ │ │ + 134
│ │ │ │ │ + 135 static inline MPI_Datatype getType()
│ │ │ │ │ + 136 {
│ │ │ │ │ + 137 if(datatype==MPI_DATATYPE_NULL) {
│ │ │ │ │ + 138 MPI_Type_contiguous(bigunsignedint::n, MPITraits::
│ │ │ │ │ +getType(),
│ │ │ │ │ + 139 &vectortype);
│ │ │ │ │ + 140 //MPI_Type_commit(&vectortype);
│ │ │ │ │ + 141 bigunsignedint data;
│ │ │ │ │ + 142 MPI_Aint base;
│ │ │ │ │ + 143 MPI_Aint displ;
│ │ │ │ │ + 144 MPI_Get_address(&data, &base);
│ │ │ │ │ + 145 MPI_Get_address(&(data.digit), &displ);
│ │ │ │ │ + 146 displ -= base;
│ │ │ │ │ + 147 int length[1]={1};
│ │ │ │ │ + 148 MPI_Type_create_struct(1, length, &displ, &vectortype, &datatype);
│ │ │ │ │ + 149 MPI_Type_commit(&datatype);
│ │ │ │ │ + 150 }
│ │ │ │ │ + 151 return datatype;
│ │ │ │ │ + 152 }
│ │ │ │ │ + 153 };
│ │ │ │ │ + 154}
│ │ │ │ │ + 155
│ │ │ │ │ + 156namespace Dune
│ │ │ │ │ + 157{
│ │ │ │ │ + 158 template
│ │ │ │ │ + 159 MPI_Datatype MPITraits >::datatype = MPI_DATATYPE_NULL;
│ │ │ │ │ + 160 template
│ │ │ │ │ + 161 MPI_Datatype MPITraits >::vectortype =
│ │ │ │ │ +MPI_DATATYPE_NULL;
│ │ │ │ │ + 162
│ │ │ │ │ + 163 template
│ │ │ │ │ + 164 struct MPITraits >
│ │ │ │ │ + 165 {
│ │ │ │ │ + 166 public:
│ │ │ │ │ + 167 inline static MPI_Datatype getType();
│ │ │ │ │ + 168 private:
│ │ │ │ │ + 169 static MPI_Datatype type;
│ │ │ │ │ + 170 };
│ │ │ │ │ + 171 template
│ │ │ │ │ + 172 MPI_Datatype MPITraits >::getType()
│ │ │ │ │ + 173 {
│ │ │ │ │ + 174 if(type==MPI_DATATYPE_NULL) {
│ │ │ │ │ + 175 int length[2] = {1, 1};
│ │ │ │ │ + 176 MPI_Aint disp[2];
│ │ │ │ │ + 177 MPI_Datatype types[2] = {MPITraits::getType(),
│ │ │ │ │ + 178 MPITraits::getType()};
│ │ │ │ │ + 179
│ │ │ │ │ + 180 using Pair = std::pair;
│ │ │ │ │ + 181 static_assert(std::is_standard_layout::value, "offsetof() is only
│ │ │ │ │ +defined for standard layout types");
│ │ │ │ │ + 182 disp[0] = offsetof(Pair, first);
│ │ │ │ │ + 183 disp[1] = offsetof(Pair, second);
│ │ │ │ │ + 184
│ │ │ │ │ + 185 MPI_Datatype tmp;
│ │ │ │ │ + 186 MPI_Type_create_struct(2, length, disp, types, &tmp);
│ │ │ │ │ + 187
│ │ │ │ │ + 188 MPI_Type_create_resized(tmp, 0, sizeof(Pair), &type);
│ │ │ │ │ + 189 MPI_Type_commit(&type);
│ │ │ │ │ + 190
│ │ │ │ │ + 191 MPI_Type_free(&tmp);
│ │ │ │ │ + 192 }
│ │ │ │ │ + 193 return type;
│ │ │ │ │ + 194 }
│ │ │ │ │ + 195
│ │ │ │ │ + 196 template
│ │ │ │ │ + 197 MPI_Datatype MPITraits >::type=MPI_DATATYPE_NULL;
│ │ │ │ │ + 198
│ │ │ │ │ + 199#endif // !DOXYGEN
│ │ │ │ │ + 200
│ │ │ │ │ + 201} // namespace Dune
│ │ │ │ │ + 202
│ │ │ │ │ + 203#endif // HAVE_MPI
│ │ │ │ │ + 204
│ │ │ │ │ + 207#endif
│ │ │ │ │ +std
│ │ │ │ │ +STL namespace.
│ │ │ │ │ Dune
│ │ │ │ │ Dune namespace.
│ │ │ │ │ Definition alignedallocator.hh:13
│ │ │ │ │ -Dune::PromotionTraits
│ │ │ │ │ -Compute type of the result of an arithmetic operation involving two different
│ │ │ │ │ -number types.
│ │ │ │ │ -Definition promotiontraits.hh:27
│ │ │ │ │ -Dune::PromotionTraits::PromotedType
│ │ │ │ │ -decltype(std::declval< T1 >()+std::declval< T2 >()) PromotedType
│ │ │ │ │ -Definition promotiontraits.hh:28
│ │ │ │ │ -Dune::PromotionTraits<_T1,_T1_>::PromotedType
│ │ │ │ │ -T1 PromotedType
│ │ │ │ │ -Definition promotiontraits.hh:35
│ │ │ │ │ +Dune::MPITraits
│ │ │ │ │ +A traits class describing the mapping of types onto MPI_Datatypes.
│ │ │ │ │ +Definition mpitraits.hh:41
│ │ │ │ │ +Dune::MPITraits::getType
│ │ │ │ │ +static MPI_Datatype getType()
│ │ │ │ │ +Definition mpitraits.hh:48
│ │ │ │ │ +Dune::MPITraits::is_intrinsic
│ │ │ │ │ +static constexpr bool is_intrinsic
│ │ │ │ │ +Definition mpitraits.hh:56
│ │ │ │ │ +Dune::bigunsignedint::n
│ │ │ │ │ +static constexpr int n
│ │ │ │ │ +Definition bigunsignedint.hh:78
│ │ │ │ │ +Dune::FieldVector
│ │ │ │ │ +vector space out of a tensor product of fields.
│ │ │ │ │ +Definition fvector.hh:95
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-common-doc/doxygen/a00023.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-common: deprecated.hh File Reference
│ │ │ │ +dune-common: mpicommunication.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │ -
Definition of the DUNE_NO_DEPRECATED_* macros.
│ │ │ │ +
Implements an utility class that provides MPI's collective communication methods.
│ │ │ │ More...
│ │ │ │ -
│ │ │ │ +
#include <algorithm>
│ │ │ │ +
#include <functional>
│ │ │ │ +
#include <memory>
│ │ │ │ +
#include <mpi.h>
│ │ │ │ +
#include <dune/common/binaryfunctions.hh >
│ │ │ │ +
#include <dune/common/exceptions.hh >
│ │ │ │ +
#include <dune/common/parallel/communication.hh >
│ │ │ │ +
#include <dune/common/parallel/mpitraits.hh >
│ │ │ │ +
#include <dune/common/parallel/mpifuture.hh >
│ │ │ │ +
#include <dune/common/parallel/mpidata.hh >
│ │ │ │ +
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ +namespace Dune Dune namespace.
│ │ │ │
│ │ │ │ -
Definition of the DUNE_NO_DEPRECATED_* macros.
│ │ │ │ -
Implements an utility class that provides MPI's collective communication methods.
│ │ │ │ +
◆
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + #define ComposeMPIOp
│ │ │ │ + (
│ │ │ │ +
│ │ │ │ + func,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + op
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
Value: template <class T, class S> \
│ │ │ │ +
class Generic_MPI_Op<T, func<S>,
std ::enable_if_t<MPITraits<S>::is_intrinsic> >{ \
│ │ │ │ +
public : \
│ │ │ │ +
static MPI_Op get(){ \
│ │ │ │ +
return op; \
│ │ │ │ +
} \
│ │ │ │ +
private : \
│ │ │ │ +
Generic_MPI_Op () {} \
│ │ │ │ +
Generic_MPI_Op (const Generic_MPI_Op & ) {} \
│ │ │ │ +
}
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ Go_to_the_source_code_of_this_file.
│ │ │ │ │ + Classes
│ │ │ │ │ +class Dune::Generic_MPI_Op<_Type,_BinaryFunction,_Enable_>
│ │ │ │ │ +
│ │ │ │ │ +class Dune::Communication<_MPI_Comm_>
│ │ │ │ │ + Specialization of Communication for MPI. More...
│ │ │ │ │ +
│ │ │ │ │ + Namespaces
│ │ │ │ │ +namespace Dune
│ │ │ │ │ + Dune namespace.
│ │ │ │ │ +
│ │ │ │ │ Macros
│ │ │ │ │ -#define DUNE_NO_DEPRECATED_BEGIN ...
│ │ │ │ │ - Ignore deprecation warnings (start)
│ │ │ │ │ +#define ComposeMPIOp(func, op)
│ │ │ │ │ +
│ │ │ │ │ + Functions
│ │ │ │ │ + Dune::ComposeMPIOp (std::plus, MPI_SUM)
│ │ │ │ │ +
│ │ │ │ │ + Dune::ComposeMPIOp (std::multiplies, MPI_PROD)
│ │ │ │ │ +
│ │ │ │ │ + Dune::ComposeMPIOp (Min, MPI_MIN)
│ │ │ │ │
│ │ │ │ │ -#define DUNE_NO_DEPRECATED_END ...
│ │ │ │ │ - Ignore deprecation warnings (end)
│ │ │ │ │ + Dune::ComposeMPIOp (Max, MPI_MAX)
│ │ │ │ │
│ │ │ │ │ ***** Detailed Description *****
│ │ │ │ │ -Definition of the DUNE_NO_DEPRECATED_* macros.
│ │ │ │ │ +Implements an utility class that provides MPI's collective communication
│ │ │ │ │ +methods.
│ │ │ │ │ +***** Macro Definition Documentation *****
│ │ │ │ │ +***** ◆ ComposeMPIOp *****
│ │ │ │ │ +#define ComposeMPIOp ( func,
│ │ │ │ │ + op
│ │ │ │ │ + )
│ │ │ │ │ +Value:
│ │ │ │ │ +template \
│ │ │ │ │ +class Generic_MPI_Op, std::enable_if_t::is_intrinsic> >
│ │ │ │ │ +{ \
│ │ │ │ │ +public: \
│ │ │ │ │ +static MPI_Op get(){ \
│ │ │ │ │ +return op; \
│ │ │ │ │ +} \
│ │ │ │ │ +private: \
│ │ │ │ │ +Generic_MPI_Op () {} \
│ │ │ │ │ +Generic_MPI_Op (const Generic_MPI_Op & ) {} \
│ │ │ │ │ +}
│ │ │ │ │ +std
│ │ │ │ │ +STL namespace.
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-common-doc/doxygen/a00023_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-common: deprecated.hh Source File
│ │ │ │ +dune-common: mpicommunication.hh Source File
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
5 #ifndef DUNE_DEPRECATED_HH
│ │ │ │ -
6 #define DUNE_DEPRECATED_HH
│ │ │ │ +
5 #ifndef DUNE_COMMON_PARALLEL_MPICOMMUNICATION_HH
│ │ │ │ +
6 #define DUNE_COMMON_PARALLEL_MPICOMMUNICATION_HH
│ │ │ │
│ │ │ │ -
│ │ │ │ -
32 #define DUNE_NO_DEPRECATED_BEGIN ...
│ │ │ │ -
38 #define DUNE_NO_DEPRECATED_END ...
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
41 # define DUNE_NO_DEPRECATED_BEGIN \
│ │ │ │ -
42 _Pragma("clang diagnostic push") \
│ │ │ │ -
43 _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
│ │ │ │ -
44 # define DUNE_NO_DEPRECATED_END _Pragma("clang diagnostic pop")
│ │ │ │ -
45 # elif defined __INTEL_COMPILER
│ │ │ │ -
46 # define DUNE_NO_DEPRECATED_BEGIN \
│ │ │ │ -
47 _Pragma("warning push") \
│ │ │ │ -
48 _Pragma("warning(disable:1478)") \
│ │ │ │ -
49 _Pragma("warning(disable:1786)")
│ │ │ │ -
50 # define DUNE_NO_DEPRECATED_END _Pragma("warning pop")
│ │ │ │ -
51 # elif defined __GNUC__
│ │ │ │ -
52 # define DUNE_NO_DEPRECATED_BEGIN \
│ │ │ │ -
53 _Pragma("GCC diagnostic push") \
│ │ │ │ -
54 _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
│ │ │ │ -
55 # define DUNE_NO_DEPRECATED_END _Pragma("GCC diagnostic pop")
│ │ │ │ -
│ │ │ │ -
57 # define DUNE_NO_DEPRECATED_BEGIN
│ │ │ │ -
58 # define DUNE_NO_DEPRECATED_END
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
39 template <
typename Type,
typename BinaryFunction,
typename Enable=
void >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
48 op = std::make_unique<MPI_Op>();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
53 MPI_Op_create((
void (*)(
void *,
void *,
int *, MPI_Datatype*))&operation,
true ,op.get());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
58 static void operation (Type *in, Type *inout,
int *len, MPI_Datatype*)
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
62 for (
int i=0; i< *len; ++i, ++in, ++inout) {
│ │ │ │ +
│ │ │ │ +
64 temp = func(*in, *inout);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
69 Generic_MPI_Op (
const Generic_MPI_Op& ) {}
│ │ │ │ +
70 static std::unique_ptr<MPI_Op> op;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
74 template <
typename Type,
typename BinaryFunction,
typename Enable>
│ │ │ │ +
75 std::unique_ptr<MPI_Op> Generic_MPI_Op<Type,BinaryFunction, Enable>::op;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
77 #define ComposeMPIOp(func,op) \
│ │ │ │ +
78 template<class T, class S> \
│ │ │ │ +
79 class Generic_MPI_Op<T, func<S>, std::enable_if_t<MPITraits<S>::is_intrinsic> >{ \
│ │ │ │ +
│ │ │ │ +
81 static MPI_Op get(){ \
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
85 Generic_MPI_Op () {} \
│ │ │ │ +
86 Generic_MPI_Op (const Generic_MPI_Op & ) {} \
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
114 if (communicator!=MPI_COMM_NULL) {
│ │ │ │ +
│ │ │ │ +
116 MPI_Initialized(&initialized);
│ │ │ │ +
│ │ │ │ +
118 DUNE_THROW (
ParallelError ,
"You must call MPIHelper::instance(argc,argv) in your main() function before using the MPI Communication!" );
│ │ │ │ +
119 MPI_Comm_rank(communicator,&me);
│ │ │ │ +
120 MPI_Comm_size(communicator,&procs);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
141 int send (
const T& data,
int dest_rank,
int tag)
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
144 return MPI_Send(mpi_data.ptr(), mpi_data.size(), mpi_data.type(),
│ │ │ │ +
145 dest_rank, tag, communicator);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
154 MPI_Isend(mpidata.ptr(), mpidata.size(), mpidata.type(),
│ │ │ │ +
155 dest_rank, tag, communicator, &future.req_);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
161 T
recv (T&& data,
int source_rank,
int tag, MPI_Status* status = MPI_STATUS_IGNORE)
const
│ │ │ │ +
│ │ │ │ +
163 T lvalue_data(std::forward<T>(data));
│ │ │ │ +
│ │ │ │ +
165 MPI_Recv(mpi_data.ptr(), mpi_data.size(), mpi_data.type(),
│ │ │ │ +
166 source_rank, tag, communicator, status);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
176 MPI_Irecv(mpidata.ptr(), mpidata.size(), mpidata.type(),
│ │ │ │ +
177 source_rank, tag, communicator, &future.req_);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
182 T
rrecv (T&& data,
int source_rank,
int tag, MPI_Status* status = MPI_STATUS_IGNORE)
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
185 MPI_Message _message;
│ │ │ │ +
186 T lvalue_data(std::forward<T>(data));
│ │ │ │ +
│ │ │ │ +
188 static_assert (!mpi_data.static_size,
"rrecv work only for non-static-sized types." );
│ │ │ │ +
189 if (status == MPI_STATUS_IGNORE)
│ │ │ │ +
│ │ │ │ +
191 MPI_Mprobe(source_rank, tag, communicator, &_message, status);
│ │ │ │ +
│ │ │ │ +
193 MPI_Get_count(status, mpi_data.type(), &
size );
│ │ │ │ +
194 mpi_data.resize(
size );
│ │ │ │ +
195 MPI_Mrecv(mpi_data.ptr(), mpi_data.size(), mpi_data.type(), &_message, status);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
204 allreduce<std::plus<T> >(&in,&out,1);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
210 int sum (T* inout,
int len)
const
│ │ │ │ +
│ │ │ │ +
212 return allreduce<std::plus<T> >(inout,len);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
220 allreduce<std::multiplies<T> >(&in,&out,1);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
226 int prod (T* inout,
int len)
const
│ │ │ │ +
│ │ │ │ +
228 return allreduce<std::multiplies<T> >(inout,len);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
236 allreduce<Min<T> >(&in,&out,1);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
242 int min (T* inout,
int len)
const
│ │ │ │ +
│ │ │ │ +
244 return allreduce<Min<T> >(inout,len);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
253 allreduce<Max<T> >(&in,&out,1);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
259 int max (T* inout,
int len)
const
│ │ │ │ +
│ │ │ │ +
261 return allreduce<Max<T> >(inout,len);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
267 return MPI_Barrier(communicator);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
274 MPI_Ibarrier(communicator, &future.req_);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
291 MPI_Ibcast(mpidata.ptr(),
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
303 int gather (
const T* in, T* out,
int len,
int root)
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
311 template <
class TIN,
class TOUT = std::vector<TIN>>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
316 assert(root != me || mpidata_in.size()*procs <= mpidata_out.size());
│ │ │ │ +
317 int outlen = (me==root) * mpidata_in.size();
│ │ │ │ +
318 MPI_Igather(mpidata_in.ptr(), mpidata_in.size(), mpidata_in.type(),
│ │ │ │ +
319 mpidata_out.ptr(), outlen, mpidata_out.type(),
│ │ │ │ +
320 root, communicator, &future.req_);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
326 int gatherv (
const T* in,
int sendDataLen, T* out,
int * recvDataLen,
int * displ,
int root)
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
336 int scatter (
const T* sendData, T* recvData,
int len,
int root)
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
344 template <
class TIN,
class TOUT = TIN>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
350 int inlen = (me==root) * mpidata_in.size()/procs;
│ │ │ │ +
351 MPI_Iscatter(mpidata_in.ptr(), inlen, mpidata_in.type(),
│ │ │ │ +
352 mpidata_out.ptr(), mpidata_out.size(), mpidata_out.type(),
│ │ │ │ +
353 root, communicator, &future.req_);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
359 int scatterv (
const T* sendData,
int * sendDataLen,
int * displ, T* recvData,
int recvDataLen,
int root)
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
367 operator MPI_Comm ()
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
373 template <
typename T,
typename T1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
382 template <
class TIN,
class TOUT = TIN>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
388 assert(mpidata_in.size()*procs <= mpidata_out.size());
│ │ │ │ +
389 int outlen = mpidata_in.size();
│ │ │ │ +
390 MPI_Iallgather(mpidata_in.ptr(), mpidata_in.size(), mpidata_in.type(),
│ │ │ │ +
391 mpidata_out.ptr(), outlen, mpidata_out.type(),
│ │ │ │ +
392 communicator, &future.req_);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
398 int allgatherv (
const T* in,
int sendDataLen, T* out,
int * recvDataLen,
int * displ)
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
406 template <
typename BinaryFunction,
typename Type>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
409 Type* out =
new Type[len];
│ │ │ │ +
410 int ret = allreduce<BinaryFunction>(inout,out,len);
│ │ │ │ +
411 std::copy(out, out+len, inout);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
416 template <
typename BinaryFunction,
typename Type>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
418 Type lvalue_data = std::forward<Type>(in);
│ │ │ │ +
│ │ │ │ +
420 MPI_Allreduce(MPI_IN_PLACE, data.ptr(), data.size(), data.type(),
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
427 template <
class BinaryFunction,
class TIN,
class TOUT = TIN>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
432 assert(mpidata_out.size() == mpidata_in.size());
│ │ │ │ +
433 assert(mpidata_out.type() == mpidata_in.type());
│ │ │ │ +
434 MPI_Iallreduce(mpidata_in.ptr(), mpidata_out.ptr(),
│ │ │ │ +
435 mpidata_out.size(), mpidata_out.type(),
│ │ │ │ +
│ │ │ │ +
437 communicator, &future.req_);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
442 template <
class BinaryFunction,
class T>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
446 MPI_Iallreduce(MPI_IN_PLACE, mpidata.ptr(),
│ │ │ │ +
447 mpidata.size(), mpidata.type(),
│ │ │ │ +
│ │ │ │ +
449 communicator, &future.req_);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
454 template <
typename BinaryFunction,
typename Type>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
462 MPI_Comm communicator;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
Interface class to translate objects to a MPI_Datatype, void* and size used for MPI calls.
│ │ │ │ +
Traits classes for mapping types onto MPI_Datatype.
│ │ │ │ +
#define ComposeMPIOp(func, op)
Definition mpicommunication.hh:77
│ │ │ │ +
│ │ │ │ +
Implements an utility class that provides collective communication methods for sequential programs.
│ │ │ │ +
A few common exception classes.
│ │ │ │ +
helper classes to provide unique types for standard functions
│ │ │ │ +
#define DUNE_THROW(E, m)
Definition exceptions.hh:218
│ │ │ │ +
Dune namespace.
Definition alignedallocator.hh:13
│ │ │ │ +
auto getMPIData(T &t)
Definition mpidata.hh:43
│ │ │ │ +
A traits class describing the mapping of types onto MPI_Datatypes.
Definition mpitraits.hh:41
│ │ │ │ +
Definition binaryfunctions.hh:18
│ │ │ │ +
Definition binaryfunctions.hh:34
│ │ │ │ +
Default exception if an error in the parallel communication of the program occurred.
Definition exceptions.hh:287
│ │ │ │ +
Collective communication interface and sequential default implementation.
Definition communication.hh:100
│ │ │ │ +
int size() const
Number of processes in set, is greater than 0.
Definition communication.hh:126
│ │ │ │ +
Definition mpicommunication.hh:41
│ │ │ │ +
static MPI_Op get()
Definition mpicommunication.hh:44
│ │ │ │ +
int max(T *inout, int len) const
Compute the maximum of the argument over all processes and return the result in every process....
Definition mpicommunication.hh:259
│ │ │ │ +
int allgatherv(const T *in, int sendDataLen, T *out, int *recvDataLen, int *displ) const
Gathers data of variable length from all tasks and distribute it to all.
Definition mpicommunication.hh:398
│ │ │ │ +
T max(const T &in) const
Compute the maximum of the argument over all processes and return the result in every process....
Definition mpicommunication.hh:250
│ │ │ │ +
MPIFuture< T > ibroadcast(T &&data, int root) const
Distribute an array from the process with rank root to all other processes nonblocking.
Definition mpicommunication.hh:288
│ │ │ │ +
MPIFuture< void > ibarrier() const
Nonblocking barrier.
Definition mpicommunication.hh:271
│ │ │ │ +
MPIFuture< const T > isend(const T &&data, int dest_rank, int tag) const
Sends the data to the dest_rank nonblocking.
Definition mpicommunication.hh:150
│ │ │ │ +
T recv(T &&data, int source_rank, int tag, MPI_Status *status=MPI_STATUS_IGNORE) const
Receives the data from the source_rank.
Definition mpicommunication.hh:161
│ │ │ │ +
int barrier() const
Wait until all processes have arrived at this point in the program.
Definition mpicommunication.hh:265
│ │ │ │ +
int rank() const
Return rank, is between 0 and size()-1.
Definition mpicommunication.hh:128
│ │ │ │ +
int scatterv(const T *sendData, int *sendDataLen, int *displ, T *recvData, int recvDataLen, int root) const
Scatter arrays of variable length from a root to all other tasks.
Definition mpicommunication.hh:359
│ │ │ │ +
MPIFuture< TOUT, TIN > iallgather(TIN &&data_in, TOUT &&data_out) const
Gathers data from all tasks and distribute it to all nonblocking.
Definition mpicommunication.hh:383
│ │ │ │ +
Type allreduce(Type &&in) const
Definition mpicommunication.hh:417
│ │ │ │ +
int sum(T *inout, int len) const
Compute the sum of the argument over all processes and return the result in every process....
Definition mpicommunication.hh:210
│ │ │ │ +
int broadcast(T *inout, int len, int root) const
Distribute an array from the process with rank root to all other processes.
Definition mpicommunication.hh:281
│ │ │ │ +
MPIFuture< T > iallreduce(T &&data) const
Compute something over all processes nonblocking.
Definition mpicommunication.hh:443
│ │ │ │ +
T sum(const T &in) const
Compute the sum of the argument over all processes and return the result in every process....
Definition mpicommunication.hh:201
│ │ │ │ +
int allreduce(const Type *in, Type *out, int len) const
Definition mpicommunication.hh:455
│ │ │ │ +
MPIFuture< TOUT, TIN > iallreduce(TIN &&data_in, TOUT &&data_out) const
Compute something over all processes nonblocking.
Definition mpicommunication.hh:428
│ │ │ │ +
int size() const
Number of processes in set, is greater than 0.
Definition mpicommunication.hh:134
│ │ │ │ +
int gather(const T *in, T *out, int len, int root) const
Gather arrays on root task.
Definition mpicommunication.hh:303
│ │ │ │ +
int allreduce(Type *inout, int len) const
Compute something over all processes for each component of an array and return the result in every pr...
Definition mpicommunication.hh:407
│ │ │ │ +
T rrecv(T &&data, int source_rank, int tag, MPI_Status *status=MPI_STATUS_IGNORE) const
Definition mpicommunication.hh:182
│ │ │ │ +
int scatter(const T *sendData, T *recvData, int len, int root) const
Scatter array from a root to all other task.
Definition mpicommunication.hh:336
│ │ │ │ +
MPIFuture< T > irecv(T &&data, int source_rank, int tag) const
Receives the data from the source_rank nonblocking.
Definition mpicommunication.hh:172
│ │ │ │ +
int prod(T *inout, int len) const
Compute the product of the argument over all processes and return the result in every process....
Definition mpicommunication.hh:226
│ │ │ │ +
MPIFuture< TOUT, TIN > igather(TIN &&data_in, TOUT &&data_out, int root) const
Gather arrays on root task nonblocking.
Definition mpicommunication.hh:312
│ │ │ │ +
T min(const T &in) const
Compute the minimum of the argument over all processes and return the result in every process....
Definition mpicommunication.hh:233
│ │ │ │ +
Communication(const MPI_Comm &c=MPI_COMM_WORLD)
Instantiation using a MPI communicator.
Definition mpicommunication.hh:111
│ │ │ │ +
MPIFuture< TOUT, TIN > iscatter(TIN &&data_in, TOUT &&data_out, int root) const
Scatter array from a root to all other task nonblocking.
Definition mpicommunication.hh:345
│ │ │ │ +
int gatherv(const T *in, int sendDataLen, T *out, int *recvDataLen, int *displ, int root) const
Gather arrays of variable size on root task.
Definition mpicommunication.hh:326
│ │ │ │ +
int min(T *inout, int len) const
Compute the minimum of the argument over all processes and return the result in every process....
Definition mpicommunication.hh:242
│ │ │ │ +
int allgather(const T *sbuf, int count, T1 *rbuf) const
Gathers data from all tasks and distribute it to all.
Definition mpicommunication.hh:374
│ │ │ │ +
int send(const T &data, int dest_rank, int tag) const
Sends the data to the dest_rank.
Definition mpicommunication.hh:141
│ │ │ │ +
T prod(const T &in) const
Compute the product of the argument over all processes and return the result in every process....
Definition mpicommunication.hh:217
│ │ │ │ +
Provides a future-like object for MPI communication. It contains the object that will be received and...
Definition mpifuture.hh:85
│ │ │ │ +
auto get_send_mpidata()
Definition mpifuture.hh:169
│ │ │ │ +
auto get_mpidata()
Definition mpifuture.hh:165
│ │ │ │
│ │ │ │ │ + 19#include
│ │ │ │ │ + 20#include
│ │ │ │ │ + 21
│ │ │ │ │ + 22#include
│ │ │ │ │ + 23
│ │ │ │ │ + 24#include
│ │ │ │ │ + 25#include
│ │ │ │ │ + 26#include
│ │ │ │ │ + 27#include
│ │ │ │ │ + 28#include
│ │ │ │ │ + 29#include
│ │ │ │ │ + 30
│ │ │ │ │ + 31namespace Dune
│ │ │ │ │ + 32{
│ │ │ │ │ + 33
│ │ │ │ │ + 34 //=======================================================
│ │ │ │ │ + 35 // use singleton pattern and template specialization to
│ │ │ │ │ + 36 // generate MPI operations
│ │ │ │ │ + 37 //=======================================================
│ │ │ │ │ + 38
│ │ │ │ │ + 39 template
│ │ │ │ │ +40 class Generic_MPI_Op
│ │ │ │ │ + 41 {
│ │ │ │ │ + 42
│ │ │ │ │ + 43 public:
│ │ │ │ │ +44 static MPI_Op get ()
│ │ │ │ │ + 45 {
│ │ │ │ │ + 46 if (!op)
│ │ │ │ │ + 47 {
│ │ │ │ │ + 48 op = std::make_unique();
│ │ │ │ │ + 49 // The following line leaks an MPI operation object, because the
│ │ │ │ │ +corresponding
│ │ │ │ │ + 50 //`MPI_Op_free` is never called. It is never called because there is no
│ │ │ │ │ +easy
│ │ │ │ │ + 51 // way to call it at the right moment: right before the call to
│ │ │ │ │ +MPI_Finalize.
│ │ │ │ │ + 52 // See https://gitlab.dune-project.org/core/dune-istl/issues/80
│ │ │ │ │ + 53 MPI_Op_create((void (*)(void*, void*, int*,
│ │ │ │ │ +MPI_Datatype*))&operation,true,op.get());
│ │ │ │ │ + 54 }
│ │ │ │ │ + 55 return *op;
│ │ │ │ │ + 56 }
│ │ │ │ │ + 57 private:
│ │ │ │ │ + 58 static void operation (Type *in, Type *inout, int *len, MPI_Datatype*)
│ │ │ │ │ + 59 {
│ │ │ │ │ + 60 BinaryFunction func;
│ │ │ │ │ 61
│ │ │ │ │ - 63
│ │ │ │ │ - 64#endif
│ │ │ │ │ + 62 for (int i=0; i< *len; ++i, ++in, ++inout) {
│ │ │ │ │ + 63 Type temp;
│ │ │ │ │ + 64 temp = func(*in, *inout);
│ │ │ │ │ + 65 *inout = temp;
│ │ │ │ │ + 66 }
│ │ │ │ │ + 67 }
│ │ │ │ │ + 68 Generic_MPI_Op () {}
│ │ │ │ │ + 69 Generic_MPI_Op (const Generic_MPI_Op& ) {}
│ │ │ │ │ + 70 static std::unique_ptr op;
│ │ │ │ │ + 71 };
│ │ │ │ │ + 72
│ │ │ │ │ + 73
│ │ │ │ │ + 74 template
│ │ │ │ │ + 75 std::unique_ptr Generic_MPI_Op::op;
│ │ │ │ │ + 76
│ │ │ │ │ +77#define ComposeMPIOp(func,op) \
│ │ │ │ │ + 78 template \
│ │ │ │ │ + 79 class Generic_MPI_Op, std::enable_if_t::
│ │ │ │ │ +is_intrinsic> >{ \
│ │ │ │ │ + 80 public: \
│ │ │ │ │ + 81 static MPI_Op get(){ \
│ │ │ │ │ + 82 return op; \
│ │ │ │ │ + 83 } \
│ │ │ │ │ + 84 private: \
│ │ │ │ │ + 85 Generic_MPI_Op () {} \
│ │ │ │ │ + 86 Generic_MPI_Op (const Generic_MPI_Op & ) {} \
│ │ │ │ │ + 87 }
│ │ │ │ │ + 88
│ │ │ │ │ + 89
│ │ │ │ │ +90 ComposeMPIOp(std::plus, MPI_SUM);
│ │ │ │ │ +91 ComposeMPIOp(std::multiplies, MPI_PROD);
│ │ │ │ │ +92 ComposeMPIOp(Min, MPI_MIN);
│ │ │ │ │ +93 ComposeMPIOp(Max, MPI_MAX);
│ │ │ │ │ + 94
│ │ │ │ │ + 95#undef ComposeMPIOp
│ │ │ │ │ + 96
│ │ │ │ │ + 97
│ │ │ │ │ + 98 //=======================================================
│ │ │ │ │ + 99 // use singleton pattern and template specialization to
│ │ │ │ │ + 100 // generate MPI operations
│ │ │ │ │ + 101 //=======================================================
│ │ │ │ │ + 102
│ │ │ │ │ + 106 template<>
│ │ │ │ │ +107 class Communication
│ │ │ │ │ + 108 {
│ │ │ │ │ + 109 public:
│ │ │ │ │ +111 Communication (const MPI_Comm& c = MPI_COMM_WORLD)
│ │ │ │ │ + 112 : communicator(c)
│ │ │ │ │ + 113 {
│ │ │ │ │ + 114 if(communicator!=MPI_COMM_NULL) {
│ │ │ │ │ + 115 int initialized = 0;
│ │ │ │ │ + 116 MPI_Initialized(&initialized);
│ │ │ │ │ + 117 if (!initialized)
│ │ │ │ │ + 118 DUNE_THROW(ParallelError,"You must call MPIHelper::instance(argc,argv) in
│ │ │ │ │ +your main() function before using the MPI Communication!");
│ │ │ │ │ + 119 MPI_Comm_rank(communicator,&me);
│ │ │ │ │ + 120 MPI_Comm_size(communicator,&procs);
│ │ │ │ │ + 121 }else{
│ │ │ │ │ + 122 procs=0;
│ │ │ │ │ + 123 me=-1;
│ │ │ │ │ + 124 }
│ │ │ │ │ + 125 }
│ │ │ │ │ + 126
│ │ │ │ │ +128 int rank () const
│ │ │ │ │ + 129 {
│ │ │ │ │ + 130 return me;
│ │ │ │ │ + 131 }
│ │ │ │ │ + 132
│ │ │ │ │ +134 int size () const
│ │ │ │ │ + 135 {
│ │ │ │ │ + 136 return procs;
│ │ │ │ │ + 137 }
│ │ │ │ │ + 138
│ │ │ │ │ + 140 template
│ │ │ │ │ +141 int send(const T& data, int dest_rank, int tag) const
│ │ │ │ │ + 142 {
│ │ │ │ │ + 143 auto mpi_data = getMPIData(data);
│ │ │ │ │ + 144 return MPI_Send(mpi_data.ptr(), mpi_data.size(), mpi_data.type(),
│ │ │ │ │ + 145 dest_rank, tag, communicator);
│ │ │ │ │ + 146 }
│ │ │ │ │ + 147
│ │ │ │ │ + 149 template
│ │ │ │ │ +150 MPIFuture isend(const T&& data, int dest_rank, int tag) const
│ │ │ │ │ + 151 {
│ │ │ │ │ + 152 MPIFuture future(std::forward(data));
│ │ │ │ │ + 153 auto mpidata = future.get_mpidata();
│ │ │ │ │ + 154 MPI_Isend(mpidata.ptr(), mpidata.size(), mpidata.type(),
│ │ │ │ │ + 155 dest_rank, tag, communicator, &future.req_);
│ │ │ │ │ + 156 return future;
│ │ │ │ │ + 157 }
│ │ │ │ │ + 158
│ │ │ │ │ + 160 template
│ │ │ │ │ +161 T recv(T&& data, int source_rank, int tag, MPI_Status* status =
│ │ │ │ │ +MPI_STATUS_IGNORE) const
│ │ │ │ │ + 162 {
│ │ │ │ │ + 163 T lvalue_data(std::forward(data));
│ │ │ │ │ + 164 auto mpi_data = getMPIData(lvalue_data);
│ │ │ │ │ + 165 MPI_Recv(mpi_data.ptr(), mpi_data.size(), mpi_data.type(),
│ │ │ │ │ + 166 source_rank, tag, communicator, status);
│ │ │ │ │ + 167 return lvalue_data;
│ │ │ │ │ + 168 }
│ │ │ │ │ + 169
│ │ │ │ │ + 171 template
│ │ │ │ │ +172 MPIFuture irecv(T&& data, int source_rank, int tag) const
│ │ │ │ │ + 173 {
│ │ │ │ │ + 174 MPIFuture future(std::forward(data));
│ │ │ │ │ + 175 auto mpidata = future.get_mpidata();
│ │ │ │ │ + 176 MPI_Irecv(mpidata.ptr(), mpidata.size(), mpidata.type(),
│ │ │ │ │ + 177 source_rank, tag, communicator, &future.req_);
│ │ │ │ │ + 178 return future;
│ │ │ │ │ + 179 }
│ │ │ │ │ + 180
│ │ │ │ │ + 181 template
│ │ │ │ │ +182 T rrecv(T&& data, int source_rank, int tag, MPI_Status* status =
│ │ │ │ │ +MPI_STATUS_IGNORE) const
│ │ │ │ │ + 183 {
│ │ │ │ │ + 184 MPI_Status _status;
│ │ │ │ │ + 185 MPI_Message _message;
│ │ │ │ │ + 186 T lvalue_data(std::forward(data));
│ │ │ │ │ + 187 auto mpi_data = getMPIData(lvalue_data);
│ │ │ │ │ + 188 static_assert(!mpi_data.static_size, "rrecv work only for non-static-sized
│ │ │ │ │ +types.");
│ │ │ │ │ + 189 if(status == MPI_STATUS_IGNORE)
│ │ │ │ │ + 190 status = &_status;
│ │ │ │ │ + 191 MPI_Mprobe(source_rank, tag, communicator, &_message, status);
│ │ │ │ │ + 192 int size;
│ │ │ │ │ + 193 MPI_Get_count(status, mpi_data.type(), &size);
│ │ │ │ │ + 194 mpi_data.resize(size);
│ │ │ │ │ + 195 MPI_Mrecv(mpi_data.ptr(), mpi_data.size(), mpi_data.type(), &_message,
│ │ │ │ │ +status);
│ │ │ │ │ + 196 return lvalue_data;
│ │ │ │ │ + 197 }
│ │ │ │ │ + 198
│ │ │ │ │ + 200 template
│ │ │ │ │ +201 T sum (const T& in) const
│ │ │ │ │ + 202 {
│ │ │ │ │ + 203 T out;
│ │ │ │ │ + 204 allreduce >(&in,&out,1);
│ │ │ │ │ + 205 return out;
│ │ │ │ │ + 206 }
│ │ │ │ │ + 207
│ │ │ │ │ + 209 template
│ │ │ │ │ +210 int sum (T* inout, int len) const
│ │ │ │ │ + 211 {
│ │ │ │ │ + 212 return allreduce >(inout,len);
│ │ │ │ │ + 213 }
│ │ │ │ │ + 214
│ │ │ │ │ + 216 template
│ │ │ │ │ +217 T prod (const T& in) const
│ │ │ │ │ + 218 {
│ │ │ │ │ + 219 T out;
│ │ │ │ │ + 220 allreduce >(&in,&out,1);
│ │ │ │ │ + 221 return out;
│ │ │ │ │ + 222 }
│ │ │ │ │ + 223
│ │ │ │ │ + 225 template
│ │ │ │ │ +226 int prod (T* inout, int len) const
│ │ │ │ │ + 227 {
│ │ │ │ │ + 228 return allreduce >(inout,len);
│ │ │ │ │ + 229 }
│ │ │ │ │ + 230
│ │ │ │ │ + 232 template
│ │ │ │ │ +233 T min (const T& in) const
│ │ │ │ │ + 234 {
│ │ │ │ │ + 235 T out;
│ │ │ │ │ + 236 allreduce >(&in,&out,1);
│ │ │ │ │ + 237 return out;
│ │ │ │ │ + 238 }
│ │ │ │ │ + 239
│ │ │ │ │ + 241 template
│ │ │ │ │ +242 int min (T* inout, int len) const
│ │ │ │ │ + 243 {
│ │ │ │ │ + 244 return allreduce >(inout,len);
│ │ │ │ │ + 245 }
│ │ │ │ │ + 246
│ │ │ │ │ + 247
│ │ │ │ │ + 249 template
│ │ │ │ │ +250 T max (const T& in) const
│ │ │ │ │ + 251 {
│ │ │ │ │ + 252 T out;
│ │ │ │ │ + 253 allreduce >(&in,&out,1);
│ │ │ │ │ + 254 return out;
│ │ │ │ │ + 255 }
│ │ │ │ │ + 256
│ │ │ │ │ + 258 template
│ │ │ │ │ +259 int max (T* inout, int len) const
│ │ │ │ │ + 260 {
│ │ │ │ │ + 261 return allreduce >(inout,len);
│ │ │ │ │ + 262 }
│ │ │ │ │ + 263
│ │ │ │ │ +265 int barrier () const
│ │ │ │ │ + 266 {
│ │ │ │ │ + 267 return MPI_Barrier(communicator);
│ │ │ │ │ + 268 }
│ │ │ │ │ + 269
│ │ │ │ │ +271 MPIFuture ibarrier () const
│ │ │ │ │ + 272 {
│ │ │ │ │ + 273 MPIFuture future(true); // make a valid MPIFuture
│ │ │ │ │ + 274 MPI_Ibarrier(communicator, &future.req_);
│ │ │ │ │ + 275 return future;
│ │ │ │ │ + 276 }
│ │ │ │ │ + 277
│ │ │ │ │ + 278
│ │ │ │ │ + 280 template
│ │ │ │ │ +281 int broadcast (T* inout, int len, int root) const
│ │ │ │ │ + 282 {
│ │ │ │ │ + 283 return MPI_Bcast(inout,len,MPITraits::getType(),root,communicator);
│ │ │ │ │ + 284 }
│ │ │ │ │ + 285
│ │ │ │ │ + 287 template
│ │ │ │ │ +288 MPIFuture ibroadcast(T&& data, int root) const{
│ │ │ │ │ + 289 MPIFuture future(std::forward(data));
│ │ │ │ │ + 290 auto mpidata = future.get_mpidata();
│ │ │ │ │ + 291 MPI_Ibcast(mpidata.ptr(),
│ │ │ │ │ + 292 mpidata.size(),
│ │ │ │ │ + 293 mpidata.type(),
│ │ │ │ │ + 294 root,
│ │ │ │ │ + 295 communicator,
│ │ │ │ │ + 296 &future.req_);
│ │ │ │ │ + 297 return future;
│ │ │ │ │ + 298 }
│ │ │ │ │ + 299
│ │ │ │ │ + 302 template
│ │ │ │ │ +303 int gather (const T* in, T* out, int len, int root) const
│ │ │ │ │ + 304 {
│ │ │ │ │ + 305 return MPI_Gather(const_cast(in),len,MPITraits::getType(),
│ │ │ │ │ + 306 out,len,MPITraits::getType(),
│ │ │ │ │ + 307 root,communicator);
│ │ │ │ │ + 308 }
│ │ │ │ │ + 309
│ │ │ │ │ + 311 template>
│ │ │ │ │ +312 MPIFuture igather(TIN&& data_in, TOUT&& data_out, int root)
│ │ │ │ │ +const{
│ │ │ │ │ + 313 MPIFuture future(std::forward(data_out), std::
│ │ │ │ │ +forward(data_in));
│ │ │ │ │ + 314 auto mpidata_in = future.get_send_mpidata();
│ │ │ │ │ + 315 auto mpidata_out = future.get_mpidata();
│ │ │ │ │ + 316 assert(root != me || mpidata_in.size()*procs <= mpidata_out.size());
│ │ │ │ │ + 317 int outlen = (me==root) * mpidata_in.size();
│ │ │ │ │ + 318 MPI_Igather(mpidata_in.ptr(), mpidata_in.size(), mpidata_in.type(),
│ │ │ │ │ + 319 mpidata_out.ptr(), outlen, mpidata_out.type(),
│ │ │ │ │ + 320 root, communicator, &future.req_);
│ │ │ │ │ + 321 return future;
│ │ │ │ │ + 322 }
│ │ │ │ │ + 323
│ │ │ │ │ + 325 template
│ │ │ │ │ +326 int gatherv (const T* in, int sendDataLen, T* out, int* recvDataLen, int*
│ │ │ │ │ +displ, int root) const
│ │ │ │ │ + 327 {
│ │ │ │ │ + 328 return MPI_Gatherv(const_cast(in),sendDataLen,MPITraits::getType(),
│ │ │ │ │ + 329 out,recvDataLen,displ,MPITraits::getType(),
│ │ │ │ │ + 330 root,communicator);
│ │ │ │ │ + 331 }
│ │ │ │ │ + 332
│ │ │ │ │ + 335 template
│ │ │ │ │ +336 int scatter (const T* sendData, T* recvData, int len, int root) const
│ │ │ │ │ + 337 {
│ │ │ │ │ + 338 return MPI_Scatter(const_cast(sendData),len,MPITraits::getType(),
│ │ │ │ │ + 339 recvData,len,MPITraits::getType(),
│ │ │ │ │ + 340 root,communicator);
│ │ │ │ │ + 341 }
│ │ │ │ │ + 342
│ │ │ │ │ + 344 template
│ │ │ │ │ +345 MPIFuture iscatter(TIN&& data_in, TOUT&& data_out, int root)
│ │ │ │ │ +const
│ │ │ │ │ + 346 {
│ │ │ │ │ + 347 MPIFuture future(std::forward(data_out), std::
│ │ │ │ │ +forward(data_in));
│ │ │ │ │ + 348 auto mpidata_in = future.get_send_mpidata();
│ │ │ │ │ + 349 auto mpidata_out = future.get_mpidata();
│ │ │ │ │ + 350 int inlen = (me==root) * mpidata_in.size()/procs;
│ │ │ │ │ + 351 MPI_Iscatter(mpidata_in.ptr(), inlen, mpidata_in.type(),
│ │ │ │ │ + 352 mpidata_out.ptr(), mpidata_out.size(), mpidata_out.type(),
│ │ │ │ │ + 353 root, communicator, &future.req_);
│ │ │ │ │ + 354 return future;
│ │ │ │ │ + 355 }
│ │ │ │ │ + 356
│ │ │ │ │ + 358 template
│ │ │ │ │ +359 int scatterv (const T* sendData, int* sendDataLen, int* displ, T* recvData,
│ │ │ │ │ +int recvDataLen, int root) const
│ │ │ │ │ + 360 {
│ │ │ │ │ + 361 return MPI_Scatterv(const_cast
│ │ │ │ │ +(sendData),sendDataLen,displ,MPITraits::getType(),
│ │ │ │ │ + 362 recvData,recvDataLen,MPITraits::getType(),
│ │ │ │ │ + 363 root,communicator);
│ │ │ │ │ + 364 }
│ │ │ │ │ + 365
│ │ │ │ │ + 366
│ │ │ │ │ +367 operator MPI_Comm () const
│ │ │ │ │ + 368 {
│ │ │ │ │ + 369 return communicator;
│ │ │ │ │ + 370 }
│ │ │ │ │ + 371
│ │ │ │ │ + 373 template
│ │ │ │ │ +374 int allgather(const T* sbuf, int count, T1* rbuf) const
│ │ │ │ │ + 375 {
│ │ │ │ │ + 376 return MPI_Allgather(const_cast(sbuf), count, MPITraits::getType(),
│ │ │ │ │ + 377 rbuf, count, MPITraits::getType(),
│ │ │ │ │ + 378 communicator);
│ │ │ │ │ + 379 }
│ │ │ │ │ + 380
│ │ │ │ │ + 382 template
│ │ │ │ │ +383 MPIFuture iallgather(TIN&& data_in, TOUT&& data_out) const
│ │ │ │ │ + 384 {
│ │ │ │ │ + 385 MPIFuture future(std::forward(data_out), std::
│ │ │ │ │ +forward(data_in));
│ │ │ │ │ + 386 auto mpidata_in = future.get_send_mpidata();
│ │ │ │ │ + 387 auto mpidata_out = future.get_mpidata();
│ │ │ │ │ + 388 assert(mpidata_in.size()*procs <= mpidata_out.size());
│ │ │ │ │ + 389 int outlen = mpidata_in.size();
│ │ │ │ │ + 390 MPI_Iallgather(mpidata_in.ptr(), mpidata_in.size(), mpidata_in.type(),
│ │ │ │ │ + 391 mpidata_out.ptr(), outlen, mpidata_out.type(),
│ │ │ │ │ + 392 communicator, &future.req_);
│ │ │ │ │ + 393 return future;
│ │ │ │ │ + 394 }
│ │ │ │ │ + 395
│ │ │ │ │ + 397 template
│ │ │ │ │ +398 int allgatherv (const T* in, int sendDataLen, T* out, int* recvDataLen,
│ │ │ │ │ +int* displ) const
│ │ │ │ │ + 399 {
│ │ │ │ │ + 400 return MPI_Allgatherv(const_cast(in),sendDataLen,MPITraits::getType
│ │ │ │ │ +(),
│ │ │ │ │ + 401 out,recvDataLen,displ,MPITraits::getType(),
│ │ │ │ │ + 402 communicator);
│ │ │ │ │ + 403 }
│ │ │ │ │ + 404
│ │ │ │ │ + 406 template
│ │ │ │ │ +407 int allreduce(Type* inout, int len) const
│ │ │ │ │ + 408 {
│ │ │ │ │ + 409 Type* out = new Type[len];
│ │ │ │ │ + 410 int ret = allreduce(inout,out,len);
│ │ │ │ │ + 411 std::copy(out, out+len, inout);
│ │ │ │ │ + 412 delete[] out;
│ │ │ │ │ + 413 return ret;
│ │ │ │ │ + 414 }
│ │ │ │ │ + 415
│ │ │ │ │ + 416 template
│ │ │ │ │ +417 Type allreduce(Type&& in) const{
│ │ │ │ │ + 418 Type lvalue_data = std::forward(in);
│ │ │ │ │ + 419 auto data = getMPIData(lvalue_data);
│ │ │ │ │ + 420 MPI_Allreduce(MPI_IN_PLACE, data.ptr(), data.size(), data.type(),
│ │ │ │ │ + 421 (Generic_MPI_Op::get()),
│ │ │ │ │ + 422 communicator);
│ │ │ │ │ + 423 return lvalue_data;
│ │ │ │ │ + 424 }
│ │ │ │ │ + 425
│ │ │ │ │ + 427 template
│ │ │ │ │ +428 MPIFuture iallreduce(TIN&& data_in, TOUT&& data_out) const {
│ │ │ │ │ + 429 MPIFuture future(std::forward(data_out), std::
│ │ │ │ │ +forward(data_in));
│ │ │ │ │ + 430 auto mpidata_in = future.get_send_mpidata();
│ │ │ │ │ + 431 auto mpidata_out = future.get_mpidata();
│ │ │ │ │ + 432 assert(mpidata_out.size() == mpidata_in.size());
│ │ │ │ │ + 433 assert(mpidata_out.type() == mpidata_in.type());
│ │ │ │ │ + 434 MPI_Iallreduce(mpidata_in.ptr(), mpidata_out.ptr(),
│ │ │ │ │ + 435 mpidata_out.size(), mpidata_out.type(),
│ │ │ │ │ + 436 (Generic_MPI_Op::get()),
│ │ │ │ │ + 437 communicator, &future.req_);
│ │ │ │ │ + 438 return future;
│ │ │ │ │ + 439 }
│ │ │ │ │ + 440
│ │ │ │ │ + 442 template
│ │ │ │ │ +443 MPIFuture iallreduce(T&& data) const{
│ │ │ │ │ + 444 MPIFuture future(std::forward(data));
│ │ │ │ │ + 445 auto mpidata = future.get_mpidata();
│ │ │ │ │ + 446 MPI_Iallreduce(MPI_IN_PLACE, mpidata.ptr(),
│ │ │ │ │ + 447 mpidata.size(), mpidata.type(),
│ │ │ │ │ + 448 (Generic_MPI_Op::get()),
│ │ │ │ │ + 449 communicator, &future.req_);
│ │ │ │ │ + 450 return future;
│ │ │ │ │ + 451 }
│ │ │ │ │ + 452
│ │ │ │ │ + 454 template
│ │ │ │ │ +455 int allreduce(const Type* in, Type* out, int len) const
│ │ │ │ │ + 456 {
│ │ │ │ │ + 457 return MPI_Allreduce(const_cast(in), out, len, MPITraits::
│ │ │ │ │ +getType(),
│ │ │ │ │ + 458 (Generic_MPI_Op::get()),communicator);
│ │ │ │ │ + 459 }
│ │ │ │ │ + 460
│ │ │ │ │ + 461 private:
│ │ │ │ │ + 462 MPI_Comm communicator;
│ │ │ │ │ + 463 int me;
│ │ │ │ │ + 464 int procs;
│ │ │ │ │ + 465 };
│ │ │ │ │ + 466} // namespace dune
│ │ │ │ │ + 467
│ │ │ │ │ + 468#endif // HAVE_MPI
│ │ │ │ │ + 469
│ │ │ │ │ + 470#endif
│ │ │ │ │ +mpidata.hh
│ │ │ │ │ +Interface class to translate objects to a MPI_Datatype, void* and size used for
│ │ │ │ │ +MPI calls.
│ │ │ │ │ +mpitraits.hh
│ │ │ │ │ +Traits classes for mapping types onto MPI_Datatype.
│ │ │ │ │ +ComposeMPIOp
│ │ │ │ │ +#define ComposeMPIOp(func, op)
│ │ │ │ │ +Definition mpicommunication.hh:77
│ │ │ │ │ +mpifuture.hh
│ │ │ │ │ +communication.hh
│ │ │ │ │ +Implements an utility class that provides collective communication methods for
│ │ │ │ │ +sequential programs.
│ │ │ │ │ +exceptions.hh
│ │ │ │ │ +A few common exception classes.
│ │ │ │ │ +binaryfunctions.hh
│ │ │ │ │ +helper classes to provide unique types for standard functions
│ │ │ │ │ +DUNE_THROW
│ │ │ │ │ +#define DUNE_THROW(E, m)
│ │ │ │ │ +Definition exceptions.hh:218
│ │ │ │ │ +Dune
│ │ │ │ │ +Dune namespace.
│ │ │ │ │ +Definition alignedallocator.hh:13
│ │ │ │ │ +Dune::getMPIData
│ │ │ │ │ +auto getMPIData(T &t)
│ │ │ │ │ +Definition mpidata.hh:43
│ │ │ │ │ +Dune::MPITraits
│ │ │ │ │ +A traits class describing the mapping of types onto MPI_Datatypes.
│ │ │ │ │ +Definition mpitraits.hh:41
│ │ │ │ │ +Dune::Min
│ │ │ │ │ +Definition binaryfunctions.hh:18
│ │ │ │ │ +Dune::Max
│ │ │ │ │ +Definition binaryfunctions.hh:34
│ │ │ │ │ +Dune::ParallelError
│ │ │ │ │ +Default exception if an error in the parallel communication of the program
│ │ │ │ │ +occurred.
│ │ │ │ │ +Definition exceptions.hh:287
│ │ │ │ │ +Dune::Communication
│ │ │ │ │ +Collective communication interface and sequential default implementation.
│ │ │ │ │ +Definition communication.hh:100
│ │ │ │ │ +Dune::Communication::size
│ │ │ │ │ +int size() const
│ │ │ │ │ +Number of processes in set, is greater than 0.
│ │ │ │ │ +Definition communication.hh:126
│ │ │ │ │ +Dune::Generic_MPI_Op
│ │ │ │ │ +Definition mpicommunication.hh:41
│ │ │ │ │ +Dune::Generic_MPI_Op::get
│ │ │ │ │ +static MPI_Op get()
│ │ │ │ │ +Definition mpicommunication.hh:44
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::max
│ │ │ │ │ +int max(T *inout, int len) const
│ │ │ │ │ +Compute the maximum of the argument over all processes and return the result in
│ │ │ │ │ +every process....
│ │ │ │ │ +Definition mpicommunication.hh:259
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::allgatherv
│ │ │ │ │ +int allgatherv(const T *in, int sendDataLen, T *out, int *recvDataLen, int
│ │ │ │ │ +*displ) const
│ │ │ │ │ +Gathers data of variable length from all tasks and distribute it to all.
│ │ │ │ │ +Definition mpicommunication.hh:398
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::max
│ │ │ │ │ +T max(const T &in) const
│ │ │ │ │ +Compute the maximum of the argument over all processes and return the result in
│ │ │ │ │ +every process....
│ │ │ │ │ +Definition mpicommunication.hh:250
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::ibroadcast
│ │ │ │ │ +MPIFuture< T > ibroadcast(T &&data, int root) const
│ │ │ │ │ +Distribute an array from the process with rank root to all other processes
│ │ │ │ │ +nonblocking.
│ │ │ │ │ +Definition mpicommunication.hh:288
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::ibarrier
│ │ │ │ │ +MPIFuture< void > ibarrier() const
│ │ │ │ │ +Nonblocking barrier.
│ │ │ │ │ +Definition mpicommunication.hh:271
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::isend
│ │ │ │ │ +MPIFuture< const T > isend(const T &&data, int dest_rank, int tag) const
│ │ │ │ │ +Sends the data to the dest_rank nonblocking.
│ │ │ │ │ +Definition mpicommunication.hh:150
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::recv
│ │ │ │ │ +T recv(T &&data, int source_rank, int tag, MPI_Status
│ │ │ │ │ +*status=MPI_STATUS_IGNORE) const
│ │ │ │ │ +Receives the data from the source_rank.
│ │ │ │ │ +Definition mpicommunication.hh:161
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::barrier
│ │ │ │ │ +int barrier() const
│ │ │ │ │ +Wait until all processes have arrived at this point in the program.
│ │ │ │ │ +Definition mpicommunication.hh:265
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::rank
│ │ │ │ │ +int rank() const
│ │ │ │ │ +Return rank, is between 0 and size()-1.
│ │ │ │ │ +Definition mpicommunication.hh:128
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::scatterv
│ │ │ │ │ +int scatterv(const T *sendData, int *sendDataLen, int *displ, T *recvData, int
│ │ │ │ │ +recvDataLen, int root) const
│ │ │ │ │ +Scatter arrays of variable length from a root to all other tasks.
│ │ │ │ │ +Definition mpicommunication.hh:359
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::iallgather
│ │ │ │ │ +MPIFuture< TOUT, TIN > iallgather(TIN &&data_in, TOUT &&data_out) const
│ │ │ │ │ +Gathers data from all tasks and distribute it to all nonblocking.
│ │ │ │ │ +Definition mpicommunication.hh:383
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::allreduce
│ │ │ │ │ +Type allreduce(Type &&in) const
│ │ │ │ │ +Definition mpicommunication.hh:417
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::sum
│ │ │ │ │ +int sum(T *inout, int len) const
│ │ │ │ │ +Compute the sum of the argument over all processes and return the result in
│ │ │ │ │ +every process....
│ │ │ │ │ +Definition mpicommunication.hh:210
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::broadcast
│ │ │ │ │ +int broadcast(T *inout, int len, int root) const
│ │ │ │ │ +Distribute an array from the process with rank root to all other processes.
│ │ │ │ │ +Definition mpicommunication.hh:281
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::iallreduce
│ │ │ │ │ +MPIFuture< T > iallreduce(T &&data) const
│ │ │ │ │ +Compute something over all processes nonblocking.
│ │ │ │ │ +Definition mpicommunication.hh:443
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::sum
│ │ │ │ │ +T sum(const T &in) const
│ │ │ │ │ +Compute the sum of the argument over all processes and return the result in
│ │ │ │ │ +every process....
│ │ │ │ │ +Definition mpicommunication.hh:201
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::allreduce
│ │ │ │ │ +int allreduce(const Type *in, Type *out, int len) const
│ │ │ │ │ +Definition mpicommunication.hh:455
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::iallreduce
│ │ │ │ │ +MPIFuture< TOUT, TIN > iallreduce(TIN &&data_in, TOUT &&data_out) const
│ │ │ │ │ +Compute something over all processes nonblocking.
│ │ │ │ │ +Definition mpicommunication.hh:428
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::size
│ │ │ │ │ +int size() const
│ │ │ │ │ +Number of processes in set, is greater than 0.
│ │ │ │ │ +Definition mpicommunication.hh:134
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::gather
│ │ │ │ │ +int gather(const T *in, T *out, int len, int root) const
│ │ │ │ │ +Gather arrays on root task.
│ │ │ │ │ +Definition mpicommunication.hh:303
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::allreduce
│ │ │ │ │ +int allreduce(Type *inout, int len) const
│ │ │ │ │ +Compute something over all processes for each component of an array and return
│ │ │ │ │ +the result in every pr...
│ │ │ │ │ +Definition mpicommunication.hh:407
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::rrecv
│ │ │ │ │ +T rrecv(T &&data, int source_rank, int tag, MPI_Status
│ │ │ │ │ +*status=MPI_STATUS_IGNORE) const
│ │ │ │ │ +Definition mpicommunication.hh:182
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::scatter
│ │ │ │ │ +int scatter(const T *sendData, T *recvData, int len, int root) const
│ │ │ │ │ +Scatter array from a root to all other task.
│ │ │ │ │ +Definition mpicommunication.hh:336
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::irecv
│ │ │ │ │ +MPIFuture< T > irecv(T &&data, int source_rank, int tag) const
│ │ │ │ │ +Receives the data from the source_rank nonblocking.
│ │ │ │ │ +Definition mpicommunication.hh:172
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::prod
│ │ │ │ │ +int prod(T *inout, int len) const
│ │ │ │ │ +Compute the product of the argument over all processes and return the result in
│ │ │ │ │ +every process....
│ │ │ │ │ +Definition mpicommunication.hh:226
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::igather
│ │ │ │ │ +MPIFuture< TOUT, TIN > igather(TIN &&data_in, TOUT &&data_out, int root) const
│ │ │ │ │ +Gather arrays on root task nonblocking.
│ │ │ │ │ +Definition mpicommunication.hh:312
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::min
│ │ │ │ │ +T min(const T &in) const
│ │ │ │ │ +Compute the minimum of the argument over all processes and return the result in
│ │ │ │ │ +every process....
│ │ │ │ │ +Definition mpicommunication.hh:233
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::Communication
│ │ │ │ │ +Communication(const MPI_Comm &c=MPI_COMM_WORLD)
│ │ │ │ │ +Instantiation using a MPI communicator.
│ │ │ │ │ +Definition mpicommunication.hh:111
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::iscatter
│ │ │ │ │ +MPIFuture< TOUT, TIN > iscatter(TIN &&data_in, TOUT &&data_out, int root) const
│ │ │ │ │ +Scatter array from a root to all other task nonblocking.
│ │ │ │ │ +Definition mpicommunication.hh:345
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::gatherv
│ │ │ │ │ +int gatherv(const T *in, int sendDataLen, T *out, int *recvDataLen, int *displ,
│ │ │ │ │ +int root) const
│ │ │ │ │ +Gather arrays of variable size on root task.
│ │ │ │ │ +Definition mpicommunication.hh:326
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::min
│ │ │ │ │ +int min(T *inout, int len) const
│ │ │ │ │ +Compute the minimum of the argument over all processes and return the result in
│ │ │ │ │ +every process....
│ │ │ │ │ +Definition mpicommunication.hh:242
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::allgather
│ │ │ │ │ +int allgather(const T *sbuf, int count, T1 *rbuf) const
│ │ │ │ │ +Gathers data from all tasks and distribute it to all.
│ │ │ │ │ +Definition mpicommunication.hh:374
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::send
│ │ │ │ │ +int send(const T &data, int dest_rank, int tag) const
│ │ │ │ │ +Sends the data to the dest_rank.
│ │ │ │ │ +Definition mpicommunication.hh:141
│ │ │ │ │ +Dune::Communication<_MPI_Comm_>::prod
│ │ │ │ │ +T prod(const T &in) const
│ │ │ │ │ +Compute the product of the argument over all processes and return the result in
│ │ │ │ │ +every process....
│ │ │ │ │ +Definition mpicommunication.hh:217
│ │ │ │ │ +Dune::MPIFuture
│ │ │ │ │ +Provides a future-like object for MPI communication. It contains the object
│ │ │ │ │ +that will be received and...
│ │ │ │ │ +Definition mpifuture.hh:85
│ │ │ │ │ +Dune::MPIFuture::get_send_mpidata
│ │ │ │ │ +auto get_send_mpidata()
│ │ │ │ │ +Definition mpifuture.hh:169
│ │ │ │ │ +Dune::MPIFuture::get_mpidata
│ │ │ │ │ +auto get_mpidata()
│ │ │ │ │ +Definition mpifuture.hh:165
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-common-doc/doxygen/a00026.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-common: typetraits.hh File Reference
│ │ │ │ +dune-common: communicator.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │ -
Traits for type conversions and type information.
│ │ │ │ +
Provides utility classes for syncing distributed data via MPI communication.
│ │ │ │ More...
│ │ │ │ -
#include <complex>
│ │ │ │ +
#include <cassert>
│ │ │ │ +
#include <cstddef>
│ │ │ │ +
#include <iostream>
│ │ │ │ +
#include <map>
│ │ │ │
#include <type_traits>
│ │ │ │
#include <utility>
│ │ │ │ -
#include <vector>
│ │ │ │ +
#include <mpi.h>
│ │ │ │ +
#include <dune/common/exceptions.hh >
│ │ │ │ +
#include <dune/common/parallel/interface.hh >
│ │ │ │ +
#include <dune/common/parallel/remoteindices.hh >
│ │ │ │ +
#include <dune/common/stdstreams.hh >
│ │ │ │
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ struct Dune::Empty Just an empty class. More... struct Dune::SizeOne Flag for marking indexed data structures where data at each index is of the same size. More... struct Dune::IsInteroperable< T1, T2 > Checks whether two types are interoperable. More... struct Dune::VariableSize Flag for marking indexed data structures where the data at each index may be a variable multiple of another type. More... struct Dune::EnableIfInterOperable< T1, T2, Type > Enable typedef if two types are interoperable. More... struct Dune::CommPolicy< V > Default policy used for communicating an indexed type. More... struct Dune::AlwaysFalse< T > template which always yields a false value More... struct Dune::CommPolicy< V >::CommPolicy< VariableBlockVector< FieldVector< K, n >, A > > struct Dune::AlwaysTrue< T > template which always yields a true value More... class Dune::CommPolicy< V >::CommunicationError Error thrown if there was a problem with the communication. More... struct Dune::IsCallable< F(Args...), R > Check if a type is callable with ()-operator and given arguments. More... struct Dune::CommPolicy< V >::CopyGatherScatter< T > GatherScatter default implementation that just copies data. More... struct Dune::IsNumber< T > Whether this type acts as a scalar in the context of (hierarchically blocked) containers. More... struct Dune::HasNaN< T > Whether this type has a value of NaN. More... struct Dune::IsIndexable< T, I > Type trait to determine whether an instance of T has an operator[](I), i.e. whether it can be indexed with an index of type I. More... struct Dune::IsIterable< T, typename > typetrait to check that a class has begin() and end() members More... struct Dune::IsTuple< T > Check if T is a std::tuple<...> More... struct Dune::IsTupleOrDerived< T > Check if T derived from a std::tuple<...> More... struct Dune::IsIntegralConstant< T > Check if T is an std::integral_constant<I, i> More... struct Dune::SizeOf< T > Compute size of variadic type list. More... struct Dune::AutonomousValueType< T > Type free of internal references that T can be converted to. More... struct Dune::AutonomousValueType< T & > Specialization to remove lvalue references. More... struct Dune::AutonomousValueType< T && > Specialization to remove rvalue references. More... struct Dune::AutonomousValueType< const T > Specialization to remove const qualifiers. More... struct Dune::AutonomousValueType< volatile T > Specialization to remove volatile qualifiers. More... struct Dune::AutonomousValueType< std::vector< bool >::reference > Specialization for the proxies of vector<bool> More... struct Dune::AutonomousValueType< volatile const T > Specialization to remove both const and volatile qualifiers. More... class Dune::BufferedCommunicator A communicator that uses buffers to gather and scatter the data to be send or received. More...
│ │ │ │ namespace Dune Dune namespace.
│ │ │ │ -template<class T , T... t, std::size_t index> constexpr auto Dune::integerSequenceEntry (std::integer_sequence< T, t... >, std::integral_constant< std::size_t, index > i) Get entry of std::integer_sequence. template<class T > constexpr AutonomousValue < T > Dune::autoCopy (T &&v) Autonomous copy of an expression's value for use in auto type deduction.
│ │ │ │
│ │ │ │ -
Traits for type conversions and type information.
│ │ │ │ -
Author Markus Blatt, Christian Engwer
│ │ │ │ +
Provides utility classes for syncing distributed data via MPI communication.
│ │ │ │ +
Author Markus Blatt
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -6,123 +6,61 @@
│ │ │ │ │ dune-common 2.9.0
│ │ │ │ │
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * dune
│ │ │ │ │ * common
│ │ │ │ │ -Classes | Namespaces | Typedefs | Functions
│ │ │ │ │ -typetraits.hh File Reference
│ │ │ │ │ -Traits for type conversions and type information. More...
│ │ │ │ │ -#include
│ │ │ │ │ + * parallel
│ │ │ │ │ +Classes | Namespaces
│ │ │ │ │ +communicator.hh File Reference
│ │ │ │ │ +Common » Parallel_Communication » Parallel_Computing_based_on_Indexsets
│ │ │ │ │ +Provides utility classes for syncing distributed data via MPI communication.
│ │ │ │ │ +More...
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ #include
│ │ │ │ │ #include
│ │ │ │ │ -#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ Go_to_the_source_code_of_this_file.
│ │ │ │ │ Classes
│ │ │ │ │ -struct Dune::Empty
│ │ │ │ │ - Just an empty class. More...
│ │ │ │ │ +struct Dune::SizeOne
│ │ │ │ │ + Flag for marking indexed data structures where data at each index is
│ │ │ │ │ + of the same size. More...
│ │ │ │ │
│ │ │ │ │ -struct Dune::IsInteroperable<_T1,_T2_>
│ │ │ │ │ - Checks whether two types are interoperable. More...
│ │ │ │ │ +struct Dune::VariableSize
│ │ │ │ │ + Flag for marking indexed data structures where the data at each index
│ │ │ │ │ + may be a variable multiple of another type. More...
│ │ │ │ │
│ │ │ │ │ -struct Dune::EnableIfInterOperable<_T1,_T2,_Type_>
│ │ │ │ │ - Enable typedef if two types are interoperable. More...
│ │ │ │ │ +struct Dune::CommPolicy<_V_>
│ │ │ │ │ + Default policy used for communicating an indexed type. More...
│ │ │ │ │
│ │ │ │ │ -struct Dune::AlwaysFalse<_T_>
│ │ │ │ │ - template which always yields a false value More...
│ │ │ │ │ +struct Dune::CommPolicy<_V_>::CommPolicy<_VariableBlockVector<_FieldVector<
│ │ │ │ │ + K,_n_>,_A_>_>
│ │ │ │ │
│ │ │ │ │ -struct Dune::AlwaysTrue<_T_>
│ │ │ │ │ - template which always yields a true value More...
│ │ │ │ │ + class Dune::CommPolicy<_V_>::CommunicationError
│ │ │ │ │ + Error thrown if there was a problem with the communication. More...
│ │ │ │ │
│ │ │ │ │ -struct Dune::IsCallable<_F(Args...),_R_>
│ │ │ │ │ - Check if a type is callable with ()-operator and given arguments.
│ │ │ │ │ - More...
│ │ │ │ │ +struct Dune::CommPolicy<_V_>::CopyGatherScatter<_T_>
│ │ │ │ │ + GatherScatter default implementation that just copies data. More...
│ │ │ │ │
│ │ │ │ │ -struct Dune::IsNumber<_T_>
│ │ │ │ │ - Whether this type acts as a scalar in the context of (hierarchically
│ │ │ │ │ - blocked) containers. More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::HasNaN<_T_>
│ │ │ │ │ - Whether this type has a value of NaN. More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::IsIndexable<_T,_I_>
│ │ │ │ │ - Type trait to determine whether an instance of T has an operator[](I),
│ │ │ │ │ - i.e. whether it can be indexed with an index of type I. More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::IsIterable<_T,_typename_>
│ │ │ │ │ - typetrait to check that a class has begin() and end() members More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::IsTuple<_T_>
│ │ │ │ │ - Check if T is a std::tuple<...> More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::IsTupleOrDerived<_T_>
│ │ │ │ │ - Check if T derived from a std::tuple<...> More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::IsIntegralConstant<_T_>
│ │ │ │ │ - Check if T is an std::integral_constant More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::SizeOf<_T_>
│ │ │ │ │ - Compute size of variadic type list. More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::AutonomousValueType<_T_>
│ │ │ │ │ - Type free of internal references that T can be converted to. More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::AutonomousValueType<_T_&_>
│ │ │ │ │ - Specialization to remove lvalue references. More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::AutonomousValueType<_T_&&_>
│ │ │ │ │ - Specialization to remove rvalue references. More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::AutonomousValueType<_const_T_>
│ │ │ │ │ - Specialization to remove const qualifiers. More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::AutonomousValueType<_volatile_T_>
│ │ │ │ │ - Specialization to remove volatile qualifiers. More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::AutonomousValueType<_std::vector<_bool_>::reference_>
│ │ │ │ │ - Specialization for the proxies of vector More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::AutonomousValueType<_volatile_const_T_>
│ │ │ │ │ - Specialization to remove both const and volatile qualifiers. More...
│ │ │ │ │ + class Dune::BufferedCommunicator
│ │ │ │ │ + A communicator that uses buffers to gather and scatter the data to be
│ │ │ │ │ + send or received. More...
│ │ │ │ │
│ │ │ │ │ Namespaces
│ │ │ │ │ namespace Dune
│ │ │ │ │ Dune namespace.
│ │ │ │ │
│ │ │ │ │ - Typedefs
│ │ │ │ │ -template
│ │ │ │ │ -using Dune::void_t = typename Impl::voider< Types... >::type
│ │ │ │ │ - Is void for all valid input types. The workhorse for C++11 SFINAE-
│ │ │ │ │ - techniques.
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -using Dune::field_t = typename FieldTraits< Type >::field_type
│ │ │ │ │ - Convenient access to FieldTraits::field_type.
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -using Dune::real_t = typename FieldTraits< Type >::real_type
│ │ │ │ │ - Convenient access to FieldTraits::real_type.
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -using Dune::AutonomousValue = typename AutonomousValueType< T >::type
│ │ │ │ │ - Type free of internal references that T can be converted to.
│ │ │ │ │ -
│ │ │ │ │ - Functions
│ │ │ │ │ -template
│ │ │ │ │ - constexpr auto Dune::integerSequenceEntry (std::
│ │ │ │ │ - integer_sequence< T, t... >, std::
│ │ │ │ │ - integral_constant< std::size_t, index > i)
│ │ │ │ │ - Get entry of std::integer_sequence.
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -constexpr AutonomousValue< T > Dune::autoCopy (T &&v)
│ │ │ │ │ - Autonomous copy of an expression's value for
│ │ │ │ │ - use in auto type deduction.
│ │ │ │ │ -
│ │ │ │ │ ***** Detailed Description *****
│ │ │ │ │ -Traits for type conversions and type information.
│ │ │ │ │ +Provides utility classes for syncing distributed data via MPI communication.
│ │ │ │ │ Author
│ │ │ │ │ - Markus Blatt, Christian Engwer
│ │ │ │ │ + Markus Blatt
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-common-doc/doxygen/a00026_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-common: typetraits.hh Source File
│ │ │ │ +dune-common: communicator.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
5 #ifndef DUNE_TYPETRAITS_HH
│ │ │ │ -
6 #define DUNE_TYPETRAITS_HH
│ │ │ │ +
5 #ifndef DUNE_COMMUNICATOR
│ │ │ │ +
6 #define DUNE_COMMUNICATOR
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
39 template <
class ... Types>
│ │ │ │ -
40 using void_t =
typename Impl::voider<Types...>::type;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
63 template <
class T1,
class T2>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
70 constexpr static bool value = std::is_convertible<T1,T2>::value || std::is_convertible<T2,T1>::value;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
78 template <
class T1,
class T2,
class Type>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
80 :
public std::enable_if<IsInteroperable<T1,T2>::value, Type>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
161 template <
typename D,
typename R =
void >
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
168 template <
typename R,
typename F,
typename ... Args>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
170 :
public std::bool_constant<
│ │ │ │ -
171 std::is_invocable_r_v<R, F, Args...>
│ │ │ │ -
172 && !std::is_member_pointer_v<std::decay_t<F>>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
192 template <
typename T>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
194 :
public std::integral_constant<bool, std::is_arithmetic<T>::value> {
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
177 template <
class K,
class A,
int n>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
199 template <
typename T>
│ │ │ │ -
│ │ │ │ -
201 :
public std::integral_constant<bool, IsNumber<T>::value> {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
210 template <
typename T>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
212 :
public std::integral_constant<bool, std::is_floating_point<T>::value> {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
217 template <
typename T>
│ │ │ │ -
│ │ │ │ -
219 :
public std::integral_constant<bool, std::is_floating_point<T>::value> {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
228 template <
typename T,
typename I,
typename =
int >
│ │ │ │ -
│ │ │ │ -
230 :
public std::false_type
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
233 template <
typename T,
typename I>
│ │ │ │ -
234 struct IsIndexable<T,I,typename
std ::enable_if<(sizeof(std::declval<T>()[std::declval<I>()]) > 0),int>::type>
│ │ │ │ -
235 :
public std::true_type
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
247 template <
typename T,
typename I = std::
size_t >
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
249 :
public Impl::IsIndexable<T,I>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
270 template <
typename T,
typename =
void >
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
272 :
public std::false_type
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
279 std::declval<T>().begin(),
│ │ │ │ -
280 std::declval<T>().end(),
│ │ │ │ -
281 std::declval<T>().begin() != std::declval<T>().end(),
│ │ │ │ -
282 decltype(std::declval<T>().begin()){std::declval<T>().end()},
│ │ │ │ -
283 ++(std::declval<std::add_lvalue_reference_t<decltype(std::declval<T>().begin())>>()),
│ │ │ │ -
284 *(std::declval<T>().begin())
│ │ │ │ -
│ │ │ │ -
286 :
public std::true_type
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
292 template <
class >
struct FieldTraits;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
296 template <
class Type>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
300 template <
class Type>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
310 struct IsTuple :
public std::false_type
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
314 struct IsTuple <
std ::tuple<T...>> :
public std::true_type
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
255 DatatypeCommunicator();
│ │ │ │ +
│ │ │ │ +
260 ~DatatypeCommunicator();
│ │ │ │ +
│ │ │ │ +
288 template <
class T1,
class T2,
class V>
│ │ │ │ +
289 void build(
const RemoteIndices & remoteIndices,
const T1& sourceFlags, V& sendData,
const T2& destFlags, V& receiveData);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
309 constexpr static int commTag_ = 234;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
316 typedef std::map<int,std::pair<MPI_Datatype,MPI_Datatype> >
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
328 public Impl::IsTuple<T>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
322 MessageTypeMap messageTypes;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
329 MPI_Request* requests_[2];
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
337 template <
class ... T,
class Dummy>
│ │ │ │ -
338 std::true_type isTupleOrDerived(
const std::tuple<T...>*, Dummy)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
341 template <
class Dummy>
│ │ │ │ -
342 std::false_type isTupleOrDerived(
const void *, Dummy)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
356 public decltype(Impl::isTupleOrDerived(std::declval<T*>(), true))
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
369 template <
class T, T t>
│ │ │ │ -
370 struct IsIntegralConstant<
std ::integral_constant<T, t>> :
public std::true_type
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
401 template <
typename ... T>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
403 :
public std::integral_constant<std::size_t,sizeof...(T)>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
339 template <
class V,
bool FORWARD>
│ │ │ │ +
340 void createRequests(V& sendData, V& receiveData);
│ │ │ │ +
│ │ │ │ +
345 template <
class T1,
class T2,
class V,
bool send>
│ │ │ │ +
346 void createDataTypes(
const T1& source,
const T2& destination, V& data);
│ │ │ │ +
│ │ │ │ +
351 void sendRecv(MPI_Request* req);
│ │ │ │ +
│ │ │ │ +
356 struct IndexedTypeInformation
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
366 displ =
new MPI_Aint[i];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
400 struct MPIDatatypeInformation
│ │ │ │ +
│ │ │ │ +
406 MPIDatatypeInformation(
const V& data) : data_(data)
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
411 template <
class T, T...>
│ │ │ │ -
412 struct IntegerSequenceHelper;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
420 template <
class T, T head, T... tail>
│ │ │ │ -
421 struct IntegerSequenceHelper<T, head, tail...>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
425 static constexpr auto get (std::integral_constant<std::size_t, 0>)
│ │ │ │ -
│ │ │ │ -
427 return std::integral_constant<T, head>();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
431 template <std::size_t index,
│ │ │ │ -
432 std::enable_if_t<(index > 0) and (index <
sizeof ...(tail)+1),
int > = 0>
│ │ │ │ -
433 static constexpr auto get(std::integral_constant<std::size_t, index>)
│ │ │ │ -
│ │ │ │ -
435 return IntegerSequenceHelper<T, tail...>::get(std::integral_constant<std::size_t, index-1>());
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
439 template <std::size_t index,
│ │ │ │ -
440 std::enable_if_t<(index >=
sizeof ...(tail)+1),
int > = 0>
│ │ │ │ -
441 static constexpr auto get (std::integral_constant<std::size_t, index>)
│ │ │ │ -
│ │ │ │ -
443 static_assert (index <
sizeof ...(tail)+1,
"index used in IntegerSequenceEntry exceed size" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
461 template <
class T, T... t, std::size_t index>
│ │ │ │ -
│ │ │ │ -
462 constexpr auto integerSequenceEntry (std::integer_sequence<T, t...> , std::integral_constant<std::size_t, index> i)
│ │ │ │ -
│ │ │ │ -
464 static_assert (index <
sizeof ...(t),
"index used in IntegerSequenceEntry exceed size" );
│ │ │ │ -
465 return Impl::IntegerSequenceHelper<T, t...>::get(i);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
475 template <
class IntegerSequence, std::
size_t index>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
480 template <
class T, T... t, std::size_t i>
│ │ │ │ -
│ │ │ │ -
482 :
public decltype(Impl::IntegerSequenceHelper<T, t...>::get(std::integral_constant<std::size_t, i>()))
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
constexpr auto integerSequenceEntry(std::integer_sequence< T, t... >, std::integral_constant< std::size_t, index > i)
Get entry of std::integer_sequence.
Definition typetraits.hh:462
│ │ │ │ -
typename FieldTraits< Type >::real_type real_t
Convenient access to FieldTraits<Type>::real_type.
Definition typetraits.hh:301
│ │ │ │ -
constexpr AutonomousValue< T > autoCopy(T &&v)
Autonomous copy of an expression's value for use in auto type deduction.
Definition typetraits.hh:642
│ │ │ │ -
typename AutonomousValueType< T >::type AutonomousValue
Type free of internal references that T can be converted to.
Definition typetraits.hh:558
│ │ │ │ -
typename Impl::voider< Types... >::type void_t
Is void for all valid input types. The workhorse for C++11 SFINAE-techniques.
Definition typetraits.hh:40
│ │ │ │ -
typename FieldTraits< Type >::field_type field_t
Convenient access to FieldTraits<Type>::field_type.
Definition typetraits.hh:297
│ │ │ │ -
│ │ │ │ +
414 void reserve(
int proc,
int size)
│ │ │ │ +
│ │ │ │ +
416 information_[proc].build(size);
│ │ │ │ +
│ │ │ │ +
424 void add(
int proc,
int local)
│ │ │ │ +
│ │ │ │ +
426 IndexedTypeInformation& info=information_[proc];
│ │ │ │ +
427 assert((info.elements)<info.size);
│ │ │ │ +
428 MPI_Get_address(
const_cast< void *
> (CommPolicy<V>::getAddress(data_, local)),
│ │ │ │ +
429 info.displ+info.elements);
│ │ │ │ +
430 info.length[info.elements]=CommPolicy<V>::getSize(data_, local);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
438 std::map<int,IndexedTypeInformation> information_;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
472 template <
class Data,
class Interface>
│ │ │ │ +
473 typename std::enable_if<std::is_same<SizeOne,typename CommPolicy<Data>::IndexedTypeFlag>::value,
void >::type
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
483 template <
class Data,
class Interface>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
514 template <
class GatherScatter,
class Data>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
545 template <
class GatherScatter,
class Data>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
573 template <
class GatherScatter,
class Data>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
601 template <
class GatherScatter,
class Data>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
619 typedef std::map<int,std::pair<InterfaceInformation,InterfaceInformation> >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
626 template <
class Data,
typename IndexedTypeFlag>
│ │ │ │ +
627 struct MessageSizeCalculator
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
635 struct MessageSizeCalculator<Data,
SizeOne >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
660 struct MessageSizeCalculator<Data,VariableSize>
│ │ │ │ +
│ │ │ │ +
670 inline int operator()(
const Data& data,
const InterfaceInformation& info)
const ;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
676 template <
class Data,
class GatherScatter,
bool send,
typename IndexedTypeFlag>
│ │ │ │ +
677 struct MessageGatherer
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
684 template <
class Data,
class GatherScatter,
bool send>
│ │ │ │ +
685 struct MessageGatherer<Data,GatherScatter,send,SizeOne>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
694 typedef GatherScatter Gatherer;
│ │ │ │ +
│ │ │ │ +
701 constexpr static bool forward = send;
│ │ │ │ +
│ │ │ │ +
710 inline void operator()(
const InterfaceMap& interface,
const Data& data, Type* buffer,
size_t bufferSize)
const ;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
717 template <
class Data,
class GatherScatter,
bool send>
│ │ │ │ +
718 struct MessageGatherer<Data,GatherScatter,send,VariableSize>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
727 typedef GatherScatter Gatherer;
│ │ │ │ +
│ │ │ │ +
734 constexpr static bool forward = send;
│ │ │ │ +
│ │ │ │ +
743 inline void operator()(
const InterfaceMap& interface,
const Data& data, Type* buffer,
size_t bufferSize)
const ;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
749 template <
class Data,
class GatherScatter,
bool send,
typename IndexedTypeFlag>
│ │ │ │ +
750 struct MessageScatterer
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
757 template <
class Data,
class GatherScatter,
bool send>
│ │ │ │ +
758 struct MessageScatterer<Data,GatherScatter,send,SizeOne>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
767 typedef GatherScatter Scatterer;
│ │ │ │ +
│ │ │ │ +
774 constexpr static bool forward = send;
│ │ │ │ +
│ │ │ │ +
783 inline void operator()(
const InterfaceMap& interface, Data& data, Type* buffer,
const int & proc)
const ;
│ │ │ │ +
│ │ │ │ +
789 template <
class Data,
class GatherScatter,
bool send>
│ │ │ │ +
790 struct MessageScatterer<Data,GatherScatter,send,VariableSize>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
799 typedef GatherScatter Scatterer;
│ │ │ │ +
│ │ │ │ +
806 constexpr static bool forward = send;
│ │ │ │ +
│ │ │ │ +
815 inline void operator()(
const InterfaceMap& interface, Data& data, Type* buffer,
const int & proc)
const ;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
821 struct MessageInformation
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
825 : start_(0), size_(0)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
835 MessageInformation(
size_t start,
size_t size)
│ │ │ │ +
836 : start_(start), size_(size)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
854 typedef std::map<int,std::pair<MessageInformation,MessageInformation> >
│ │ │ │ +
│ │ │ │ +
859 InformationMap messageInformation_;
│ │ │ │ +
│ │ │ │ +
867 size_t bufferSize_[2];
│ │ │ │ +
│ │ │ │ +
872 constexpr static int commTag_ = 0;
│ │ │ │ +
│ │ │ │ +
877 std::map<int,std::pair<InterfaceInformation,InterfaceInformation> > interfaces_;
│ │ │ │ +
│ │ │ │ +
879 MPI_Comm communicator_;
│ │ │ │ +
│ │ │ │ +
884 template <
class GatherScatter,
bool FORWARD,
class Data>
│ │ │ │ +
885 void sendRecv(
const Data& source, Data& target);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
903 template <
class K,
class A,
int n>
│ │ │ │ +
904 inline const void * CommPolicy<VariableBlockVector<FieldVector<K, n>, A> >::getAddress(
const Type& v,
int index)
│ │ │ │ +
│ │ │ │ +
906 return &(v[index][0]);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
909 template <
class K,
class A,
int n>
│ │ │ │ +
910 inline int CommPolicy<VariableBlockVector<FieldVector<K, n>, A> >::getSize(
const Type& v,
int index)
│ │ │ │ +
│ │ │ │ +
912 return v[index].getsize();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
916 inline const typename CopyGatherScatter<T>::IndexedType& CopyGatherScatter<T>::gather(
const T & vec, std::size_t i)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
922 inline void CopyGatherScatter<T>::scatter(T& vec,
const IndexedType& v, std::size_t i)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
928 DatatypeCommunicator<T>::DatatypeCommunicator()
│ │ │ │ +
929 : remoteIndices_(0), created_(false)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
938 DatatypeCommunicator<T>::~DatatypeCommunicator()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
944 template <
class T1,
class T2,
class V>
│ │ │ │ +
945 inline void DatatypeCommunicator<T>::build(
const RemoteIndices& remoteIndices,
│ │ │ │ +
946 const T1& source, V& sendData,
│ │ │ │ +
947 const T2& destination, V& receiveData)
│ │ │ │ +
│ │ │ │ +
949 remoteIndices_ = &remoteIndices;
│ │ │ │ +
│ │ │ │ +
951 createDataTypes<T1,T2,V,false>(source,destination, receiveData);
│ │ │ │ +
952 createDataTypes<T1,T2,V,true>(source,destination, sendData);
│ │ │ │ +
953 createRequests<V,true>(sendData, receiveData);
│ │ │ │ +
954 createRequests<V,false>(receiveData, sendData);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
959 void DatatypeCommunicator<T>::free()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
962 delete [] requests_[0];
│ │ │ │ +
963 delete [] requests_[1];
│ │ │ │ +
964 typedef MessageTypeMap::iterator iterator;
│ │ │ │ +
965 typedef MessageTypeMap::const_iterator const_iterator;
│ │ │ │ +
│ │ │ │ +
967 const const_iterator end=messageTypes.end();
│ │ │ │ +
│ │ │ │ +
969 for (iterator process = messageTypes.begin(); process != end; ++process) {
│ │ │ │ +
970 MPI_Datatype *type = &(process->second.first);
│ │ │ │ +
│ │ │ │ +
972 MPI_Finalized(&finalized);
│ │ │ │ +
973 if (*type!=MPI_DATATYPE_NULL && !finalized)
│ │ │ │ +
│ │ │ │ +
975 type = &(process->second.second);
│ │ │ │ +
976 if (*type!=MPI_DATATYPE_NULL && !finalized)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
979 messageTypes.clear();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
986 template <
class T1,
class T2,
class V,
bool send>
│ │ │ │ +
987 void DatatypeCommunicator<T>::createDataTypes(
const T1& sourceFlags,
const T2& destFlags, V& data)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
990 MPIDatatypeInformation<V> dataInfo(data);
│ │ │ │ +
991 this->
template buildInterface<RemoteIndices,T1,T2,MPIDatatypeInformation<V>,send>(*remoteIndices_,sourceFlags, destFlags, dataInfo);
│ │ │ │ +
│ │ │ │ +
993 typedef typename RemoteIndices::RemoteIndexMap::const_iterator const_iterator;
│ │ │ │ +
994 const const_iterator end=this->remoteIndices_->end();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
997 for (const_iterator process=this->remoteIndices_->begin(); process != end; ++process) {
│ │ │ │ +
998 IndexedTypeInformation& info=dataInfo.information_[process->first];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1003 for (
int i=0; i< info.elements; i++) {
│ │ │ │ +
1004 info.displ[i]-=base;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1008 MPI_Datatype* type = &( send ? messageTypes[process->first].first : messageTypes[process->first].second);
│ │ │ │ +
1009 MPI_Type_create_hindexed(info.elements, info.length, info.displ,
│ │ │ │ +
│ │ │ │ +
1011 MPI_Type_commit(type);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1017 template <
typename T>
│ │ │ │ +
1018 template <
class V,
bool createForward>
│ │ │ │ +
1019 void DatatypeCommunicator<T>::createRequests(V& sendData, V& receiveData)
│ │ │ │ +
│ │ │ │ +
1021 typedef std::map<int,std::pair<MPI_Datatype,MPI_Datatype> >::const_iterator MapIterator;
│ │ │ │ +
│ │ │ │ +
1023 static int index = createForward ? 1 : 0;
│ │ │ │ +
1024 int noMessages = messageTypes.size();
│ │ │ │ +
│ │ │ │ +
1026 requests_[index] =
new MPI_Request[2*noMessages];
│ │ │ │ +
1027 const MapIterator end = messageTypes.end();
│ │ │ │ +
│ │ │ │ +
1029 MPI_Comm_rank(MPI_COMM_WORLD, &rank);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1032 for (MapIterator process = messageTypes.begin(); process != end;
│ │ │ │ +
1033 ++process, ++request) {
│ │ │ │ +
1034 MPI_Datatype type = createForward ? process->second.second : process->second.first;
│ │ │ │ +
│ │ │ │ +
1036 MPI_Recv_init(address, 1, type, process->first, commTag_, this->remoteIndices_->communicator(), requests_[index]+request);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1041 for (MapIterator process = messageTypes.begin(); process != end;
│ │ │ │ +
1042 ++process, ++request) {
│ │ │ │ +
1043 MPI_Datatype type = createForward ? process->second.first : process->second.second;
│ │ │ │ +
│ │ │ │ +
1045 MPI_Ssend_init(address, 1, type, process->first, commTag_, this->remoteIndices_->communicator(), requests_[index]+request);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1049 template <
typename T>
│ │ │ │ +
1050 void DatatypeCommunicator<T>::forward()
│ │ │ │ +
│ │ │ │ +
1052 sendRecv(requests_[1]);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1055 template <
typename T>
│ │ │ │ +
1056 void DatatypeCommunicator<T>::backward()
│ │ │ │ +
│ │ │ │ +
1058 sendRecv(requests_[0]);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1061 template <
typename T>
│ │ │ │ +
1062 void DatatypeCommunicator<T>::sendRecv(MPI_Request* requests)
│ │ │ │ +
│ │ │ │ +
1064 int noMessages = messageTypes.size();
│ │ │ │ +
│ │ │ │ +
1066 MPI_Startall(noMessages, requests);
│ │ │ │ +
│ │ │ │ +
1068 MPI_Startall(noMessages, requests+noMessages);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1071 MPI_Status* status=
new MPI_Status[2*noMessages];
│ │ │ │ +
1072 for (
int i=0; i<2*noMessages; i++)
│ │ │ │ +
1073 status[i].MPI_ERROR=MPI_SUCCESS;
│ │ │ │ +
│ │ │ │ +
1075 int send = MPI_Waitall(noMessages, requests+noMessages, status+noMessages);
│ │ │ │ +
1076 int receive = MPI_Waitall(noMessages, requests, status);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1079 int success=1, globalSuccess=0;
│ │ │ │ +
1080 if (send==MPI_ERR_IN_STATUS) {
│ │ │ │ +
│ │ │ │ +
1082 MPI_Comm_rank(this->remoteIndices_->communicator(), &rank);
│ │ │ │ +
1083 std::cerr<<rank<<
": Error in sending :" <<std::endl;
│ │ │ │ +
│ │ │ │ +
1085 for (
int i=noMessages; i< 2*noMessages; i++)
│ │ │ │ +
1086 if (status[i].MPI_ERROR!=MPI_SUCCESS) {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1089 MPI_Error_string(status[i].MPI_ERROR, message, &messageLength);
│ │ │ │ +
1090 std::cerr<<
" source=" <<status[i].MPI_SOURCE<<
" message: " ;
│ │ │ │ +
1091 for (
int j = 0; j < messageLength; j++)
│ │ │ │ +
1092 std::cout << message[j];
│ │ │ │ +
│ │ │ │ +
1094 std::cerr<<std::endl;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1098 if (receive==MPI_ERR_IN_STATUS) {
│ │ │ │ +
│ │ │ │ +
1100 MPI_Comm_rank(this->remoteIndices_->communicator(), &rank);
│ │ │ │ +
1101 std::cerr<<rank<<
": Error in receiving!" <<std::endl;
│ │ │ │ +
│ │ │ │ +
1103 for (
int i=0; i< noMessages; i++)
│ │ │ │ +
1104 if (status[i].MPI_ERROR!=MPI_SUCCESS) {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1107 MPI_Error_string(status[i].MPI_ERROR, message, &messageLength);
│ │ │ │ +
1108 std::cerr<<
" source=" <<status[i].MPI_SOURCE<<
" message: " ;
│ │ │ │ +
1109 for (
int j = 0; j < messageLength; j++)
│ │ │ │ +
1110 std::cerr << message[j];
│ │ │ │ +
│ │ │ │ +
1112 std::cerr<<std::endl;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1116 MPI_Allreduce(&success, &globalSuccess, 1, MPI_INT, MPI_MIN, this->remoteIndices_->communicator());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1121 DUNE_THROW (CommunicationError,
"A communication error occurred!" );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1133 template <
class Data,
class Interface>
│ │ │ │ +
1134 typename std::enable_if<std::is_same<SizeOne, typename CommPolicy<Data>::IndexedTypeFlag>::value,
void >::type
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1137 interfaces_=interface.interfaces();
│ │ │ │ +
1138 communicator_=interface.communicator();
│ │ │ │ +
1139 typedef typename std::map<int,std::pair<InterfaceInformation,InterfaceInformation> >
│ │ │ │ +
1140 ::const_iterator const_iterator;
│ │ │ │ +
│ │ │ │ +
1142 const const_iterator end = interfaces_.end();
│ │ │ │ +
│ │ │ │ +
1144 MPI_Comm_rank(communicator_, &lrank);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1149 for (const_iterator interfacePair = interfaces_.begin();
│ │ │ │ +
1150 interfacePair != end; ++interfacePair) {
│ │ │ │ +
1151 int noSend = MessageSizeCalculator<Data,Flag>() (interfacePair->second.first);
│ │ │ │ +
1152 int noRecv = MessageSizeCalculator<Data,Flag>() (interfacePair->second.second);
│ │ │ │ +
1153 if (noSend + noRecv > 0)
│ │ │ │ +
1154 messageInformation_.insert(std::make_pair(interfacePair->first,
│ │ │ │ +
1155 std::make_pair(MessageInformation(bufferSize_[0],
│ │ │ │ +
│ │ │ │ +
1157 MessageInformation(bufferSize_[1],
│ │ │ │ +
│ │ │ │ +
1159 bufferSize_[0] += noSend;
│ │ │ │ +
1160 bufferSize_[1] += noRecv;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1167 buffers_[0] =
new char [bufferSize_[0]];
│ │ │ │ +
1168 buffers_[1] =
new char [bufferSize_[1]];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1171 template <
class Data,
class Interface>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1175 interfaces_=interface.interfaces();
│ │ │ │ +
1176 communicator_=interface.communicator();
│ │ │ │ +
1177 typedef typename std::map<int,std::pair<InterfaceInformation,InterfaceInformation> >
│ │ │ │ +
1178 ::const_iterator const_iterator;
│ │ │ │ +
│ │ │ │ +
1180 const const_iterator end = interfaces_.end();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1185 for (const_iterator interfacePair = interfaces_.begin();
│ │ │ │ +
1186 interfacePair != end; ++interfacePair) {
│ │ │ │ +
1187 int noSend = MessageSizeCalculator<Data,Flag>() (source, interfacePair->second.first);
│ │ │ │ +
1188 int noRecv = MessageSizeCalculator<Data,Flag>() (dest, interfacePair->second.second);
│ │ │ │ +
1189 if (noSend + noRecv > 0)
│ │ │ │ +
1190 messageInformation_.insert(std::make_pair(interfacePair->first,
│ │ │ │ +
1191 std::make_pair(MessageInformation(bufferSize_[0],
│ │ │ │ +
│ │ │ │ +
1193 MessageInformation(bufferSize_[1],
│ │ │ │ +
│ │ │ │ +
1195 bufferSize_[0] += noSend;
│ │ │ │ +
1196 bufferSize_[1] += noRecv;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1202 buffers_[0] =
new char [bufferSize_[0]];
│ │ │ │ +
1203 buffers_[1] =
new char [bufferSize_[1]];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1208 messageInformation_.clear();
│ │ │ │ +
│ │ │ │ +
1210 delete [] buffers_[0];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1213 delete [] buffers_[1];
│ │ │ │ +
1214 buffers_[0]=buffers_[1]=0;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1222 template <
class Data>
│ │ │ │ +
1223 inline int BufferedCommunicator::MessageSizeCalculator<Data,SizeOne>::operator()
│ │ │ │ +
1224 (
const InterfaceInformation& info)
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1230 template <
class Data>
│ │ │ │ +
1231 inline int BufferedCommunicator::MessageSizeCalculator<Data,SizeOne>::operator()
│ │ │ │ +
1232 (
const Data&,
const InterfaceInformation& info)
const
│ │ │ │ +
│ │ │ │ +
1234 return operator()(info);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1238 template <
class Data>
│ │ │ │ +
1239 inline int BufferedCommunicator::MessageSizeCalculator<Data, VariableSize>::operator()
│ │ │ │ +
1240 (
const Data& data,
const InterfaceInformation& info)
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1244 for (
size_t i=0; i < info.size(); i++)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1251 template <
class Data,
class GatherScatter,
bool FORWARD>
│ │ │ │ +
1252 inline void BufferedCommunicator::MessageGatherer<Data,GatherScatter,FORWARD,VariableSize>::operator()(
const InterfaceMap& interfaces,
const Data& data, Type* buffer, [[maybe_unused]]
size_t bufferSize)
const
│ │ │ │ +
│ │ │ │ +
1254 typedef typename InterfaceMap::const_iterator
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1258 MPI_Comm_rank(MPI_COMM_WORLD, &rank);
│ │ │ │ +
1259 const const_iterator end = interfaces.end();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1262 for (const_iterator interfacePair = interfaces.begin();
│ │ │ │ +
1263 interfacePair != end; ++interfacePair) {
│ │ │ │ +
1264 int size = forward ? interfacePair->second.first.size() :
│ │ │ │ +
1265 interfacePair->second.second.size();
│ │ │ │ +
│ │ │ │ +
1267 for (
int i=0; i < size; i++) {
│ │ │ │ +
1268 int local = forward ? interfacePair->second.first[i] :
│ │ │ │ +
1269 interfacePair->second.second[i];
│ │ │ │ +
1270 for (std::size_t j=0; j < CommPolicy<Data>::getSize(data, local); j++, index++) {
│ │ │ │ +
│ │ │ │ +
1272 #ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1275 buffer[index]=GatherScatter::gather(data, local, j);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1284 template <
class Data,
class GatherScatter,
bool FORWARD>
│ │ │ │ +
1285 inline void BufferedCommunicator::MessageGatherer<Data,GatherScatter,FORWARD,SizeOne>::operator()(
│ │ │ │ +
1286 const InterfaceMap& interfaces,
const Data& data, Type* buffer, [[maybe_unused]]
size_t bufferSize)
const
│ │ │ │ +
│ │ │ │ +
1288 typedef typename InterfaceMap::const_iterator
│ │ │ │ +
│ │ │ │ +
1290 const const_iterator end = interfaces.end();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1294 MPI_Comm_rank(MPI_COMM_WORLD, &rank);
│ │ │ │ +
│ │ │ │ +
1296 for (const_iterator interfacePair = interfaces.begin();
│ │ │ │ +
1297 interfacePair != end; ++interfacePair) {
│ │ │ │ +
1298 size_t size = FORWARD ? interfacePair->second.first.size() :
│ │ │ │ +
1299 interfacePair->second.second.size();
│ │ │ │ +
│ │ │ │ +
1301 for (
size_t i=0; i < size; i++) {
│ │ │ │ +
│ │ │ │ +
1303 #ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1307 buffer[index++] = GatherScatter::gather(data, FORWARD ? interfacePair->second.first[i] :
│ │ │ │ +
1308 interfacePair->second.second[i]);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1315 template <
class Data,
class GatherScatter,
bool FORWARD>
│ │ │ │ +
1316 inline void BufferedCommunicator::MessageScatterer<Data,GatherScatter,FORWARD,VariableSize>::operator()(
const InterfaceMap& interfaces, Data& data, Type* buffer,
const int & proc)
const
│ │ │ │ +
│ │ │ │ +
1318 typedef typename InterfaceMap::value_type::second_type::first_type Information;
│ │ │ │ +
1319 const typename InterfaceMap::const_iterator infoPair = interfaces.find(proc);
│ │ │ │ +
│ │ │ │ +
1321 assert(infoPair!=interfaces.end());
│ │ │ │ +
│ │ │ │ +
1323 const Information& info = FORWARD ? infoPair->second.second :
│ │ │ │ +
1324 infoPair->second.first;
│ │ │ │ +
│ │ │ │ +
1326 for (
size_t i=0, index=0; i < info.size(); i++) {
│ │ │ │ +
1327 for (
size_t j=0; j < CommPolicy<Data>::getSize(data, info[i]); j++)
│ │ │ │ +
1328 GatherScatter::scatter(data, buffer[index++], info[i], j);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1333 template <
class Data,
class GatherScatter,
bool FORWARD>
│ │ │ │ +
1334 inline void BufferedCommunicator::MessageScatterer<Data,GatherScatter,FORWARD,SizeOne>::operator()(
const InterfaceMap& interfaces, Data& data, Type* buffer,
const int & proc)
const
│ │ │ │ +
│ │ │ │ +
1336 typedef typename InterfaceMap::value_type::second_type::first_type Information;
│ │ │ │ +
1337 const typename InterfaceMap::const_iterator infoPair = interfaces.find(proc);
│ │ │ │ +
│ │ │ │ +
1339 assert(infoPair!=interfaces.end());
│ │ │ │ +
│ │ │ │ +
1341 const Information& info = FORWARD ? infoPair->second.second :
│ │ │ │ +
1342 infoPair->second.first;
│ │ │ │ +
│ │ │ │ +
1344 for (
size_t i=0; i < info.size(); i++) {
│ │ │ │ +
1345 GatherScatter::scatter(data, buffer[i], info[i]);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1350 template <
class GatherScatter,
class Data>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1353 this->
template sendRecv<GatherScatter,true>(data, data);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1357 template <
class GatherScatter,
class Data>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1360 this->
template sendRecv<GatherScatter,false>(data, data);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1364 template <
class GatherScatter,
class Data>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1367 this->
template sendRecv<GatherScatter,true>(source, dest);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1371 template <
class GatherScatter,
class Data>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1374 this->
template sendRecv<GatherScatter,false>(dest, source);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1378 template <
class GatherScatter,
bool FORWARD,
class Data>
│ │ │ │ +
1379 void BufferedCommunicator::sendRecv(
const Data& source, Data& dest)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1383 MPI_Comm_rank(MPI_COMM_WORLD,&rank);
│ │ │ │ +
1384 MPI_Comm_rank(MPI_COMM_WORLD,&lrank);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1387 Type *sendBuffer, *recvBuffer;
│ │ │ │ +
1388 size_t sendBufferSize;
│ │ │ │ +
│ │ │ │ +
1390 size_t recvBufferSize;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1394 sendBuffer =
reinterpret_cast< Type*
> (buffers_[0]);
│ │ │ │ +
1395 sendBufferSize = bufferSize_[0];
│ │ │ │ +
1396 recvBuffer =
reinterpret_cast< Type*
> (buffers_[1]);
│ │ │ │ +
│ │ │ │ +
1398 recvBufferSize = bufferSize_[1];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1401 sendBuffer =
reinterpret_cast< Type*
> (buffers_[1]);
│ │ │ │ +
1402 sendBufferSize = bufferSize_[1];
│ │ │ │ +
1403 recvBuffer =
reinterpret_cast< Type*
> (buffers_[0]);
│ │ │ │ +
│ │ │ │ +
1405 recvBufferSize = bufferSize_[0];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1410 MessageGatherer<Data,GatherScatter,FORWARD,Flag>() (interfaces_, source, sendBuffer, sendBufferSize);
│ │ │ │ +
│ │ │ │ +
1412 MPI_Request* sendRequests =
new MPI_Request[messageInformation_.size()];
│ │ │ │ +
1413 MPI_Request* recvRequests =
new MPI_Request[messageInformation_.size()];
│ │ │ │ +
│ │ │ │ +
1415 size_t numberOfRealRecvRequests = 0;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1418 typedef typename InformationMap::const_iterator const_iterator;
│ │ │ │ +
│ │ │ │ +
1420 const const_iterator end = messageInformation_.end();
│ │ │ │ +
│ │ │ │ +
1422 int * processMap =
new int [messageInformation_.size()];
│ │ │ │ +
│ │ │ │ +
1424 for (const_iterator info = messageInformation_.begin(); info != end; ++info, ++i) {
│ │ │ │ +
1425 processMap[i]=info->first;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1428 Dune::dvverb <<rank<<
": receiving " <<info->second.second.size_<<
" from " <<info->first<<std::endl;
│ │ │ │ +
1429 if (info->second.second.size_) {
│ │ │ │ +
1430 MPI_Irecv(recvBuffer+info->second.second.start_, info->second.second.size_,
│ │ │ │ +
1431 MPI_BYTE, info->first, commTag_, communicator_,
│ │ │ │ +
│ │ │ │ +
1433 numberOfRealRecvRequests += 1;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1436 recvRequests[i]=MPI_REQUEST_NULL;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1440 Dune::dvverb <<rank<<
": receiving " <<info->second.first.size_<<
" to " <<info->first<<std::endl;
│ │ │ │ +
1441 if (info->second.first.size_) {
│ │ │ │ +
1442 MPI_Irecv(recvBuffer+info->second.first.start_, info->second.first.size_,
│ │ │ │ +
1443 MPI_BYTE, info->first, commTag_, communicator_,
│ │ │ │ +
│ │ │ │ +
1445 numberOfRealRecvRequests += 1;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1448 recvRequests[i]=MPI_REQUEST_NULL;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1455 for (const_iterator info = messageInformation_.begin(); info != end; ++info, ++i)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1458 Dune::dvverb <<rank<<
": sending " <<info->second.first.size_<<
" to " <<info->first<<std::endl;
│ │ │ │ +
│ │ │ │ +
1460 if (info->second.first.size_)
│ │ │ │ +
1461 MPI_Issend(sendBuffer+info->second.first.start_, info->second.first.size_,
│ │ │ │ +
1462 MPI_BYTE, info->first, commTag_, communicator_,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1466 sendRequests[i]=MPI_REQUEST_NULL;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1469 Dune::dvverb <<rank<<
": sending " <<info->second.second.size_<<
" to " <<info->first<<std::endl;
│ │ │ │ +
1470 if (info->second.second.size_)
│ │ │ │ +
1471 MPI_Issend(sendBuffer+info->second.second.start_, info->second.second.size_,
│ │ │ │ +
1472 MPI_BYTE, info->first, commTag_, communicator_,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1476 sendRequests[i]=MPI_REQUEST_NULL;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1482 int finished = MPI_UNDEFINED;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1486 for (i=0; i< numberOfRealRecvRequests; i++) {
│ │ │ │ +
1487 status.MPI_ERROR=MPI_SUCCESS;
│ │ │ │ +
1488 MPI_Waitany(messageInformation_.size(), recvRequests, &finished, &status);
│ │ │ │ +
1489 assert(finished != MPI_UNDEFINED);
│ │ │ │ +
│ │ │ │ +
1491 if (status.MPI_ERROR==MPI_SUCCESS) {
│ │ │ │ +
1492 int & proc = processMap[finished];
│ │ │ │ +
1493 typename InformationMap::const_iterator infoIter = messageInformation_.find(proc);
│ │ │ │ +
1494 assert(infoIter != messageInformation_.end());
│ │ │ │ +
│ │ │ │ +
1496 MessageInformation info = (FORWARD) ? infoIter->second.second : infoIter->second.first;
│ │ │ │ +
1497 assert(info.start_+info.size_ <= recvBufferSize);
│ │ │ │ +
│ │ │ │ +
1499 MessageScatterer<Data,GatherScatter,FORWARD,Flag>() (interfaces_, dest, recvBuffer+info.start_, proc);
│ │ │ │ +
│ │ │ │ +
1501 std::cerr<<rank<<
": MPI_Error occurred while receiving message from " <<processMap[finished]<<std::endl;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1506 MPI_Status recvStatus;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1509 for (i=0; i< messageInformation_.size(); i++)
│ │ │ │ +
1510 if (MPI_SUCCESS!=MPI_Wait(sendRequests+i, &recvStatus)) {
│ │ │ │ +
1511 std::cerr<<rank<<
": MPI_Error occurred while sending message to " <<processMap[finished]<<std::endl;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1521 delete [] processMap;
│ │ │ │ +
1522 delete [] sendRequests;
│ │ │ │ +
1523 delete [] recvRequests;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
Classes describing a distributed indexset.
│ │ │ │ +
A few common exception classes.
│ │ │ │ +
Standard Dune debug streams.
│ │ │ │ +
#define DUNE_THROW(E, m)
Definition exceptions.hh:218
│ │ │ │ +
DVVerbType dvverb(std::cout)
stream for very verbose output.
Definition stdstreams.hh:95
│ │ │ │
Dune namespace.
Definition alignedallocator.hh:13
│ │ │ │ -
Reference get(const RAPropertyMapHelper< Reference, PropertyMap > &pmap, const Key &key)
Definition propertymap.hh:84
│ │ │ │ -
Whether this type acts as a scalar in the context of (hierarchically blocked) containers.
Definition typetraits.hh:194
│ │ │ │ -
T field_type
export the type representing the field
Definition ftraits.hh:28
│ │ │ │ -
T real_type
export the type representing the real type of the field
Definition ftraits.hh:30
│ │ │ │ -
Just an empty class.
Definition typetraits.hh:55
│ │ │ │ -
Checks whether two types are interoperable.
Definition typetraits.hh:65
│ │ │ │ -
static constexpr bool value
True if either a conversion from T1 to T2 or vice versa exists.
Definition typetraits.hh:70
│ │ │ │ -
Enable typedef if two types are interoperable.
Definition typetraits.hh:81
│ │ │ │ -
template which always yields a false value
Definition typetraits.hh:124
│ │ │ │ -
template which always yields a true value
Definition typetraits.hh:134
│ │ │ │ -
Check if a type is callable with ()-operator and given arguments.
Definition typetraits.hh:162
│ │ │ │ -
Whether this type has a value of NaN.
Definition typetraits.hh:212
│ │ │ │ -
Type trait to determine whether an instance of T has an operator[](I), i.e. whether it can be indexed...
Definition typetraits.hh:250
│ │ │ │ -
typetrait to check that a class has begin() and end() members
Definition typetraits.hh:273
│ │ │ │ -
Check if T is a std::tuple<...>
Definition typetraits.hh:329
│ │ │ │ -
Check if T derived from a std::tuple<...>
Definition typetraits.hh:357
│ │ │ │ -
Check if T is an std::integral_constant<I, i>
Definition typetraits.hh:384
│ │ │ │ -
Compute size of variadic type list.
Definition typetraits.hh:404
│ │ │ │ -
Get entry of std::integer_sequence.
Definition typetraits.hh:476
│ │ │ │ -
Type free of internal references that T can be converted to.
Definition typetraits.hh:501
│ │ │ │ -
T type
Definition typetraits.hh:501
│ │ │ │ -
bool type
Definition typetraits.hh:523
│ │ │ │ +
Default exception class for I/O errors.
Definition exceptions.hh:231
│ │ │ │ +
Flag for marking indexed data structures where data at each index is of the same size.
Definition communicator.hh:110
│ │ │ │ +
Flag for marking indexed data structures where the data at each index may be a variable multiple of a...
Definition communicator.hh:118
│ │ │ │ +
Default policy used for communicating an indexed type.
Definition communicator.hh:128
│ │ │ │ +
V::value_type IndexedType
The type we get at each index with operator[].
Definition communicator.hh:147
│ │ │ │ +
static int getSize(const V &, int index)
Get the number of primitive elements at that index.
│ │ │ │ +
SizeOne IndexedTypeFlag
Whether the indexed type has variable size or there is always one value at each index.
Definition communicator.hh:153
│ │ │ │ +
static const void * getAddress(const V &v, int index)
Get the address of entry at an index.
│ │ │ │ +
V Type
The type the policy is for.
Definition communicator.hh:140
│ │ │ │ +
Definition communicator.hh:173
│ │ │ │ +
Definition communicator.hh:175
│ │ │ │ +
static int getSize(const Type &v, int i)
│ │ │ │ +
VariableSize IndexedTypeFlag
Definition communicator.hh:184
│ │ │ │ +
VariableBlockVector< FieldVector< K, n >, A > Type
Definition communicator.hh:180
│ │ │ │ +
static const void * getAddress(const Type &v, int i)
│ │ │ │ +
Type::B IndexedType
Definition communicator.hh:182
│ │ │ │ +
Error thrown if there was a problem with the communication.
Definition communicator.hh:195
│ │ │ │ +
GatherScatter default implementation that just copies data.
Definition communicator.hh:202
│ │ │ │ +
static void scatter(T &vec, const IndexedType &v, std::size_t i)
│ │ │ │ +
CommPolicy< T >::IndexedType IndexedType
Definition communicator.hh:203
│ │ │ │ +
static const IndexedType & gather(const T &vec, std::size_t i)
│ │ │ │ +
A communicator that uses buffers to gather and scatter the data to be send or received.
Definition communicator.hh:458
│ │ │ │ +
void backward(Data &data)
Backward send where target and source are the same.
│ │ │ │ +
BufferedCommunicator()
Constructor.
│ │ │ │ +
~BufferedCommunicator()
Destructor.
│ │ │ │ +
void forward(const Data &source, Data &dest)
Send from source to target.
│ │ │ │ +
void free()
Free the allocated memory (i.e. buffers and message information.
│ │ │ │ +
std::enable_if< std::is_same< SizeOne, typenameCommPolicy< Data >::IndexedTypeFlag >::value, void >::type build(const Interface &interface)
Build the buffers and information for the communication process.
│ │ │ │ +
void backward(Data &source, const Data &dest)
Communicate in the reverse direction, i.e. send from target to source.
│ │ │ │ +
void build(const Data &source, const Data &target, const Interface &interface)
Build the buffers and information for the communication process.
│ │ │ │ +
void forward(Data &data)
Forward send where target and source are the same.
│ │ │ │ +
Manager class for the mapping between local indices and globally unique indices.
Definition indexset.hh:218
│ │ │ │ +
Base class of all classes representing a communication interface.
Definition parallel/interface.hh:35
│ │ │ │ +
Information describing an interface.
Definition parallel/interface.hh:101
│ │ │ │ +
Communication interface between remote and local indices.
Definition parallel/interface.hh:209
│ │ │ │ +
An index present on the local process.
Definition localindex.hh:35
│ │ │ │ +
The indices present on remote processes.
Definition remoteindices.hh:189
│ │ │ │ +
ParallelIndexSet::GlobalIndex GlobalIndex
The type of the global index.
Definition remoteindices.hh:215
│ │ │ │ +
LocalIndex::Attribute Attribute
The type of the attribute.
Definition remoteindices.hh:226
│ │ │ │ +
ParallelIndexSet::LocalIndex LocalIndex
The type of the local index.
Definition remoteindices.hh:221
│ │ │ │ +
Provides classes for building the communication interface between remote indices.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -7,464 +7,1208 @@
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * dune
│ │ │ │ │ * common
│ │ │ │ │ -typetraits.hh
│ │ │ │ │ + * parallel
│ │ │ │ │ +communicator.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ 3// SPDX-FileCopyrightInfo: Copyright (C) DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 4// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
│ │ │ │ │ - 5#ifndef DUNE_TYPETRAITS_HH
│ │ │ │ │ - 6#define DUNE_TYPETRAITS_HH
│ │ │ │ │ + 5#ifndef DUNE_COMMUNICATOR
│ │ │ │ │ + 6#define DUNE_COMMUNICATOR
│ │ │ │ │ 7
│ │ │ │ │ - 8#include
│ │ │ │ │ - 9#include
│ │ │ │ │ - 10#include
│ │ │ │ │ - 11#include
│ │ │ │ │ - 12
│ │ │ │ │ - 13namespace Dune
│ │ │ │ │ - 14{
│ │ │ │ │ - 15
│ │ │ │ │ - 16 namespace Impl
│ │ │ │ │ - 17 {
│ │ │ │ │ - 19
│ │ │ │ │ - 23 template
│ │ │ │ │ - 24 struct voider
│ │ │ │ │ - 25 {
│ │ │ │ │ - 26 using type = void;
│ │ │ │ │ - 27 };
│ │ │ │ │ - 28 }
│ │ │ │ │ - 29
│ │ │ │ │ - 31
│ │ │ │ │ - 39 template
│ │ │ │ │ -40 using void_t = typename Impl::voider::type;
│ │ │ │ │ - 41
│ │ │ │ │ -55 struct Empty {};
│ │ │ │ │ - 56
│ │ │ │ │ - 63 template
│ │ │ │ │ -64 struct IsInteroperable
│ │ │ │ │ - 65 {
│ │ │ │ │ -70 constexpr static bool value = std::is_convertible::value || std::
│ │ │ │ │ -is_convertible::value;
│ │ │ │ │ - 71 };
│ │ │ │ │ - 72
│ │ │ │ │ - 78 template
│ │ │ │ │ -79 struct EnableIfInterOperable
│ │ │ │ │ - 80 : public std::enable_if::value, Type>
│ │ │ │ │ - 81 {};
│ │ │ │ │ - 82
│ │ │ │ │ - 100
│ │ │ │ │ - 116
│ │ │ │ │ - 123 template
│ │ │ │ │ -124 struct AlwaysFalse : public std::false_type {};
│ │ │ │ │ - 125
│ │ │ │ │ - 133 template
│ │ │ │ │ -134 struct AlwaysTrue : public std::true_type {};
│ │ │ │ │ - 135
│ │ │ │ │ - 161 template
│ │ │ │ │ -162 struct IsCallable;
│ │ │ │ │ - 163
│ │ │ │ │ - 168 template
│ │ │ │ │ -169 struct IsCallable
│ │ │ │ │ - 170 : public std::bool_constant<
│ │ │ │ │ - 171 std::is_invocable_r_v
│ │ │ │ │ - 172 && !std::is_member_pointer_v>
│ │ │ │ │ - 173 > {};
│ │ │ │ │ + 8#if HAVE_MPI
│ │ │ │ │ + 9
│ │ │ │ │ + 10#include
│ │ │ │ │ + 11#include
│ │ │ │ │ + 12#include
│ │ │ │ │ + 13#include
│ │ │ │ │ + 14#include
│ │ │ │ │ + 15#include
│ │ │ │ │ + 16
│ │ │ │ │ + 17#include
│ │ │ │ │ + 18
│ │ │ │ │ + 19#include
│ │ │ │ │ + 20#include
│ │ │ │ │ + 21#include
│ │ │ │ │ + 22#include
│ │ │ │ │ + 23
│ │ │ │ │ + 24namespace Dune
│ │ │ │ │ + 25{
│ │ │ │ │ +109 struct SizeOne
│ │ │ │ │ + 110 {};
│ │ │ │ │ + 111
│ │ │ │ │ +117 struct VariableSize
│ │ │ │ │ + 118 {};
│ │ │ │ │ + 119
│ │ │ │ │ + 120
│ │ │ │ │ + 126 template
│ │ │ │ │ +127 struct CommPolicy
│ │ │ │ │ + 128 {
│ │ │ │ │ +140 typedef V Type;
│ │ │ │ │ + 141
│ │ │ │ │ +147 typedef typename V::value_type IndexedType;
│ │ │ │ │ + 148
│ │ │ │ │ +153 typedef SizeOne IndexedTypeFlag;
│ │ │ │ │ + 154
│ │ │ │ │ +163 static const void* getAddress(const V& v, int index);
│ │ │ │ │ + 164
│ │ │ │ │ +170 static int getSize(const V&, int index);
│ │ │ │ │ + 171 };
│ │ │ │ │ + 172
│ │ │ │ │ +173 template class FieldVector;
│ │ │ │ │ 174
│ │ │ │ │ - 177
│ │ │ │ │ - 192 template
│ │ │ │ │ -193 struct IsNumber
│ │ │ │ │ - 194 : public std::integral_constant::value> {
│ │ │ │ │ - 195 };
│ │ │ │ │ +175 template class VariableBlockVector;
│ │ │ │ │ + 176
│ │ │ │ │ + 177 template
│ │ │ │ │ +178 struct CommPolicy, A> >
│ │ │ │ │ + 179 {
│ │ │ │ │ +180 typedef VariableBlockVector, A> Type;
│ │ │ │ │ + 181
│ │ │ │ │ +182 typedef typename Type::B IndexedType;
│ │ │ │ │ + 183
│ │ │ │ │ +184 typedef VariableSize IndexedTypeFlag;
│ │ │ │ │ + 185
│ │ │ │ │ +186 static const void* getAddress(const Type& v, int i);
│ │ │ │ │ + 187
│ │ │ │ │ +188 static int getSize(const Type& v, int i);
│ │ │ │ │ + 189 };
│ │ │ │ │ + 190
│ │ │ │ │ +194 class CommunicationError : public IOError
│ │ │ │ │ + 195 {};
│ │ │ │ │ 196
│ │ │ │ │ - 197#ifndef DOXYGEN
│ │ │ │ │ - 198
│ │ │ │ │ - 199 template
│ │ │ │ │ - 200 struct IsNumber>
│ │ │ │ │ - 201 : public std::integral_constant::value> {
│ │ │ │ │ - 202 };
│ │ │ │ │ - 203
│ │ │ │ │ - 204#endif // DOXYGEN
│ │ │ │ │ - 205
│ │ │ │ │ - 207
│ │ │ │ │ - 210 template
│ │ │ │ │ -211 struct HasNaN
│ │ │ │ │ - 212 : public std::integral_constant::value> {
│ │ │ │ │ - 213 };
│ │ │ │ │ - 214
│ │ │ │ │ - 215#ifndef DOXYGEN
│ │ │ │ │ - 216
│ │ │ │ │ - 217 template
│ │ │ │ │ - 218 struct HasNaN>
│ │ │ │ │ - 219 : public std::integral_constant::value> {
│ │ │ │ │ - 220 };
│ │ │ │ │ - 221
│ │ │ │ │ - 222#endif // DOXYGEN
│ │ │ │ │ - 223
│ │ │ │ │ - 224#ifndef DOXYGEN
│ │ │ │ │ - 225
│ │ │ │ │ - 226 namespace Impl {
│ │ │ │ │ - 227
│ │ │ │ │ - 228 template
│ │ │ │ │ - 229 struct IsIndexable
│ │ │ │ │ - 230 : public std::false_type
│ │ │ │ │ - 231 {};
│ │ │ │ │ - 232
│ │ │ │ │ - 233 template
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -6,33 +6,33 @@
│ │ │ │ │ dune-common 2.9.0
│ │ │ │ │
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * dune
│ │ │ │ │ * common
│ │ │ │ │ -Namespaces | Functions
│ │ │ │ │ -dynmatrixev.hh File Reference
│ │ │ │ │ -utility functions to compute eigenvalues for dense matrices. More...
│ │ │ │ │ -#include