parallel_sync_unit.C File Reference

Go to the source code of this file.

Functions
void	fill_scalar_data (std::map< processor_id_type, std::vector< unsigned int >> &data, int M)
void	fill_scalar_data (std::multimap< processor_id_type, std::vector< unsigned int >> &data, int M)
void	fill_vector_data (std::map< processor_id_type, std::vector< std::vector< unsigned int >>> &data, int M)
void	fill_vector_data (std::multimap< processor_id_type, std::vector< std::vector< unsigned int >>> &data, int M)
void	testPushImpl (int M)
void	testPush ()
void	testPushOversized ()
void	testPushMove ()
void	testPullImpl (int M)
void	testPull ()
void	testPullOversized ()
void	testPushVecVecImpl (int M)
void	testPushVecVec ()
void	testPushVecVecOversized ()
void	testPullVecVecImpl (int M)
void	testPullVecVec ()
void	testPullVecVecOversized ()
void	testPushMultimapImpl (int M)
void	testPushMultimap ()
void	testPushMultimapOversized ()
void	testPushMultimapVecVecImpl (int M)
void	testPushMultimapVecVec ()
void	testPushMultimapVecVecOversized ()
void	testEmptyEntry ()
void	testStringSyncType ()
void	run_tests ()
int	main (int argc, const char *const *argv)

Variables
Communicator *	TestCommWorld

Function Documentation

fill_scalar_data() [1/2]

void fill_scalar_data	(	std::map< processor_id_type, std::vector< unsigned int >> &	data,
		int	M
	)

Definition at line 19 of file parallel_sync_unit.C.

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

Referenced by testEmptyEntry(), testPullImpl(), testPushImpl(), testPushMove(), and testPushMultimapImpl().

  {
    const int rank = TestCommWorld->rank();
    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].push_back(d);
      }
  }

fill_scalar_data() [2/2]

void fill_scalar_data	(	std::multimap< processor_id_type, std::vector< unsigned int >> &	data,
		int	M
	)

Definition at line 39 of file parallel_sync_unit.C.

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

  {
    const int rank = TestCommWorld->rank();
    for (int d=0; d != M; ++d)
      {
        int diffsize = std::abs(d-rank);
        int diffsqrt = std::sqrt(diffsize);
        if (diffsqrt*diffsqrt == diffsize)
          {
            std::vector<unsigned int> v;
            for (int i=-1; i != diffsqrt; ++i)
              v.push_back(d);
            data.emplace(d, v);
            v.resize(1, d);
            data.emplace(d, v);
          }
      }
  }

fill_vector_data() [1/2]

void fill_vector_data	(	std::map< processor_id_type, std::vector< std::vector< unsigned int >>> &	data,
		int	M
	)

Definition at line 65 of file parallel_sync_unit.C.

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

Referenced by testPullVecVecImpl(), testPushMultimapVecVecImpl(), and testPushVecVecImpl().

  {
    const int rank = TestCommWorld->rank();
    for (int d=0; d != M; ++d)
      {
        int diffsize = std::abs(d-rank);
        int diffsqrt = std::sqrt(diffsize);
        if (diffsqrt*diffsqrt == diffsize)
          {
            data[d].resize(2);
            for (int i=-1; i != diffsqrt; ++i)
              data[d][0].push_back(d);
            data[d][1].push_back(d);
          }
      }
  }

fill_vector_data() [2/2]

void fill_vector_data	(	std::multimap< processor_id_type, std::vector< std::vector< unsigned int >>> &	data,
		int	M
	)

Definition at line 90 of file parallel_sync_unit.C.

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

  {
    const int rank = TestCommWorld->rank();
    for (int d=0; d != M; ++d)
      {
        int diffsize = std::abs(d-rank);
        int diffsqrt = std::sqrt(diffsize);
        if (diffsqrt*diffsqrt == diffsize)
          {
            std::vector<std::vector<unsigned int>> vv(2);
            for (int i=-1; i != diffsqrt; ++i)
              vv[0].push_back(d);
            vv[1].push_back(d);
            data.emplace(d, vv);
            vv.resize(1);
            vv[0].resize(1);
            data.emplace(d, vv);
          }
      }
  }

