packed_range_unit.C File Reference

Go to the source code of this file.

Classes
struct	null_output_iterator< T >
class	libMesh::Parallel::Packing< std::unique_ptr< int > >

Namespaces
namespace	libMesh
namespace	libMesh::Parallel

Functions
std::string	stringy_number (int number)
std::vector< char >	fake_stringy_number (int number)
template<int i, typename T >
auto	my_get (T &container) -> decltype(std::get< i >(container))
template<int i, typename T , std::size_t N>
auto	my_get (std::array< T, N > &container) -> decltype(std::get< i >(container))
template<typename T >
void	my_resize (T &container, std::size_t size)
template<typename T , typename U >
void	my_resize (std::pair< T, U > &, std::size_t)
template<typename ... Types>
void	my_resize (std::tuple< Types... > &, std::size_t)
template<typename T , std::size_t N>
void	my_resize (std::array< T, N > &, std::size_t)
void	testNullAllGather ()
template<typename PairAtLeast >
void	testGettableStringAllGather ()
void	testPairStringAllGather ()
void	testArrayStringAllGather ()
void	testListStringAllGather ()
void	testVectorStringAllGather ()
void	testTupleStringAllGather ()
void	testNestingAllGather ()
void	testNullSendReceive ()
void	testContainerAllGather ()
void	testContainerSendReceive ()
void	testLargeSetUnion ()
void	testPushPackedImpl (int M)
void	testPushPacked ()
void	testPushPackedOversized ()
template<typename FillFunctor , typename PushFunctor >
void	testPushPackedNestedImpl (FillFunctor fill_functor, PushFunctor push_functor)
void	testPushPackedNested ()
void	testPushPackedDispatch ()
void	testPushPackedOneTuple ()
void	testPushPackedFailureCase ()
void	testPushPackedImplMove (int M)
void	testPushPackedMove ()
void	testPushPackedMoveOversized ()
int	main (int argc, const char *const *argv)

Variables
Communicator *	TestCommWorld

Function Documentation

fake_stringy_number()

std::vector< char > fake_stringy_number

(

int

number

)

Definition at line 32 of file packed_range_unit.C.

{
  const std::string returnval = stringy_number(number);
  return std::vector<char>(returnval.begin(), returnval.end());
}

References TIMPI::cast_int(), and stringy_number().

Referenced by testPushPackedDispatch(), and testPushPackedNested().

main()

int main	(	int	argc,
		const char *const *	argv
	)

Definition at line 763 of file packed_range_unit.C.

{
  TIMPI::TIMPIInit init(argc, argv);
  TestCommWorld = &init.comm();
 
  testNullAllGather();
  testPairStringAllGather();
  testArrayStringAllGather();
  testTupleStringAllGather();
  testNestingAllGather();
  testNullSendReceive();
  testContainerAllGather();
  testContainerSendReceive();
 
  testLargeSetUnion();
 
  testPushPacked();
  testPushPackedOversized();
  testPushPackedNested();
  testPushPackedDispatch();
  testPushPackedOneTuple();
  testPushPackedFailureCase();
#if __cplusplus > 201402L
  testPushPackedMove();
  testPushPackedMoveOversized();
#endif
 
  TestCommWorld->sync_type(Communicator::ALLTOALL_COUNTS);
  testPushPacked();
  testPushPackedOversized();
  testPushPackedNested();
  testPushPackedDispatch();
  testPushPackedOneTuple();
  testPushPackedFailureCase();
#if __cplusplus > 201402L
  testPushPackedMove();
  testPushPackedMoveOversized();
#endif
 
  TestCommWorld->sync_type(Communicator::SENDRECEIVE);
  testPushPacked();
  testPushPackedOversized();
  testPushPackedNested();
  testPushPackedDispatch();
  testPushPackedOneTuple();
  testPushPackedFailureCase();
#if __cplusplus > 201402L
  testPushPackedMove();
  testPushPackedMoveOversized();
#endif
 
  return 0;
}

References TIMPI::Communicator::ALLTOALL_COUNTS, TIMPI::cast_int(), TIMPI::Communicator::SENDRECEIVE, TIMPI::Communicator::sync_type(), testArrayStringAllGather(), TestCommWorld, testContainerAllGather(), testContainerSendReceive(), testLargeSetUnion(), testNestingAllGather(), testNullAllGather(), testNullSendReceive(), testPairStringAllGather(), testPushPacked(), testPushPackedDispatch(), testPushPackedFailureCase(), testPushPackedMove(), testPushPackedMoveOversized(), testPushPackedNested(), testPushPackedOneTuple(), testPushPackedOversized(), and testTupleStringAllGather().

