parallel_point_test.C

Go to the documentation of this file.

#include <libmesh/int_range.h>
#include <libmesh/parallel.h>
#include <libmesh/parallel_algebra.h>
 
#include "test_comm.h"
#include "libmesh_cppunit.h"
 
 
using namespace libMesh;
 
class ParallelPointTest : public CppUnit::TestCase {
public:
  LIBMESH_CPPUNIT_TEST_SUITE( ParallelPointTest );
 
#if LIBMESH_DIM > 2
  CPPUNIT_TEST( testAllGatherPoint );
  CPPUNIT_TEST( testAllGatherPairPointPoint );
  CPPUNIT_TEST( testAllGatherPairRealPoint );
  CPPUNIT_TEST( testMapUnionGradient );
  CPPUNIT_TEST( testMapUnionPoint );
#endif
 
  CPPUNIT_TEST( testBroadcastVectorValueInt );
  CPPUNIT_TEST( testBroadcastVectorValueReal );
  CPPUNIT_TEST( testBroadcastPoint );
  CPPUNIT_TEST( testIsendRecv );
  CPPUNIT_TEST( testIrecvSend );
 
  CPPUNIT_TEST_SUITE_END();
 
private:
 
public:
  void setUp()
  {}
 
  void tearDown()
  {}
 
 
 
