TIMPI
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 ( )
inline

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::vector< T TIMPI_P_COMMA A >  )

◆ TIMPI_DECL_PACKING_RANGE_SUBCLASS() [2/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() [3/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() [4/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() [5/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() [6/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() [7/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() [8/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() [9/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() [10/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_PACKING_RANGE_SUBCLASS() [1/10]

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

◆ TIMPI_PACKING_RANGE_SUBCLASS() [2/10]

template<typename T , typename A >
libMesh::Parallel::TIMPI_PACKING_RANGE_SUBCLASS ( std::list< T 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::map< K TIMPI_P_COMMA T TIMPI_P_COMMA C TIMPI_P_COMMA A >  )

◆ TIMPI_PACKING_RANGE_SUBCLASS() [4/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() [5/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() [6/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() [7/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() [8/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() [9/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() [10/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 >  )
Generated on Tue Oct 28 2025 21:23:13 for TIMPI by   doxygen 1.8.14