my_get() [1/2]

template<int i, typename T , std::size_t N>

auto my_get ( std::array< T, N > &  container ) -> decltype(std::get<i>(container))

inline

Definition at line 86 of file packed_range_unit.C.

{
  return std::get<i>(container);
}

References TIMPI::cast_int().

my_get() [2/2]

template<int i, typename T >

auto my_get ( T &  container ) -> decltype(std::get<i>(container))

inline

Definition at line 66 of file packed_range_unit.C.

{
  return std::get<i>(container);
}

References TIMPI::cast_int().

my_resize() [1/4]

template<typename T , std::size_t N>

void my_resize ( std::array< T, N > &  , std::size_t    )

inline

Definition at line 102 of file packed_range_unit.C.

{}

my_resize() [2/4]

template<typename T , typename U >

void my_resize ( std::pair< T, U > &  , std::size_t    )

inline

Definition at line 96 of file packed_range_unit.C.

{}

my_resize() [3/4]

template<typename ... Types>

void my_resize ( std::tuple< Types... > &  , std::size_t    )

inline

Definition at line 99 of file packed_range_unit.C.

{}

my_resize() [4/4]

template<typename T >

void my_resize ( T &  container, std::size_t  size  )

inline

Definition at line 93 of file packed_range_unit.C.

{ container.resize(size); }

References TIMPI::cast_int().

Referenced by testGettableStringAllGather().

stringy_number()

std::string stringy_number

(

int

number

)

Definition at line 16 of file packed_range_unit.C.

{
  std::string digit_strings [10] = {"zero", "one", "two",
      "three", "four", "five", "six", "seven", "eight", "nine"};
 
  std::string returnval = "done";
  while (number)
    {
      returnval = digit_strings[number%10]+" "+returnval;
      number = number/10;
    };
 
  return returnval;
}

References TIMPI::cast_int().

Referenced by fake_stringy_number(), fill_data(), testPushPackedFailureCase(), testPushPackedImpl(), and testPushPackedOneTuple().

testArrayStringAllGather()

void testArrayStringAllGather

(

)

Definition at line 203 of file packed_range_unit.C.

  {
    testGettableStringAllGather<std::array<std::string, 4>>();
  }

References TIMPI::cast_int().

Referenced by main().

testContainerAllGather()

void testContainerAllGather

(

)

Definition at line 343 of file packed_range_unit.C.

  {
    // This method uses a specialized allgather method that is only defined
    // when we have MPI
#ifdef TIMPI_HAVE_MPI
    std::vector<std::string> vals;
    const unsigned int my_rank = TestCommWorld->rank();
    TestCommWorld->allgather(std::string(my_rank+1, '0' + my_rank), vals);
 
    const std::size_t comm_size = TestCommWorld->size();
    const std::size_t vec_size = vals.size();
    TIMPI_UNIT_ASSERT(comm_size == vec_size);
 
    for (std::size_t i = 0; i < vec_size; ++i)
      TIMPI_UNIT_ASSERT(vals[i] == std::string(i + 1, '0' + i));
#endif
  }

References TIMPI::Communicator::allgather(), TIMPI::cast_int(), TIMPI::Communicator::rank(), TIMPI::Communicator::size(), and TestCommWorld.

Referenced by main().

testContainerSendReceive()

void testContainerSendReceive

(

)

Definition at line 361 of file packed_range_unit.C.

  {
    std::vector<processor_id_type> vals;
 
    std::vector<std::string> send(1), recv;
 
    const unsigned int my_rank = TestCommWorld->rank();
    const unsigned int dest_rank =
      (my_rank + 1) % TestCommWorld->size();
    const unsigned int source_rank =
      (my_rank + TestCommWorld->size() - 1) % TestCommWorld->size();
 
    {
      std::ostringstream os;
      os << my_rank;
      send[0] = os.str();
    }
 
    TestCommWorld->send_receive_packed_range
      (dest_rank, (void *)(NULL), send.begin(), send.end(),
       source_rank, (void *)(NULL),
       std::back_inserter(recv),
       (std::string*)NULL);
 
    TIMPI_UNIT_ASSERT(recv.size() == std::size_t(1));
 
    std::string check;
    {
      std::ostringstream os;
      os << source_rank;
      check = os.str();
    }
 
    TIMPI_UNIT_ASSERT(recv[0] == check);
  }