main()

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

Definition at line 741 of file parallel_sync_unit.C.

References TIMPI::Communicator::ALLTOALL_COUNTS, TIMPI::TIMPIInit::comm(), run_tests(), TIMPI::Communicator::SENDRECEIVE, TIMPI::Communicator::sync_type(), and TestCommWorld.

{
  TIMPI::TIMPIInit init(argc, argv);
  TestCommWorld = &init.comm();

  run_tests();

  TestCommWorld->sync_type(Communicator::ALLTOALL_COUNTS);
  run_tests();

  TestCommWorld->sync_type(Communicator::SENDRECEIVE);
  run_tests();

  return 0;
}

run_tests()

void run_tests

(

)

Definition at line 715 of file parallel_sync_unit.C.

References testEmptyEntry(), testPull(), testPullOversized(), testPullVecVec(), testPullVecVecOversized(), testPush(), testPushMove(), testPushMultimap(), testPushMultimapOversized(), testPushMultimapVecVec(), testPushMultimapVecVecOversized(), testPushOversized(), testPushVecVec(), testPushVecVecOversized(), and testStringSyncType().

Referenced by main().

{
  testPush();
  testPushMove();
  testPull();
  testPushVecVec();
  testPullVecVec();
  testPushMultimap();
  testPushMultimapVecVec();

  testEmptyEntry();

  // Our sync functions need to support sending to ranks that don't
  // exist!  If we're on N processors but working on a mesh
  // partitioned into M parts with M > N, then subpartition p belongs
  // to processor p%N.  Let's make M > N for these tests.
  testPushOversized();
  testPullOversized();
  testPushVecVecOversized();
  testPullVecVecOversized();
  testPushMultimapOversized();
  testPushMultimapVecVecOversized();

  testStringSyncType();
}

testEmptyEntry()

void testEmptyEntry

(

)

Definition at line 626 of file parallel_sync_unit.C.

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

Referenced by run_tests().

  {
    const int size = TestCommWorld->size(),
              rank = TestCommWorld->rank();
    const int M=size;

    std::map<processor_id_type, std::vector<unsigned int> > data, received_data;

    fill_scalar_data(data, M);

    // Give some processors empty sends
    for (int i=0; i != M; ++i)
      if (!(rank % 3))
        data[i];

    auto collect_data =
      [&received_data]
      (processor_id_type pid,
       const typename std::vector<unsigned int> & vec_received)
      {
        // Even if we send them we shouldn't get them
        TIMPI_UNIT_ASSERT (!vec_received.empty())

        auto & vec = received_data[pid];
        vec.insert(vec.end(), vec_received.begin(), vec_received.end());
      };

#ifndef NDEBUG
    bool caught_exception = false;
    try {
#endif
    TIMPI::push_parallel_vector_data(*TestCommWorld, data, collect_data);
#ifndef NDEBUG
    }
    catch (std::logic_error & e) {
      caught_exception = true;
      std::regex msg_regex("empty data");
      TIMPI_UNIT_ASSERT(std::regex_search(e.what(), msg_regex));
    }

    // We didn't leave room for empty sends in the 2 processor case
    if (M > 2)
      TIMPI_UNIT_ASSERT(caught_exception);
#endif

    // 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::vector<unsigned int> & datum = received_data[srcp];
                  TIMPI_UNIT_ASSERT(std::count(datum.begin(), datum.end(), p) == std::ptrdiff_t(0));
                }
              continue;
            }

          TIMPI_UNIT_ASSERT(received_data.count(srcp) == std::size_t(1));
          const std::vector<unsigned int> & datum = received_data[srcp];
          TIMPI_UNIT_ASSERT(std::count(datum.begin(), datum.end(), 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());
  }

testPull()

void testPull

(

)

Definition at line 283 of file parallel_sync_unit.C.

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

