ParallelSyncTest Class Reference

Inheritance diagram for ParallelSyncTest:

Public Member Functions
	CPPUNIT_TEST_SUITE (ParallelSyncTest)
	CPPUNIT_TEST (testPush)
	CPPUNIT_TEST (testPull)
	CPPUNIT_TEST (testPushVecVec)
	CPPUNIT_TEST (testPullVecVec)
	CPPUNIT_TEST (testPushMultimap)
	CPPUNIT_TEST (testPushMultimapVecVec)
	CPPUNIT_TEST (testPushOversized)
	CPPUNIT_TEST (testPullOversized)
	CPPUNIT_TEST (testPushVecVecOversized)
	CPPUNIT_TEST (testPullVecVecOversized)
	CPPUNIT_TEST (testPushMultimapOversized)
	CPPUNIT_TEST (testPushMultimapVecVecOversized)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
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	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 ()

Detailed Description

Definition at line 17 of file parallel_sync_test.C.

Member Function Documentation

CPPUNIT_TEST() [1/12]

ParallelSyncTest::CPPUNIT_TEST

(

testPull

)

CPPUNIT_TEST() [2/12]

ParallelSyncTest::CPPUNIT_TEST

(

testPullOversized

)

CPPUNIT_TEST() [3/12]

ParallelSyncTest::CPPUNIT_TEST

(

testPullVecVec

)

CPPUNIT_TEST() [4/12]

ParallelSyncTest::CPPUNIT_TEST

(

testPullVecVecOversized

)

CPPUNIT_TEST() [5/12]

ParallelSyncTest::CPPUNIT_TEST

(

testPush

)

CPPUNIT_TEST() [6/12]

ParallelSyncTest::CPPUNIT_TEST

(

testPushMultimap

)

CPPUNIT_TEST() [7/12]

ParallelSyncTest::CPPUNIT_TEST

(

testPushMultimapOversized

)

CPPUNIT_TEST() [8/12]

ParallelSyncTest::CPPUNIT_TEST

(

testPushMultimapVecVec

)

CPPUNIT_TEST() [9/12]

ParallelSyncTest::CPPUNIT_TEST

(

testPushMultimapVecVecOversized

)

CPPUNIT_TEST() [10/12]

ParallelSyncTest::CPPUNIT_TEST

(

testPushOversized

)

CPPUNIT_TEST() [11/12]

ParallelSyncTest::CPPUNIT_TEST

(

testPushVecVec

)

CPPUNIT_TEST() [12/12]

ParallelSyncTest::CPPUNIT_TEST

(

testPushVecVecOversized

)

CPPUNIT_TEST_SUITE()

ParallelSyncTest::CPPUNIT_TEST_SUITE

(

ParallelSyncTest

)

CPPUNIT_TEST_SUITE_END()

ParallelSyncTest::CPPUNIT_TEST_SUITE_END

(

)

fill_scalar_data() [1/2]

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

inline

Definition at line 55 of file parallel_sync_test.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 std::abs(), data, std::sqrt(), and TestCommWorld.

fill_scalar_data() [2/2]

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

inline

Definition at line 75 of file parallel_sync_test.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 std::abs(), data, std::sqrt(), and TestCommWorld.

fill_vector_data() [1/2]

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

inline

Definition at line 101 of file parallel_sync_test.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 std::abs(), data, std::sqrt(), and TestCommWorld.

fill_vector_data() [2/2]

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

inline

Definition at line 126 of file parallel_sync_test.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 std::abs(), data, std::sqrt(), and TestCommWorld.

setUp()

void ParallelSyncTest::setUp ( )

inline

Definition at line 44 of file parallel_sync_test.C.

  {}

tearDown()

void ParallelSyncTest::tearDown ( )

inline

Definition at line 47 of file parallel_sync_test.C.

  {}

testPull()

void ParallelSyncTest::testPull ( )

inline

Definition at line 259 of file parallel_sync_test.C.

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

References TestCommWorld.

testPullImpl()

void ParallelSyncTest::testPullImpl ( int  M )

inline

Definition at line 210 of file parallel_sync_test.C.

  {
    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();
        CPPUNIT_ASSERT_EQUAL(query_size, response.size());
        for (unsigned int i=0; i != query_size; ++i)
          {
            CPPUNIT_ASSERT_EQUAL(query[i]*query[i], response[i]);
          }
        received_data[pid] = response;
      };
 
    // Do the pull
    unsigned int * ex = nullptr;
    Parallel::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)
      {
        CPPUNIT_ASSERT_EQUAL(data[p].size(), received_data[p].size());
        for (auto i : index_range(data[p]))
          CPPUNIT_ASSERT_EQUAL(data[p][i]*data[p][i], received_data[p][i]);
      }
  }

References data, libMesh::index_range(), query, and TestCommWorld.

testPullOversized()

void ParallelSyncTest::testPullOversized ( )

inline

Definition at line 265 of file parallel_sync_test.C.

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

