TIMPI
Loading...
Searching...
No Matches
Classes | Functions
libMesh::Parallel Namespace Reference

Classes

class  Communicator
 
struct  DefaultBufferType
 
struct  DefaultBufferType< T, typename std::enable_if< Has_buffer_type< Packing< T > >::value >::type >
 
struct  DefaultBufferType< T, typename std::enable_if<!Has_buffer_type< Packing< T > >::value >::type >
 
struct  DefaultValueType
 
struct  DefaultValueType< std::pair< const K, V > >
 
class  Has_buffer_type
 
class  Packing
 Define data types and (un)serialization functions for use when encoding a potentially-variable-size object of type T. More...
 
class  Packing< std::array< T, N >, typename std::enable_if< Has_buffer_type< Packing< T > >::value >::type >
 
class  Packing< std::basic_string< T >, typename std::enable_if< TIMPI::StandardType< T >::is_fixed_type >::type >
 
class  Packing< std::pair< T1, T2 >, typename std::enable_if< PairHasPacking< T1, T2 >::value >::type >
 
class  Packing< std::tuple< T, Types... >, typename std::enable_if< TupleHasPacking< T, Types... >::value >::type >
 
class  Packing< std::tuple<>, Enable >
 
class  Packing< std::unique_ptr< int > >
 
struct  PackingMixedType
 
class  PackingRange
 
struct  PairBufferTypeHelper
 
struct  PairBufferTypeHelper< T1, false, T2, false >
 
struct  PairBufferTypeHelper< T1, false, T2, true >
 
struct  PairBufferTypeHelper< T1, true, T2, false >
 
struct  PairBufferTypeHelper< T1, true, T2, true >
 
struct  PairHasPacking
 
struct  TupleBufferType
 
struct  TupleBufferType< T1 >
 
struct  TupleBufferType< T1, MoreTypes... >
 
struct  TupleBufferTypeHelper
 
struct  TupleBufferTypeHelper< false, true, T1, MoreTypes... >
 
struct  TupleBufferTypeHelper< true, false, T1, MoreTypes... >
 
struct  TupleBufferTypeHelper< true, MoreTypes_have_buffer_Type, T1 >
 
struct  TupleBufferTypeHelper< true, true, T1, MoreTypes... >
 
struct  TupleHasPacking
 
struct  TupleHasPacking< T, Types... >
 
struct  TupleHasPacking<>
 

Functions

template<typename buffer_type >
constexpr int get_packed_len_entries ()
 
template<typename buffer_type , typename Iter >
void put_packed_len (unsigned int len, Iter data_out)
 
template<typename buffer_type >
unsigned int get_packed_len (typename std::vector< buffer_type >::const_iterator in)
 
template<typename T , typename A >
 TIMPI_PACKING_RANGE_SUBCLASS (std::vector< T TIMPI_P_COMMA A >)
 
template<typename T , typename A >
 TIMPI_PACKING_RANGE_SUBCLASS (std::list< T TIMPI_P_COMMA A >)
 
template<typename K , typename T , typename C , typename A >
 TIMPI_PACKING_RANGE_SUBCLASS (std::map< K TIMPI_P_COMMA T TIMPI_P_COMMA C TIMPI_P_COMMA A >)
 
template<typename K , typename T , typename C , typename A >
 TIMPI_PACKING_RANGE_SUBCLASS (std::multimap< K TIMPI_P_COMMA T TIMPI_P_COMMA C TIMPI_P_COMMA A >)
 
template<typename K , typename C , typename A >
 TIMPI_PACKING_RANGE_SUBCLASS (std::multiset< K TIMPI_P_COMMA C TIMPI_P_COMMA A >)
 
template<typename K , typename C , typename A >
 TIMPI_PACKING_RANGE_SUBCLASS (std::set< K TIMPI_P_COMMA C TIMPI_P_COMMA A >)
 
template<typename K , typename T , typename H , typename KE , typename A >
 TIMPI_PACKING_RANGE_SUBCLASS (std::unordered_map< K TIMPI_P_COMMA T TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
 
template<typename K , typename T , typename H , typename KE , typename A >
 TIMPI_PACKING_RANGE_SUBCLASS (std::unordered_multimap< K TIMPI_P_COMMA T TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
 
template<typename K , typename H , typename KE , typename A >
 TIMPI_PACKING_RANGE_SUBCLASS (std::unordered_multiset< K TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
 
template<typename K , typename H , typename KE , typename A >
 TIMPI_PACKING_RANGE_SUBCLASS (std::unordered_set< K TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
 
template<typename T , typename A >
 TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::vector< T TIMPI_P_COMMA A >)
 
template<typename T , typename A >
 TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::list< T TIMPI_P_COMMA A >)
 
template<typename K , typename T , typename C , typename A >
 TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::map< K TIMPI_P_COMMA T TIMPI_P_COMMA C TIMPI_P_COMMA A >)
 
template<typename K , typename T , typename C , typename A >
 TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::multimap< K TIMPI_P_COMMA T TIMPI_P_COMMA C TIMPI_P_COMMA A >)
 