Referenced by run_tests().

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

testPullImpl()

void testPullImpl

(

int

M

)

Definition at line 225 of file parallel_sync_unit.C.

References fill_scalar_data(), TIMPI::pull_parallel_vector_data(), TIMPI::Communicator::SENDRECEIVE, TIMPI::Communicator::size(), TIMPI::Communicator::sync_type(), and TestCommWorld.

Referenced by testPull(), and testPullOversized().

  {
    // Oversized pulls are well-defined with NBX and ALLTOALL_COUNTS
    // because of C++11's guarantees regarding preservation of insert
    // ordering in multimaps, combined with MPI's guarantees about
    // non-overtaking ... but we do receives in a different order with
    // SENDRECEIVE mode, so let's skip oversized test there.
    if (TestCommWorld->sync_type() == Communicator::SENDRECEIVE &&
        M > int(TestCommWorld->size()))
      return;

    std::map<processor_id_type, std::vector<unsigned int> > data, received_data;

    fill_scalar_data(data, M);

    auto compose_replies =
      []
      (processor_id_type /* pid */,
       const std::vector<unsigned int> & query,
       std::vector<unsigned int> & response)
      {
        const std::size_t query_size = query.size();
        response.resize(query_size);
        for (unsigned int i=0; i != query_size; ++i)
          response[i] = query[i]*query[i];
      };


    auto collect_replies =
      [&received_data]
      (processor_id_type pid,
       const std::vector<unsigned int> & query,
       const std::vector<unsigned int> & response)
      {
        const std::size_t query_size = query.size();
        TIMPI_UNIT_ASSERT(query_size == response.size());
        for (unsigned int i=0; i != query_size; ++i)
          {
            TIMPI_UNIT_ASSERT(query[i]*query[i] == response[i]);
          }
        received_data[pid] = response;
      };

    // Do the pull
    unsigned int * ex = nullptr;
    TIMPI::pull_parallel_vector_data
      (*TestCommWorld, data, compose_replies, collect_replies, ex);

    // Test the received results, for each query we sent.
    for (int p=0; p != M; ++p)
      {
        TIMPI_UNIT_ASSERT(data[p].size() == received_data[p].size());
        for (std::size_t i = 0; i != data[p].size(); ++i)
          TIMPI_UNIT_ASSERT(data[p][i]*data[p][i] == received_data[p][i]);
      }
  }

testPullOversized()

void testPullOversized

(

)

Definition at line 289 of file parallel_sync_unit.C.

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

Referenced by run_tests().

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

testPullVecVec()

void testPullVecVec

(

)

Definition at line 432 of file parallel_sync_unit.C.

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

Referenced by run_tests().

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

testPullVecVecImpl()

void testPullVecVecImpl

(

int

M

)

Definition at line 360 of file parallel_sync_unit.C.

References fill_vector_data(), TIMPI::pull_parallel_vector_data(), TIMPI::Communicator::SENDRECEIVE, TIMPI::Communicator::size(), TIMPI::Communicator::sync_type(), and TestCommWorld.

