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 18 of file parallel_sync_unit.C.

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

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

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

fill_scalar_data() [2/2]

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

Definition at line 38 of file parallel_sync_unit.C.

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

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

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 64 of file parallel_sync_unit.C.

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

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

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

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 89 of file parallel_sync_unit.C.

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

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

main()

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

Definition at line 741 of file parallel_sync_unit.C.

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

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

run_tests()

void run_tests

(

)

Definition at line 715 of file parallel_sync_unit.C.

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

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

Referenced by main().

testEmptyEntry()

void testEmptyEntry

(

)

Definition at line 626 of file parallel_sync_unit.C.

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

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

Referenced by run_tests().

testPull()

void testPull

(

)

Definition at line 283 of file parallel_sync_unit.C.

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

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

Referenced by run_tests().

testPullImpl()

void testPullImpl

(

int

M

)

Definition at line 225 of file parallel_sync_unit.C.

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

References TIMPI::cast_int(), 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().

testPullOversized()

void testPullOversized

(

)

Definition at line 289 of file parallel_sync_unit.C.

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

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

Referenced by run_tests().

testPullVecVec()

void testPullVecVec

(

)

Definition at line 432 of file parallel_sync_unit.C.

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

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

Referenced by run_tests().

testPullVecVecImpl()

void testPullVecVecImpl

(

int

M

)

Definition at line 360 of file parallel_sync_unit.C.

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

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

Referenced by testPullVecVec().

testPullVecVecOversized()

void testPullVecVecOversized

(

)

Definition at line 438 of file parallel_sync_unit.C.

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

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

Referenced by run_tests().

testPush()

void testPush

(

)

Definition at line 162 of file parallel_sync_unit.C.

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

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

Referenced by run_tests().

testPushImpl()

void testPushImpl

(

int

M

)

Definition at line 113 of file parallel_sync_unit.C.

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

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

Referenced by testPush(), and testPushOversized().

testPushMove()

void testPushMove

(

)

Definition at line 174 of file parallel_sync_unit.C.

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

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

Referenced by run_tests().

testPushMultimap()

void testPushMultimap

(

)

Definition at line 517 of file parallel_sync_unit.C.

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

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

Referenced by run_tests().

testPushMultimapImpl()

void testPushMultimapImpl

(

int

M

)

Definition at line 444 of file parallel_sync_unit.C.

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

References TIMPI::cast_int(), 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().

testPushMultimapOversized()

void testPushMultimapOversized

(

)

Definition at line 523 of file parallel_sync_unit.C.

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

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

Referenced by run_tests().

testPushMultimapVecVec()

void testPushMultimapVecVec

(

)

Definition at line 612 of file parallel_sync_unit.C.

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

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

Referenced by run_tests().

testPushMultimapVecVecImpl()

void testPushMultimapVecVecImpl

(

int

M

)

Definition at line 529 of file parallel_sync_unit.C.

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

References TIMPI::cast_int(), 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().

testPushMultimapVecVecOversized()

void testPushMultimapVecVecOversized

(

)

Definition at line 618 of file parallel_sync_unit.C.

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

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

Referenced by run_tests().

testPushOversized()

void testPushOversized

(

)

Definition at line 168 of file parallel_sync_unit.C.

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

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

Referenced by run_tests().

testPushVecVec()

void testPushVecVec

(

)

Definition at line 348 of file parallel_sync_unit.C.

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

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

Referenced by run_tests().

testPushVecVecImpl()

void testPushVecVecImpl

(

int

M

)

Definition at line 295 of file parallel_sync_unit.C.

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

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

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

testPushVecVecOversized()

void testPushVecVecOversized

(

)

Definition at line 354 of file parallel_sync_unit.C.

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

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

Referenced by run_tests().

testStringSyncType()

void testStringSyncType

(

)

Definition at line 700 of file parallel_sync_unit.C.

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

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

Referenced by run_tests().

Variable Documentation

TestCommWorld

Communicator* TestCommWorld

Definition at line 13 of file parallel_sync_unit.C.

Referenced by fill_scalar_data(), fill_scalar_data(), fill_vector_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().