  void testAllGatherPoint()
  {
    LOG_UNIT_TEST;
 
    std::vector<Point> vals;
    Real myrank = TestCommWorld->rank();
    TestCommWorld->allgather(Point(myrank, myrank+0.25, myrank+0.5),vals);
 
    const std::size_t comm_size = TestCommWorld->size();
    const std::size_t vec_size  = vals.size();
    CPPUNIT_ASSERT_EQUAL( comm_size, vec_size );
    for (processor_id_type i=0; i<vals.size(); i++)
      {
        Real theirrank = i;
        CPPUNIT_ASSERT_EQUAL( theirrank,            vals[i](0) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.25), vals[i](1) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.5),  vals[i](2) );
      }
  }
 
 
 
  void testAllGatherPairPointPoint()
  {
    LOG_UNIT_TEST;
 
    std::vector<std::pair<Point, Point>> vals;
    Real myrank = TestCommWorld->rank();
    TestCommWorld->allgather
      (std::make_pair(Point(myrank, myrank+0.125, myrank+0.25), Point(myrank+0.5, myrank+0.625, myrank+0.75)), vals);
 
    const std::size_t comm_size = TestCommWorld->size();
    const std::size_t vec_size  = vals.size();
    CPPUNIT_ASSERT_EQUAL( comm_size, vec_size );
 
    for (processor_id_type i=0; i<vals.size(); i++)
      {
        Real theirrank = i;
        CPPUNIT_ASSERT_EQUAL( theirrank,             vals[i].first(0) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.125), vals[i].first(1) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.25),  vals[i].first(2) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.5),   vals[i].second(0) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.625), vals[i].second(1) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.75),  vals[i].second(2) );
      }
  }
 
 
  void testAllGatherPairRealPoint()
  {
    LOG_UNIT_TEST;
 
    std::vector<std::pair<Real, Point>> vals;
    Real myrank = TestCommWorld->rank();
    TestCommWorld->allgather
      (std::make_pair(Real(myrank+0.75), Point(myrank, myrank+0.25, myrank+0.5)), vals);
 
    const std::size_t comm_size = TestCommWorld->size();
    const std::size_t vec_size  = vals.size();
    CPPUNIT_ASSERT_EQUAL( comm_size, vec_size );
 
    for (processor_id_type i=0; i<vals.size(); i++)
      {
        Real theirrank = i;
        CPPUNIT_ASSERT_EQUAL( theirrank,            vals[i].second(0) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.25), vals[i].second(1) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.5),  vals[i].second(2) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.75), vals[i].first );
      }
  }
 
 
 
  template <typename VecType>
  void testMapUnionVec()
  {
    // std::map<processor_id_type , std::vector<Point>> vals;
    std::map<processor_id_type , std::vector<VecType>> vals;
 
    const processor_id_type myrank = TestCommWorld->rank();
 
    vals[myrank*2].resize(1);
    vals[myrank*2][0](0) = myrank+1;
 
    TestCommWorld->set_union(vals);
 
    const processor_id_type comm_size = TestCommWorld->size();
 
    CPPUNIT_ASSERT_EQUAL(vals.size(), std::size_t(comm_size));
    for (auto p : make_range(comm_size))
      {
        CPPUNIT_ASSERT_EQUAL(vals[p*2].size(), std::size_t(1));
        CPPUNIT_ASSERT_EQUAL(Real(p+1), libmesh_real(vals[p*2][0](0)));
      }
  }
 
 
  void testMapUnionGradient()
  {
    LOG_UNIT_TEST;
 
    testMapUnionVec<Gradient>();
  }
 
 
  void testMapUnionPoint()
  {
    LOG_UNIT_TEST;
 
    testMapUnionVec<Point>();
  }
 
 
  template <typename T>
  void testBroadcastVectorValue()
  {
    std::vector<VectorValue<T>> src(3), dest(3);
 
    {
      T val=T(0);
      for (unsigned int i=0; i<3; i++)
        for (unsigned int j=0; j<LIBMESH_DIM; j++)
          src[i](j) = val++;
 
      if (TestCommWorld->rank() == 0)
        dest = src;
    }
 
    TestCommWorld->broadcast(dest);
 
    for (unsigned int i=0; i<3; i++)
      for (unsigned int j=0; j<LIBMESH_DIM; j++)
        CPPUNIT_ASSERT_EQUAL (src[i](j), dest[i](j) );
  }
 
 
 
  void testBroadcastVectorValueInt()
  {
    LOG_UNIT_TEST;
 
    this->testBroadcastVectorValue<int>();
  }
 
 
 
  void testBroadcastVectorValueReal()
  {
    LOG_UNIT_TEST;
 
    this->testBroadcastVectorValue<Real>();
  }
 
 
 
  void testBroadcastPoint()
  {
    LOG_UNIT_TEST;
 
    std::vector<Point> src(3), dest(3);
 
    {
      Real val=0.;
      for (unsigned int i=0; i<3; i++)
        for (unsigned int j=0; j<LIBMESH_DIM; j++)
          src[i](j) = val++;
 
      if (TestCommWorld->rank() == 0)
        dest = src;
    }
 
    TestCommWorld->broadcast(dest);
 
    for (unsigned int i=0; i<3; i++)
      for (unsigned int j=0; j<LIBMESH_DIM; j++)
        CPPUNIT_ASSERT_EQUAL (src[i](j), dest[i](j) );
  }
 
 
 
  void testIsendRecv ()
  {
    LOG_UNIT_TEST;
 
    unsigned int procup = (TestCommWorld->rank() + 1) %
      TestCommWorld->size();
    unsigned int procdown = (TestCommWorld->size() +
                             TestCommWorld->rank() - 1) %
      TestCommWorld->size();
 
    std::vector<unsigned int> src_val(3), recv_val(3);
 
    src_val[0] = 0;
    src_val[1] = 1;
    src_val[2] = 2;
 
    Parallel::Request request;
 
    if (TestCommWorld->size() > 1)
      {
        // Default communication
        TestCommWorld->send_mode(Parallel::Communicator::DEFAULT);
 
        TestCommWorld->send (procup,
                             src_val,
                             request);
 
        TestCommWorld->receive (procdown,
                                recv_val);
 
        Parallel::wait (request);
 
        CPPUNIT_ASSERT_EQUAL ( src_val.size() , recv_val.size() );
 
        for (std::size_t i=0; i<src_val.size(); i++)
          CPPUNIT_ASSERT_EQUAL( src_val[i] , recv_val[i] );
 
 
        // Synchronous communication
        TestCommWorld->send_mode(Parallel::Communicator::SYNCHRONOUS);
        std::fill (recv_val.begin(), recv_val.end(), 0);
 
        TestCommWorld->send (procup,
                             src_val,
                             request);
 
        TestCommWorld->receive (procdown,
                                recv_val);
 
        Parallel::wait (request);
 
        CPPUNIT_ASSERT_EQUAL ( src_val.size() , recv_val.size() );
 
        for (std::size_t i=0; i<src_val.size(); i++)
          CPPUNIT_ASSERT_EQUAL( src_val[i] , recv_val[i] );
 
        // Restore default communication
        TestCommWorld->send_mode(Parallel::Communicator::DEFAULT);
      }
  }
 
 
 
  void testIrecvSend ()
  {
    LOG_UNIT_TEST;
 
    unsigned int procup = (TestCommWorld->rank() + 1) %
      TestCommWorld->size();
    unsigned int procdown = (TestCommWorld->size() +
                             TestCommWorld->rank() - 1) %
      TestCommWorld->size();
 
    std::vector<unsigned int> src_val(3), recv_val(3);
 
    src_val[0] = 0;
    src_val[1] = 1;
    src_val[2] = 2;
 
    Parallel::Request request;
 
    if (TestCommWorld->size() > 1)
      {
        // Default communication
        TestCommWorld->send_mode(Parallel::Communicator::DEFAULT);
 
        TestCommWorld->receive (procdown,
                                recv_val,
                                request);
 
        TestCommWorld->send (procup,
                             src_val);
 
        Parallel::wait (request);
 
        CPPUNIT_ASSERT_EQUAL ( src_val.size() , recv_val.size() );
 
        for (std::size_t i=0; i<src_val.size(); i++)
          CPPUNIT_ASSERT_EQUAL( src_val[i] , recv_val[i] );
 
        // Synchronous communication
        TestCommWorld->send_mode(Parallel::Communicator::SYNCHRONOUS);
        std::fill (recv_val.begin(), recv_val.end(), 0);
 
 
        TestCommWorld->receive (procdown,
                                recv_val,
                                request);
 
        TestCommWorld->send (procup,
                             src_val);
 
        Parallel::wait (request);
 
        CPPUNIT_ASSERT_EQUAL ( src_val.size() , recv_val.size() );
 
        for (std::size_t i=0; i<src_val.size(); i++)
          CPPUNIT_ASSERT_EQUAL( src_val[i] , recv_val[i] );
 
        // Restore default communication
        TestCommWorld->send_mode(Parallel::Communicator::DEFAULT);
      }
  }
 
 
 
 
};
 
CPPUNIT_TEST_SUITE_REGISTRATION( ParallelPointTest );