References TIMPI::cast_int(), TIMPI::Communicator::rank(), TIMPI::Communicator::send_receive_packed_range(), TIMPI::Communicator::size(), and TestCommWorld.

Referenced by main().

testGettableStringAllGather()

template<typename PairAtLeast >

void testGettableStringAllGather

(

)

Definition at line 153 of file packed_range_unit.C.

  {
    std::vector<PairAtLeast> sendv(2);
    my_resize(sendv[0], 2);
    my_resize(sendv[1], 2);
 
    my_get<0>(sendv[0]).assign("Hello");
    auto & s0 = my_get<1>(sendv[0]);
    s0.assign("Is it me you're looking for?\n");
    for (int i=0; i != 6; ++i)
      s0 = s0+s0;
    timpi_assert_greater(s0.size(), 256);
 
    my_get<0>(sendv[1]).assign("Goodbye");
    auto & s1 = my_get<1>(sendv[1]);
    s1.assign("to you!  Guess it's better to say, goodbye\n");
    for (int i=0; i != 6; ++i)
      s1 = s1+s1;
    timpi_assert_greater(s1.size(), 256);
 
    std::vector<PairAtLeast> send(1);
    my_resize(send[0], 2);
 
    if (TestCommWorld->rank() == 0)
      send[0] = sendv[0];
    else
      send[0] = sendv[1];
 
    std::vector<PairAtLeast> recv;
 
    TestCommWorld->allgather_packed_range
      ((void *)(NULL), send.begin(), send.end(),
       std::back_inserter(recv));
 
    const std::size_t comm_size = TestCommWorld->size();
    const std::size_t vec_size = recv.size();
    TIMPI_UNIT_ASSERT(comm_size == vec_size);
 
    TIMPI_UNIT_ASSERT(sendv[0] == recv[0]);
    for (std::size_t i=1; i < vec_size; ++i)
      TIMPI_UNIT_ASSERT(sendv[1] == recv[i]);
  }

References TIMPI::Communicator::allgather_packed_range(), TIMPI::cast_int(), my_resize(), TIMPI::Communicator::rank(), TIMPI::Communicator::size(), and TestCommWorld.

testLargeSetUnion()

void testLargeSetUnion

(

)

Definition at line 397 of file packed_range_unit.C.

  {
    // Number of entries in the map on each processor
    const unsigned int n_map_entries = 147;
 
    // Offset between blocks of entries; must exceed n_map_entries
    const unsigned int map_offset = 1000;
 
    // Large enough strings that we'll exceed a single packed buffer
    const unsigned int string_size = 32768;
 
    // Each entry in the map will be the same test_string
    std::string test_string(/*count*/string_size, 'a');
 
    std::map<unsigned int, std::string> map_of_strings;
 
    // Use an offset so that the map keys do not overlap
    const unsigned int my_offset =
      (TestCommWorld->rank() + 1) * map_offset;
    for (unsigned int i=0; i != n_map_entries; ++i)
      map_of_strings[my_offset + i] = test_string;
 
    TestCommWorld->set_union(map_of_strings);
 
    TIMPI_UNIT_ASSERT(map_of_strings.size() ==
                      TestCommWorld->size() * n_map_entries);
 
    TIMPI_UNIT_ASSERT(map_of_strings.begin()->first == map_offset);
  }

References TIMPI::cast_int(), TIMPI::Communicator::rank(), TIMPI::Communicator::set_union(), TIMPI::Communicator::size(), and TestCommWorld.

Referenced by main().

testListStringAllGather()

void testListStringAllGather

(

)

Definition at line 209 of file packed_range_unit.C.

  {
    testGettableStringAllGather<std::list<std::string>>();
  }

References TIMPI::cast_int().

testNestingAllGather()

void testNestingAllGather

(

)