Referenced by testPullVecVec().

  {
    // Oversized pulls are well-defined with NBX and ALLTOALL_COUNTS
    // because of C++11's guarantees regarding preservation of insert
    // ordering in multimaps, combined with MPI's guarantees about
    // non-overtaking ... but we do receives in a different order with
    // SENDRECEIVE mode, so let's skip oversized test there.
    if (TestCommWorld->sync_type() == Communicator::SENDRECEIVE &&
        M > int(TestCommWorld->size()))
      return;

    std::map<processor_id_type, std::vector<std::vector<unsigned int>>> data;
    std::map<processor_id_type, std::vector<std::vector<unsigned int>>> received_data;

    fill_vector_data(data, M);

    auto compose_replies =
      []
      (processor_id_type /* pid */,
       const std::vector<std::vector<unsigned int>> & query,
       std::vector<std::vector<unsigned int>> & response)
      {
        const std::size_t query_size = query.size();
        response.resize(query_size);
        for (unsigned int i=0; i != query_size; ++i)
          {
            const std::size_t query_i_size = query[i].size();
            response[i].resize(query_i_size);
            for (unsigned int j=0; j != query_i_size; ++j)
            response[i][j] = query[i][j]*query[i][j];
          }
      };


    auto collect_replies =
      [&received_data]
      (processor_id_type pid,
       const std::vector<std::vector<unsigned int>> & query,
       const std::vector<std::vector<unsigned int>> & response)
      {
        const std::size_t query_size = query.size();
        TIMPI_UNIT_ASSERT(query_size == response.size());
        for (unsigned int i=0; i != query_size; ++i)
          {
            const std::size_t query_i_size = query[i].size();
            TIMPI_UNIT_ASSERT(query_i_size == response[i].size());
            for (unsigned int j=0; j != query_i_size; ++j)
              TIMPI_UNIT_ASSERT(query[i][j]*query[i][j] == response[i][j]);
          }
        auto & vec = received_data[pid];
        vec.emplace_back(response[0].begin(), response[0].end());
        TIMPI_UNIT_ASSERT(response[1].size() == std::size_t(1));
        TIMPI_UNIT_ASSERT(response[1][0] == response[0][0]);
        vec.emplace_back(response[1].begin(), response[1].end());
      };

    // Do the pull
    std::vector<unsigned int> * ex = nullptr;
    TIMPI::pull_parallel_vector_data
      (*TestCommWorld, data, compose_replies, collect_replies, ex);

    // Test the received results, for each query we sent.
    for (int p=0; p != M; ++p)
      {
        TIMPI_UNIT_ASSERT(data[p].size() == received_data[p].size());
        for (std::size_t i = 0; i != data[p].size(); ++i)
          for (std::size_t j = 0; j != data[p][i].size(); ++j)
            TIMPI_UNIT_ASSERT(data[p][i][j]*data[p][i][j] == received_data[p][i][j]);
      }
  }

testPullVecVecOversized()

void testPullVecVecOversized

(

)

Definition at line 438 of file parallel_sync_unit.C.

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

Referenced by run_tests().

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

testPush()

void testPush

(

)

Definition at line 162 of file parallel_sync_unit.C.

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

Referenced by run_tests().

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

testPushImpl()

void testPushImpl

(

int

M

)

Definition at line 113 of file parallel_sync_unit.C.

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

Referenced by testPush(), and testPushOversized().

  {
    const int size = TestCommWorld->size(),
              rank = TestCommWorld->rank();

    std::map<processor_id_type, std::vector<unsigned int> > data, received_data;

    fill_scalar_data(data, M);

    auto collect_data =
      [&received_data]
      (processor_id_type pid,
       const typename std::vector<unsigned int> & vec_received)
      {
        auto & vec = received_data[pid];
        vec.insert(vec.end(), vec_received.begin(), vec_received.end());
      };

    TIMPI::push_parallel_vector_data(*TestCommWorld, data, 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))
                {
                  const std::vector<unsigned int> & datum = received_data[srcp];
                  TIMPI_UNIT_ASSERT(std::count(datum.begin(), datum.end(), p) == std::ptrdiff_t(0));
                }
              continue;
            }

          TIMPI_UNIT_ASSERT(received_data.count(srcp) == std::size_t(1));
          const std::vector<unsigned int> & datum = received_data[srcp];
          TIMPI_UNIT_ASSERT(std::count(datum.begin(), datum.end(), 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());
  }

testPushMove()

void testPushMove

(

)

Definition at line 174 of file parallel_sync_unit.C.

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

