,
│ │ │ │ │ -MPIPack>::value>> {
│ │ │ │ │ - 197 protected:
│ │ │ │ │ -198 friend auto getMPIData(P& t);
│ │ │ │ │ -199 MPIData(P& t) :
│ │ │ │ │ - 200 data_(t)
│ │ │ │ │ - 201 {}
│ │ │ │ │ - 202 public:
│ │ │ │ │ -203 static constexpr bool static_size = std::is_const
::value;
│ │ │ │ │ - 204
│ │ │ │ │ -205 void* ptr() {
│ │ │ │ │ - 206 return (void*) data_._buffer.data();
│ │ │ │ │ - 207 }
│ │ │ │ │ - 208
│ │ │ │ │ -209 int size() {
│ │ │ │ │ - 210 return data_.size();
│ │ │ │ │ - 211 }
│ │ │ │ │ - 212
│ │ │ │ │ -213 MPI_Datatype type() const{
│ │ │ │ │ - 214 return MPI_PACKED;
│ │ │ │ │ - 215 }
│ │ │ │ │ - 216
│ │ │ │ │ -217 void resize(int size){
│ │ │ │ │ - 218 data_.resize(size);
│ │ │ │ │ - 219 }
│ │ │ │ │ - 220 protected:
│ │ │ │ │ -221 P& data_;
│ │ │ │ │ - 222 };
│ │ │ │ │ - 223
│ │ │ │ │ - 224} // end namespace Dune
│ │ │ │ │ - 225
│ │ │ │ │ - 226#endif
│ │ │ │ │ - 227#endif
│ │ │ │ │ -mpicommunication.hh
│ │ │ │ │ -Implements an utility class that provides MPI's collective communication
│ │ │ │ │ -methods.
│ │ │ │ │ -mpidata.hh
│ │ │ │ │ -Interface class to translate objects to a MPI_Datatype, void* and size used for
│ │ │ │ │ -MPI calls.
│ │ │ │ │ -std
│ │ │ │ │ -STL namespace.
│ │ │ │ │ + 5#ifndef DUNE_CLASSNAME_HH
│ │ │ │ │ + 6#define DUNE_CLASSNAME_HH
│ │ │ │ │ + 7
│ │ │ │ │ + 13#include
│ │ │ │ │ + 14#include
│ │ │ │ │ + 15#include
│ │ │ │ │ + 16#include
│ │ │ │ │ + 17#include
│ │ │ │ │ + 18
│ │ │ │ │ + 19#if __has_include() && !DISABLE_CXA_DEMANGLE
│ │ │ │ │ + 20#define HAVE_CXA_DEMANGLE 1
│ │ │ │ │ + 21#include
│ │ │ │ │ + 22#endif // #if HAVE_CXA_DEMANGLE
│ │ │ │ │ + 23
│ │ │ │ │ + 24namespace Dune {
│ │ │ │ │ + 25
│ │ │ │ │ + 26 namespace Impl {
│ │ │ │ │ + 27
│ │ │ │ │ + 28 inline std::string demangle(std::string name)
│ │ │ │ │ + 29 {
│ │ │ │ │ + 30#if HAVE_CXA_DEMANGLE
│ │ │ │ │ + 31 int status;
│ │ │ │ │ + 32 std::unique_ptr
│ │ │ │ │ + 33 demangled(abi::__cxa_demangle(name.c_str(), nullptr, nullptr, &status),
│ │ │ │ │ + 34 std::free);
│ │ │ │ │ + 35 if( demangled )
│ │ │ │ │ + 36 name = demangled.get();
│ │ │ │ │ + 37#endif // #if HAVE_CXA_DEMANGLE
│ │ │ │ │ + 38 return name;
│ │ │ │ │ + 39 }
│ │ │ │ │ + 40 }
│ │ │ │ │ + 41
│ │ │ │ │ + 43 /*
│ │ │ │ │ + 44 * \ingroup CxxUtilities
│ │ │ │ │ + 45 */
│ │ │ │ │ + 46 template
│ │ │ │ │ +47 std::string className ()
│ │ │ │ │ + 48 {
│ │ │ │ │ + 49 typedef typename std::remove_reference::type TR;
│ │ │ │ │ + 50 std::string className = Impl::demangle( typeid( TR ).name() );
│ │ │ │ │ + 51 if (std::is_const::value)
│ │ │ │ │ + 52 className += " const";
│ │ │ │ │ + 53 if (std::is_volatile ::value)
│ │ │ │ │ + 54 className += " volatile";
│ │ │ │ │ + 55 if (std::is_lvalue_reference::value)
│ │ │ │ │ + 56 className += "&";
│ │ │ │ │ + 57 else if (std::is_rvalue_reference::value)
│ │ │ │ │ + 58 className += "&&";
│ │ │ │ │ + 59 return className;
│ │ │ │ │ + 60 }
│ │ │ │ │ + 61
│ │ │ │ │ + 63 /*
│ │ │ │ │ + 64 * \ingroup CxxUtilities
│ │ │ │ │ + 65 */
│ │ │ │ │ + 66 template
│ │ │ │ │ +67 std::string className ( T&& v)
│ │ │ │ │ + 68 {
│ │ │ │ │ + 69 typedef typename std::remove_reference::type TR;
│ │ │ │ │ + 70 std::string className = Impl::demangle( typeid(v).name() );
│ │ │ │ │ + 71 if (std::is_const::value)
│ │ │ │ │ + 72 className += " const";
│ │ │ │ │ + 73 if (std::is_volatile ::value)
│ │ │ │ │ + 74 className += " volatile";
│ │ │ │ │ + 75 return className;
│ │ │ │ │ + 76 }
│ │ │ │ │ + 77} // namespace Dune
│ │ │ │ │ + 78
│ │ │ │ │ + 79#endif // DUNE_CLASSNAME_HH
│ │ │ │ │ Dune
│ │ │ │ │ Dune namespace.
│ │ │ │ │ Definition: alignedallocator.hh:13
│ │ │ │ │ -Dune::getMPIData
│ │ │ │ │ -auto getMPIData(T &t)
│ │ │ │ │ -Definition: mpidata.hh:43
│ │ │ │ │ -Dune::Communication<_MPI_Comm_>
│ │ │ │ │ -Specialization of Communication for MPI.
│ │ │ │ │ -Definition: mpicommunication.hh:108
│ │ │ │ │ -Dune::MPIData
│ │ │ │ │ -Definition: mpidata.hh:50
│ │ │ │ │ -Dune::MPIData::data_
│ │ │ │ │ -T & data_
│ │ │ │ │ -Definition: mpidata.hh:53
│ │ │ │ │ -Dune::MPIData::size
│ │ │ │ │ -int size() const
│ │ │ │ │ -Definition: mpidata.hh:67
│ │ │ │ │ -Dune::MPIData::static_size
│ │ │ │ │ -static constexpr bool static_size
│ │ │ │ │ -Definition: mpidata.hh:65
│ │ │ │ │ -Dune::MPIPack
│ │ │ │ │ -Definition: mpipack.hh:32
│ │ │ │ │ -Dune::MPIPack::enlarge
│ │ │ │ │ -void enlarge(int s)
│ │ │ │ │ -Enlarges the internal buffer.
│ │ │ │ │ -Definition: mpipack.hh:147
│ │ │ │ │ -Dune::MPIPack::operator>>
│ │ │ │ │ -friend MPIPack & operator>>(MPIPack &p, T &t)
│ │ │ │ │ -Unpacks data from the object.
│ │ │ │ │ -Definition: mpipack.hh:119
│ │ │ │ │ -Dune::MPIPack::operator<<
│ │ │ │ │ -friend MPIPack & operator<<(MPIPack &p, const T &t)
│ │ │ │ │ -Packs the data into the object. Enlarges the internal buffer if necessary.
│ │ │ │ │ -Definition: mpipack.hh:112
│ │ │ │ │ -Dune::MPIPack::operator!=
│ │ │ │ │ -friend bool operator!=(const MPIPack &a, const MPIPack &b)
│ │ │ │ │ -Definition: mpipack.hh:189
│ │ │ │ │ -Dune::MPIPack::size
│ │ │ │ │ -size_t size() const
│ │ │ │ │ -Returns the size of the internal buffer.
│ │ │ │ │ -Definition: mpipack.hh:153
│ │ │ │ │ -Dune::MPIPack::operator=
│ │ │ │ │ -MPIPack & operator=(const MPIPack &other)=delete
│ │ │ │ │ -Dune::MPIPack::MPIPack
│ │ │ │ │ -MPIPack(Communication< MPI_Comm > comm, std::size_t size=0)
│ │ │ │ │ -Definition: mpipack.hh:40
│ │ │ │ │ -Dune::MPIPack::pack
│ │ │ │ │ -void pack(const T &data)
│ │ │ │ │ -Packs the data into the object. Enlarges the internal buffer if necessary.
│ │ │ │ │ -Definition: mpipack.hh:58
│ │ │ │ │ -Dune::MPIPack::unpack
│ │ │ │ │ -auto unpack(T &data) -> std::enable_if_t
│ │ │ │ │ -Unpacks data from the object.
│ │ │ │ │ -Definition: mpipack.hh:95
│ │ │ │ │ -Dune::MPIPack::unpack
│ │ │ │ │ -auto unpack(T &data) -> std::enable_if_t< decltype(getMPIData(data))::
│ │ │ │ │ -static_size, void >
│ │ │ │ │ -Unpacks data from the object.
│ │ │ │ │ -Definition: mpipack.hh:81
│ │ │ │ │ -Dune::MPIPack::operator==
│ │ │ │ │ -friend bool operator==(const MPIPack &a, const MPIPack &b)
│ │ │ │ │ -Definition: mpipack.hh:186
│ │ │ │ │ -Dune::MPIPack::MPIPack
│ │ │ │ │ -MPIPack(const MPIPack &)=delete
│ │ │ │ │ -Dune::MPIPack::seek
│ │ │ │ │ -void seek(int p)
│ │ │ │ │ -Sets the position in the buffer where the next pack/unpack operation should
│ │ │ │ │ -take place.
│ │ │ │ │ -Definition: mpipack.hh:160
│ │ │ │ │ -Dune::MPIPack::eof
│ │ │ │ │ -bool eof() const
│ │ │ │ │ -Checks whether the end of the buffer is reached.
│ │ │ │ │ -Definition: mpipack.hh:173
│ │ │ │ │ -Dune::MPIPack::resize
│ │ │ │ │ -void resize(size_t size)
│ │ │ │ │ -Resizes the internal buffer.
│ │ │ │ │ -Definition: mpipack.hh:141
│ │ │ │ │ -Dune::MPIPack::tell
│ │ │ │ │ -int tell() const
│ │ │ │ │ -Gets the position in the buffer where the next pack/unpack operation should
│ │ │ │ │ -take place.
│ │ │ │ │ -Definition: mpipack.hh:167
│ │ │ │ │ -Dune::MPIPack::MPIPack
│ │ │ │ │ -MPIPack(MPIPack &&)=default
│ │ │ │ │ -Dune::MPIPack::read
│ │ │ │ │ -MPIPack & read(T &t)
│ │ │ │ │ -Unpacks data from the object.
│ │ │ │ │ -Definition: mpipack.hh:126
│ │ │ │ │ -Dune::MPIPack::getPackSize
│ │ │ │ │ -static int getPackSize(int len, const MPI_Comm &comm, const MPI_Datatype &dt)
│ │ │ │ │ -Returns the size of the data needed to store the data in an MPIPack. See
│ │ │ │ │ -MPI_Pack_size.
│ │ │ │ │ -Definition: mpipack.hh:180
│ │ │ │ │ -Dune::MPIPack::write
│ │ │ │ │ -MPIPack & write(const T &t)
│ │ │ │ │ -Packs the data into the object. Enlarges the internal buffer if necessary.
│ │ │ │ │ -Definition: mpipack.hh:133
│ │ │ │ │ -Dune::MPIData<_P,_std::enable_if_t<_std::is_same<_std::remove_const_t<_P_>,
│ │ │ │ │ -MPIPack_>::value_>_>::type
│ │ │ │ │ -MPI_Datatype type() const
│ │ │ │ │ -Definition: mpipack.hh:213
│ │ │ │ │ -Dune::MPIData<_P,_std::enable_if_t<_std::is_same<_std::remove_const_t<_P_>,
│ │ │ │ │ -MPIPack_>::value_>_>::MPIData
│ │ │ │ │ -MPIData(P &t)
│ │ │ │ │ -Definition: mpipack.hh:199
│ │ │ │ │ -Dune::MPIData<_P,_std::enable_if_t<_std::is_same<_std::remove_const_t<_P_>,
│ │ │ │ │ -MPIPack_>::value_>_>::size
│ │ │ │ │ -int size()
│ │ │ │ │ -Definition: mpipack.hh:209
│ │ │ │ │ -Dune::MPIData<_P,_std::enable_if_t<_std::is_same<_std::remove_const_t<_P_>,
│ │ │ │ │ -MPIPack_>::value_>_>::ptr
│ │ │ │ │ -void * ptr()
│ │ │ │ │ -Definition: mpipack.hh:205
│ │ │ │ │ -Dune::MPIData<_P,_std::enable_if_t<_std::is_same<_std::remove_const_t<_P_>,
│ │ │ │ │ -MPIPack_>::value_>_>::data_
│ │ │ │ │ -P & data_
│ │ │ │ │ -Definition: mpipack.hh:221
│ │ │ │ │ -Dune::MPIData<_P,_std::enable_if_t<_std::is_same<_std::remove_const_t<_P_>,
│ │ │ │ │ -MPIPack_>::value_>_>::resize
│ │ │ │ │ -void resize(int size)
│ │ │ │ │ -Definition: mpipack.hh:217
│ │ │ │ │ +Dune::className
│ │ │ │ │ +std::string className()
│ │ │ │ │ +Provide the demangled class name of a type T as a string.
│ │ │ │ │ +Definition: classname.hh:47
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-common-doc/doxygen/a00017.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-common: remoteindices.hh File Reference
│ │ │ │ +dune-common: fmatrixev.cc File Reference
│ │ │ │
│ │ │ │ -
│ │ │ │ -
Classes describing a distributed indexset.
│ │ │ │ -More...
│ │ │ │ -
#include <cassert>
│ │ │ │ -
#include <iostream>
│ │ │ │ -
#include <ostream>
│ │ │ │ -
#include <map>
│ │ │ │ -
#include <memory>
│ │ │ │ -
#include <set>
│ │ │ │ -
#include <utility>
│ │ │ │ -
#include <vector>
│ │ │ │ -
#include <mpi.h>
│ │ │ │ -
#include <dune/common/exceptions.hh >
│ │ │ │ -
#include <dune/common/parallel/indexset.hh >
│ │ │ │ -
#include <dune/common/parallel/mpitraits.hh >
│ │ │ │ -
#include <dune/common/parallel/plocalindex.hh >
│ │ │ │ -
#include <dune/common/sllist.hh >
│ │ │ │ -
#include <dune/common/stdstreams.hh >
│ │ │ │ -
│ │ │ │ -
Go to the source code of this file.
│ │ │ │ -
│ │ │ │ -namespace Dune Dune namespace.
│ │ │ │ -template<typename T1 , typename T2 > std::ostream & Dune::operator<< (std::ostream &os, const RemoteIndex< T1, T2 > &index) template<class T , class A > std::ostream & Dune::operator<< (std::ostream &os, const RemoteIndices< T, A > &indices) template<typename TG , typename TA > std::ostream & Dune::operator<< (std::ostream &os, const RemoteIndex< TG, TA > &index) #include <iostream>
│ │ │ │ +
#include <cmath>
│ │ │ │ +
#include <cassert>
│ │ │ │ +
#include <dune/common/exceptions.hh >
│ │ │ │ +
Classes describing a distributed indexset.
│ │ │ │ -
Author Markus Blatt
│ │ │ │ -
◆
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + #define DUNE_FMATRIXEIGENVALUES_CC
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ │ +Macros
│ │ │ │ │ +fmatrixev.cc File Reference
│ │ │ │ │ #include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ #include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -Go_to_the_source_code_of_this_file.
│ │ │ │ │ - Classes
│ │ │ │ │ -class Dune::MPITraits<_IndexPair<_TG,_ParallelLocalIndex<_TA_>_>_>
│ │ │ │ │ -
│ │ │ │ │ -class Dune::RemoteIndex<_T1,_T2_>
│ │ │ │ │ - Information about an index residing on another processor. More...
│ │ │ │ │ -
│ │ │ │ │ -class Dune::RemoteIndices<_T,_A_>
│ │ │ │ │ - The indices present on remote processes. More...
│ │ │ │ │ -
│ │ │ │ │ -class Dune::RemoteIndexListModifier<_T,_A,_mode_>
│ │ │ │ │ - Modifier for adding and/or deleting remote indices from the remote
│ │ │ │ │ - index list. More...
│ │ │ │ │ -
│ │ │ │ │ -class Dune::RemoteIndexListModifier<_T,_A,_mode_>::InvalidPosition
│ │ │ │ │ -
│ │ │ │ │ -class Dune::CollectiveIterator<_T,_A_>
│ │ │ │ │ - A collective iterator for moving over the remote indices for all
│ │ │ │ │ - processes collectively. More...
│ │ │ │ │ -
│ │ │ │ │ -class Dune::CollectiveIterator<_T,_A_>::iterator
│ │ │ │ │ - Iterator over the valid underlying iterators. More...
│ │ │ │ │ -
│ │ │ │ │ - Namespaces
│ │ │ │ │ -namespace Dune
│ │ │ │ │ - Dune namespace.
│ │ │ │ │ -
│ │ │ │ │ - Functions
│ │ │ │ │ -template
│ │ │ │ │ -std::ostream & Dune::operator<< (std::ostream &os, const RemoteIndex< T1, T2 >
│ │ │ │ │ - &index)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -std::ostream & Dune::operator<< (std::ostream &os, const RemoteIndices< T, A >
│ │ │ │ │ - &indices)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -std::ostream & Dune::operator<< (std::ostream &os, const RemoteIndex< TG, TA >
│ │ │ │ │ - &index)
│ │ │ │ │ + Macros
│ │ │ │ │ +#define DUNE_FMATRIXEIGENVALUES_CC
│ │ │ │ │
│ │ │ │ │ -***** Detailed Description *****
│ │ │ │ │ -Classes describing a distributed indexset.
│ │ │ │ │ - Author
│ │ │ │ │ - Markus Blatt
│ │ │ │ │ +***** Macro Definition Documentation *****
│ │ │ │ │ +***** ◆ DUNE_FMATRIXEIGENVALUES_CC *****
│ │ │ │ │ +#define DUNE_FMATRIXEIGENVALUES_CC
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-common-doc/doxygen/a00020.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-common: future.hh File Reference
│ │ │ │ +dune-common: streamoperators.hh File Reference
│ │ │ │
│ │ │ │ -
#include <memory>
│ │ │ │ -
#include <dune/common/exceptions.hh >
│ │ │ │ +
│ │ │ │ +
Implementation of stream operators for std::array and std::tuple.
│ │ │ │ +More...
│ │ │ │ +
#include <array>
│ │ │ │ +
#include <tuple>
│ │ │ │ +
#include <utility>
│ │ │ │ +
#include <dune/common/hybridutilities.hh >
│ │ │ │
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ -class Dune::InvalidFutureException This exception is thrown when ready(), wait() or get() get() More... class Dune::Future< T > Type-erasure for future-like objects. A future-like object is a object satisfying the interface of FutureBase. More... class Dune::PseudoFuture< T > A wrapper-class for a object which is ready immediately. More... class Dune::PseudoFuture< void >
│ │ │ │ namespace Dune Dune namespace.
│ │ │ │ +template<typename Stream , typename... Ts> Stream & Dune::operator<< (Stream &stream, const std::tuple< Ts... > &t) Print a std::tuple. More... template<typename Stream , typename... Ts> Stream & Dune::operator>> (Stream &stream, std::tuple< Ts... > &t) Read a std::tuple. More... template<typename Stream , typename T , std::size_t N> Stream & Dune::operator<< (Stream &stream, const std::array< T, N > &a) Print a std::array. More...
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
Implementation of stream operators for std::array and std::tuple.
│ │ │ │ +
│ │ │ │ │ -#include
│ │ │ │ │ +Namespaces | Functions
│ │ │ │ │ +streamoperators.hh File Reference
│ │ │ │ │ +Implementation of stream operators for std::array and std::tuple. More...
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ Go_to_the_source_code_of_this_file.
│ │ │ │ │ - Classes
│ │ │ │ │ -class Dune::InvalidFutureException
│ │ │ │ │ - This exception is thrown when ready(), wait() or get() is called on an
│ │ │ │ │ - invalid future. A future is valid until get() is called and if it is
│ │ │ │ │ - not default-constructed and it was not moved from. More...
│ │ │ │ │ -
│ │ │ │ │ -class Dune::Future<_T_>
│ │ │ │ │ - Type-erasure for future-like objects. A future-like object is a object
│ │ │ │ │ - satisfying the interface of FutureBase. More...
│ │ │ │ │ -
│ │ │ │ │ -class Dune::PseudoFuture<_T_>
│ │ │ │ │ - A wrapper-class for a object which is ready immediately. More...
│ │ │ │ │ -
│ │ │ │ │ -class Dune::PseudoFuture<_void_>
│ │ │ │ │ -
│ │ │ │ │ Namespaces
│ │ │ │ │ namespace Dune
│ │ │ │ │ Dune namespace.
│ │ │ │ │
│ │ │ │ │ + Functions
│ │ │ │ │ +template
│ │ │ │ │ +Stream & Dune::operator<< (Stream &stream, const std::tuple< Ts... > &t)
│ │ │ │ │ + Print a std::tuple. More...
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +Stream & Dune::operator>> (Stream &stream, std::tuple< Ts... > &t)
│ │ │ │ │ + Read a std::tuple. More...
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +Stream & Dune::operator<< (Stream &stream, const std::array< T, N > &a)
│ │ │ │ │ + Print a std::array. More...
│ │ │ │ │ +
│ │ │ │ │ +***** Detailed Description *****
│ │ │ │ │ +Implementation of stream operators for std::array and std::tuple.
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-common-doc/doxygen/a00020_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-common: future.hh Source File
│ │ │ │ +dune-common: streamoperators.hh Source File
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
5 #ifndef DUNE_COMMON_PARALLEL_FUTURE_HH
│ │ │ │ -
6 #define DUNE_COMMON_PARALLEL_FUTURE_HH
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
32 virtual ~FutureBase() =
default ;
│ │ │ │ -
33 virtual void wait () = 0;
│ │ │ │ -
34 virtual bool ready ()
const = 0;
│ │ │ │ -
35 virtual bool valid ()
const = 0;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
47 : _future(std::forward<F>(f))
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
6 #ifndef DUNE_STREAMOPERATORS_HH
│ │ │ │ +
7 #define DUNE_STREAMOPERATORS_HH
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
27 template <
typename Stream,
typename ... Ts>
│ │ │ │ +
28 inline Stream&
operator<< (Stream& stream,
const std::tuple<Ts...>& t)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
34 [&](
auto i){stream<<std::get<i>(t)<<
"," ;});
│ │ │ │ +
35 stream<<
std::get <
sizeof ...(Ts)-1>(t);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
42 template <
typename Stream,
typename ... Ts>
│ │ │ │ +
43 inline Stream&
operator>> (Stream& stream, std::tuple<Ts...>& t)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
46 [&](
auto i){stream>>std::get<i>(t);});
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
50 virtual void wait ()
override
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
55 virtual bool ready ()
const override
│ │ │ │ -
│ │ │ │ -
57 return _future.ready();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
60 virtual bool valid ()
const override
│ │ │ │ -
│ │ │ │ -
62 return _future.valid();
│ │ │ │ -
│ │ │ │ +
51 template <
typename Stream,
typename T, std::
size_t N>
│ │ │ │ +
52 inline Stream&
operator<< (Stream& stream,
const std::array<T,N>& a)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
57 for (std::size_t i=0; i<N-1; ++i)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
65 virtual T
get ()
override {
│ │ │ │ -
66 return (T)_future.get();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
70 std::unique_ptr<FutureBase> _future;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
74 : _future(
std ::make_unique<FutureModel<F>>(
std ::forward<F>(f)))
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
77 template<class U, std::enable_if_t<std::is_same<U,T>::value && !std::is_same<T,void>::value>>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
96 return _future->get();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
104 return _future->ready();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
114 return _future->valid();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
133 data_(
std ::forward<U>(u))
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
151 return std::forward<T>(data_);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
A few common exception classes.
│ │ │ │ -
#define DUNE_THROW(E, m)
Definition: exceptions.hh:218
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
Stream & operator>>(Stream &stream, std::tuple< Ts... > &t)
Read a std::tuple.
Definition: streamoperators.hh:43
│ │ │ │ +
constexpr void forEach(Range &&range, F &&f)
Range based for loop.
Definition: hybridutilities.hh:268
│ │ │ │ +
std::ostream & operator<<(std::ostream &s, const bigunsignedint< k > &x)
Definition: bigunsignedint.hh:278
│ │ │ │
Dune namespace.
Definition: alignedallocator.hh:13
│ │ │ │ -
Default exception if a function was called while the object is not in a valid state for that function...
Definition: exceptions.hh:281
│ │ │ │ -
This exception is thrown when ready(), wait() or get() is called on an invalid future....
Definition: future.hh:18
│ │ │ │ -
A wrapper-class for a object which is ready immediately.
Definition: future.hh:122
│ │ │ │ -
bool ready() const
Definition: future.hh:141
│ │ │ │ -
T get()
Definition: future.hh:147
│ │ │ │ -
PseudoFuture(U &&u)
Definition: future.hh:131
│ │ │ │ -
PseudoFuture()
Definition: future.hh:126
│ │ │ │ -
void wait()
Definition: future.hh:136
│ │ │ │ -
bool valid() const
Definition: future.hh:154
│ │ │ │ -
Type-erasure for future-like objects. A future-like object is a object satisfying the interface of Fu...
Definition: future.hh:28
│ │ │ │ -
bool ready() const
Definition: future.hh:103
│ │ │ │ -
void wait()
wait until the future is ready
Definition: future.hh:87
│ │ │ │ -
Future(U &&data)
Definition: future.hh:78
│ │ │ │ -
T get()
Waits until the future is ready and returns the resulting value.
Definition: future.hh:95
│ │ │ │ -
│ │ │ │ -
bool valid() const
Checks whether the future is valid. I.e. ‘get()’ was not called on that future and when it was not de...
Definition: future.hh:112
│ │ │ │ -
Future(F &&f)
Definition: future.hh:73
│ │ │ │ -
bool ready() const
Definition: future.hh:171
│ │ │ │ -
bool valid() const
Definition: future.hh:183
│ │ │ │ -
void get()
Definition: future.hh:177
│ │ │ │ -
PseudoFuture(bool valid=false)
Definition: future.hh:163
│ │ │ │ -
void wait()
Definition: future.hh:167
│ │ │ │ +
Reference get(const RAPropertyMapHelper< Reference, PropertyMap > &pmap, const Key &key)
Definition: propertymap.hh:84
│ │ │ │
│ │ │ │ │ - 9#include
│ │ │ │ │ - 10
│ │ │ │ │ - 11namespace Dune{
│ │ │ │ │ - 12
│ │ │ │ │ -17 class InvalidFutureException : public InvalidStateException
│ │ │ │ │ - 18 {};
│ │ │ │ │ - 19
│ │ │ │ │ - 20 // forward declaration
│ │ │ │ │ - 21 template
│ │ │ │ │ - 22 class PseudoFuture;
│ │ │ │ │ - 23
│ │ │ │ │ - 27 template
│ │ │ │ │ -28 class Future{
│ │ │ │ │ - 29 // Future interface:
│ │ │ │ │ - 30 class FutureBase{
│ │ │ │ │ - 31 public:
│ │ │ │ │ - 32 virtual ~FutureBase() = default;
│ │ │ │ │ - 33 virtual void wait() = 0;
│ │ │ │ │ - 34 virtual bool ready() const = 0;
│ │ │ │ │ - 35 virtual bool valid() const = 0;
│ │ │ │ │ - 36 virtual T get() = 0;
│ │ │ │ │ - 37 };
│ │ │ │ │ - 38
│ │ │ │ │ - 39 // model class
│ │ │ │ │ - 40 template
│ │ │ │ │ - 41 class FutureModel
│ │ │ │ │ - 42 : public FutureBase
│ │ │ │ │ - 43 {
│ │ │ │ │ - 44 F _future;
│ │ │ │ │ - 45 public:
│ │ │ │ │ - 46 FutureModel(F&& f)
│ │ │ │ │ - 47 : _future(std::forward(f))
│ │ │ │ │ - 48 {}
│ │ │ │ │ + 5
│ │ │ │ │ + 6#ifndef DUNE_STREAMOPERATORS_HH
│ │ │ │ │ + 7#define DUNE_STREAMOPERATORS_HH
│ │ │ │ │ + 8
│ │ │ │ │ + 13#include
│ │ │ │ │ + 14#include
│ │ │ │ │ + 15#include
│ │ │ │ │ + 16
│ │ │ │ │ + 17#include
│ │ │ │ │ + 18
│ │ │ │ │ + 19namespace Dune
│ │ │ │ │ + 20{
│ │ │ │ │ + 27 template
│ │ │ │ │ +28 inline Stream& operator<<(Stream& stream, const std::tuple& t)
│ │ │ │ │ + 29 {
│ │ │ │ │ + 30 stream<<"[";
│ │ │ │ │ + 31 if(sizeof...(Ts)>0)
│ │ │ │ │ + 32 {
│ │ │ │ │ + 33 Hybrid::forEach(std::make_index_sequence{},
│ │ │ │ │ + 34 [&](auto i){stream<(t)<<",";});
│ │ │ │ │ + 35 stream<(t);
│ │ │ │ │ + 36 }
│ │ │ │ │ + 37 stream<<"]";
│ │ │ │ │ + 38 return stream;
│ │ │ │ │ + 39 }
│ │ │ │ │ + 40
│ │ │ │ │ + 42 template
│ │ │ │ │ +43 inline Stream& operator>>(Stream& stream, std::tuple& t)
│ │ │ │ │ + 44 {
│ │ │ │ │ + 45 Hybrid::forEach(std::make_index_sequence{},
│ │ │ │ │ + 46 [&](auto i){stream>>std::get(t);});
│ │ │ │ │ + 47 return stream;
│ │ │ │ │ + 48 }
│ │ │ │ │ 49
│ │ │ │ │ - 50 virtual void wait() override
│ │ │ │ │ - 51 {
│ │ │ │ │ - 52 _future.wait();
│ │ │ │ │ - 53 }
│ │ │ │ │ - 54
│ │ │ │ │ - 55 virtual bool ready() const override
│ │ │ │ │ + 51 template
│ │ │ │ │ +52 inline Stream& operator<<(Stream& stream, const std::array& a)
│ │ │ │ │ + 53 {
│ │ │ │ │ + 54 stream<<"[";
│ │ │ │ │ + 55 if(N>0)
│ │ │ │ │ 56 {
│ │ │ │ │ - 57 return _future.ready();
│ │ │ │ │ - 58 }
│ │ │ │ │ - 59
│ │ │ │ │ - 60 virtual bool valid() const override
│ │ │ │ │ - 61 {
│ │ │ │ │ - 62 return _future.valid();
│ │ │ │ │ + 57 for(std::size_t i=0; i _future;
│ │ │ │ │ - 71 public:
│ │ │ │ │ - 72 template
│ │ │ │ │ -73 Future(F&& f)
│ │ │ │ │ - 74 : _future(std::make_unique>(std::forward(f)))
│ │ │ │ │ - 75 {}
│ │ │ │ │ - 76
│ │ │ │ │ - 77 template::value && !std::
│ │ │ │ │ -is_same::value>>
│ │ │ │ │ -78 Future(U&& data)
│ │ │ │ │ - 79 : _future(std::make_unique>>(PseudoFuture
│ │ │ │ │ -(std::forward(data))))
│ │ │ │ │ - 80 {}
│ │ │ │ │ - 81
│ │ │ │ │ -82 Future() = default;
│ │ │ │ │ - 83
│ │ │ │ │ -87 void wait(){
│ │ │ │ │ - 88 _future->wait();
│ │ │ │ │ - 89 }
│ │ │ │ │ - 90
│ │ │ │ │ -95 T get() {
│ │ │ │ │ - 96 return _future->get();
│ │ │ │ │ - 97 }
│ │ │ │ │ - 98
│ │ │ │ │ -103 bool ready() const {
│ │ │ │ │ - 104 return _future->ready();
│ │ │ │ │ - 105 }
│ │ │ │ │ - 106
│ │ │ │ │ -112 bool valid() const {
│ │ │ │ │ - 113 if(_future)
│ │ │ │ │ - 114 return _future->valid();
│ │ │ │ │ - 115 return false;
│ │ │ │ │ - 116 }
│ │ │ │ │ - 117 };
│ │ │ │ │ - 118
│ │ │ │ │ - 121 template
│ │ │ │ │ -122 class PseudoFuture{
│ │ │ │ │ - 123 bool valid_;
│ │ │ │ │ - 124 T data_;
│ │ │ │ │ - 125 public:
│ │ │ │ │ -126 PseudoFuture() :
│ │ │ │ │ - 127 valid_(false)
│ │ │ │ │ - 128 {}
│ │ │ │ │ - 129
│ │ │ │ │ - 130 template
│ │ │ │ │ -131 PseudoFuture(U&& u) :
│ │ │ │ │ - 132 valid_(true),
│ │ │ │ │ - 133 data_(std::forward(u))
│ │ │ │ │ - 134 {}
│ │ │ │ │ - 135
│ │ │ │ │ -136 void wait() {
│ │ │ │ │ - 137 if(!valid_)
│ │ │ │ │ - 138 DUNE_THROW(InvalidFutureException, "The PseudoFuture is not valid");
│ │ │ │ │ - 139 }
│ │ │ │ │ - 140
│ │ │ │ │ -141 bool ready() const {
│ │ │ │ │ - 142 if(!valid_)
│ │ │ │ │ - 143 DUNE_THROW(InvalidFutureException, "The PseudoFuture is not valid");
│ │ │ │ │ - 144 return true;
│ │ │ │ │ - 145 }
│ │ │ │ │ - 146
│ │ │ │ │ -147 T get() {
│ │ │ │ │ - 148 if(!valid_)
│ │ │ │ │ - 149 DUNE_THROW(InvalidFutureException, "The PseudoFuture is not valid");
│ │ │ │ │ - 150 valid_ = false;
│ │ │ │ │ - 151 return std::forward(data_);
│ │ │ │ │ - 152 }
│ │ │ │ │ - 153
│ │ │ │ │ -154 bool valid() const {
│ │ │ │ │ - 155 return valid_;
│ │ │ │ │ - 156 }
│ │ │ │ │ - 157 };
│ │ │ │ │ - 158
│ │ │ │ │ - 159 template<>
│ │ │ │ │ -160 class PseudoFuture{
│ │ │ │ │ - 161 bool valid_;
│ │ │ │ │ - 162 public:
│ │ │ │ │ -163 PseudoFuture(bool valid = false) :
│ │ │ │ │ - 164 valid_(valid)
│ │ │ │ │ - 165 {}
│ │ │ │ │ - 166
│ │ │ │ │ -167 void wait(){
│ │ │ │ │ - 168 if(!valid_)
│ │ │ │ │ - 169 DUNE_THROW(InvalidFutureException, "The PseudoFuture is not valid");
│ │ │ │ │ - 170 }
│ │ │ │ │ -171 bool ready() const{
│ │ │ │ │ - 172 if(!valid_)
│ │ │ │ │ - 173 DUNE_THROW(InvalidFutureException, "The PseudoFuture is not valid");
│ │ │ │ │ - 174 return true;
│ │ │ │ │ - 175 }
│ │ │ │ │ - 176
│ │ │ │ │ -177 void get(){
│ │ │ │ │ - 178 if(!valid_)
│ │ │ │ │ - 179 DUNE_THROW(InvalidFutureException, "The PseudoFuture is not valid");
│ │ │ │ │ - 180 valid_ = false;
│ │ │ │ │ - 181 }
│ │ │ │ │ - 182
│ │ │ │ │ -183 bool valid() const{
│ │ │ │ │ - 184 return valid_;
│ │ │ │ │ - 185 }
│ │ │ │ │ - 186 };
│ │ │ │ │ - 187}
│ │ │ │ │ - 188
│ │ │ │ │ - 189#endif
│ │ │ │ │ -exceptions.hh
│ │ │ │ │ -A few common exception classes.
│ │ │ │ │ -DUNE_THROW
│ │ │ │ │ -#define DUNE_THROW(E, m)
│ │ │ │ │ -Definition: exceptions.hh:218
│ │ │ │ │ -std
│ │ │ │ │ -STL namespace.
│ │ │ │ │ + 67} // end namespace Dune
│ │ │ │ │ + 68
│ │ │ │ │ + 69#endif
│ │ │ │ │ +hybridutilities.hh
│ │ │ │ │ +Dune::operator>>
│ │ │ │ │ +Stream & operator>>(Stream &stream, std::tuple< Ts... > &t)
│ │ │ │ │ +Read a std::tuple.
│ │ │ │ │ +Definition: streamoperators.hh:43
│ │ │ │ │ +Dune::Hybrid::forEach
│ │ │ │ │ +constexpr void forEach(Range &&range, F &&f)
│ │ │ │ │ +Range based for loop.
│ │ │ │ │ +Definition: hybridutilities.hh:268
│ │ │ │ │ +Dune::operator<<
│ │ │ │ │ +std::ostream & operator<<(std::ostream &s, const bigunsignedint< k > &x)
│ │ │ │ │ +Definition: bigunsignedint.hh:278
│ │ │ │ │ Dune
│ │ │ │ │ Dune namespace.
│ │ │ │ │ Definition: alignedallocator.hh:13
│ │ │ │ │ -Dune::InvalidStateException
│ │ │ │ │ -Default exception if a function was called while the object is not in a valid
│ │ │ │ │ -state for that function...
│ │ │ │ │ -Definition: exceptions.hh:281
│ │ │ │ │ -Dune::InvalidFutureException
│ │ │ │ │ -This exception is thrown when ready(), wait() or get() is called on an invalid
│ │ │ │ │ -future....
│ │ │ │ │ -Definition: future.hh:18
│ │ │ │ │ -Dune::PseudoFuture
│ │ │ │ │ -A wrapper-class for a object which is ready immediately.
│ │ │ │ │ -Definition: future.hh:122
│ │ │ │ │ -Dune::PseudoFuture::ready
│ │ │ │ │ -bool ready() const
│ │ │ │ │ -Definition: future.hh:141
│ │ │ │ │ -Dune::PseudoFuture::get
│ │ │ │ │ -T get()
│ │ │ │ │ -Definition: future.hh:147
│ │ │ │ │ -Dune::PseudoFuture::PseudoFuture
│ │ │ │ │ -PseudoFuture(U &&u)
│ │ │ │ │ -Definition: future.hh:131
│ │ │ │ │ -Dune::PseudoFuture::PseudoFuture
│ │ │ │ │ -PseudoFuture()
│ │ │ │ │ -Definition: future.hh:126
│ │ │ │ │ -Dune::PseudoFuture::wait
│ │ │ │ │ -void wait()
│ │ │ │ │ -Definition: future.hh:136
│ │ │ │ │ -Dune::PseudoFuture::valid
│ │ │ │ │ -bool valid() const
│ │ │ │ │ -Definition: future.hh:154
│ │ │ │ │ -Dune::Future
│ │ │ │ │ -Type-erasure for future-like objects. A future-like object is a object
│ │ │ │ │ -satisfying the interface of Fu...
│ │ │ │ │ -Definition: future.hh:28
│ │ │ │ │ -Dune::Future::ready
│ │ │ │ │ -bool ready() const
│ │ │ │ │ -Definition: future.hh:103
│ │ │ │ │ -Dune::Future::wait
│ │ │ │ │ -void wait()
│ │ │ │ │ -wait until the future is ready
│ │ │ │ │ -Definition: future.hh:87
│ │ │ │ │ -Dune::Future::Future
│ │ │ │ │ -Future(U &&data)
│ │ │ │ │ -Definition: future.hh:78
│ │ │ │ │ -Dune::Future::get
│ │ │ │ │ -T get()
│ │ │ │ │ -Waits until the future is ready and returns the resulting value.
│ │ │ │ │ -Definition: future.hh:95
│ │ │ │ │ -Dune::Future::Future
│ │ │ │ │ -Future()=default
│ │ │ │ │ -Dune::Future::valid
│ │ │ │ │ -bool valid() const
│ │ │ │ │ -Checks whether the future is valid. I.e. ‘get()’ was not called on that future
│ │ │ │ │ -and when it was not de...
│ │ │ │ │ -Definition: future.hh:112
│ │ │ │ │ -Dune::Future::Future
│ │ │ │ │ -Future(F &&f)
│ │ │ │ │ -Definition: future.hh:73
│ │ │ │ │ -Dune::PseudoFuture<_void_>::ready
│ │ │ │ │ -bool ready() const
│ │ │ │ │ -Definition: future.hh:171
│ │ │ │ │ -Dune::PseudoFuture<_void_>::valid
│ │ │ │ │ -bool valid() const
│ │ │ │ │ -Definition: future.hh:183
│ │ │ │ │ -Dune::PseudoFuture<_void_>::get
│ │ │ │ │ -void get()
│ │ │ │ │ -Definition: future.hh:177
│ │ │ │ │ -Dune::PseudoFuture<_void_>::PseudoFuture
│ │ │ │ │ -PseudoFuture(bool valid=false)
│ │ │ │ │ -Definition: future.hh:163
│ │ │ │ │ -Dune::PseudoFuture<_void_>::wait
│ │ │ │ │ -void wait()
│ │ │ │ │ -Definition: future.hh:167
│ │ │ │ │ +Dune::get
│ │ │ │ │ +Reference get(const RAPropertyMapHelper< Reference, PropertyMap > &pmap, const
│ │ │ │ │ +Key &key)
│ │ │ │ │ +Definition: propertymap.hh:84
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-common-doc/doxygen/a00023.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-common: communication.hh File Reference
│ │ │ │ +dune-common: mallocallocator.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │ -
Implements an utility class that provides collective communication methods for sequential programs.
│ │ │ │ +
Allocators that use malloc/free.
│ │ │ │ More...
│ │ │ │ -
#include <iostream>
│ │ │ │ -
#include <complex>
│ │ │ │ -
#include <algorithm>
│ │ │ │ -
#include <vector>
│ │ │ │ -
#include <dune/common/binaryfunctions.hh >
│ │ │ │ -
#include <dune/common/exceptions.hh >
│ │ │ │ -
#include <dune/common/parallel/future.hh >
│ │ │ │ +
#include <exception>#include <cstdlib>#include <new>#include <utility>
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ namespace Dune Dune namespace.
│ │ │ │ bool Dune::operator== (const No_Comm &, const No_Comm &) Comparison operator for MPI compatibility. More... bool Dune::operator!= (const No_Comm &, const No_Comm &) Comparison operator for MPI compatibility. More... template<class T > constexpr bool Dune::operator== (const MallocAllocator< T > &, const MallocAllocator< T > &) check whether allocators are equivalent More... template<class T > constexpr bool Dune::operator!= (const MallocAllocator< T > &, const MallocAllocator< T > &) check whether allocators are not equivalent More...
│ │ │ │
│ │ │ │ -
Implements an utility class that provides collective communication methods for sequential programs.
│ │ │ │ -
An abstraction to the basic methods of parallel communication, following the message-passing paradigm.
│ │ │ │ +
Allocators that use malloc/free.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -4,51 +4,41 @@
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ dune-common 2.9.0
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * common
│ │ │ │ │ - * parallel
│ │ │ │ │ -Classes | Namespaces | Typedefs | Functions
│ │ │ │ │ -communication.hh File Reference
│ │ │ │ │ -Common » Parallel_Communication | Common » Parallel_Communication
│ │ │ │ │ -Implements an utility class that provides collective communication methods for
│ │ │ │ │ -sequential programs. More...
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ +Classes | Namespaces | Functions
│ │ │ │ │ +mallocallocator.hh File Reference
│ │ │ │ │ +Allocators that use malloc/free. More...
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ Go_to_the_source_code_of_this_file.
│ │ │ │ │ Classes
│ │ │ │ │ -struct Dune::No_Comm
│ │ │ │ │ + class Dune::MallocAllocator<_T_>
│ │ │ │ │ + Allocators implementation which simply calls malloc/free. More...
│ │ │ │ │
│ │ │ │ │ - class Dune::Communication<_Communicator_>
│ │ │ │ │ - Collective communication interface and sequential default
│ │ │ │ │ - implementation. More...
│ │ │ │ │ +struct Dune::MallocAllocator<_T_>::rebind<_U_>
│ │ │ │ │
│ │ │ │ │ Namespaces
│ │ │ │ │ namespace Dune
│ │ │ │ │ Dune namespace.
│ │ │ │ │
│ │ │ │ │ - Typedefs
│ │ │ │ │ -template
│ │ │ │ │ -using Dune::CollectiveCommunication = Communication< T >
│ │ │ │ │ -
│ │ │ │ │ Functions
│ │ │ │ │ -bool Dune::operator== (const No_Comm &, const No_Comm &)
│ │ │ │ │ - Comparison operator for MPI compatibility. More...
│ │ │ │ │ +template
│ │ │ │ │ +constexpr bool Dune::operator== (const MallocAllocator< T > &, const
│ │ │ │ │ + MallocAllocator< T > &)
│ │ │ │ │ + check whether allocators are equivalent More...
│ │ │ │ │
│ │ │ │ │ -bool Dune::operator!= (const No_Comm &, const No_Comm &)
│ │ │ │ │ - Comparison operator for MPI compatibility. More...
│ │ │ │ │ +template
│ │ │ │ │ +constexpr bool Dune::operator!= (const MallocAllocator< T > &, const
│ │ │ │ │ + MallocAllocator< T > &)
│ │ │ │ │ + check whether allocators are not equivalent More...
│ │ │ │ │
│ │ │ │ │ ***** Detailed Description *****
│ │ │ │ │ -Implements an utility class that provides collective communication methods for
│ │ │ │ │ -sequential programs.
│ │ │ │ │ -An abstraction to the basic methods of parallel communication, following the
│ │ │ │ │ -message-passing paradigm.
│ │ │ │ │ +Allocators that use malloc/free.
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-common-doc/doxygen/a00023_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-common: communication.hh Source File
│ │ │ │ +dune-common: mallocallocator.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
5 #ifndef DUNE_COMMON_PARALLEL_COMMUNICATION_HH
│ │ │ │ -
6 #define DUNE_COMMON_PARALLEL_COMMUNICATION_HH
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
5 #ifndef DUNE_MALLOC_ALLOCATOR_HH
│ │ │ │ +
6 #define DUNE_MALLOC_ALLOCATOR_HH
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
98 template <
typename Communicator>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
135 int send ([[maybe_unused]]
const T& data,
│ │ │ │ -
136 [[maybe_unused]]
int dest_rank,
│ │ │ │ -
137 [[maybe_unused]]
int tag)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
147 [[maybe_unused]]
int dest_rank,
│ │ │ │ -
148 [[maybe_unused]]
int tag)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
157 T
recv ([[maybe_unused]] T&& data,
│ │ │ │ -
158 [[maybe_unused]]
int source_rank,
│ │ │ │ -
159 [[maybe_unused]]
int tag,
│ │ │ │ -
160 [[maybe_unused]]
void * status = 0)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
170 [[maybe_unused]]
int source_rank,
│ │ │ │ -
171 [[maybe_unused]]
int tag)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
178 [[maybe_unused]]
int source_rank,
│ │ │ │ -
179 [[maybe_unused]]
int tag,
│ │ │ │ -
180 [[maybe_unused]]
void * status = 0)
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
199 int sum ([[maybe_unused]] T* inout, [[maybe_unused]]
int len)
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
219 int prod ([[maybe_unused]] T* inout, [[maybe_unused]]
int len)
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
239 int min ([[maybe_unused]] T* inout, [[maybe_unused]]
int len)
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
259 int max ([[maybe_unused]] T* inout, [[maybe_unused]]
int len)
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
285 [[maybe_unused]]
int len,
│ │ │ │ -
286 [[maybe_unused]]
int root)
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
296 return {std::forward<T>(data)};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
313 int gather (
const T* in, T* out,
int len, [[maybe_unused]]
int root)
const
│ │ │ │ -
│ │ │ │ -
315 for (
int i=0; i<len; i++)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
323 template <
class TIN,
class TOUT = std::vector<TIN>>
│ │ │ │ -
│ │ │ │ -
325 *(data_out.begin()) = std::forward<TIN>(data_in);
│ │ │ │ -
326 return {std::forward<TOUT>(data_out)};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
353 [[maybe_unused]]
int * recvDataLen,
│ │ │ │ -
│ │ │ │ -
355 [[maybe_unused]]
int root)
const
│ │ │ │ -
│ │ │ │ -
357 for (
int i=*displ; i<sendDataLen; i++)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
376 int scatter (
const T* sendData, T* recvData,
int len, [[maybe_unused]]
int root)
const
│ │ │ │ -
│ │ │ │ -
378 for (
int i=0; i<len; i++)
│ │ │ │ -
379 recvData[i] = sendData[i];
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
386 template <
class TIN,
class TOUT = TIN>
│ │ │ │ -
│ │ │ │ -
388 data_out = *(std::forward<TIN>(data_in).begin());
│ │ │ │ -
389 return {std::forward<TOUT>(data_out)};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
411 int scatterv (
const T* sendData,
int * sendDataLen,
int * displ, T* recvData,
│ │ │ │ -
412 [[maybe_unused]]
int recvDataLen, [[maybe_unused]]
int root)
const
│ │ │ │ -
│ │ │ │ -
414 for (
int i=*displ; i<*sendDataLen; i++)
│ │ │ │ -
415 recvData[i] = sendData[i];
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
435 for (
const T* end=sbuf+count; sbuf < end; ++sbuf, ++rbuf)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
444 template <
class TIN,
class TOUT = TIN>
│ │ │ │ -
│ │ │ │ -
446 return {std::forward<TOUT>(data_out)};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
466 int allgatherv (
const T* in,
int sendDataLen, T* out, [[maybe_unused]]
int * recvDataLen,
int * displ)
const
│ │ │ │ -
│ │ │ │ -
468 for (
int i=*displ; i<sendDataLen; i++)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
485 template <
typename BinaryFunction,
typename Type>
│ │ │ │ -
486 int allreduce ([[maybe_unused]] Type* inout, [[maybe_unused]]
int len)
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
495 template <
class BinaryFunction,
class TIN,
class TOUT = TIN>
│ │ │ │ -
│ │ │ │ -
497 data_out = std::forward<TIN>(data_in);
│ │ │ │ -
498 return {std::forward<TOUT>(data_out)};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
505 template <
class BinaryFunction,
class T>
│ │ │ │ -
│ │ │ │ -
507 return {std::forward<T>(data)};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
524 template <
typename BinaryFunction,
typename Type>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
527 std::copy(in, in+len, out);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
540 [[deprecated(
"CollectiveCommunication is deprecated. Use Communication instead." )]]
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
A few common exception classes.
│ │ │ │ -
helper classes to provide unique types for standard functions
│ │ │ │ -
#define DUNE_THROW(E, m)
Definition: exceptions.hh:218
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
56 [[maybe_unused]]
const void * hint = 0)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
59 throw std::bad_alloc();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
63 throw std::bad_alloc();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
82 ::new((
void *)p)T(val);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
86 template <
typename ... Args>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
89 ::new((
void *)p)T(std::forward<Args>(args) ...);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
EnableIfInterOperable< T1, T2, bool >::type operator==(const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
Checks for equality.
Definition: iteratorfacades.hh:237
│ │ │ │
EnableIfInterOperable< T1, T2, bool >::type operator!=(const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
Checks for inequality.
Definition: iteratorfacades.hh:259
│ │ │ │
Dune namespace.
Definition: alignedallocator.hh:13
│ │ │ │ -
Default exception if an error in the parallel communication of the program occurred.
Definition: exceptions.hh:287
│ │ │ │ -
Definition: communication.hh:46
│ │ │ │ -
Collective communication interface and sequential default implementation.
Definition: communication.hh:100
│ │ │ │ -
PseudoFuture< TOUT > iallreduce(TIN &&data_in, TOUT &&data_out)
Compute something over all processes nonblocking.
Definition: communication.hh:496
│ │ │ │ -
int send(const T &data, int dest_rank, int tag)
Sends the data to the dest_rank.
Definition: communication.hh:135
│ │ │ │ -
int allreduce(const Type *in, Type *out, int len) const
Compute something over all processes for each component of an array and return the result in every pr...
Definition: communication.hh:525
│ │ │ │ -
T max(const T &in) const
Compute the maximum of the argument over all processes and return the result in every process....
Definition: communication.hh:248
│ │ │ │ -
int rank() const
Return rank, is between 0 and size()-1.
Definition: communication.hh:114
│ │ │ │ -
T sum(const T &in) const
Compute the sum of the argument over all processes and return the result in every process....
Definition: communication.hh:188
│ │ │ │ -
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: communication.hh:411
│ │ │ │ -
int prod(T *inout, int len) const
Compute the product over all processes for each component of an array and return the result in every ...
Definition: communication.hh:219
│ │ │ │ -
T recv(T &&data, int source_rank, int tag, void *status=0)
Receives the data from the source_rank.
Definition: communication.hh:157
│ │ │ │ -
PseudoFuture< T > isend(const T &&data, int dest_rank, int tag)
Sends the data to the dest_rank nonblocking.
Definition: communication.hh:146
│ │ │ │ -
PseudoFuture< void > ibarrier() const
Nonblocking barrier.
Definition: communication.hh:275
│ │ │ │ -
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: communication.hh:486
│ │ │ │ -
int size() const
Number of processes in set, is greater than 0.
Definition: communication.hh:126
│ │ │ │ -
int sum(T *inout, int len) const
Compute the sum over all processes for each component of an array and return the result in every proc...
Definition: communication.hh:199
│ │ │ │ -
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: communication.hh:466
│ │ │ │ -
T min(const T &in) const
Compute the minimum of the argument over all processes and return the result in every process....
Definition: communication.hh:228
│ │ │ │ -
PseudoFuture< T > irecv(T &&data, int source_rank, int tag)
Receives the data from the source_rank nonblocking.
Definition: communication.hh:169
│ │ │ │ -
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: communication.hh:350
│ │ │ │ -
PseudoFuture< T > ibroadcast(T &&data, int root) const
Distribute an array from the process with rank root to all other processes nonblocking.
Definition: communication.hh:295
│ │ │ │ -
int allgather(const T *sbuf, int count, T *rbuf) const
Gathers data from all tasks and distribute it to all.
Definition: communication.hh:433
│ │ │ │ -
int scatter(const T *sendData, T *recvData, int len, int root) const
Scatter array from a root to all other task.
Definition: communication.hh:376
│ │ │ │ -
int gather(const T *in, T *out, int len, int root) const
Gather arrays on root task.
Definition: communication.hh:313
│ │ │ │ -
PseudoFuture< T > iallreduce(T &&data)
Compute something over all processes nonblocking and in-place.
Definition: communication.hh:506
│ │ │ │ -
Communication(const Communicator &)
Constructor with a given communicator.
Definition: communication.hh:110
│ │ │ │ -
int max(T *inout, int len) const
Compute the maximum over all processes for each component of an array and return the result in every ...
Definition: communication.hh:259
│ │ │ │ -
T prod(const T &in) const
Compute the product of the argument over all processes and return the result in every process....
Definition: communication.hh:208
│ │ │ │ -
int broadcast(T *inout, int len, int root) const
Distribute an array from the process with rank root to all other processes.
Definition: communication.hh:284
│ │ │ │ -
T rrecv(T &&data, int source_rank, int tag, void *status=0) const
Definition: communication.hh:177
│ │ │ │ -
PseudoFuture< TOUT > iscatter(TIN &&data_in, TOUT &&data_out, int root)
Scatter array from a root to all other task nonblocking.
Definition: communication.hh:387
│ │ │ │ -
int min(T *inout, int len) const
Compute the minimum over all processes for each component of an array and return the result in every ...
Definition: communication.hh:239
│ │ │ │ -
int barrier() const
Wait until all processes have arrived at this point in the program.
Definition: communication.hh:267
│ │ │ │ -
PseudoFuture< TOUT > igather(TIN &&data_in, TOUT &&data_out, int root)
Gather arrays on root task nonblocking.
Definition: communication.hh:324
│ │ │ │ -
PseudoFuture< TOUT > iallgather(TIN &&data_in, TOUT &&data_out)
Gathers data from all tasks and distribute it to all nonblocking.
Definition: communication.hh:445
│ │ │ │ -
Communication()
Construct default object.
Definition: communication.hh:103
│ │ │ │ -
A wrapper-class for a object which is ready immediately.
Definition: future.hh:122
│ │ │ │ -
Definition: future.hh:160
│ │ │ │ +
Allocators implementation which simply calls malloc/free.
Definition: mallocallocator.hh:24
│ │ │ │ +
~MallocAllocator() noexcept
cleanup this allocator
Definition: mallocallocator.hh:43
│ │ │ │ +
T * pointer
Definition: mallocallocator.hh:28
│ │ │ │ +
void construct(pointer p, const T &val)
copy-construct an object of type T (i.e. make a placement new on p)
Definition: mallocallocator.hh:80
│ │ │ │ +
MallocAllocator() noexcept
create a new MallocAllocator
Definition: mallocallocator.hh:38
│ │ │ │ +
MallocAllocator(const MallocAllocator< U > &) noexcept
copy construct from an other MallocAllocator, possibly for a different result type
Definition: mallocallocator.hh:41
│ │ │ │ +
std::size_t size_type
Definition: mallocallocator.hh:26
│ │ │ │ +
std::ptrdiff_t difference_type
Definition: mallocallocator.hh:27
│ │ │ │ +
void deallocate(pointer p, size_type n)
deallocate n objects of type T at address p
Definition: mallocallocator.hh:68
│ │ │ │ +
T value_type
Definition: mallocallocator.hh:32
│ │ │ │ +
const_pointer address(const_reference x) const
Definition: mallocallocator.hh:49
│ │ │ │ +
const T & const_reference
Definition: mallocallocator.hh:31
│ │ │ │ +
void destroy(pointer p)
destroy an object of type T (i.e. call the destructor)
Definition: mallocallocator.hh:93
│ │ │ │ +
pointer allocate(size_type n, const void *hint=0)
allocate n objects of type T
Definition: mallocallocator.hh:55
│ │ │ │ +
pointer address(reference x) const
Definition: mallocallocator.hh:45
│ │ │ │ +
void construct(pointer p, Args &&... args)
construct an object of type T from variadic parameters
Definition: mallocallocator.hh:87
│ │ │ │ +
T & reference
Definition: mallocallocator.hh:30
│ │ │ │ +
size_type max_size() const noexcept
max size for allocate
Definition: mallocallocator.hh:74
│ │ │ │ +
const T * const_pointer
Definition: mallocallocator.hh:29
│ │ │ │ +
Definition: mallocallocator.hh:33
│ │ │ │ +
MallocAllocator< U > other
Definition: mallocallocator.hh:34
│ │ │ │
│ │ │ │ │ - 15#include
│ │ │ │ │ - 16#include
│ │ │ │ │ - 17#include
│ │ │ │ │ - 18
│ │ │ │ │ - 19#include
│ │ │ │ │ - 20#include
│ │ │ │ │ - 21#include
│ │ │ │ │ - 22
│ │ │ │ │ - 42namespace Dune
│ │ │ │ │ - 43{
│ │ │ │ │ + 5#ifndef DUNE_MALLOC_ALLOCATOR_HH
│ │ │ │ │ + 6#define DUNE_MALLOC_ALLOCATOR_HH
│ │ │ │ │ + 7
│ │ │ │ │ + 8#include
│ │ │ │ │ + 9#include
│ │ │ │ │ + 10#include
│ │ │ │ │ + 11#include
│ │ │ │ │ + 12
│ │ │ │ │ + 17namespace Dune
│ │ │ │ │ + 18{
│ │ │ │ │ + 23 template
│ │ │ │ │ +24 class MallocAllocator {
│ │ │ │ │ + 25 public:
│ │ │ │ │ +26 typedef std::size_t size_type;
│ │ │ │ │ +27 typedef std::ptrdiff_t difference_type;
│ │ │ │ │ +28 typedef T* pointer;
│ │ │ │ │ +29 typedef const T* const_pointer;
│ │ │ │ │ +30 typedef T& reference;
│ │ │ │ │ +31 typedef const T& const_reference;
│ │ │ │ │ +32 typedef T value_type;
│ │ │ │ │ +33 template struct rebind {
│ │ │ │ │ +34 typedef MallocAllocator other;
│ │ │ │ │ + 35 };
│ │ │ │ │ + 36
│ │ │ │ │ +38 MallocAllocator() noexcept {}
│ │ │ │ │ + 40 template
│ │ │ │ │ +41 MallocAllocator(const MallocAllocator&) noexcept {}
│ │ │ │ │ +43 ~MallocAllocator() noexcept {}
│ │ │ │ │ 44
│ │ │ │ │ - 45 /* define some type that definitely differs from MPI_Comm */
│ │ │ │ │ -46 struct No_Comm {};
│ │ │ │ │ - 47
│ │ │ │ │ -52 inline bool operator==(const No_Comm&, const No_Comm&)
│ │ │ │ │ - 53 {
│ │ │ │ │ - 54 return true;
│ │ │ │ │ - 55 }
│ │ │ │ │ - 56
│ │ │ │ │ -61 inline bool operator!=(const No_Comm&, const No_Comm&)
│ │ │ │ │ - 62 {
│ │ │ │ │ - 63 return false;
│ │ │ │ │ - 64 }
│ │ │ │ │ - 65
│ │ │ │ │ - 98 template
│ │ │ │ │ -99 class Communication
│ │ │ │ │ - 100 {
│ │ │ │ │ - 101 public:
│ │ │ │ │ -103 Communication()
│ │ │ │ │ - 104 {}
│ │ │ │ │ - 105
│ │ │ │ │ -110 Communication (const Communicator&)
│ │ │ │ │ - 111 {}
│ │ │ │ │ - 112
│ │ │ │ │ -114 int rank () const
│ │ │ │ │ - 115 {
│ │ │ │ │ - 116 return 0;
│ │ │ │ │ - 117 }
│ │ │ │ │ - 118
│ │ │ │ │ -120 operator No_Comm() const
│ │ │ │ │ - 121 {
│ │ │ │ │ - 122 return {};
│ │ │ │ │ - 123 }
│ │ │ │ │ - 124
│ │ │ │ │ -126 int size () const
│ │ │ │ │ - 127 {
│ │ │ │ │ - 128 return 1;
│ │ │ │ │ - 129 }
│ │ │ │ │ - 130
│ │ │ │ │ - 134 template
│ │ │ │ │ -135 int send([[maybe_unused]] const T& data,
│ │ │ │ │ - 136 [[maybe_unused]] int dest_rank,
│ │ │ │ │ - 137 [[maybe_unused]] int tag)
│ │ │ │ │ - 138 {
│ │ │ │ │ - 139 DUNE_THROW(ParallelError, "This method is not supported in sequential
│ │ │ │ │ -programs");
│ │ │ │ │ - 140 }
│ │ │ │ │ - 141
│ │ │ │ │ - 145 template
│ │ │ │ │ -146 PseudoFuture isend([[maybe_unused]] const T&& data,
│ │ │ │ │ - 147 [[maybe_unused]] int dest_rank,
│ │ │ │ │ - 148 [[maybe_unused]] int tag)
│ │ │ │ │ - 149 {
│ │ │ │ │ - 150 DUNE_THROW(ParallelError, "This method is not supported in sequential
│ │ │ │ │ -programs");
│ │ │ │ │ - 151 }
│ │ │ │ │ - 152
│ │ │ │ │ - 156 template
│ │ │ │ │ -157 T recv([[maybe_unused]] T&& data,
│ │ │ │ │ - 158 [[maybe_unused]] int source_rank,
│ │ │ │ │ - 159 [[maybe_unused]] int tag,
│ │ │ │ │ - 160 [[maybe_unused]] void* status = 0)
│ │ │ │ │ - 161 {
│ │ │ │ │ - 162 DUNE_THROW(ParallelError, "This method is not supported in sequential
│ │ │ │ │ -programs");
│ │ │ │ │ - 163 }
│ │ │ │ │ - 164
│ │ │ │ │ - 168 template
│ │ │ │ │ -169 PseudoFuture irecv([[maybe_unused]] T&& data,
│ │ │ │ │ - 170 [[maybe_unused]] int source_rank,
│ │ │ │ │ - 171 [[maybe_unused]] int tag)
│ │ │ │ │ - 172 {
│ │ │ │ │ - 173 DUNE_THROW(ParallelError, "This method is not supported in sequential
│ │ │ │ │ -programs");
│ │ │ │ │ - 174 }
│ │ │ │ │ - 175
│ │ │ │ │ - 176 template
│ │ │ │ │ -177 T rrecv([[maybe_unused]] T&& data,
│ │ │ │ │ - 178 [[maybe_unused]] int source_rank,
│ │ │ │ │ - 179 [[maybe_unused]] int tag,
│ │ │ │ │ - 180 [[maybe_unused]] void* status = 0) const
│ │ │ │ │ - 181 {
│ │ │ │ │ - 182 DUNE_THROW(ParallelError, "This method is not supported in sequential
│ │ │ │ │ -programs");
│ │ │ │ │ - 183 }
│ │ │ │ │ - 187 template
│ │ │ │ │ -188 T sum (const T& in) const
│ │ │ │ │ - 189 {
│ │ │ │ │ - 190 return in;
│ │ │ │ │ - 191 }
│ │ │ │ │ - 192
│ │ │ │ │ - 198 template
│ │ │ │ │ -199 int sum ([[maybe_unused]] T* inout, [[maybe_unused]] int len) const
│ │ │ │ │ - 200 {
│ │ │ │ │ - 201 return 0;
│ │ │ │ │ - 202 }
│ │ │ │ │ - 203
│ │ │ │ │ - 207 template
│ │ │ │ │ -208 T prod (const T& in) const
│ │ │ │ │ - 209 {
│ │ │ │ │ - 210 return in;
│ │ │ │ │ - 211 }
│ │ │ │ │ - 212
│ │ │ │ │ - 218 template
│ │ │ │ │ -219 int prod ([[maybe_unused]] T* inout, [[maybe_unused]] int len) const
│ │ │ │ │ - 220 {
│ │ │ │ │ - 221 return 0;
│ │ │ │ │ - 222 }
│ │ │ │ │ - 223
│ │ │ │ │ - 227 template
│ │ │ │ │ -228 T min (const T& in) const
│ │ │ │ │ - 229 {
│ │ │ │ │ - 230 return in;
│ │ │ │ │ - 231 }
│ │ │ │ │ - 232
│ │ │ │ │ - 238 template
│ │ │ │ │ -239 int min ([[maybe_unused]] T* inout, [[maybe_unused]] int len) const
│ │ │ │ │ - 240 {
│ │ │ │ │ - 241 return 0;
│ │ │ │ │ - 242 }
│ │ │ │ │ - 243
│ │ │ │ │ - 247 template
│ │ │ │ │ -248 T max (const T& in) const
│ │ │ │ │ - 249 {
│ │ │ │ │ - 250 return in;
│ │ │ │ │ - 251 }
│ │ │ │ │ - 252
│ │ │ │ │ - 258 template
│ │ │ │ │ -259 int max ([[maybe_unused]] T* inout, [[maybe_unused]] int len) const
│ │ │ │ │ - 260 {
│ │ │ │ │ - 261 return 0;
│ │ │ │ │ - 262 }
│ │ │ │ │ - 263
│ │ │ │ │ -267 int barrier () const
│ │ │ │ │ - 268 {
│ │ │ │ │ - 269 return 0;
│ │ │ │ │ - 270 }
│ │ │ │ │ - 271
│ │ │ │ │ -275 PseudoFuture ibarrier () const
│ │ │ │ │ - 276 {
│ │ │ │ │ - 277 return {true}; // return a valid future
│ │ │ │ │ - 278 }
│ │ │ │ │ - 279
│ │ │ │ │ - 283 template
│ │ │ │ │ -284 int broadcast ([[maybe_unused]] T* inout,
│ │ │ │ │ - 285 [[maybe_unused]] int len,
│ │ │ │ │ - 286 [[maybe_unused]] int root) const
│ │ │ │ │ - 287 {
│ │ │ │ │ - 288 return 0;
│ │ │ │ │ - 289 }
│ │ │ │ │ - 290
│ │ │ │ │ - 294 template
│ │ │ │ │ -295 PseudoFuture ibroadcast(T&& data, int root) const{
│ │ │ │ │ - 296 return {std::forward(data)};
│ │ │ │ │ - 297 }
│ │ │ │ │ - 298
│ │ │ │ │ - 299
│ │ │ │ │ - 312 template
│ │ │ │ │ -313 int gather (const T* in, T* out, int len, [[maybe_unused]] int root) const
│ │ │ │ │ -// note out must have same size as in
│ │ │ │ │ - 314 {
│ │ │ │ │ - 315 for (int i=0; i>
│ │ │ │ │ -324 PseudoFuture igather(TIN&& data_in, TOUT&& data_out, int root){
│ │ │ │ │ - 325 *(data_out.begin()) = std::forward(data_in);
│ │ │ │ │ - 326 return {std::forward(data_out)};
│ │ │ │ │ - 327 }
│ │ │ │ │ - 328
│ │ │ │ │ - 329
│ │ │ │ │ - 349 template
│ │ │ │ │ -350 int gatherv (const T* in,
│ │ │ │ │ - 351 int sendDataLen,
│ │ │ │ │ - 352 T* out,
│ │ │ │ │ - 353 [[maybe_unused]] int* recvDataLen,
│ │ │ │ │ - 354 int* displ,
│ │ │ │ │ - 355 [[maybe_unused]] int root) const
│ │ │ │ │ - 356 {
│ │ │ │ │ - 357 for (int i=*displ; i
│ │ │ │ │ -376 int scatter (const T* sendData, T* recvData, int len, [[maybe_unused]] int
│ │ │ │ │ -root) const // note out must have same size as in
│ │ │ │ │ - 377 {
│ │ │ │ │ - 378 for (int i=0; i
│ │ │ │ │ -387 PseudoFuture iscatter(TIN&& data_in, TOUT&& data_out, int root){
│ │ │ │ │ - 388 data_out = *(std::forward(data_in).begin());
│ │ │ │ │ - 389 return {std::forward(data_out)};
│ │ │ │ │ - 390 }
│ │ │ │ │ - 391
│ │ │ │ │ - 410 template
│ │ │ │ │ -411 int scatterv (const T* sendData,int* sendDataLen, int* displ, T* recvData,
│ │ │ │ │ - 412 [[maybe_unused]] int recvDataLen, [[maybe_unused]] int root) const
│ │ │ │ │ - 413 {
│ │ │ │ │ - 414 for (int i=*displ; i<*sendDataLen; i++)
│ │ │ │ │ - 415 recvData[i] = sendData[i];
│ │ │ │ │ - 416 return 0;
│ │ │ │ │ - 417 }
│ │ │ │ │ - 418
│ │ │ │ │ - 432 template
│ │ │ │ │ -433 int allgather(const T* sbuf, int count, T* rbuf) const
│ │ │ │ │ - 434 {
│ │ │ │ │ - 435 for(const T* end=sbuf+count; sbuf < end; ++sbuf, ++rbuf)
│ │ │ │ │ - 436 *rbuf=*sbuf;
│ │ │ │ │ - 437 return 0;
│ │ │ │ │ - 438 }
│ │ │ │ │ - 439
│ │ │ │ │ - 444 template
│ │ │ │ │ -445 PseudoFuture iallgather(TIN&& data_in, TOUT&& data_out){
│ │ │ │ │ - 446 return {std::forward(data_out)};
│ │ │ │ │ - 447 }
│ │ │ │ │ - 448
│ │ │ │ │ - 465 template
│ │ │ │ │ -466 int allgatherv (const T* in, int sendDataLen, T* out, [[maybe_unused]] int*
│ │ │ │ │ -recvDataLen, int* displ) const
│ │ │ │ │ - 467 {
│ │ │ │ │ - 468 for (int i=*displ; i
│ │ │ │ │ -486 int allreduce([[maybe_unused]] Type* inout, [[maybe_unused]] int len) const
│ │ │ │ │ - 487 {
│ │ │ │ │ - 488 return 0;
│ │ │ │ │ - 489 }
│ │ │ │ │ - 490
│ │ │ │ │ - 495 template
│ │ │ │ │ -496 PseudoFuture iallreduce(TIN&& data_in, TOUT&& data_out){
│ │ │ │ │ - 497 data_out = std::forward(data_in);
│ │ │ │ │ - 498 return {std::forward(data_out)};
│ │ │ │ │ - 499 }
│ │ │ │ │ - 500
│ │ │ │ │ - 505 template
│ │ │ │ │ -506 PseudoFuture iallreduce(T&& data){
│ │ │ │ │ - 507 return {std::forward(data)};
│ │ │ │ │ - 508 }
│ │ │ │ │ - 509
│ │ │ │ │ - 510
│ │ │ │ │ - 524 template
│ │ │ │ │ -525 int allreduce(const Type* in, Type* out, int len) const
│ │ │ │ │ - 526 {
│ │ │ │ │ - 527 std::copy(in, in+len, out);
│ │ │ │ │ - 528 return 0;
│ │ │ │ │ - 529 }
│ │ │ │ │ - 530
│ │ │ │ │ - 531 };
│ │ │ │ │ - 532
│ │ │ │ │ - 538 template
│ │ │ │ │ -539 using CollectiveCommunication
│ │ │ │ │ - 540 [[deprecated("CollectiveCommunication is deprecated. Use Communication
│ │ │ │ │ -instead.")]]
│ │ │ │ │ - 541 = Communication;
│ │ │ │ │ - 542}
│ │ │ │ │ - 543
│ │ │ │ │ - 544#endif
│ │ │ │ │ -future.hh
│ │ │ │ │ -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
│ │ │ │ │ +45 pointer address(reference x) const
│ │ │ │ │ + 46 {
│ │ │ │ │ + 47 return &x;
│ │ │ │ │ + 48 }
│ │ │ │ │ +49 const_pointer address(const_reference x) const
│ │ │ │ │ + 50 {
│ │ │ │ │ + 51 return &x;
│ │ │ │ │ + 52 }
│ │ │ │ │ + 53
│ │ │ │ │ +55 pointer allocate(size_type n,
│ │ │ │ │ + 56 [[maybe_unused]] const void* hint = 0)
│ │ │ │ │ + 57 {
│ │ │ │ │ + 58 if (n > this->max_size())
│ │ │ │ │ + 59 throw std::bad_alloc();
│ │ │ │ │ + 60
│ │ │ │ │ + 61 pointer ret = static_cast(std::malloc(n * sizeof(T)));
│ │ │ │ │ + 62 if (!ret)
│ │ │ │ │ + 63 throw std::bad_alloc();
│ │ │ │ │ + 64 return ret;
│ │ │ │ │ + 65 }
│ │ │ │ │ + 66
│ │ │ │ │ +68 void deallocate(pointer p, [[maybe_unused]] size_type n)
│ │ │ │ │ + 69 {
│ │ │ │ │ + 70 std::free(p);
│ │ │ │ │ + 71 }
│ │ │ │ │ + 72
│ │ │ │ │ +74 size_type max_size() const noexcept
│ │ │ │ │ + 75 {
│ │ │ │ │ + 76 return size_type(-1) / sizeof(T);
│ │ │ │ │ + 77 }
│ │ │ │ │ + 78
│ │ │ │ │ +80 void construct(pointer p, const T& val)
│ │ │ │ │ + 81 {
│ │ │ │ │ + 82 ::new((void*)p)T(val);
│ │ │ │ │ + 83 }
│ │ │ │ │ + 84
│ │ │ │ │ + 86 template
│ │ │ │ │ +87 void construct(pointer p, Args&&... args)
│ │ │ │ │ + 88 {
│ │ │ │ │ + 89 ::new((void *)p)T(std::forward(args) ...);
│ │ │ │ │ + 90 }
│ │ │ │ │ + 91
│ │ │ │ │ +93 void destroy(pointer p)
│ │ │ │ │ + 94 {
│ │ │ │ │ + 95 p->~T();
│ │ │ │ │ + 96 }
│ │ │ │ │ + 97 };
│ │ │ │ │ + 98
│ │ │ │ │ + 100 template
│ │ │ │ │ + 101 constexpr bool
│ │ │ │ │ +102 operator==(const MallocAllocator &, const MallocAllocator &)
│ │ │ │ │ + 103 {
│ │ │ │ │ + 104 return true;
│ │ │ │ │ + 105 }
│ │ │ │ │ + 106
│ │ │ │ │ + 108 template
│ │ │ │ │ + 109 constexpr bool
│ │ │ │ │ +110 operator!=(const MallocAllocator &, const MallocAllocator &)
│ │ │ │ │ + 111 {
│ │ │ │ │ + 112 return false;
│ │ │ │ │ + 113 }
│ │ │ │ │ + 114}
│ │ │ │ │ + 115
│ │ │ │ │ + 116#endif // DUNE_MALLOC_ALLOCATOR_HH
│ │ │ │ │ Dune::operator==
│ │ │ │ │ EnableIfInterOperable< T1, T2, bool >::type operator==(const
│ │ │ │ │ ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2,
│ │ │ │ │ V2, R2, D > &rhs)
│ │ │ │ │ Checks for equality.
│ │ │ │ │ Definition: iteratorfacades.hh:237
│ │ │ │ │ Dune::operator!=
│ │ │ │ │ @@ -315,173 +119,82 @@
│ │ │ │ │ ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2,
│ │ │ │ │ V2, R2, D > &rhs)
│ │ │ │ │ Checks for inequality.
│ │ │ │ │ Definition: iteratorfacades.hh:259
│ │ │ │ │ Dune
│ │ │ │ │ Dune namespace.
│ │ │ │ │ Definition: alignedallocator.hh:13
│ │ │ │ │ -Dune::ParallelError
│ │ │ │ │ -Default exception if an error in the parallel communication of the program
│ │ │ │ │ -occurred.
│ │ │ │ │ -Definition: exceptions.hh:287
│ │ │ │ │ -Dune::No_Comm
│ │ │ │ │ -Definition: communication.hh:46
│ │ │ │ │ -Dune::Communication
│ │ │ │ │ -Collective communication interface and sequential default implementation.
│ │ │ │ │ -Definition: communication.hh:100
│ │ │ │ │ -Dune::Communication::iallreduce
│ │ │ │ │ -PseudoFuture< TOUT > iallreduce(TIN &&data_in, TOUT &&data_out)
│ │ │ │ │ -Compute something over all processes nonblocking.
│ │ │ │ │ -Definition: communication.hh:496
│ │ │ │ │ -Dune::Communication::send
│ │ │ │ │ -int send(const T &data, int dest_rank, int tag)
│ │ │ │ │ -Sends the data to the dest_rank.
│ │ │ │ │ -Definition: communication.hh:135
│ │ │ │ │ -Dune::Communication::allreduce
│ │ │ │ │ -int allreduce(const Type *in, Type *out, int len) const
│ │ │ │ │ -Compute something over all processes for each component of an array and return
│ │ │ │ │ -the result in every pr...
│ │ │ │ │ -Definition: communication.hh:525
│ │ │ │ │ -Dune::Communication::max
│ │ │ │ │ -T max(const T &in) const
│ │ │ │ │ -Compute the maximum of the argument over all processes and return the result in
│ │ │ │ │ -every process....
│ │ │ │ │ -Definition: communication.hh:248
│ │ │ │ │ -Dune::Communication::rank
│ │ │ │ │ -int rank() const
│ │ │ │ │ -Return rank, is between 0 and size()-1.
│ │ │ │ │ -Definition: communication.hh:114
│ │ │ │ │ -Dune::Communication::sum
│ │ │ │ │ -T sum(const T &in) const
│ │ │ │ │ -Compute the sum of the argument over all processes and return the result in
│ │ │ │ │ -every process....
│ │ │ │ │ -Definition: communication.hh:188
│ │ │ │ │ -Dune::Communication::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: communication.hh:411
│ │ │ │ │ -Dune::Communication::prod
│ │ │ │ │ -int prod(T *inout, int len) const
│ │ │ │ │ -Compute the product over all processes for each component of an array and
│ │ │ │ │ -return the result in every ...
│ │ │ │ │ -Definition: communication.hh:219
│ │ │ │ │ -Dune::Communication::recv
│ │ │ │ │ -T recv(T &&data, int source_rank, int tag, void *status=0)
│ │ │ │ │ -Receives the data from the source_rank.
│ │ │ │ │ -Definition: communication.hh:157
│ │ │ │ │ -Dune::Communication::isend
│ │ │ │ │ -PseudoFuture< T > isend(const T &&data, int dest_rank, int tag)
│ │ │ │ │ -Sends the data to the dest_rank nonblocking.
│ │ │ │ │ -Definition: communication.hh:146
│ │ │ │ │ -Dune::Communication::ibarrier
│ │ │ │ │ -PseudoFuture< void > ibarrier() const
│ │ │ │ │ -Nonblocking barrier.
│ │ │ │ │ -Definition: communication.hh:275
│ │ │ │ │ -Dune::Communication::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: communication.hh:486
│ │ │ │ │ -Dune::Communication::size
│ │ │ │ │ -int size() const
│ │ │ │ │ -Number of processes in set, is greater than 0.
│ │ │ │ │ -Definition: communication.hh:126
│ │ │ │ │ -Dune::Communication::sum
│ │ │ │ │ -int sum(T *inout, int len) const
│ │ │ │ │ -Compute the sum over all processes for each component of an array and return
│ │ │ │ │ -the result in every proc...
│ │ │ │ │ -Definition: communication.hh:199
│ │ │ │ │ -Dune::Communication::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: communication.hh:466
│ │ │ │ │ -Dune::Communication::min
│ │ │ │ │ -T min(const T &in) const
│ │ │ │ │ -Compute the minimum of the argument over all processes and return the result in
│ │ │ │ │ -every process....
│ │ │ │ │ -Definition: communication.hh:228
│ │ │ │ │ -Dune::Communication::irecv
│ │ │ │ │ -PseudoFuture< T > irecv(T &&data, int source_rank, int tag)
│ │ │ │ │ -Receives the data from the source_rank nonblocking.
│ │ │ │ │ -Definition: communication.hh:169
│ │ │ │ │ -Dune::Communication::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: communication.hh:350
│ │ │ │ │ -Dune::Communication::ibroadcast
│ │ │ │ │ -PseudoFuture< T > ibroadcast(T &&data, int root) const
│ │ │ │ │ -Distribute an array from the process with rank root to all other processes
│ │ │ │ │ -nonblocking.
│ │ │ │ │ -Definition: communication.hh:295
│ │ │ │ │ -Dune::Communication::allgather
│ │ │ │ │ -int allgather(const T *sbuf, int count, T *rbuf) const
│ │ │ │ │ -Gathers data from all tasks and distribute it to all.
│ │ │ │ │ -Definition: communication.hh:433
│ │ │ │ │ -Dune::Communication::scatter
│ │ │ │ │ -int scatter(const T *sendData, T *recvData, int len, int root) const
│ │ │ │ │ -Scatter array from a root to all other task.
│ │ │ │ │ -Definition: communication.hh:376
│ │ │ │ │ -Dune::Communication::gather
│ │ │ │ │ -int gather(const T *in, T *out, int len, int root) const
│ │ │ │ │ -Gather arrays on root task.
│ │ │ │ │ -Definition: communication.hh:313
│ │ │ │ │ -Dune::Communication::iallreduce
│ │ │ │ │ -PseudoFuture< T > iallreduce(T &&data)
│ │ │ │ │ -Compute something over all processes nonblocking and in-place.
│ │ │ │ │ -Definition: communication.hh:506
│ │ │ │ │ -Dune::Communication::Communication
│ │ │ │ │ -Communication(const Communicator &)
│ │ │ │ │ -Constructor with a given communicator.
│ │ │ │ │ -Definition: communication.hh:110
│ │ │ │ │ -Dune::Communication::max
│ │ │ │ │ -int max(T *inout, int len) const
│ │ │ │ │ -Compute the maximum over all processes for each component of an array and
│ │ │ │ │ -return the result in every ...
│ │ │ │ │ -Definition: communication.hh:259
│ │ │ │ │ -Dune::Communication::prod
│ │ │ │ │ -T prod(const T &in) const
│ │ │ │ │ -Compute the product of the argument over all processes and return the result in
│ │ │ │ │ -every process....
│ │ │ │ │ -Definition: communication.hh:208
│ │ │ │ │ -Dune::Communication::broadcast
│ │ │ │ │ -int broadcast(T *inout, int len, int root) const
│ │ │ │ │ -Distribute an array from the process with rank root to all other processes.
│ │ │ │ │ -Definition: communication.hh:284
│ │ │ │ │ -Dune::Communication::rrecv
│ │ │ │ │ -T rrecv(T &&data, int source_rank, int tag, void *status=0) const
│ │ │ │ │ -Definition: communication.hh:177
│ │ │ │ │ -Dune::Communication::iscatter
│ │ │ │ │ -PseudoFuture< TOUT > iscatter(TIN &&data_in, TOUT &&data_out, int root)
│ │ │ │ │ -Scatter array from a root to all other task nonblocking.
│ │ │ │ │ -Definition: communication.hh:387
│ │ │ │ │ -Dune::Communication::min
│ │ │ │ │ -int min(T *inout, int len) const
│ │ │ │ │ -Compute the minimum over all processes for each component of an array and
│ │ │ │ │ -return the result in every ...
│ │ │ │ │ -Definition: communication.hh:239
│ │ │ │ │ -Dune::Communication::barrier
│ │ │ │ │ -int barrier() const
│ │ │ │ │ -Wait until all processes have arrived at this point in the program.
│ │ │ │ │ -Definition: communication.hh:267
│ │ │ │ │ -Dune::Communication::igather
│ │ │ │ │ -PseudoFuture< TOUT > igather(TIN &&data_in, TOUT &&data_out, int root)
│ │ │ │ │ -Gather arrays on root task nonblocking.
│ │ │ │ │ -Definition: communication.hh:324
│ │ │ │ │ -Dune::Communication::iallgather
│ │ │ │ │ -PseudoFuture< TOUT > iallgather(TIN &&data_in, TOUT &&data_out)
│ │ │ │ │ -Gathers data from all tasks and distribute it to all nonblocking.
│ │ │ │ │ -Definition: communication.hh:445
│ │ │ │ │ -Dune::Communication::Communication
│ │ │ │ │ -Communication()
│ │ │ │ │ -Construct default object.
│ │ │ │ │ -Definition: communication.hh:103
│ │ │ │ │ -Dune::PseudoFuture
│ │ │ │ │ -A wrapper-class for a object which is ready immediately.
│ │ │ │ │ -Definition: future.hh:122
│ │ │ │ │ -Dune::PseudoFuture<_void_>
│ │ │ │ │ -Definition: future.hh:160
│ │ │ │ │ +Dune::MallocAllocator
│ │ │ │ │ +Allocators implementation which simply calls malloc/free.
│ │ │ │ │ +Definition: mallocallocator.hh:24
│ │ │ │ │ +Dune::MallocAllocator::~MallocAllocator
│ │ │ │ │ +~MallocAllocator() noexcept
│ │ │ │ │ +cleanup this allocator
│ │ │ │ │ +Definition: mallocallocator.hh:43
│ │ │ │ │ +Dune::MallocAllocator::pointer
│ │ │ │ │ +T * pointer
│ │ │ │ │ +Definition: mallocallocator.hh:28
│ │ │ │ │ +Dune::MallocAllocator::construct
│ │ │ │ │ +void construct(pointer p, const T &val)
│ │ │ │ │ +copy-construct an object of type T (i.e. make a placement new on p)
│ │ │ │ │ +Definition: mallocallocator.hh:80
│ │ │ │ │ +Dune::MallocAllocator::MallocAllocator
│ │ │ │ │ +MallocAllocator() noexcept
│ │ │ │ │ +create a new MallocAllocator
│ │ │ │ │ +Definition: mallocallocator.hh:38
│ │ │ │ │ +Dune::MallocAllocator::MallocAllocator
│ │ │ │ │ +MallocAllocator(const MallocAllocator< U > &) noexcept
│ │ │ │ │ +copy construct from an other MallocAllocator, possibly for a different result
│ │ │ │ │ +type
│ │ │ │ │ +Definition: mallocallocator.hh:41
│ │ │ │ │ +Dune::MallocAllocator::size_type
│ │ │ │ │ +std::size_t size_type
│ │ │ │ │ +Definition: mallocallocator.hh:26
│ │ │ │ │ +Dune::MallocAllocator::difference_type
│ │ │ │ │ +std::ptrdiff_t difference_type
│ │ │ │ │ +Definition: mallocallocator.hh:27
│ │ │ │ │ +Dune::MallocAllocator::deallocate
│ │ │ │ │ +void deallocate(pointer p, size_type n)
│ │ │ │ │ +deallocate n objects of type T at address p
│ │ │ │ │ +Definition: mallocallocator.hh:68
│ │ │ │ │ +Dune::MallocAllocator::value_type
│ │ │ │ │ +T value_type
│ │ │ │ │ +Definition: mallocallocator.hh:32
│ │ │ │ │ +Dune::MallocAllocator::address
│ │ │ │ │ +const_pointer address(const_reference x) const
│ │ │ │ │ +Definition: mallocallocator.hh:49
│ │ │ │ │ +Dune::MallocAllocator::const_reference
│ │ │ │ │ +const T & const_reference
│ │ │ │ │ +Definition: mallocallocator.hh:31
│ │ │ │ │ +Dune::MallocAllocator::destroy
│ │ │ │ │ +void destroy(pointer p)
│ │ │ │ │ +destroy an object of type T (i.e. call the destructor)
│ │ │ │ │ +Definition: mallocallocator.hh:93
│ │ │ │ │ +Dune::MallocAllocator::allocate
│ │ │ │ │ +pointer allocate(size_type n, const void *hint=0)
│ │ │ │ │ +allocate n objects of type T
│ │ │ │ │ +Definition: mallocallocator.hh:55
│ │ │ │ │ +Dune::MallocAllocator::address
│ │ │ │ │ +pointer address(reference x) const
│ │ │ │ │ +Definition: mallocallocator.hh:45
│ │ │ │ │ +Dune::MallocAllocator::construct
│ │ │ │ │ +void construct(pointer p, Args &&... args)
│ │ │ │ │ +construct an object of type T from variadic parameters
│ │ │ │ │ +Definition: mallocallocator.hh:87
│ │ │ │ │ +Dune::MallocAllocator::reference
│ │ │ │ │ +T & reference
│ │ │ │ │ +Definition: mallocallocator.hh:30
│ │ │ │ │ +Dune::MallocAllocator::max_size
│ │ │ │ │ +size_type max_size() const noexcept
│ │ │ │ │ +max size for allocate
│ │ │ │ │ +Definition: mallocallocator.hh:74
│ │ │ │ │ +Dune::MallocAllocator::const_pointer
│ │ │ │ │ +const T * const_pointer
│ │ │ │ │ +Definition: mallocallocator.hh:29
│ │ │ │ │ +Dune::MallocAllocator::rebind
│ │ │ │ │ +Definition: mallocallocator.hh:33
│ │ │ │ │ +Dune::MallocAllocator::rebind::other
│ │ │ │ │ +MallocAllocator< U > other
│ │ │ │ │ +Definition: mallocallocator.hh:34
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-common-doc/doxygen/a00026.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-common: mpihelper.hh File Reference
│ │ │ │ +dune-common: filledarray.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │ -
Helpers for dealing with MPI.
│ │ │ │ +
Utility to generate an array with a certain value.
│ │ │ │ More...
│ │ │ │ -
#include <cassert>
│ │ │ │ -
#include <mpi.h>
│ │ │ │ -
#include <mutex>
│ │ │ │ -
#include <dune/common/parallel/communication.hh >
│ │ │ │ -
#include <dune/common/parallel/mpicommunication.hh >
│ │ │ │ -
#include <dune/common/stdstreams.hh >
│ │ │ │ -
#include <dune/common/visibility.hh >
│ │ │ │ +
#include <array>#include <cstddef>
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ namespace Dune Dune namespace.
│ │ │ │ +template<std::size_t n, class T > constexpr std::array< T, n > Dune::filledArray (const T &t) Return an array filled with the provided value. More...
│ │ │ │
│ │ │ │ -
Helpers for dealing with MPI.
│ │ │ │ -
Basically there are two helpers available:
│ │ │ │ -FakeMPIHelper
│ │ │ │ -A class adhering to the interface of MPIHelper that does not need MPI at all. This can be used to create a sequential program even if MPI is used to compile it.
│ │ │ │ -MPIHelper
│ │ │ │ -A real MPI helper. When the singleton gets instantiated MPI_Init will be called and before the program exits MPI_Finalize will be called.
│ │ │ │ -
│ │ │ │ -
Example of who to use these classes:
│ │ │ │ -
A program that is parallel if compiled with MPI and sequential otherwise:
int main (
int argc,
char ** argv){
│ │ │ │ -
│ │ │ │ -
MPIHelper::instance(argc, argv);
│ │ │ │ -
typename MPIHelper::MPICommunicator world =
│ │ │ │ -
MPIHelper::getCommunicator();
│ │ │ │ -
...
│ │ │ │ -
int main(int argc, char **argv)
Definition: mpi_collective_benchmark.cc:293
│ │ │ │ -
A real mpi helper.
Definition: mpihelper.hh:179
│ │ │ │ -
If one wants to have sequential program even if the code is compiled with mpi then one simply has to exchange the typedef with
.
│ │ │ │ -
For checking whether we really use MPI or just fake please use MPIHelper::isFake (this is also possible at compile time!)
│ │ │ │ +
Utility to generate an array with a certain value.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -4,64 +4,28 @@
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ dune-common 2.9.0
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * common
│ │ │ │ │ - * parallel
│ │ │ │ │ -Classes | Namespaces
│ │ │ │ │ -mpihelper.hh File Reference
│ │ │ │ │ -Common » Parallel_Communication
│ │ │ │ │ -Helpers for dealing with MPI. More...
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ +Namespaces | Functions
│ │ │ │ │ +filledarray.hh File Reference
│ │ │ │ │ +Utility to generate an array with a certain value. More...
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ Go_to_the_source_code_of_this_file.
│ │ │ │ │ - Classes
│ │ │ │ │ -class Dune::FakeMPIHelper
│ │ │ │ │ - A fake mpi helper. More...
│ │ │ │ │ -
│ │ │ │ │ -class Dune::MPIHelper
│ │ │ │ │ - A real mpi helper. More...
│ │ │ │ │ -
│ │ │ │ │ Namespaces
│ │ │ │ │ namespace Dune
│ │ │ │ │ Dune namespace.
│ │ │ │ │
│ │ │ │ │ + Functions
│ │ │ │ │ +template
│ │ │ │ │ +constexpr std::array< T, n > Dune::filledArray (const T &t)
│ │ │ │ │ + Return an array filled with the provided value.
│ │ │ │ │ + More...
│ │ │ │ │ +
│ │ │ │ │ ***** Detailed Description *****
│ │ │ │ │ -Helpers for dealing with MPI.
│ │ │ │ │ -Basically there are two helpers available:
│ │ │ │ │ - FakeMPIHelper
│ │ │ │ │ - A class adhering to the interface of MPIHelper that does not need MPI at
│ │ │ │ │ - all. This can be used to create a sequential program even if MPI is used
│ │ │ │ │ - to compile it.
│ │ │ │ │ - MPIHelper
│ │ │ │ │ - A real MPI helper. When the singleton gets instantiated MPI_Init will be
│ │ │ │ │ - called and before the program exits MPI_Finalize will be called.
│ │ │ │ │ -Example of who to use these classes:
│ │ │ │ │ -A program that is parallel if compiled with MPI and sequential otherwise:
│ │ │ │ │ -int main(int argc, char** argv){
│ │ │ │ │ -typedef Dune::MPIHelper MPIHelper;
│ │ │ │ │ -MPIHelper::instance(argc, argv);
│ │ │ │ │ -typename MPIHelper::MPICommunicator world =
│ │ │ │ │ -MPIHelper::getCommunicator();
│ │ │ │ │ -...
│ │ │ │ │ -main
│ │ │ │ │ -int main(int argc, char **argv)
│ │ │ │ │ -Definition: mpi_collective_benchmark.cc:293
│ │ │ │ │ -Dune::MPIHelper
│ │ │ │ │ -A real mpi helper.
│ │ │ │ │ -Definition: mpihelper.hh:179
│ │ │ │ │ -If one wants to have sequential program even if the code is compiled with mpi
│ │ │ │ │ -then one simply has to exchange the typedef with
│ │ │ │ │ -typedef Dune::MPIHelper FakeMPIHelper;
│ │ │ │ │ -.
│ │ │ │ │ -For checking whether we really use MPI or just fake please use MPIHelper::
│ │ │ │ │ -isFake (this is also possible at compile time!)
│ │ │ │ │ +Utility to generate an array with a certain value.
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-common-doc/doxygen/a00026_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-common: mpihelper.hh Source File
│ │ │ │ +dune-common: filledarray.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
117 [[deprecated(
"getCollectionCommunication is deprecated. Use getCommunication instead." )]]
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
145 [[maybe_unused]]
char ** argv)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
159 int rank ()
const {
return 0; }
│ │ │ │ -
163 int size ()
const {
return 1; }
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
167 FakeMPIHelper(
const FakeMPIHelper&);
│ │ │ │ -
168 FakeMPIHelper& operator=(
const FakeMPIHelper);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
200 return MPI_COMM_WORLD;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
211 return MPI_COMM_SELF;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
219 [[deprecated(
"getCollectionCommunication is deprecated. Use getCommunication instead." )]]
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
250 static std::mutex mutex;
│ │ │ │ -
251 std::lock_guard<std::mutex> guard(mutex);
│ │ │ │ -
│ │ │ │ -
253 instance_.reset(
new MPIHelper (argc,argv));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
268 int rank ()
const {
return rank_; }
│ │ │ │ -
272 int size ()
const {
return size_; }
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
277 int wasFinalized = -1;
│ │ │ │ -
278 MPI_Finalized( &wasFinalized );
│ │ │ │ -
279 if (!wasFinalized && initializedHere_)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
282 dverb <<
"Called MPI_Finalize on p=" << rank_ <<
"!" <<std::endl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
290 bool initializedHere_;
│ │ │ │ -
291 void prevent_warning(
int ){}
│ │ │ │ -
292 static inline std::unique_ptr<MPIHelper> instance_ = {};
│ │ │ │ -
│ │ │ │ -
295 MPIHelper(
int & argc,
char **& argv)
│ │ │ │ -
296 : initializedHere_(false)
│ │ │ │ -
│ │ │ │ -
298 int wasInitialized = -1;
│ │ │ │ -
299 MPI_Initialized( &wasInitialized );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
304 static int is_initialized = MPI_Init(&argc, &argv);
│ │ │ │ -
305 prevent_warning(is_initialized);
│ │ │ │ -
306 initializedHere_ =
true ;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
309 MPI_Comm_rank(MPI_COMM_WORLD,&rank_);
│ │ │ │ -
310 MPI_Comm_size(MPI_COMM_WORLD,&size_);
│ │ │ │ -
│ │ │ │ -
312 assert( rank_ >= 0 );
│ │ │ │ -
313 assert( size_ >= 1 );
│ │ │ │ -
│ │ │ │ -
315 dverb <<
"Called MPI_Init on p=" << rank_ <<
"!" << std::endl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
318 MPIHelper(
const MPIHelper&);
│ │ │ │ -
319 MPIHelper& operator=(
const MPIHelper);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
328 typedef FakeMPIHelper MPIHelper;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
Implements an utility class that provides collective communication methods for sequential programs.
│ │ │ │ -
Implements an utility class that provides MPI's collective communication methods.
│ │ │ │ -
Definition of macros controlling symbol visibility at the ABI level.
│ │ │ │ -
#define DUNE_EXPORT
Export a symbol as part of the public ABI.
Definition: visibility.hh:20
│ │ │ │ -
Standard Dune debug streams.
│ │ │ │ -
#define DUNE_THROW(E, m)
Definition: exceptions.hh:218
│ │ │ │ -
DVerbType dverb(std::cout)
Singleton of verbose debug stream.
Definition: stdstreams.hh:116
│ │ │ │ +
│ │ │ │ +
6 #ifndef DUNE_COMMON_FILLED_ARRAY_HH
│ │ │ │ +
7 #define DUNE_COMMON_FILLED_ARRAY_HH
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
32 template <std::
size_t n,
class T>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
35 std::array<T, n> arr{};
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
constexpr std::array< T, n > filledArray(const T &t)
Return an array filled with the provided value.
Definition: filledarray.hh:33
│ │ │ │
Dune namespace.
Definition: alignedallocator.hh:13
│ │ │ │ -
Default exception if a function was called while the object is not in a valid state for that function...
Definition: exceptions.hh:281
│ │ │ │ -
Definition: communication.hh:46
│ │ │ │ -
Collective communication interface and sequential default implementation.
Definition: communication.hh:100
│ │ │ │ -
A fake mpi helper.
Definition: mpihelper.hh:74
│ │ │ │ -
static DUNE_EXPORT MPICommunicator getCommunicator()
get the default communicator
Definition: mpihelper.hh:93
│ │ │ │ -
int size() const
return rank of process, i.e. one
Definition: mpihelper.hh:163
│ │ │ │ -
static Communication< MPICommunicator > getCollectiveCommunication()
Definition: mpihelper.hh:118
│ │ │ │ -
static MPICommunicator getLocalCommunicator()
get a local communicator
Definition: mpihelper.hh:105
│ │ │ │ -
No_Comm MPICommunicator
The type of the mpi communicator.
Definition: mpihelper.hh:85
│ │ │ │ -
static DUNE_EXPORT FakeMPIHelper & instance(int argc, char **argv)
Get the singleton instance of the helper.
Definition: mpihelper.hh:144
│ │ │ │ -
static DUNE_EXPORT FakeMPIHelper & instance()
Definition: mpihelper.hh:150
│ │ │ │ -
static Communication< MPICommunicator > getCommunication()
Definition: mpihelper.hh:124
│ │ │ │ -
static constexpr bool isFake
Are we fake (i.e. pretend to have MPI support but are compiled without.)
Definition: mpihelper.hh:80
│ │ │ │ -
int rank() const
return rank of process, i.e. zero
Definition: mpihelper.hh:159
│ │ │ │ -
A real mpi helper.
Definition: mpihelper.hh:179
│ │ │ │ -
int size() const
return number of processes
Definition: mpihelper.hh:272
│ │ │ │ -
static DUNE_EXPORT MPIHelper & instance()
Definition: mpihelper.hh:258
│ │ │ │ -
static constexpr bool isFake
Are we fake (i. e. pretend to have MPI support but are compiled without.
Definition: mpihelper.hh:185
│ │ │ │ -
static DUNE_EXPORT MPIHelper & instance(int &argc, char **&argv)
Get the singleton instance of the helper.
Definition: mpihelper.hh:246
│ │ │ │ -
static Communication< MPICommunicator > getCommunication()
Definition: mpihelper.hh:227
│ │ │ │ -
~MPIHelper()
calls MPI_Finalize
Definition: mpihelper.hh:275
│ │ │ │ -
int rank() const
return rank of process
Definition: mpihelper.hh:268
│ │ │ │ -
MPI_Comm MPICommunicator
The type of the mpi communicator.
Definition: mpihelper.hh:190
│ │ │ │ -
static MPICommunicator getCommunicator()
get the default communicator
Definition: mpihelper.hh:198
│ │ │ │ -
static MPICommunicator getLocalCommunicator()
get a local communicator
Definition: mpihelper.hh:209
│ │ │ │ -
static Communication< MPICommunicator > getCollectiveCommunication()
Definition: mpihelper.hh:221
│ │ │ │
│ │ │ │ │ - 10#include
│ │ │ │ │ - 11#endif
│ │ │ │ │ - 12
│ │ │ │ │ - 13#include
│ │ │ │ │ - 14
│ │ │ │ │ - 15#include
│ │ │ │ │ - 16#if HAVE_MPI
│ │ │ │ │ - 17#include
│ │ │ │ │ - 18#include
│ │ │ │ │ - 19#endif
│ │ │ │ │ - 20#include
│ │ │ │ │ - 21
│ │ │ │ │ - 22namespace Dune
│ │ │ │ │ - 23{
│ │ │ │ │ -73 class FakeMPIHelper
│ │ │ │ │ - 74 {
│ │ │ │ │ - 75 public:
│ │ │ │ │ -80 constexpr static bool isFake = true;
│ │ │ │ │ - 81
│ │ │ │ │ -85 typedef No_Comm MPICommunicator;
│ │ │ │ │ - 86
│ │ │ │ │ -93 DUNE_EXPORT static MPICommunicator getCommunicator ()
│ │ │ │ │ - 94 {
│ │ │ │ │ - 95 static MPICommunicator comm;
│ │ │ │ │ - 96 return comm;
│ │ │ │ │ - 97 }
│ │ │ │ │ - 98
│ │ │ │ │ -105 static MPICommunicator getLocalCommunicator ()
│ │ │ │ │ - 106 {
│ │ │ │ │ - 107 return getCommunicator();
│ │ │ │ │ - 108 }
│ │ │ │ │ - 109
│ │ │ │ │ - 110
│ │ │ │ │ - 111
│ │ │ │ │ - 117 [[deprecated("getCollectionCommunication is deprecated. Use
│ │ │ │ │ -getCommunication instead.")]]
│ │ │ │ │ -118 static Communication getCollectiveCommunication()
│ │ │ │ │ - 119 {
│ │ │ │ │ - 120 return Communication(getCommunicator());
│ │ │ │ │ - 121 }
│ │ │ │ │ - 122
│ │ │ │ │ - 123 static Communication
│ │ │ │ │ -124 getCommunication()
│ │ │ │ │ - 125 {
│ │ │ │ │ - 126 return Communication(getCommunicator());
│ │ │ │ │ - 127 }
│ │ │ │ │ - 128
│ │ │ │ │ -144 DUNE_EXPORT static FakeMPIHelper& instance([[maybe_unused]] int argc,
│ │ │ │ │ - 145 [[maybe_unused]] char** argv)
│ │ │ │ │ - 146 {
│ │ │ │ │ - 147 return instance();
│ │ │ │ │ - 148 }
│ │ │ │ │ - 149
│ │ │ │ │ -150 DUNE_EXPORT static FakeMPIHelper& instance()
│ │ │ │ │ - 151 {
│ │ │ │ │ - 152 static FakeMPIHelper singleton;
│ │ │ │ │ - 153 return singleton;
│ │ │ │ │ - 154 }
│ │ │ │ │ - 155
│ │ │ │ │ -159 int rank () const { return 0; }
│ │ │ │ │ -163 int size () const { return 1; }
│ │ │ │ │ - 164
│ │ │ │ │ - 165 private:
│ │ │ │ │ - 166 FakeMPIHelper() {}
│ │ │ │ │ - 167 FakeMPIHelper(const FakeMPIHelper&);
│ │ │ │ │ - 168 FakeMPIHelper& operator=(const FakeMPIHelper);
│ │ │ │ │ - 169 };
│ │ │ │ │ - 170
│ │ │ │ │ - 171#if HAVE_MPI
│ │ │ │ │ -178 class MPIHelper
│ │ │ │ │ - 179 {
│ │ │ │ │ - 180 public:
│ │ │ │ │ -185 constexpr static bool isFake = false;
│ │ │ │ │ - 186
│ │ │ │ │ -190 typedef MPI_Comm MPICommunicator;
│ │ │ │ │ - 191
│ │ │ │ │ -198 static MPICommunicator getCommunicator ()
│ │ │ │ │ - 199 {
│ │ │ │ │ - 200 return MPI_COMM_WORLD;
│ │ │ │ │ - 201 }
│ │ │ │ │ - 202
│ │ │ │ │ -209 static MPICommunicator getLocalCommunicator ()
│ │ │ │ │ - 210 {
│ │ │ │ │ - 211 return MPI_COMM_SELF;
│ │ │ │ │ - 212 }
│ │ │ │ │ - 213
│ │ │ │ │ - 219 [[deprecated("getCollectionCommunication is deprecated. Use
│ │ │ │ │ -getCommunication instead.")]]
│ │ │ │ │ - 220 static Communication
│ │ │ │ │ -221 getCollectiveCommunication()
│ │ │ │ │ - 222 {
│ │ │ │ │ - 223 return Communication(getCommunicator());
│ │ │ │ │ - 224 }
│ │ │ │ │ - 225
│ │ │ │ │ - 226 static Communication
│ │ │ │ │ -227 getCommunication()
│ │ │ │ │ - 228 {
│ │ │ │ │ - 229 return Communication(getCommunicator());
│ │ │ │ │ - 230 }
│ │ │ │ │ -246 DUNE_EXPORT static MPIHelper& instance(int& argc, char**& argv)
│ │ │ │ │ - 247 {
│ │ │ │ │ - 248 // create singleton instance
│ │ │ │ │ - 249 if (!instance_){
│ │ │ │ │ - 250 static std::mutex mutex;
│ │ │ │ │ - 251 std::lock_guard guard(mutex);
│ │ │ │ │ - 252 if(!instance_)
│ │ │ │ │ - 253 instance_.reset(new MPIHelper(argc,argv));
│ │ │ │ │ - 254 }
│ │ │ │ │ - 255 return *instance_;
│ │ │ │ │ - 256 }
│ │ │ │ │ - 257
│ │ │ │ │ -258 DUNE_EXPORT static MPIHelper& instance()
│ │ │ │ │ - 259 {
│ │ │ │ │ - 260 if(!instance_)
│ │ │ │ │ - 261 DUNE_THROW(InvalidStateException, "MPIHelper not initialized! Call
│ │ │ │ │ -MPIHelper::instance(argc, argv) with arguments first.");
│ │ │ │ │ - 262 return *instance_;
│ │ │ │ │ - 263 }
│ │ │ │ │ - 264
│ │ │ │ │ -268 int rank () const { return rank_; }
│ │ │ │ │ -272 int size () const { return size_; }
│ │ │ │ │ - 273
│ │ │ │ │ -275 ~MPIHelper()
│ │ │ │ │ - 276 {
│ │ │ │ │ - 277 int wasFinalized = -1;
│ │ │ │ │ - 278 MPI_Finalized( &wasFinalized );
│ │ │ │ │ - 279 if(!wasFinalized && initializedHere_)
│ │ │ │ │ - 280 {
│ │ │ │ │ - 281 MPI_Finalize();
│ │ │ │ │ - 282 dverb << "Called MPI_Finalize on p=" << rank_ << "!" < instance_ = {};
│ │ │ │ │ - 293
│ │ │ │ │ - 295 MPIHelper(int& argc, char**& argv)
│ │ │ │ │ - 296 : initializedHere_(false)
│ │ │ │ │ - 297 {
│ │ │ │ │ - 298 int wasInitialized = -1;
│ │ │ │ │ - 299 MPI_Initialized( &wasInitialized );
│ │ │ │ │ - 300 if(!wasInitialized)
│ │ │ │ │ - 301 {
│ │ │ │ │ - 302 rank_ = -1;
│ │ │ │ │ - 303 size_ = -1;
│ │ │ │ │ - 304 static int is_initialized = MPI_Init(&argc, &argv);
│ │ │ │ │ - 305 prevent_warning(is_initialized);
│ │ │ │ │ - 306 initializedHere_ = true;
│ │ │ │ │ - 307 }
│ │ │ │ │ - 308
│ │ │ │ │ - 309 MPI_Comm_rank(MPI_COMM_WORLD,&rank_);
│ │ │ │ │ - 310 MPI_Comm_size(MPI_COMM_WORLD,&size_);
│ │ │ │ │ - 311
│ │ │ │ │ - 312 assert( rank_ >= 0 );
│ │ │ │ │ - 313 assert( size_ >= 1 );
│ │ │ │ │ - 314
│ │ │ │ │ - 315 dverb << "Called MPI_Init on p=" << rank_ << "!" << std::endl;
│ │ │ │ │ - 316 }
│ │ │ │ │ - 317
│ │ │ │ │ - 318 MPIHelper(const MPIHelper&);
│ │ │ │ │ - 319 MPIHelper& operator=(const MPIHelper);
│ │ │ │ │ - 320 };
│ │ │ │ │ - 321#else // !HAVE_MPI
│ │ │ │ │ - 322 // We do not have MPI therefore FakeMPIHelper
│ │ │ │ │ - 323 // is the MPIHelper
│ │ │ │ │ - 328 typedef FakeMPIHelper MPIHelper;
│ │ │ │ │ - 329
│ │ │ │ │ - 330#endif // !HAVE_MPI
│ │ │ │ │ - 331
│ │ │ │ │ - 332} // end namespace Dune
│ │ │ │ │ - 333#endif
│ │ │ │ │ -communication.hh
│ │ │ │ │ -Implements an utility class that provides collective communication methods for
│ │ │ │ │ -sequential programs.
│ │ │ │ │ -mpicommunication.hh
│ │ │ │ │ -Implements an utility class that provides MPI's collective communication
│ │ │ │ │ -methods.
│ │ │ │ │ -visibility.hh
│ │ │ │ │ -Definition of macros controlling symbol visibility at the ABI level.
│ │ │ │ │ -DUNE_EXPORT
│ │ │ │ │ -#define DUNE_EXPORT
│ │ │ │ │ -Export a symbol as part of the public ABI.
│ │ │ │ │ -Definition: visibility.hh:20
│ │ │ │ │ -stdstreams.hh
│ │ │ │ │ -Standard Dune debug streams.
│ │ │ │ │ -DUNE_THROW
│ │ │ │ │ -#define DUNE_THROW(E, m)
│ │ │ │ │ -Definition: exceptions.hh:218
│ │ │ │ │ -Dune::dverb
│ │ │ │ │ -DVerbType dverb(std::cout)
│ │ │ │ │ -Singleton of verbose debug stream.
│ │ │ │ │ -Definition: stdstreams.hh:116
│ │ │ │ │ + 5
│ │ │ │ │ + 6#ifndef DUNE_COMMON_FILLED_ARRAY_HH
│ │ │ │ │ + 7#define DUNE_COMMON_FILLED_ARRAY_HH
│ │ │ │ │ + 8
│ │ │ │ │ + 13#include
│ │ │ │ │ + 14#include
│ │ │ │ │ + 15
│ │ │ │ │ + 16namespace Dune
│ │ │ │ │ + 17{
│ │ │ │ │ + 24
│ │ │ │ │ + 32 template
│ │ │ │ │ +33 constexpr std::array filledArray(const T& t)
│ │ │ │ │ + 34 {
│ │ │ │ │ + 35 std::array arr{};
│ │ │ │ │ + 36 // this is constexpr in c++17, `arr.fill(t)` is not
│ │ │ │ │ + 37 for(auto &el : arr)
│ │ │ │ │ + 38 el = t;
│ │ │ │ │ + 39 return arr;
│ │ │ │ │ + 40 }
│ │ │ │ │ + 41
│ │ │ │ │ + 44} // end namespace Dune
│ │ │ │ │ + 45
│ │ │ │ │ + 46#endif // DUNE_COMMON_FILLED_ARRAY_HH
│ │ │ │ │ +Dune::filledArray
│ │ │ │ │ +constexpr std::array< T, n > filledArray(const T &t)
│ │ │ │ │ +Return an array filled with the provided value.
│ │ │ │ │ +Definition: filledarray.hh:33
│ │ │ │ │ Dune
│ │ │ │ │ Dune namespace.
│ │ │ │ │ Definition: alignedallocator.hh:13
│ │ │ │ │ -Dune::InvalidStateException
│ │ │ │ │ -Default exception if a function was called while the object is not in a valid
│ │ │ │ │ -state for that function...
│ │ │ │ │ -Definition: exceptions.hh:281
│ │ │ │ │ -Dune::No_Comm
│ │ │ │ │ -Definition: communication.hh:46
│ │ │ │ │ -Dune::Communication
│ │ │ │ │ -Collective communication interface and sequential default implementation.
│ │ │ │ │ -Definition: communication.hh:100
│ │ │ │ │ -Dune::FakeMPIHelper
│ │ │ │ │ -A fake mpi helper.
│ │ │ │ │ -Definition: mpihelper.hh:74
│ │ │ │ │ -Dune::FakeMPIHelper::getCommunicator
│ │ │ │ │ -static DUNE_EXPORT MPICommunicator getCommunicator()
│ │ │ │ │ -get the default communicator
│ │ │ │ │ -Definition: mpihelper.hh:93
│ │ │ │ │ -Dune::FakeMPIHelper::size
│ │ │ │ │ -int size() const
│ │ │ │ │ -return rank of process, i.e. one
│ │ │ │ │ -Definition: mpihelper.hh:163
│ │ │ │ │ -Dune::FakeMPIHelper::getCollectiveCommunication
│ │ │ │ │ -static Communication< MPICommunicator > getCollectiveCommunication()
│ │ │ │ │ -Definition: mpihelper.hh:118
│ │ │ │ │ -Dune::FakeMPIHelper::getLocalCommunicator
│ │ │ │ │ -static MPICommunicator getLocalCommunicator()
│ │ │ │ │ -get a local communicator
│ │ │ │ │ -Definition: mpihelper.hh:105
│ │ │ │ │ -Dune::FakeMPIHelper::MPICommunicator
│ │ │ │ │ -No_Comm MPICommunicator
│ │ │ │ │ -The type of the mpi communicator.
│ │ │ │ │ -Definition: mpihelper.hh:85
│ │ │ │ │ -Dune::FakeMPIHelper::instance
│ │ │ │ │ -static DUNE_EXPORT FakeMPIHelper & instance(int argc, char **argv)
│ │ │ │ │ -Get the singleton instance of the helper.
│ │ │ │ │ -Definition: mpihelper.hh:144
│ │ │ │ │ -Dune::FakeMPIHelper::instance
│ │ │ │ │ -static DUNE_EXPORT FakeMPIHelper & instance()
│ │ │ │ │ -Definition: mpihelper.hh:150
│ │ │ │ │ -Dune::FakeMPIHelper::getCommunication
│ │ │ │ │ -static Communication< MPICommunicator > getCommunication()
│ │ │ │ │ -Definition: mpihelper.hh:124
│ │ │ │ │ -Dune::FakeMPIHelper::isFake
│ │ │ │ │ -static constexpr bool isFake
│ │ │ │ │ -Are we fake (i.e. pretend to have MPI support but are compiled without.)
│ │ │ │ │ -Definition: mpihelper.hh:80
│ │ │ │ │ -Dune::FakeMPIHelper::rank
│ │ │ │ │ -int rank() const
│ │ │ │ │ -return rank of process, i.e. zero
│ │ │ │ │ -Definition: mpihelper.hh:159
│ │ │ │ │ -Dune::MPIHelper
│ │ │ │ │ -A real mpi helper.
│ │ │ │ │ -Definition: mpihelper.hh:179
│ │ │ │ │ -Dune::MPIHelper::size
│ │ │ │ │ -int size() const
│ │ │ │ │ -return number of processes
│ │ │ │ │ -Definition: mpihelper.hh:272
│ │ │ │ │ -Dune::MPIHelper::instance
│ │ │ │ │ -static DUNE_EXPORT MPIHelper & instance()
│ │ │ │ │ -Definition: mpihelper.hh:258
│ │ │ │ │ -Dune::MPIHelper::isFake
│ │ │ │ │ -static constexpr bool isFake
│ │ │ │ │ -Are we fake (i. e. pretend to have MPI support but are compiled without.
│ │ │ │ │ -Definition: mpihelper.hh:185
│ │ │ │ │ -Dune::MPIHelper::instance
│ │ │ │ │ -static DUNE_EXPORT MPIHelper & instance(int &argc, char **&argv)
│ │ │ │ │ -Get the singleton instance of the helper.
│ │ │ │ │ -Definition: mpihelper.hh:246
│ │ │ │ │ -Dune::MPIHelper::getCommunication
│ │ │ │ │ -static Communication< MPICommunicator > getCommunication()
│ │ │ │ │ -Definition: mpihelper.hh:227
│ │ │ │ │ -Dune::MPIHelper::~MPIHelper
│ │ │ │ │ -~MPIHelper()
│ │ │ │ │ -calls MPI_Finalize
│ │ │ │ │ -Definition: mpihelper.hh:275
│ │ │ │ │ -Dune::MPIHelper::rank
│ │ │ │ │ -int rank() const
│ │ │ │ │ -return rank of process
│ │ │ │ │ -Definition: mpihelper.hh:268
│ │ │ │ │ -Dune::MPIHelper::MPICommunicator
│ │ │ │ │ -MPI_Comm MPICommunicator
│ │ │ │ │ -The type of the mpi communicator.
│ │ │ │ │ -Definition: mpihelper.hh:190
│ │ │ │ │ -Dune::MPIHelper::getCommunicator
│ │ │ │ │ -static MPICommunicator getCommunicator()
│ │ │ │ │ -get the default communicator
│ │ │ │ │ -Definition: mpihelper.hh:198
│ │ │ │ │ -Dune::MPIHelper::getLocalCommunicator
│ │ │ │ │ -static MPICommunicator getLocalCommunicator()
│ │ │ │ │ -get a local communicator
│ │ │ │ │ -Definition: mpihelper.hh:209
│ │ │ │ │ -Dune::MPIHelper::getCollectiveCommunication
│ │ │ │ │ -static Communication< MPICommunicator > getCollectiveCommunication()
│ │ │ │ │ -Definition: mpihelper.hh:221
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-common-doc/doxygen/a00029.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-common: mpitraits.hh File Reference
│ │ │ │ +dune-common: ios_state.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │ -
Traits classes for mapping types onto MPI_Datatype.
│ │ │ │ +
Utility class for storing and resetting stream attributes.
│ │ │ │ More...
│ │ │ │ -
#include <cstddef>
│ │ │ │ -
#include <cstdint>
│ │ │ │ -
#include <type_traits>
│ │ │ │ -
#include <utility>
│ │ │ │ -
#include <complex>
│ │ │ │ -
#include <mpi.h>
│ │ │ │ +
#include <ios>
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ namespace Dune Dune namespace.
│ │ │ │
│ │ │ │ -
Traits classes for mapping types onto MPI_Datatype.
│ │ │ │ +
Utility class for storing and resetting stream attributes.
│ │ │ │
Author Markus Blatt
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -4,35 +4,28 @@
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ dune-common 2.9.0
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * common
│ │ │ │ │ - * parallel
│ │ │ │ │ Classes | Namespaces
│ │ │ │ │ -mpitraits.hh File Reference
│ │ │ │ │ -Common » Parallel_Communication
│ │ │ │ │ -Traits classes for mapping types onto MPI_Datatype. More...
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ +ios_state.hh File Reference
│ │ │ │ │ +Common
│ │ │ │ │ +Utility class for storing and resetting stream attributes. More...
│ │ │ │ │ +#include
│ │ │ │ │ Go_to_the_source_code_of_this_file.
│ │ │ │ │ Classes
│ │ │ │ │ -struct Dune::MPITraits<_T_>
│ │ │ │ │ - A traits class describing the mapping of types onto MPI_Datatypes.
│ │ │ │ │ - More...
│ │ │ │ │ +class Dune::ios_base_all_saver
│ │ │ │ │ + Utility class for storing and resetting stream attributes. More...
│ │ │ │ │
│ │ │ │ │ Namespaces
│ │ │ │ │ namespace Dune
│ │ │ │ │ Dune namespace.
│ │ │ │ │
│ │ │ │ │ ***** Detailed Description *****
│ │ │ │ │ -Traits classes for mapping types onto MPI_Datatype.
│ │ │ │ │ +Utility class for storing and resetting stream attributes.
│ │ │ │ │ Author
│ │ │ │ │ Markus Blatt
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-common-doc/doxygen/a00029_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-common: mpitraits.hh Source File
│ │ │ │ +dune-common: ios_state.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
5 #ifndef DUNE_MPITRAITS_HH
│ │ │ │ -
6 #define DUNE_MPITRAITS_HH
│ │ │ │ +
5 #ifndef DUNE_COMMON_IOS_STATE_HH
│ │ │ │ +
6 #define DUNE_COMMON_IOS_STATE_HH
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
45 static MPI_Datatype datatype;
│ │ │ │ -
46 static MPI_Datatype vectortype;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
50 if (datatype==MPI_DATATYPE_NULL) {
│ │ │ │ -
51 MPI_Type_contiguous(
sizeof (T),MPI_BYTE,&datatype);
│ │ │ │ -
52 MPI_Type_commit(&datatype);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
64 #define ComposeMPITraits(p,m) \
│ │ │ │ -
│ │ │ │ -
66 struct MPITraits<p>{ \
│ │ │ │ -
67 static inline MPI_Datatype getType(){ \
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
70 static constexpr bool is_intrinsic = true; \
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
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<double>, MPI_CXX_DOUBLE_COMPLEX);
│ │ │ │ -
85 ComposeMPITraits(std::complex<long double>, MPI_CXX_LONG_DOUBLE_COMPLEX);
│ │ │ │ -
86 ComposeMPITraits(std::complex<float>, MPI_CXX_FLOAT_COMPLEX);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
89 #undef ComposeMPITraits
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
93 template <
class K,
int n>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
96 static MPI_Datatype datatype;
│ │ │ │ -
97 static MPI_Datatype vectortype;
│ │ │ │ -
│ │ │ │ -
99 static inline MPI_Datatype
getType ()
│ │ │ │ -
│ │ │ │ -
101 if (datatype==MPI_DATATYPE_NULL) {
│ │ │ │ -
│ │ │ │ -
103 MPI_Type_commit(&vectortype);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
107 MPI_Get_address(&fvector, &base);
│ │ │ │ -
108 MPI_Get_address(&(fvector[0]), &displ);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
112 MPI_Type_create_struct(1, length, &displ, &vectortype, &datatype);
│ │ │ │ -
113 MPI_Type_commit(&datatype);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
120 template <
class K,
int n>
│ │ │ │ -
121 MPI_Datatype MPITraits<FieldVector<K,n> >::datatype = MPI_DATATYPE_NULL;
│ │ │ │ -
122 template <
class K,
int n>
│ │ │ │ -
123 MPI_Datatype MPITraits<FieldVector<K,n> >::vectortype = {MPI_DATATYPE_NULL};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
127 class bigunsignedint;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
130 struct MPITraits<bigunsignedint<k> >
│ │ │ │ -
│ │ │ │ -
132 static MPI_Datatype datatype;
│ │ │ │ -
133 static MPI_Datatype vectortype;
│ │ │ │ -
│ │ │ │ -
135 static inline MPI_Datatype
getType ()
│ │ │ │ -
│ │ │ │ -
137 if (datatype==MPI_DATATYPE_NULL) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
141 bigunsignedint<k> data;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
144 MPI_Get_address(&data, &base);
│ │ │ │ -
145 MPI_Get_address(&(data.digit), &displ);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
148 MPI_Type_create_struct(1, length, &displ, &vectortype, &datatype);
│ │ │ │ -
149 MPI_Type_commit(&datatype);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
159 MPI_Datatype MPITraits<bigunsignedint<k> >::datatype = MPI_DATATYPE_NULL;
│ │ │ │ -
│ │ │ │ -
161 MPI_Datatype MPITraits<bigunsignedint<k> >::vectortype = MPI_DATATYPE_NULL;
│ │ │ │ -
│ │ │ │ -
163 template <
typename T1,
typename T2>
│ │ │ │ -
164 struct MPITraits<
std ::pair<T1,T2 > >
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
167 inline static MPI_Datatype
getType ();
│ │ │ │ -
│ │ │ │ -
169 static MPI_Datatype type;
│ │ │ │ -
│ │ │ │ -
171 template <
typename T1,
typename T2>
│ │ │ │ -
172 MPI_Datatype MPITraits<std::pair<T1,T2> >::getType()
│ │ │ │ -
│ │ │ │ -
174 if (type==MPI_DATATYPE_NULL) {
│ │ │ │ -
175 int length[2] = {1, 1};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
180 using Pair = std::pair<T1, T2>;
│ │ │ │ -
181 static_assert (std::is_standard_layout<Pair>::value,
"offsetof() is only defined for standard layout types" );
│ │ │ │ -
182 disp[0] = offsetof(Pair, first);
│ │ │ │ -
183 disp[1] = offsetof(Pair, second);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
186 MPI_Type_create_struct(2, length, disp, types, &tmp);
│ │ │ │ -
│ │ │ │ -
188 MPI_Type_create_resized(tmp, 0,
sizeof (Pair), &type);
│ │ │ │ -
189 MPI_Type_commit(&type);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
196 template <
typename T1,
typename T2>
│ │ │ │ -
197 MPI_Datatype MPITraits<std::pair<T1,T2> >::type=MPI_DATATYPE_NULL;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
67 state_type::fmtflags oldflags;
│ │ │ │ +
69 std::streamsize oldprec;
│ │ │ │ +
71 std::streamsize oldwidth;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
~ios_base_all_saver()
Destructor that restores the flags stored by the constructor.
Definition: ios_state.cc:24
│ │ │ │ +
void restore()
Restore flags now.
Definition: ios_state.cc:29
│ │ │ │ +
std::ios_base state_type
Export type of object we save the state for.
Definition: ios_state.hh:37
│ │ │ │ +
ios_base_all_saver(state_type &ios_)
Constructor that stores the currently used flags.
Definition: ios_state.cc:19
│ │ │ │
Dune namespace.
Definition: alignedallocator.hh:13
│ │ │ │ -
A traits class describing the mapping of types onto MPI_Datatypes.
Definition: mpitraits.hh:41
│ │ │ │ -
static MPI_Datatype getType()
Definition: mpitraits.hh:48
│ │ │ │ -
static constexpr bool is_intrinsic
Definition: mpitraits.hh:56
│ │ │ │ -
static constexpr int n
Definition: bigunsignedint.hh:78
│ │ │ │ -
vector space out of a tensor product of fields.
Definition: fvector.hh:95
│ │ │ │ +
Utility class for storing and resetting stream attributes.
Definition: ios_state.hh:34
│ │ │ │
│ │ │ │ │ - 21#include
│ │ │ │ │ - 22#include
│ │ │ │ │ - 23#include
│ │ │ │ │ - 24#include
│ │ │ │ │ - 25
│ │ │ │ │ - 26#include
│ │ │ │ │ - 27
│ │ │ │ │ - 28namespace Dune
│ │ │ │ │ - 29{
│ │ │ │ │ - 39 template
│ │ │ │ │ -40 struct MPITraits
│ │ │ │ │ - 41 {
│ │ │ │ │ - 42 private:
│ │ │ │ │ - 43 MPITraits(){}
│ │ │ │ │ - 44 MPITraits(const MPITraits&){}
│ │ │ │ │ - 45 static MPI_Datatype datatype;
│ │ │ │ │ - 46 static MPI_Datatype vectortype;
│ │ │ │ │ - 47 public:
│ │ │ │ │ -48 static inline MPI_Datatype getType()
│ │ │ │ │ - 49 {
│ │ │ │ │ - 50 if(datatype==MPI_DATATYPE_NULL) {
│ │ │ │ │ - 51 MPI_Type_contiguous(sizeof(T),MPI_BYTE,&datatype);
│ │ │ │ │ - 52 MPI_Type_commit(&datatype);
│ │ │ │ │ - 53 }
│ │ │ │ │ - 54 return datatype;
│ │ │ │ │ - 55 }
│ │ │ │ │ -56 static constexpr bool is_intrinsic = false;
│ │ │ │ │ - 57 };
│ │ │ │ │ - 58 template
│ │ │ │ │ - 59 MPI_Datatype MPITraits::datatype = MPI_DATATYPE_NULL;
│ │ │ │ │ - 60
│ │ │ │ │ - 61#ifndef DOXYGEN
│ │ │ │ │ + 8#include
│ │ │ │ │ + 9
│ │ │ │ │ + 10namespace Dune {
│ │ │ │ │ +33 class ios_base_all_saver
│ │ │ │ │ + 34 {
│ │ │ │ │ + 35 public:
│ │ │ │ │ +37 typedef std::ios_base state_type;
│ │ │ │ │ + 38
│ │ │ │ │ + 48 ios_base_all_saver(state_type& ios_);
│ │ │ │ │ + 49
│ │ │ │ │ + 53 ~ios_base_all_saver();
│ │ │ │ │ + 54
│ │ │ │ │ + 61 void restore();
│ │ │ │ │ 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
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── encoding
│ │ │ │ │ @@ -1 +1 @@
│ │ │ │ │ -utf-8
│ │ │ │ │ +us-ascii
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -4,35 +4,24 @@
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ dune-common 2.9.0
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * common
│ │ │ │ │ -Classes | Namespaces | Functions
│ │ │ │ │ -tuplevector.hh File Reference
│ │ │ │ │ -Provides the TupleVector class that augments std::tuple by operator[]. More...
│ │ │ │ │ -#include