Definition at line 279 of file packed_range_unit.C.

  {
    typedef std::tuple<unsigned int, std::vector<std::tuple<char,int,std::size_t>>, unsigned int> send_type;
 
#ifdef TIMPI_HAVE_CXX17 // static_assert without message
    static_assert(Has_buffer_type<Packing<std::vector<std::tuple<char,int,std::size_t>>>>::value);
    static_assert(Has_buffer_type<Packing<send_type>>::value);
#endif
 
    std::vector<send_type> sendv(2);
 
    std::get<0>(sendv[0]) = 100;
    std::get<1>(sendv[0]) = {{'a', -4, 1000},{'b', -5, 2000}};
    std::get<2>(sendv[0]) = 3000;
 
    std::get<0>(sendv[1]) = 200;
    std::get<1>(sendv[1]) = {{'c', -6, 4000},{'d', -7, 5000}};
    std::get<2>(sendv[1]) = 6000;
 
    std::vector<send_type> send(1);
    if (TestCommWorld->rank() == 0)
      send[0] = sendv[0];
    else
      send[0] = sendv[1];
 
    std::vector<send_type> recv;
 
    TestCommWorld->allgather_packed_range
      ((void *)(NULL), send.begin(), send.end(),
       std::back_inserter(recv));
 
    const std::size_t comm_size = TestCommWorld->size();
    const std::size_t vec_size = recv.size();
    TIMPI_UNIT_ASSERT(comm_size == vec_size);
 
    TIMPI_UNIT_ASSERT(sendv[0] == recv[0]);
    for (std::size_t i=1; i < vec_size; ++i)
      TIMPI_UNIT_ASSERT(sendv[1] == recv[i]);
  }

References TIMPI::Communicator::allgather_packed_range(), TIMPI::cast_int(), TIMPI::Communicator::rank(), TIMPI::Communicator::size(), and TestCommWorld.

Referenced by main().

testNullAllGather()

void testNullAllGather

(

)

Definition at line 136 of file packed_range_unit.C.

  {
    std::vector<std::string> send(1);
    if (TestCommWorld->rank() == 0)
      send[0].assign("Hello");
    else
      send[0].assign("Goodbye");
 
    TestCommWorld->allgather_packed_range
      ((void *)(NULL), send.begin(), send.end(),
       null_output_iterator<std::string>());
  }

References TIMPI::Communicator::allgather_packed_range(), TIMPI::cast_int(), TIMPI::Communicator::rank(), and TestCommWorld.

Referenced by main().

testNullSendReceive()

void testNullSendReceive

(

)

Definition at line 321 of file packed_range_unit.C.

  {
    std::vector<std::string> send(1);
    const unsigned int my_rank = TestCommWorld->rank();
    const unsigned int dest_rank =
      (my_rank + 1) % TestCommWorld->size();
    const unsigned int source_rank =
      (my_rank + TestCommWorld->size() - 1) % TestCommWorld->size();
 
    {
      std::ostringstream os;
      os << my_rank;
      send[0] = os.str();
    }
 
    TestCommWorld->send_receive_packed_range
      (dest_rank, (void *)(NULL), send.begin(), send.end(),
       source_rank, (void *)(NULL),
       null_output_iterator<std::string>(),
       (std::string*)NULL);
  }

References TIMPI::cast_int(), TIMPI::Communicator::rank(), TIMPI::Communicator::send_receive_packed_range(), TIMPI::Communicator::size(), and TestCommWorld.

Referenced by main().

testPairStringAllGather()

void testPairStringAllGather

(

)

Definition at line 197 of file packed_range_unit.C.

  {
    testGettableStringAllGather<std::pair<std::string, std::string>>();
  }

References TIMPI::cast_int().

Referenced by main().

testPushPacked()

void testPushPacked

(

)

Definition at line 521 of file packed_range_unit.C.

  {
    testPushPackedImpl(TestCommWorld->size());
  }

References TIMPI::Communicator::size(), TestCommWorld, and testPushPackedImpl().

Referenced by main().

testPushPackedDispatch()

void testPushPackedDispatch

(

)

Definition at line 611 of file packed_range_unit.C.

  {
    // Do the push implicitly with an auto-dispatching function
    auto implicitly_packed_push = [](auto & data, auto & collect_data) {
      TIMPI::push_parallel_vector_data(*TestCommWorld, data, collect_data);
    };
 
    typedef std::tuple<unsigned int, std::vector<char>, unsigned int,
            unsigned int, unsigned int, unsigned int> tuple_type;
    auto fill_tuple= [] (int n) {
      return tuple_type(n, fake_stringy_number(n), n, n, n, n);
    };
 
    testPushPackedNestedImpl(fill_tuple, implicitly_packed_push);
  }