References TestCommWorld.

testPullVecVec()

void ParallelSyncTest::testPullVecVec ( )

inline

Definition at line 399 of file parallel_sync_test.C.

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

References TestCommWorld.

testPullVecVecImpl()

void ParallelSyncTest::testPullVecVecImpl ( int  M )

inline

Definition at line 336 of file parallel_sync_test.C.

  {
    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();
        CPPUNIT_ASSERT_EQUAL(query_size, response.size());
        for (unsigned int i=0; i != query_size; ++i)
          {
            const std::size_t query_i_size = query[i].size();
            CPPUNIT_ASSERT_EQUAL(query_i_size, response[i].size());
            for (unsigned int j=0; j != query_i_size; ++j)
              CPPUNIT_ASSERT_EQUAL(query[i][j]*query[i][j], response[i][j]);
          }
        auto & vec = received_data[pid];
        vec.emplace_back(response[0].begin(), response[0].end());
        CPPUNIT_ASSERT_EQUAL(response[1].size(), std::size_t(1));
        CPPUNIT_ASSERT_EQUAL(response[1][0], response[0][0]);
        vec.emplace_back(response[1].begin(), response[1].end());
      };
 
    // Do the pull
    std::vector<unsigned int> * ex = nullptr;
    Parallel::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)
      {
        CPPUNIT_ASSERT_EQUAL(data[p].size(), received_data[p].size());
        for (auto i : index_range(data[p]))
          for (auto j : index_range(data[p][i]))
            CPPUNIT_ASSERT_EQUAL(data[p][i][j]*data[p][i][j], received_data[p][i][j]);
      }
  }

References data, end, libMesh::index_range(), query, and TestCommWorld.

testPullVecVecOversized()

void ParallelSyncTest::testPullVecVecOversized ( )

inline

Definition at line 405 of file parallel_sync_test.C.

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

References TestCommWorld.

testPush()

void ParallelSyncTest::testPush ( )

inline

Definition at line 198 of file parallel_sync_test.C.

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

References TestCommWorld.

testPushImpl()

void ParallelSyncTest::testPushImpl ( int  M )

inline

Definition at line 149 of file parallel_sync_test.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> & data)
      {
        auto & vec = received_data[pid];
        vec.insert(vec.end(), data.begin(), data.end());
      };
 
    Parallel::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];
                  CPPUNIT_ASSERT_EQUAL(std::count(datum.begin(), datum.end(), p), std::ptrdiff_t(0));
                }
              continue;
            }
 
          CPPUNIT_ASSERT_EQUAL(received_data.count(srcp), std::size_t(1));
          const std::vector<unsigned int> & datum = received_data[srcp];
          CPPUNIT_ASSERT_EQUAL(std::count(datum.begin(), datum.end(), p), std::ptrdiff_t(diffsqrt+1));
          checked_sizes[srcp] += diffsqrt+1;
        }
 
    for (int srcp=0; srcp != size; ++srcp)
      CPPUNIT_ASSERT_EQUAL(checked_sizes[srcp], received_data[srcp].size());
  }

References std::abs(), data, std::sqrt(), and TestCommWorld.

testPushMultimap()

void ParallelSyncTest::testPushMultimap ( )

inline

Definition at line 478 of file parallel_sync_test.C.

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

References TestCommWorld.

testPushMultimapImpl()

void ParallelSyncTest::testPushMultimapImpl ( int  M )

inline

Definition at line 411 of file parallel_sync_test.C.

  {
    const int size = TestCommWorld->size(),
              rank = TestCommWorld->rank();
 
    // This is going to make sense because of C++11's guarantees
    // regarding preservation of insert ordering in multimaps,
    // combined with MPI's guarantees about non-overtaking
    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> & data)
      {
        received_data.emplace(pid, data);
      };
 
    Parallel::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 : as_range(rng))
                {
                  CPPUNIT_ASSERT_EQUAL(std::count(pv_it.second.begin(), pv_it.second.end(), p), std::ptrdiff_t(0));
                }
              continue;
            }
 
          CPPUNIT_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)
                {
                  CPPUNIT_ASSERT_EQUAL(cnt, std::ptrdiff_t(diffsqrt+1));
                  auto pv_it2 = pv_it; ++pv_it2;
                  CPPUNIT_ASSERT(pv_it2 != rng.second);
                  std::ptrdiff_t cnt2 = std::count(pv_it2->second.begin(), pv_it2->second.end(), p);
                  CPPUNIT_ASSERT_EQUAL(cnt2, std::ptrdiff_t(1));
                  checked_sizes[srcp] += cnt + cnt2;
                  break;
                }
            }
        }
 
    for (int srcp=0; srcp != size; ++srcp)
      {
        std::size_t total_size = 0;
        for (auto & pv_it : as_range(received_data.equal_range(srcp)))
          total_size += pv_it.second.size();
        CPPUNIT_ASSERT_EQUAL(checked_sizes[srcp], total_size);
      }
  }