Referenced by run_tests().

  {
    const int size = TestCommWorld->size(),
              rank = TestCommWorld->rank();

    std::map<processor_id_type, std::vector<unsigned int>> data, received_data;

    const int M = TestCommWorld->size();
    fill_scalar_data(data, M);

    auto collect_data =
      [&received_data]
      (processor_id_type pid,
       typename std::vector<unsigned int> && vec_received)
      {
        auto & vec = received_data[pid];
        for (auto & val : vec_received)
          vec.emplace_back(std::move(val));
      };

    TIMPI::push_parallel_vector_data(*TestCommWorld, std::move(data), 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))
                {
                  const std::vector<unsigned int> & datum = received_data[srcp];
                  TIMPI_UNIT_ASSERT(std::count(datum.begin(), datum.end(), p) == std::ptrdiff_t(0));
                }
              continue;
            }

          TIMPI_UNIT_ASSERT(received_data.count(srcp) == std::size_t(1));
          const std::vector<unsigned int> & datum = received_data[srcp];
          TIMPI_UNIT_ASSERT(std::count(datum.begin(), datum.end(), 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());
  }

testPushMultimap()

void testPushMultimap

(

)

Definition at line 517 of file parallel_sync_unit.C.

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

Referenced by run_tests().

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

testPushMultimapImpl()

void testPushMultimapImpl

(

int

M

)

Definition at line 444 of file parallel_sync_unit.C.

References fill_scalar_data(), TIMPI::push_parallel_vector_data(), TIMPI::Communicator::rank(), TIMPI::Communicator::SENDRECEIVE, TIMPI::Communicator::size(), TIMPI::Communicator::sync_type(), and TestCommWorld.

Referenced by testPushMultimap(), and testPushMultimapOversized().

  {
    const int size = TestCommWorld->size(),
              rank = TestCommWorld->rank();

    // This is going to be well-defined with NBX and ALLTOALL_COUNTS
    // because of C++11's guarantees regarding preservation of insert
    // ordering in multimaps, combined with MPI's guarantees about
    // non-overtaking ... but we do receives in a different order with
    // SENDRECEIVE mode, so let's skip this test there.
    if (TestCommWorld->sync_type() == Communicator::SENDRECEIVE)
      return;

    std::multimap<processor_id_type, std::vector<unsigned int> > data, received_data;

    fill_scalar_data(data, M);

    auto collect_data =
      [&received_data]
      (processor_id_type pid,
       const typename std::vector<unsigned int> & vec_received)
      {
        received_data.emplace(pid, vec_received);
      };

    TIMPI::push_parallel_vector_data(*TestCommWorld, data, 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);
          auto rng = received_data.equal_range(srcp);
          if (diffsqrt*diffsqrt != diffsize)
            {
              for (auto pv_it = rng.first; pv_it != rng.second; ++pv_it)
                {
                  TIMPI_UNIT_ASSERT(std::count(pv_it->second.begin(), pv_it->second.end(), p) == std::ptrdiff_t(0));
                }
              continue;
            }

          TIMPI_UNIT_ASSERT(rng.first != rng.second);
          for (auto pv_it = rng.first; pv_it != rng.second; ++pv_it)
            {
              std::ptrdiff_t cnt = std::count(pv_it->second.begin(), pv_it->second.end(), p);
              if (cnt)
                {
                  TIMPI_UNIT_ASSERT(cnt == std::ptrdiff_t(diffsqrt+1));
                  auto pv_it2 = pv_it; ++pv_it2;
                  TIMPI_UNIT_ASSERT(pv_it2 != rng.second);
                  std::ptrdiff_t cnt2 = std::count(pv_it2->second.begin(), pv_it2->second.end(), p);
                  TIMPI_UNIT_ASSERT(cnt2 == std::ptrdiff_t(1));
                  checked_sizes[srcp] += cnt + cnt2;
                  break;
                }
            }
        }

    for (int srcp=0; srcp != size; ++srcp)
      {
        std::size_t total_size = 0;
        auto rng = received_data.equal_range(srcp);
        for (auto pv_it = rng.first; pv_it != rng.second; ++pv_it)
          total_size += pv_it->second.size();
        TIMPI_UNIT_ASSERT(checked_sizes[srcp] == total_size);
      }
  }

testPushMultimapOversized()

void testPushMultimapOversized

(

)

Definition at line 523 of file parallel_sync_unit.C.

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