References TIMPI::cast_int(), fake_stringy_number(), TIMPI::push_parallel_vector_data(), TestCommWorld, and testPushPackedNestedImpl().

Referenced by main().

testPushPackedFailureCase()

void testPushPackedFailureCase

(

)

Definition at line 662 of file packed_range_unit.C.

  {
    typedef std::tuple<std::size_t, int, std::unordered_map<unsigned int, std::string>> tuple_type;
 
    auto fill_tuple = [] (int n)
      {
        tuple_type returnval;
        std::get<0>(returnval) = n;
        std::get<1>(returnval) = n;
        (std::get<2>(returnval))[n] = stringy_number(n);
        (std::get<2>(returnval))[n+1] = stringy_number(n+1);
        return returnval;
      };
 
    auto implicitly_packed_push = [](auto & data, auto & collect_data) {
      TIMPI::push_parallel_vector_data(*TestCommWorld, data, collect_data);
    };
 
    testPushPackedNestedImpl(fill_tuple, implicitly_packed_push);
  }

References TIMPI::cast_int(), TIMPI::push_parallel_vector_data(), stringy_number(), TestCommWorld, and testPushPackedNestedImpl().

Referenced by main().

testPushPackedImpl()

void testPushPackedImpl

(

int

M

)

Definition at line 428 of file packed_range_unit.C.

  {
    const int size = TestCommWorld->size(),
              rank = TestCommWorld->rank();
 
    std::map<processor_id_type, std::multiset<std::string>>
      data, received_data;
 
    auto stringy_number = [] (int number)
      {
        std::string digit_strings [10] = {"zero", "one", "two",
            "three", "four", "five", "six", "seven", "eight", "nine"};
 
        std::string returnval = "done";
        while (number)
          {
            returnval = digit_strings[number%10]+" "+returnval;
            number = number/10;
          };
 
        return returnval;
      };
 
    for (int d=0; d != M; ++d)
      {
        int diffsize = std::abs(d-rank);
        int diffsqrt = std::sqrt(diffsize);
        if (diffsqrt*diffsqrt == diffsize)
          for (int i=-1; i != diffsqrt; ++i)
            data[d].insert(stringy_number(d));
      }
 
    auto collect_data =
      [&received_data]
      (processor_id_type pid,
       const typename std::multiset<std::string> & multiset_received)
      {
        auto & received = received_data[pid];
        received.insert(multiset_received.begin(), multiset_received.end());
      };
 
    // Ensure that no const_cast perfidy in parallel_sync.h messes up
    // our original data
    std::map<processor_id_type, std::multiset<std::string>> preserved_data {data};
 
    // Do the push
    void * context = nullptr;
    TIMPI::push_parallel_packed_range(*TestCommWorld, data, context, collect_data);
 
    // Test the sent data, which shouldn't have changed
    TIMPI_UNIT_ASSERT(preserved_data.size() == data.size());
    for (const auto & pair: preserved_data)
      {
        const auto &pd_ms = pair.second;
        const auto &d_ms = data[pair.first];
        TIMPI_UNIT_ASSERT(pd_ms.size() == d_ms.size());
        for (auto entry : pd_ms)
          TIMPI_UNIT_ASSERT(pd_ms.count(entry) == d_ms.count(entry));
      }
 
    // Test the received results, for each processor id p we're in
    // charge of.
    std::vector<std::size_t> checked_sizes(size, 0);
    for (int p=rank; p < M; p += size)
      for (int srcp=0; srcp != size; ++srcp)
        {
          int diffsize = std::abs(srcp-p);
          int diffsqrt = std::sqrt(diffsize);
          if (diffsqrt*diffsqrt != diffsize)
            {
              if (received_data.count(srcp))
                {
                  const std::multiset<std::string> & datum = received_data[srcp];
                  TIMPI_UNIT_ASSERT
                    (std::count(datum.begin(), datum.end(),
                                stringy_number(p)) == std::ptrdiff_t(0));
                }
              continue;
            }
 
          TIMPI_UNIT_ASSERT(received_data.count(srcp) == std::size_t(1));
          const std::multiset<std::string> & datum = received_data[srcp];
          TIMPI_UNIT_ASSERT
            (std::count(datum.begin(), datum.end(), stringy_number(p)) ==
             std::ptrdiff_t(diffsqrt+1));
          checked_sizes[srcp] += diffsqrt+1;
        }
 
    for (int srcp=0; srcp != size; ++srcp)
      TIMPI_UNIT_ASSERT(checked_sizes[srcp] == received_data[srcp].size());
 
  }

