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
	libMesh
	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.

References stringy_number().

Referenced by testPushPackedDispatch(), and testPushPackedNested().

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

main()

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

Definition at line 763 of file packed_range_unit.C.

References TIMPI::Communicator::ALLTOALL_COUNTS, TIMPI::TIMPIInit::comm(), 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().

{
  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;
}

my_get() [1/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);
}

my_get() [2/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);
}

my_resize() [1/4]

template<typename T >

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

inline

Definition at line 93 of file packed_range_unit.C.

Referenced by testGettableStringAllGather().

{ container.resize(size); }

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 , 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.

{}

stringy_number()

std::string stringy_number

(

int

number

)

Definition at line 16 of file packed_range_unit.C.

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

{
  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;
}

testArrayStringAllGather()

void testArrayStringAllGather

(

)

Definition at line 203 of file packed_range_unit.C.

Referenced by main().

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

testContainerAllGather()

void testContainerAllGather

(

)

Definition at line 343 of file packed_range_unit.C.

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

Referenced by main().

  {
    // 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
  }

testContainerSendReceive()

void testContainerSendReceive

(

)

Definition at line 361 of file packed_range_unit.C.

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

Referenced by main().

  {
    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);
  }

testGettableStringAllGather()

template<typename PairAtLeast >

void testGettableStringAllGather

(

)

Definition at line 153 of file packed_range_unit.C.

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

  {
    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]);
  }

testLargeSetUnion()

void testLargeSetUnion

(

)

Definition at line 397 of file packed_range_unit.C.

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

Referenced by main().

  {
    // 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);
  }

testListStringAllGather()

void testListStringAllGather

(

)

Definition at line 209 of file packed_range_unit.C.

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

testNestingAllGather()

void testNestingAllGather

(

)

Definition at line 279 of file packed_range_unit.C.

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

Referenced by main().

  {
    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]);
  }

testNullAllGather()

void testNullAllGather

(

)

Definition at line 136 of file packed_range_unit.C.

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

Referenced by main().

  {
    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>());
  }

testNullSendReceive()

void testNullSendReceive

(

)

Definition at line 321 of file packed_range_unit.C.

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

Referenced by main().

  {
    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);
  }

testPairStringAllGather()

void testPairStringAllGather

(

)

Definition at line 197 of file packed_range_unit.C.

Referenced by main().

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

testPushPacked()

void testPushPacked

(

)

Definition at line 521 of file packed_range_unit.C.

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

Referenced by main().

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

testPushPackedDispatch()

void testPushPackedDispatch

(

)

Definition at line 611 of file packed_range_unit.C.

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

Referenced by main().

  {
    // 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);
  }

testPushPackedFailureCase()

void testPushPackedFailureCase

(

)

Definition at line 662 of file packed_range_unit.C.

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

Referenced by main().

  {
    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);
  }

testPushPackedImpl()

void testPushPackedImpl

(

int

M

)

Definition at line 428 of file packed_range_unit.C.

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

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

  {
    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());

  }

testPushPackedImplMove()

void testPushPackedImplMove

(

int

M

)

Definition at line 685 of file packed_range_unit.C.

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

  {
    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());
  }

testPushPackedMove()

void testPushPackedMove

(

)

Definition at line 752 of file packed_range_unit.C.

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

Referenced by main().

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

testPushPackedMoveOversized()

void testPushPackedMoveOversized

(

)

Definition at line 757 of file packed_range_unit.C.

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

Referenced by main().

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

testPushPackedNested()

void testPushPackedNested

(

)

Definition at line 593 of file packed_range_unit.C.

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

Referenced by main().

  {
    // 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);
  }

testPushPackedNestedImpl()

template<typename FillFunctor , typename PushFunctor >

void testPushPackedNestedImpl	(	FillFunctor	fill_functor,
		PushFunctor	push_functor
	)

Definition at line 532 of file packed_range_unit.C.

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

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

  {
    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));
      }
  }

testPushPackedOneTuple()

void testPushPackedOneTuple

(

)

Definition at line 628 of file packed_range_unit.C.

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

Referenced by main().

  {
    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);
  }

testPushPackedOversized()

void testPushPackedOversized

(

)

Definition at line 526 of file packed_range_unit.C.

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

Referenced by main().

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

testTupleStringAllGather()

void testTupleStringAllGather

(

)

Definition at line 224 of file packed_range_unit.C.

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

Referenced by main().

  {
#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]);
  }

testVectorStringAllGather()

void testVectorStringAllGather

(

)

Definition at line 215 of file packed_range_unit.C.

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

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().