Referenced by run_tests().

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

testPushMultimapVecVec()

void testPushMultimapVecVec

(

)

Definition at line 612 of file parallel_sync_unit.C.

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

Referenced by run_tests().

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

testPushMultimapVecVecImpl()

void testPushMultimapVecVecImpl

(

int

M

)

Definition at line 529 of file parallel_sync_unit.C.

References fill_vector_data(), TIMPI::push_parallel_vector_data(), TIMPI::Communicator::rank(), TIMPI::Communicator::SENDRECEIVE, TIMPI::Communicator::size(), TIMPI::Communicator::sync_type(), and TestCommWorld.

Referenced by testPushMultimapVecVec(), and testPushMultimapVecVecOversized().

  {
    const int size = TestCommWorld->size(),
              rank = TestCommWorld->rank();

    // This is going to be well-defined with NBX and ALLTOALL_COUNTS
    // because of C++11's guarantees regarding preservation of insert
    // ordering in multimaps, combined with MPI's guarantees about
    // non-overtaking ... but we do receives in a different order with
    // SENDRECEIVE mode, so let's skip this test there.
    if (TestCommWorld->sync_type() == Communicator::SENDRECEIVE)
      return;

    std::multimap<processor_id_type, std::vector<std::vector<unsigned int>>> data, received_data;

    fill_vector_data(data, M);

    auto collect_data =
      [&received_data]
      (processor_id_type pid,
       const typename std::vector<std::vector<unsigned int>> & vecvec_received)
      {
        received_data.emplace(pid, vecvec_received);
      };

    TIMPI::push_parallel_vector_data(*TestCommWorld, data, 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);
          auto rng = received_data.equal_range(srcp);
          if (diffsqrt*diffsqrt != diffsize)
            {
              for (auto pvv = rng.first; pvv != rng.second; ++pvv)
                {
                  for (auto & v : pvv->second)
                  TIMPI_UNIT_ASSERT(std::count(v.begin(), v.end(), p) == std::ptrdiff_t(0));
                }
              continue;
            }

          TIMPI_UNIT_ASSERT(rng.first != rng.second);
          for (auto pvv_it = rng.first; pvv_it != rng.second; ++pvv_it)
            {
              if(pvv_it->second.size() != std::size_t(2))
                timpi_error();
              TIMPI_UNIT_ASSERT(pvv_it->second.size() == std::size_t(2));
              std::ptrdiff_t cnt = std::count(pvv_it->second[0].begin(), pvv_it->second[0].end(), p);
              if (cnt)
                {
                  TIMPI_UNIT_ASSERT(cnt == std::ptrdiff_t(diffsqrt+1));
                  std::ptrdiff_t cnt2 = std::count(pvv_it->second[1].begin(), pvv_it->second[1].end(), p);
                  TIMPI_UNIT_ASSERT(cnt2 == std::ptrdiff_t(1));
                  auto pvv_it2 = pvv_it; ++pvv_it2;
                  TIMPI_UNIT_ASSERT(pvv_it2 != rng.second);
                  TIMPI_UNIT_ASSERT(pvv_it2->second.size() == std::size_t(1));
                  std::ptrdiff_t cnt3 = std::count(pvv_it2->second[0].begin(), pvv_it2->second[0].end(), p);
                  TIMPI_UNIT_ASSERT(cnt3 == std::ptrdiff_t(1));
                  checked_sizes[srcp] += cnt + cnt2 + cnt3;
                  break;
                }
              ++pvv_it;
              timpi_assert(pvv_it != rng.second);
            }
        }

    for (int srcp=0; srcp != size; ++srcp)
      {
        std::size_t total_size = 0;
        auto rng = received_data.equal_range(srcp);
        for (auto pvv = rng.first; pvv != rng.second; ++pvv)
          for (auto & v : pvv->second)
            total_size += v.size();
        TIMPI_UNIT_ASSERT(checked_sizes[srcp] == total_size);
      }
  }

testPushMultimapVecVecOversized()