References TIMPI::cast_int(), TIMPI::push_parallel_packed_range(), TIMPI::Communicator::rank(), TIMPI::Communicator::size(), stringy_number(), and TestCommWorld.

Referenced by testPushPacked(), testPushPackedMove(), testPushPackedMoveOversized(), and testPushPackedOversized().

testPushPackedImplMove()

void testPushPackedImplMove

(

int

M

)

Definition at line 685 of file packed_range_unit.C.

  {
    const int size = TestCommWorld->size(),
              rank = TestCommWorld->rank();
 
    std::map<processor_id_type, std::vector<std::unique_ptr<int>>>
      data, received_data;
 
    for (int d=0; d != M; ++d)
      {
        int diffsize = std::abs(d-rank);
        int diffsqrt = std::sqrt(diffsize);
        if (diffsqrt*diffsqrt == diffsize)
          for (int i=-1; i != diffsqrt; ++i)
            data[d].emplace_back(std::make_unique<int>(d));
      }
 
    auto collect_data =
      [&received_data]
      (processor_id_type pid,
       std::vector<std::unique_ptr<int>> && vector_received)
      {
        auto & received = received_data[pid];
        for (auto & val : vector_received)
          received.emplace_back(std::move(val));
      };
 
    void * context = nullptr;
    TIMPI::push_parallel_packed_range(*TestCommWorld, std::move(data), context, collect_data);
 
    // Test the received results, for each processor id p we're in
    // charge of.
    std::vector<std::size_t> checked_sizes(size, 0);
    for (int p=rank; p < M; p += size)
      for (int srcp=0; srcp != size; ++srcp)
        {
          int diffsize = std::abs(srcp-p);
          int diffsqrt = std::sqrt(diffsize);
          if (diffsqrt*diffsqrt != diffsize)
            {
              if (received_data.count(srcp))
                {
                  std::size_t count = 0;
                  for (const auto & val : received_data[srcp])
                    if (*val == p)
                      ++count;
 
                  TIMPI_UNIT_ASSERT(count == (std::size_t)std::ptrdiff_t(0));
                }
              continue;
            }
 
          TIMPI_UNIT_ASSERT(received_data.count(srcp) == std::size_t(1));
 
          std::size_t count = 0;
          for (const auto & val : received_data[srcp])
            if (*val == p)
              ++count;
 
          TIMPI_UNIT_ASSERT(count == (std::size_t)std::ptrdiff_t(diffsqrt+1));
          checked_sizes[srcp] += diffsqrt+1;
        }
 
    for (int srcp=0; srcp != size; ++srcp)
      TIMPI_UNIT_ASSERT(checked_sizes[srcp] == received_data[srcp].size());
  }

References TIMPI::cast_int(), TIMPI::push_parallel_packed_range(), TIMPI::Communicator::rank(), TIMPI::Communicator::size(), and TestCommWorld.

testPushPackedMove()

void testPushPackedMove

(

)

Definition at line 752 of file packed_range_unit.C.

  {
    testPushPackedImpl(TestCommWorld->size());
  }

References TIMPI::Communicator::size(), TestCommWorld, and testPushPackedImpl().

Referenced by main().

testPushPackedMoveOversized()

void testPushPackedMoveOversized

(

)

Definition at line 757 of file packed_range_unit.C.

  {
    testPushPackedImpl((TestCommWorld->size() + 4) * 2);
  }

References TIMPI::Communicator::size(), TestCommWorld, and testPushPackedImpl().

Referenced by main().

testPushPackedNested()

void testPushPackedNested

(

)

Definition at line 593 of file packed_range_unit.C.

  {
    // Do the push explicitly with a packed_range function
    auto explicitly_packed_push = [](auto & data, auto & collect_data) {
      void * context = nullptr;
      TIMPI::push_parallel_packed_range(*TestCommWorld, data, context, collect_data);
    };
 
    typedef std::tuple<unsigned int, std::vector<char>, unsigned int,
            unsigned int, unsigned int, unsigned int> tuple_type;
    auto fill_tuple= [] (int n) {
      return tuple_type(n, fake_stringy_number(n), n, n, n, n);
    };
 
    testPushPackedNestedImpl(fill_tuple, explicitly_packed_push);
  }