template<typename K , typename C , typename A >
 TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::multiset< K TIMPI_P_COMMA C TIMPI_P_COMMA A >)
 
template<typename K , typename C , typename A >
 TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::set< K TIMPI_P_COMMA C TIMPI_P_COMMA A >)
 
template<typename K , typename T , typename H , typename KE , typename A >
 TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::unordered_map< K TIMPI_P_COMMA T TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
 
template<typename K , typename T , typename H , typename KE , typename A >
 TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::unordered_multimap< K TIMPI_P_COMMA T TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
 
template<typename K , typename H , typename KE , typename A >
 TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::unordered_multiset< K TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
 
template<typename K , typename H , typename KE , typename A >
 TIMPI_DECL_PACKING_RANGE_SUBCLASS (std::unordered_set< K TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >)
 

Function Documentation

◆ get_packed_len()

template<typename buffer_type >
unsigned int libMesh::Parallel::get_packed_len ( typename std::vector< buffer_type >::const_iterator  in)
inline

Definition at line 157 of file packing.h.

158{
159 // If we're using 2-byte or 1-byte buffer type then we have to split
160 // into multiple entries
161 constexpr int n_bits = (sizeof(buffer_type) * CHAR_BIT);
162
163 // We may have a small signed buffer type into which we stuffed
164 // an unsigned value. Try to use constexpr here for efficiency and
165 // to avoid shift size warnings.
166 timpi_if_constexpr (n_bits < sizeof(unsigned int) * CHAR_BIT)
167 {
168 const int n_size_entries = get_packed_len_entries<buffer_type>();
169 unsigned int packed_len = 0;
170
171 for (signed int i = n_size_entries-1; i >= 0; --i)
172 {
173 packed_len <<= n_bits;
174
175 const auto next_entry = in[i];
176
177 if (next_entry < 0)
178 packed_len += 1 << n_bits;
179
180 packed_len += next_entry;
181 }
182 return packed_len;
183 }
184
185 // With 32 bits or more this is trivial
186
187 timpi_assert_equal_to(get_packed_len_entries<buffer_type>(), 1);
188 timpi_assert_greater_equal(*in, 0);
189
190 return *in;
191}

◆ get_packed_len_entries()

template<typename buffer_type >
constexpr int libMesh::Parallel::get_packed_len_entries ( )
inlineconstexpr

Definition at line 105 of file packing.h.

106{
107 return
108 (sizeof(unsigned int) + (sizeof(buffer_type)-1)) /
109 sizeof(buffer_type);
110}

◆ put_packed_len()

template<typename buffer_type , typename Iter >
void libMesh::Parallel::put_packed_len ( unsigned int  len,
Iter  data_out 
)
inline

Definition at line 116 of file packing.h.

117{
118 // I hoped decltype(*data_out) would always be buffer_type, but no dice
119
120 // If we're using 2-byte or 1-byte buffer type then we have to split
121 // into multiple entries
122 constexpr int n_bits = (sizeof(buffer_type) * CHAR_BIT);
123
124 // We may have a small signed buffer type into which we stuffed
125 // an unsigned value
126 if (n_bits < sizeof(unsigned int) * CHAR_BIT)
127 {
128 constexpr int size_entries = get_packed_len_entries<buffer_type>();
129
130 // Some compilers warn about shifting by too many bits even when
131 // that's unreachable code. After we require C++17 we should
132 // see if "if constexpr" is a better ifx.
133 constexpr int compiler_workaround =
134 std::max(n_bits-1, int(sizeof(unsigned int) * CHAR_BIT));
135
136 const std::size_t max_entry = std::size_t(1) <<
137 compiler_workaround;
138
139 for (unsigned int i=0; i != size_entries; ++i)
140 {
141 *data_out++ = (len % max_entry);
142 len /= max_entry;
143 }
144
145 return;
146 }
147
148 // With 32 bits or more this is trivial
149 timpi_assert_equal_to(get_packed_len_entries<buffer_type>(), 1);
150 *data_out++ = len;
151}

◆ TIMPI_DECL_PACKING_RANGE_SUBCLASS() [1/10]

template<typename T , typename A >
libMesh::Parallel::TIMPI_DECL_PACKING_RANGE_SUBCLASS ( std::list< T TIMPI_P_COMMA A >  )

◆ TIMPI_DECL_PACKING_RANGE_SUBCLASS() [2/10]

template<typename K , typename T , typename C , typename A >
libMesh::Parallel::TIMPI_DECL_PACKING_RANGE_SUBCLASS ( std::map< K TIMPI_P_COMMA T TIMPI_P_COMMA C TIMPI_P_COMMA A >  )

◆ TIMPI_DECL_PACKING_RANGE_SUBCLASS() [3/10]

template<typename K , typename T , typename C , typename A >
libMesh::Parallel::TIMPI_DECL_PACKING_RANGE_SUBCLASS ( std::multimap< K TIMPI_P_COMMA T TIMPI_P_COMMA C TIMPI_P_COMMA A >  )

◆ TIMPI_DECL_PACKING_RANGE_SUBCLASS() [4/10]

