ParallelSyncTest Class Reference

Inheritance diagram for ParallelSyncTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (ParallelSyncTest)
	CPPUNIT_TEST (testPush)
	CPPUNIT_TEST (testPull)
	CPPUNIT_TEST (testPushVecVec)
	CPPUNIT_TEST (testPullVecVec)
	CPPUNIT_TEST (testPushOversized)
	CPPUNIT_TEST (testPushVecVecOversized)
	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	testPushVecVecImpl (int M)
void	testPushVecVec ()
void	testPushVecVecOversized ()
void	testPullVecVecImpl (int M)
void	testPullVecVec ()

Detailed Description

Definition at line 17 of file parallel_sync_test.C.

Member Function Documentation

CPPUNIT_TEST() [1/6]

ParallelSyncTest::CPPUNIT_TEST

(

testPush

)

CPPUNIT_TEST() [2/6]

ParallelSyncTest::CPPUNIT_TEST

(

testPull

)

CPPUNIT_TEST() [3/6]

ParallelSyncTest::CPPUNIT_TEST

(

testPushVecVec

)

CPPUNIT_TEST() [4/6]

ParallelSyncTest::CPPUNIT_TEST

(

testPullVecVec

)

CPPUNIT_TEST() [5/6]

ParallelSyncTest::CPPUNIT_TEST

(

testPushOversized

)

CPPUNIT_TEST() [6/6]

ParallelSyncTest::CPPUNIT_TEST

(

testPushVecVecOversized

)

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 49 of file parallel_sync_test.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)
          for (int i=-1; i != diffsqrt; ++i)
            data[d].push_back(d);
      }
  }

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 69 of file parallel_sync_test.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 ParallelSyncTest::fill_vector_data ( std::map< processor_id_type, std::vector< std::vector< unsigned int >>> &  data, int  M  )

inline

Definition at line 95 of file parallel_sync_test.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)
          {
            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 ParallelSyncTest::fill_vector_data ( std::multimap< processor_id_type, std::vector< std::vector< unsigned int >>> &  data, int  M  )

inline

Definition at line 120 of file parallel_sync_test.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);
          }
      }
  }

LIBMESH_CPPUNIT_TEST_SUITE()

ParallelSyncTest::LIBMESH_CPPUNIT_TEST_SUITE

(

ParallelSyncTest

)

setUp()

void ParallelSyncTest::setUp ( )

inline

Definition at line 38 of file parallel_sync_test.C.

  {}

tearDown()

void ParallelSyncTest::tearDown ( )

inline

Definition at line 41 of file parallel_sync_test.C.

  {}

testPull()

void ParallelSyncTest::testPull ( )

inline

Definition at line 257 of file parallel_sync_test.C.

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

  {
    LOG_UNIT_TEST;

    testPullImpl(TestCommWorld->size());
  }

testPullImpl()

void ParallelSyncTest::testPullImpl ( int  M )

inline

Definition at line 208 of file parallel_sync_test.C.

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

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

    fill_scalar_data(data, M);

    auto compose_replies =
      []
      (processor_id_type,
       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]);
      }
  }

testPullVecVec()

void ParallelSyncTest::testPullVecVec ( )

inline

Definition at line 397 of file parallel_sync_test.C.

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

  {
    LOG_UNIT_TEST;

    testPullVecVecImpl(TestCommWorld->size());
  }

testPullVecVecImpl()

void ParallelSyncTest::testPullVecVecImpl ( int  M )

inline

Definition at line 334 of file parallel_sync_test.C.

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

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

testPush()

void ParallelSyncTest::testPush ( )

inline

Definition at line 192 of file parallel_sync_test.C.

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

  {
    LOG_UNIT_TEST;

    testPushImpl(TestCommWorld->size());
  }

testPushImpl()

void ParallelSyncTest::testPushImpl ( int  M )

inline

Definition at line 143 of file parallel_sync_test.C.

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

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

testPushOversized()

void ParallelSyncTest::testPushOversized ( )

inline

Definition at line 200 of file parallel_sync_test.C.

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

  {
    LOG_UNIT_TEST;

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

testPushVecVec()

void ParallelSyncTest::testPushVecVec ( )

inline

Definition at line 318 of file parallel_sync_test.C.

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

  {
    LOG_UNIT_TEST;

    testPushVecVecImpl(TestCommWorld->size());
  }

testPushVecVecImpl()

void ParallelSyncTest::testPushVecVecImpl ( int  M )

inline

Definition at line 265 of file parallel_sync_test.C.

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

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

testPushVecVecOversized()

void ParallelSyncTest::testPushVecVecOversized ( )

inline

Definition at line 326 of file parallel_sync_test.C.

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

  {
    LOG_UNIT_TEST;

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

---

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

• tests/parallel/parallel_sync_test.C