References TIMPI::cast_int(), fake_stringy_number(), TIMPI::push_parallel_packed_range(), TestCommWorld, and testPushPackedNestedImpl().

Referenced by main().

testPushPackedNestedImpl()

template<typename FillFunctor , typename PushFunctor >

void testPushPackedNestedImpl	(	FillFunctor	fill_functor,
		PushFunctor	push_functor
	)

Definition at line 532 of file packed_range_unit.C.

  {
    const int size = TestCommWorld->size(),
              rank = TestCommWorld->rank();
 
    typedef decltype(fill_functor(0)) fill_type;
 
    typedef std::vector<fill_type> vec_type;
    std::map<processor_id_type, vec_type> data, received_data;
 
    for (int d=0; d != size; ++d)
      {
        int diffsize = std::abs(d-rank);
        int diffsqrt = std::sqrt(diffsize);
        if (diffsqrt*diffsqrt == diffsize)
          for (int i=-1; i != diffsqrt; ++i)
            data[d].push_back(fill_functor(d));
      }
 
    auto collect_data =
      [&received_data]
      (processor_id_type pid,
       const vec_type & vec_received)
      {
        auto & received = received_data[pid];
        received = vec_received;
      };
 
    // Ensure that no const_cast perfidy in parallel_sync.h messes up
    // our original data
    std::map<processor_id_type, vec_type> preserved_data {data};
 
    // Do the push
    push_functor(data, collect_data);
 
    // Test the sent data, which shouldn't have changed
    TIMPI_UNIT_ASSERT(preserved_data == data);
 
    // Test the received results, for each processor id p we're in
    // charge of.
    std::vector<std::size_t> checked_sizes(size, 0);
    for (int srcp=0; srcp != size; ++srcp)
      {
        int diffsize = std::abs(srcp-rank);
        int diffsqrt = std::sqrt(diffsize);
        if (diffsqrt*diffsqrt != diffsize)
          {
            TIMPI_UNIT_ASSERT(!received_data.count(srcp));
            continue;
          }
 
        TIMPI_UNIT_ASSERT(received_data.count(srcp));
        const auto & rec = received_data[srcp];
        TIMPI_UNIT_ASSERT(rec.size() == std::size_t(diffsqrt+1));
 
        for (auto & tup : rec)
          TIMPI_UNIT_ASSERT(tup == fill_functor(rank));
      }
  }

References TIMPI::cast_int(), TIMPI::Communicator::rank(), TIMPI::Communicator::size(), and TestCommWorld.

Referenced by testPushPackedDispatch(), testPushPackedFailureCase(), testPushPackedNested(), and testPushPackedOneTuple().

testPushPackedOneTuple()

void testPushPackedOneTuple

(

)

Definition at line 628 of file packed_range_unit.C.

  {
    typedef std::tuple<std::unordered_map<unsigned int, std::string>> tuple_type;
#ifdef TIMPI_HAVE_CXX17 // static_assert without message
    static_assert(Has_buffer_type<Packing<std::string>>::value);
    static_assert(TIMPI::StandardType<std::pair<unsigned int, unsigned int>>::is_fixed_type);
    static_assert(TIMPI::StandardType<std::pair<const unsigned int, unsigned int>>::is_fixed_type);
    static_assert(Has_buffer_type<Packing<std::unordered_map<unsigned int, unsigned int>>>::value);
    static_assert(Has_buffer_type<Packing<std::pair<std::string, std::string>>>::value);
    static_assert(Has_buffer_type<Packing<std::pair<const std::string, std::string>>>::value);
    static_assert(Has_buffer_type<Packing<std::unordered_map<std::string, std::string>>>::value);
    static_assert(Has_buffer_type<Packing<std::pair<unsigned int, std::string>>>::value);
    static_assert(Has_buffer_type<Packing<std::pair<const unsigned int, std::string>>>::value);
    static_assert(Has_buffer_type<Packing<std::unordered_map<unsigned int, std::string>>>::value);
    static_assert(Has_buffer_type<Packing<tuple_type>>::value);
#endif
 
    auto fill_tuple = [] (int n)
      {
        tuple_type returnval;
        (std::get<0>(returnval))[n] = stringy_number(n);
        (std::get<0>(returnval))[n+1] = stringy_number(n+1);
        return returnval;
      };
 
    auto implicitly_packed_push = [](auto & data, auto & collect_data) {
      TIMPI::push_parallel_vector_data(*TestCommWorld, data, collect_data);
    };
 
    testPushPackedNestedImpl(fill_tuple, implicitly_packed_push);
  }