template<typename K , typename C , typename A >
libMesh::Parallel::TIMPI_DECL_PACKING_RANGE_SUBCLASS ( std::multiset< K TIMPI_P_COMMA C TIMPI_P_COMMA A >  )

◆ TIMPI_DECL_PACKING_RANGE_SUBCLASS() [5/10]

template<typename K , typename C , typename A >
libMesh::Parallel::TIMPI_DECL_PACKING_RANGE_SUBCLASS ( std::set< K TIMPI_P_COMMA C TIMPI_P_COMMA A >  )

◆ TIMPI_DECL_PACKING_RANGE_SUBCLASS() [6/10]

template<typename K , typename T , typename H , typename KE , typename A >
libMesh::Parallel::TIMPI_DECL_PACKING_RANGE_SUBCLASS ( std::unordered_map< K TIMPI_P_COMMA T TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >  )

◆ TIMPI_DECL_PACKING_RANGE_SUBCLASS() [7/10]

template<typename K , typename T , typename H , typename KE , typename A >
libMesh::Parallel::TIMPI_DECL_PACKING_RANGE_SUBCLASS ( std::unordered_multimap< K TIMPI_P_COMMA T TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >  )

◆ TIMPI_DECL_PACKING_RANGE_SUBCLASS() [8/10]

template<typename K , typename H , typename KE , typename A >
libMesh::Parallel::TIMPI_DECL_PACKING_RANGE_SUBCLASS ( std::unordered_multiset< K TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >  )

◆ TIMPI_DECL_PACKING_RANGE_SUBCLASS() [9/10]

template<typename K , typename H , typename KE , typename A >
libMesh::Parallel::TIMPI_DECL_PACKING_RANGE_SUBCLASS ( std::unordered_set< K TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >  )

◆ TIMPI_DECL_PACKING_RANGE_SUBCLASS() [10/10]

template<typename T , typename A >
libMesh::Parallel::TIMPI_DECL_PACKING_RANGE_SUBCLASS ( std::vector< T TIMPI_P_COMMA A >  )

◆ TIMPI_PACKING_RANGE_SUBCLASS() [1/10]

template<typename T , typename A >
libMesh::Parallel::TIMPI_PACKING_RANGE_SUBCLASS ( std::list< T TIMPI_P_COMMA A >  )

◆ TIMPI_PACKING_RANGE_SUBCLASS() [2/10]

template<typename K , typename T , typename C , typename A >
libMesh::Parallel::TIMPI_PACKING_RANGE_SUBCLASS ( std::map< K TIMPI_P_COMMA T TIMPI_P_COMMA C TIMPI_P_COMMA A >  )

◆ TIMPI_PACKING_RANGE_SUBCLASS() [3/10]

template<typename K , typename T , typename C , typename A >
libMesh::Parallel::TIMPI_PACKING_RANGE_SUBCLASS ( std::multimap< K TIMPI_P_COMMA T TIMPI_P_COMMA C TIMPI_P_COMMA A >  )

◆ TIMPI_PACKING_RANGE_SUBCLASS() [4/10]

template<typename K , typename C , typename A >
libMesh::Parallel::TIMPI_PACKING_RANGE_SUBCLASS ( std::multiset< K TIMPI_P_COMMA C TIMPI_P_COMMA A >  )

◆ TIMPI_PACKING_RANGE_SUBCLASS() [5/10]

template<typename K , typename C , typename A >
libMesh::Parallel::TIMPI_PACKING_RANGE_SUBCLASS ( std::set< K TIMPI_P_COMMA C TIMPI_P_COMMA A >  )

◆ TIMPI_PACKING_RANGE_SUBCLASS() [6/10]

template<typename K , typename T , typename H , typename KE , typename A >
libMesh::Parallel::TIMPI_PACKING_RANGE_SUBCLASS ( std::unordered_map< K TIMPI_P_COMMA T TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >  )

◆ TIMPI_PACKING_RANGE_SUBCLASS() [7/10]

template<typename K , typename T , typename H , typename KE , typename A >
libMesh::Parallel::TIMPI_PACKING_RANGE_SUBCLASS ( std::unordered_multimap< K TIMPI_P_COMMA T TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >  )

◆ TIMPI_PACKING_RANGE_SUBCLASS() [8/10]

template<typename K , typename H , typename KE , typename A >
libMesh::Parallel::TIMPI_PACKING_RANGE_SUBCLASS ( std::unordered_multiset< K TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >  )

◆ TIMPI_PACKING_RANGE_SUBCLASS() [9/10]

template<typename K , typename H , typename KE , typename A >
libMesh::Parallel::TIMPI_PACKING_RANGE_SUBCLASS ( std::unordered_set< K TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A >  )

◆ TIMPI_PACKING_RANGE_SUBCLASS() [10/10]

template<typename T , typename A >
libMesh::Parallel::TIMPI_PACKING_RANGE_SUBCLASS ( std::vector< T TIMPI_P_COMMA A >  )
Generated on Fri Aug 21 2026 13:32:14 for TIMPI by doxygen 1.9.8