References std::abs(), libMesh::as_range(), data, std::sqrt(), and TestCommWorld.

testPushMultimapOversized()

void ParallelSyncTest::testPushMultimapOversized ( )

inline

Definition at line 484 of file parallel_sync_test.C.

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

References TestCommWorld.

testPushMultimapVecVec()

void ParallelSyncTest::testPushMultimapVecVec ( )

inline

Definition at line 567 of file parallel_sync_test.C.

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

References TestCommWorld.

testPushMultimapVecVecImpl()

void ParallelSyncTest::testPushMultimapVecVecImpl ( int  M )

inline

Definition at line 490 of file parallel_sync_test.C.

  {
    const int size = TestCommWorld->size(),
              rank = TestCommWorld->rank();
 
    // This is going to make sense because of C++11's guarantees
    // regarding preservation of insert ordering in multimaps,
    // combined with MPI's guarantees about non-overtaking
    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>> & data)
      {
        received_data.emplace(pid, data);
      };
 
    Parallel::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 : as_range(rng))
                {
                  for (auto & v : pvv.second)
                  CPPUNIT_ASSERT_EQUAL(std::count(v.begin(), v.end(), p), std::ptrdiff_t(0));
                }
              continue;
            }
 
          CPPUNIT_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))
                libmesh_error();
              CPPUNIT_ASSERT_EQUAL(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)
                {
                  CPPUNIT_ASSERT_EQUAL(cnt, std::ptrdiff_t(diffsqrt+1));
                  std::ptrdiff_t cnt2 = std::count(pvv_it->second[1].begin(), pvv_it->second[1].end(), p);
                  CPPUNIT_ASSERT_EQUAL(cnt2, std::ptrdiff_t(1));
                  auto pvv_it2 = pvv_it; ++pvv_it2;
                  CPPUNIT_ASSERT(pvv_it2 != rng.second);
                  CPPUNIT_ASSERT_EQUAL(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);
                  CPPUNIT_ASSERT_EQUAL(cnt3, std::ptrdiff_t(1));
                  checked_sizes[srcp] += cnt + cnt2 + cnt3;
                  break;
                }
              ++pvv_it;
              libmesh_assert(pvv_it != rng.second);
            }
        }
 
    for (int srcp=0; srcp != size; ++srcp)
      {
        std::size_t total_size = 0;
        for (auto & pvv : as_range(received_data.equal_range(srcp)))
          for (auto & v : pvv.second)
            total_size += v.size();
        CPPUNIT_ASSERT_EQUAL(checked_sizes[srcp], total_size);
      }
  }

References std::abs(), libMesh::as_range(), data, libMesh::libmesh_assert(), std::sqrt(), and TestCommWorld.

testPushMultimapVecVecOversized()

void ParallelSyncTest::testPushMultimapVecVecOversized ( )

inline

Definition at line 573 of file parallel_sync_test.C.

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

References TestCommWorld.

testPushOversized()

void ParallelSyncTest::testPushOversized ( )

inline

Definition at line 204 of file parallel_sync_test.C.

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

References TestCommWorld.

testPushVecVec()

void ParallelSyncTest::testPushVecVec ( )

inline

Definition at line 324 of file parallel_sync_test.C.

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

References TestCommWorld.

testPushVecVecImpl()

void ParallelSyncTest::testPushVecVecImpl ( int  M )

inline

Definition at line 271 of file parallel_sync_test.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>> & data)
      {
        auto & vec = received_data[pid];
        vec.insert(vec.end(), data[0].begin(), data[0].end());
        CPPUNIT_ASSERT_EQUAL(data.size(), std::size_t(2));
        CPPUNIT_ASSERT_EQUAL(data[1].size(), std::size_t(1));
        CPPUNIT_ASSERT_EQUAL(data[0][0], data[1][0]);
      };
 
    Parallel::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];
                  CPPUNIT_ASSERT_EQUAL(std::count(datum.begin(), datum.end(), p), std::ptrdiff_t(0));
                }
              continue;
            }
 
          CPPUNIT_ASSERT_EQUAL(received_data.count(srcp), std::size_t(1));
          const std::vector<unsigned int> & datum = received_data[srcp];
          CPPUNIT_ASSERT_EQUAL(std::count(datum.begin(), datum.end(), p), std::ptrdiff_t(diffsqrt+1));
          checked_sizes[srcp] += diffsqrt+1;
        }
 
    for (int srcp=0; srcp != size; ++srcp)
      CPPUNIT_ASSERT_EQUAL(checked_sizes[srcp], received_data[srcp].size());
  }

References std::abs(), data, std::sqrt(), and TestCommWorld.

testPushVecVecOversized()

void ParallelSyncTest::testPushVecVecOversized ( )

inline

Definition at line 330 of file parallel_sync_test.C.

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

References TestCommWorld.

---

The documentation for this class was generated from the following file:

• tests/parallel/parallel_sync_test.C