References TIMPI::cast_int(), TIMPI::push_parallel_vector_data(), stringy_number(), TestCommWorld, and testPushPackedNestedImpl().

Referenced by main().

testPushPackedOversized()

void testPushPackedOversized

(

)

Definition at line 526 of file packed_range_unit.C.

  {
    testPushPackedImpl((TestCommWorld->size() + 4) * 2);
  }

References TIMPI::Communicator::size(), TestCommWorld, and testPushPackedImpl().

Referenced by main().

testTupleStringAllGather()

void testTupleStringAllGather

(

)

Definition at line 224 of file packed_range_unit.C.

  {
#ifdef TIMPI_HAVE_CXX17 // static_assert without message
    static_assert(Has_buffer_type<Packing<std::string>>::value);
    static_assert(libMesh::Parallel::TupleHasPacking<std::string>::value);
    static_assert(Has_buffer_type<Packing<std::tuple<std::string>>>::value);
    static_assert(libMesh::Parallel::TupleHasPacking<std::string, std::string>::value);
    static_assert(Has_buffer_type<Packing<std::tuple<std::string, std::string>>>::value);
    static_assert(libMesh::Parallel::TupleHasPacking<std::string, std::string, int>::value);
    static_assert(Has_buffer_type<Packing<std::tuple<std::string, std::string, int>>>::value);
#endif
 
    std::vector<std::tuple<std::string, std::string, int>> sendv(2);
 
    auto & s0 = std::get<1>(sendv[0]);
    std::get<0>(sendv[0]).assign("Hello");
    s0.assign("Is it me you're looking for?\n");
    for (int i=0; i != 6; ++i)
      s0 = s0+s0;
    timpi_assert_greater(s0.size(), 256);
    std::get<2>(sendv[0]) = 257;
 
    auto & s1 = std::get<1>(sendv[1]);
    std::get<0>(sendv[1]).assign("Goodbye");
    s1.assign("to you!  Guess it's better to say, goodbye\n");
    for (int i=0; i != 6; ++i)
      s1 = s1+s1;
    timpi_assert_greater(s1.size(), 256);
    std::get<2>(sendv[1]) = 258;
 
    std::vector<std::tuple<std::string, std::string, int>> send(1);
    if (TestCommWorld->rank() == 0)
      send[0] = sendv[0];
    else
      send[0] = sendv[1];
 
    std::vector<std::tuple<std::string, std::string, int>> recv;
 
    TestCommWorld->allgather_packed_range
      ((void *)(NULL), send.begin(), send.end(),
       std::back_inserter(recv));
 
    const std::size_t comm_size = TestCommWorld->size();
    const std::size_t vec_size = recv.size();
    TIMPI_UNIT_ASSERT(comm_size == vec_size);
 
    TIMPI_UNIT_ASSERT(sendv[0] == recv[0]);
    for (std::size_t i=1; i < vec_size; ++i)
      TIMPI_UNIT_ASSERT(sendv[1] == recv[i]);
  }

References TIMPI::Communicator::allgather_packed_range(), TIMPI::cast_int(), TIMPI::Communicator::rank(), TIMPI::Communicator::size(), and TestCommWorld.

Referenced by main().

testVectorStringAllGather()

void testVectorStringAllGather

(

)

Definition at line 215 of file packed_range_unit.C.

  {
    testGettableStringAllGather<std::vector<std::string>>();
  }

References TIMPI::cast_int().

Variable Documentation

TestCommWorld

Communicator* TestCommWorld

Definition at line 134 of file packed_range_unit.C.

Referenced by main(), testContainerAllGather(), testContainerSendReceive(), testGettableStringAllGather(), testLargeSetUnion(), testNestingAllGather(), testNullAllGather(), testNullSendReceive(), testPushPacked(), testPushPackedDispatch(), testPushPackedFailureCase(), testPushPackedImpl(), testPushPackedImplMove(), testPushPackedMove(), testPushPackedMoveOversized(), testPushPackedNested(), testPushPackedNestedImpl(), testPushPackedOneTuple(), testPushPackedOversized(), and testTupleStringAllGather().