void testPushMultimapVecVecOversized

(

)

Definition at line 618 of file parallel_sync_unit.C.

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

Referenced by run_tests().

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

testPushOversized()

void testPushOversized

(

)

Definition at line 168 of file parallel_sync_unit.C.

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

Referenced by run_tests().

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

testPushVecVec()

void testPushVecVec

(

)

Definition at line 348 of file parallel_sync_unit.C.

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

Referenced by run_tests().

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

testPushVecVecImpl()

void testPushVecVecImpl

(

int

M

)

Definition at line 295 of file parallel_sync_unit.C.

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

Referenced by testPullVecVecOversized(), testPushVecVec(), and testPushVecVecOversized().

  {
    const int size = TestCommWorld->size(),
              rank = TestCommWorld->rank();

    std::map<processor_id_type, std::vector<std::vector<unsigned int>>> data;
    std::map<processor_id_type, std::vector<unsigned int>> received_data;

    fill_vector_data(data, M);

    auto collect_data =
      [&received_data]
      (processor_id_type pid,
       const typename std::vector<std::vector<unsigned int>> & vecvec_received)
      {
        TIMPI_UNIT_ASSERT(vecvec_received.size() == std::size_t(2));
        TIMPI_UNIT_ASSERT(vecvec_received[1].size() == std::size_t(1));
        TIMPI_UNIT_ASSERT(vecvec_received[0][0] == vecvec_received[1][0]);
        auto & vec = received_data[pid];
        vec.insert(vec.end(), vecvec_received[0].begin(), vecvec_received[0].end());
      };

    TIMPI::push_parallel_vector_data(*TestCommWorld, data, 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))
                {
                  const std::vector<unsigned int> & datum = received_data[srcp];
                  TIMPI_UNIT_ASSERT(std::count(datum.begin(), datum.end(), p) == std::ptrdiff_t(0));
                }
              continue;
            }

          TIMPI_UNIT_ASSERT(received_data.count(srcp) == std::size_t(1));
          const std::vector<unsigned int> & datum = received_data[srcp];
          TIMPI_UNIT_ASSERT(std::count(datum.begin(), datum.end(), 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());
  }

testPushVecVecOversized()

void testPushVecVecOversized

(

)

Definition at line 354 of file parallel_sync_unit.C.

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

Referenced by run_tests().

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

testStringSyncType()

void testStringSyncType

(

)

Definition at line 700 of file parallel_sync_unit.C.

References TIMPI::Communicator::ALLTOALL_COUNTS, TIMPI::Communicator::duplicate(), TIMPI::Communicator::NBX, TIMPI::Communicator::SENDRECEIVE, TIMPI::Communicator::sync_type(), and TestCommWorld.

Referenced by run_tests().

  {
    Communicator comm;
    comm.duplicate(*TestCommWorld);

    comm.sync_type("nbx");
    TIMPI_UNIT_ASSERT(comm.sync_type() == Communicator::NBX);

    comm.sync_type("sendreceive");
    TIMPI_UNIT_ASSERT(comm.sync_type() == Communicator::SENDRECEIVE);

    comm.sync_type("alltoall");
    TIMPI_UNIT_ASSERT(comm.sync_type() == Communicator::ALLTOALL_COUNTS);
  }

Variable Documentation

TestCommWorld

Communicator* TestCommWorld

Definition at line 13 of file parallel_sync_unit.C.

Referenced by fill_scalar_data(), fill_vector_data(), main(), testEmptyEntry(), testPull(), testPullImpl(), testPullOversized(), testPullVecVec(), testPullVecVecImpl(), testPullVecVecOversized(), testPush(), testPushImpl(), testPushMove(), testPushMultimap(), testPushMultimapImpl(), testPushMultimapOversized(), testPushMultimapVecVec(), testPushMultimapVecVecImpl(), testPushMultimapVecVecOversized(), testPushOversized(), testPushVecVec(), testPushVecVecImpl(), testPushVecVecOversized(), and testStringSyncType().