ParallelTest Class Reference

Inheritance diagram for ParallelTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (ParallelTest)
	CPPUNIT_TEST (testGather)
	CPPUNIT_TEST (testAllGather)
	CPPUNIT_TEST (testGatherString)
	CPPUNIT_TEST (testAllGatherString)
	CPPUNIT_TEST (testAllGatherVectorString)
	CPPUNIT_TEST (testAllGatherEmptyVectorString)
	CPPUNIT_TEST (testAllGatherHalfEmptyVectorString)
	CPPUNIT_TEST (testBroadcast)
	CPPUNIT_TEST (testBroadcastNestedType)
	CPPUNIT_TEST (testScatter)
	CPPUNIT_TEST (testBarrier)
	CPPUNIT_TEST (testMin)
	CPPUNIT_TEST (testMax)
	CPPUNIT_TEST (testMinloc)
	CPPUNIT_TEST (testMaxloc)
	CPPUNIT_TEST (testMinlocReal)
	CPPUNIT_TEST (testMaxlocReal)
	CPPUNIT_TEST (testInfinityMin)
	CPPUNIT_TEST (testInfinityMax)
	CPPUNIT_TEST (testIsendRecv)
	CPPUNIT_TEST (testIrecvSend)
	CPPUNIT_TEST (testRecvIsendSets)
	CPPUNIT_TEST (testRecvIsendVecVecs)
	CPPUNIT_TEST (testSendRecvVecVecs)
	CPPUNIT_TEST (testSemiVerify)
	CPPUNIT_TEST (testSplit)
	CPPUNIT_TEST (testParallelForThreadSubset)
	CPPUNIT_TEST (testParallelReduceThreadSubset)
	CPPUNIT_TEST (testRequestedThreadCountExceedsGlobal)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	testGather ()
void	testGatherString ()
void	testAllGather ()
void	testAllGatherString ()
void	testAllGatherVectorString ()
void	testAllGatherEmptyVectorString ()
void	testAllGatherHalfEmptyVectorString ()
void	testBroadcast ()
void	testBroadcastNestedType ()
void	testScatter ()
void	testBarrier ()
void	testMin ()
void	testMax ()
void	testMinloc ()
void	testMaxloc ()
void	testMinlocReal ()
void	testMaxlocReal ()
void	testInfinityMin ()
void	testInfinityMax ()
void	testIsendRecv ()
void	testIrecvSend ()
void	testRecvIsendSets ()
void	testRecvIsendVecVecs ()
void	testSendRecvVecVecs ()
void	testSemiVerify ()
void	testSplit ()
void	testSplitByType ()
void	testParallelForThreadSubset ()
void	testParallelReduceThreadSubset ()
void	testRequestedThreadCountExceedsGlobal ()

Private Attributes
std::vector< std::string >	_number

Detailed Description

Definition at line 130 of file parallel_test.C.

Member Function Documentation

CPPUNIT_TEST() [1/29]

ParallelTest::CPPUNIT_TEST

(

testGather

)

CPPUNIT_TEST() [2/29]

ParallelTest::CPPUNIT_TEST

(

testAllGather

)

CPPUNIT_TEST() [3/29]

ParallelTest::CPPUNIT_TEST

(

testGatherString

)

CPPUNIT_TEST() [4/29]

ParallelTest::CPPUNIT_TEST

(

testAllGatherString

)

CPPUNIT_TEST() [5/29]

ParallelTest::CPPUNIT_TEST

(

testAllGatherVectorString

)

CPPUNIT_TEST() [6/29]

ParallelTest::CPPUNIT_TEST

(

testAllGatherEmptyVectorString

)

CPPUNIT_TEST() [7/29]

ParallelTest::CPPUNIT_TEST

(

testAllGatherHalfEmptyVectorString

)

CPPUNIT_TEST() [8/29]

ParallelTest::CPPUNIT_TEST

(

testBroadcast

)

CPPUNIT_TEST() [9/29]

ParallelTest::CPPUNIT_TEST

(

testBroadcastNestedType

)

CPPUNIT_TEST() [10/29]

ParallelTest::CPPUNIT_TEST

(

testScatter

)

CPPUNIT_TEST() [11/29]

ParallelTest::CPPUNIT_TEST

(

testBarrier

)

CPPUNIT_TEST() [12/29]

ParallelTest::CPPUNIT_TEST

(

testMin

)

CPPUNIT_TEST() [13/29]

ParallelTest::CPPUNIT_TEST

(

testMax

)

CPPUNIT_TEST() [14/29]

ParallelTest::CPPUNIT_TEST

(

testMinloc

)

CPPUNIT_TEST() [15/29]

ParallelTest::CPPUNIT_TEST

(

testMaxloc

)

CPPUNIT_TEST() [16/29]

ParallelTest::CPPUNIT_TEST

(

testMinlocReal

)

CPPUNIT_TEST() [17/29]

ParallelTest::CPPUNIT_TEST

(

testMaxlocReal

)

CPPUNIT_TEST() [18/29]

ParallelTest::CPPUNIT_TEST

(

testInfinityMin

)

CPPUNIT_TEST() [19/29]

ParallelTest::CPPUNIT_TEST

(

testInfinityMax

)

CPPUNIT_TEST() [20/29]

ParallelTest::CPPUNIT_TEST

(

testIsendRecv

)

CPPUNIT_TEST() [21/29]

ParallelTest::CPPUNIT_TEST

(

testIrecvSend

)

CPPUNIT_TEST() [22/29]

ParallelTest::CPPUNIT_TEST

(

testRecvIsendSets

)

CPPUNIT_TEST() [23/29]

ParallelTest::CPPUNIT_TEST

(

testRecvIsendVecVecs

)

CPPUNIT_TEST() [24/29]

ParallelTest::CPPUNIT_TEST

(

testSendRecvVecVecs

)

CPPUNIT_TEST() [25/29]

ParallelTest::CPPUNIT_TEST

(

testSemiVerify

)

CPPUNIT_TEST() [26/29]

ParallelTest::CPPUNIT_TEST

(

testSplit

)

CPPUNIT_TEST() [27/29]

ParallelTest::CPPUNIT_TEST

(

testParallelForThreadSubset

)

CPPUNIT_TEST() [28/29]

ParallelTest::CPPUNIT_TEST

(

testParallelReduceThreadSubset

)

CPPUNIT_TEST() [29/29]

ParallelTest::CPPUNIT_TEST

(

testRequestedThreadCountExceedsGlobal

)

CPPUNIT_TEST_SUITE_END()

ParallelTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

ParallelTest::LIBMESH_CPPUNIT_TEST_SUITE

(

ParallelTest

)

setUp()

void ParallelTest::setUp ( )

inline

Definition at line 172 of file parallel_test.C.

  {
    _number.resize(10);
    _number[0] = "Zero";
    _number[1] = "One";
    _number[2] = "Two";
    _number[3] = "Three";
    _number[4] = "Four";
    _number[5] = "Five";
    _number[6] = "Six";
    _number[7] = "Seven";
    _number[8] = "Eight";
    _number[9] = "Nine";
  }

tearDown()

void ParallelTest::tearDown ( )

inline

Definition at line 187 of file parallel_test.C.

  {}

testAllGather()

void ParallelTest::testAllGather ( )

inline

Definition at line 220 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    std::vector<processor_id_type> vals;
    TestCommWorld->allgather(cast_int<processor_id_type>(TestCommWorld->rank()),vals);

    for (processor_id_type i=0; i<vals.size(); i++)
      CPPUNIT_ASSERT_EQUAL( i , vals[i] );
  }

testAllGatherEmptyVectorString()

void ParallelTest::testAllGatherEmptyVectorString ( )

inline

Definition at line 264 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    std::vector<std::string> vals;
    TestCommWorld->allgather(vals);

    CPPUNIT_ASSERT( vals.empty() );
  }

testAllGatherHalfEmptyVectorString()

void ParallelTest::testAllGatherHalfEmptyVectorString ( )

inline

Definition at line 276 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    std::vector<std::string> vals;

    if (!TestCommWorld->rank())
      vals.push_back("Proc 0 only");

    TestCommWorld->allgather(vals);

    CPPUNIT_ASSERT_EQUAL( vals[0], std::string("Proc 0 only") );
  }

testAllGatherString()

void ParallelTest::testAllGatherString ( )

inline

Definition at line 233 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    std::vector<std::string> vals;
    TestCommWorld->gather(0, "Processor" + _number[TestCommWorld->rank() % 10], vals);

    for (processor_id_type i=0; i<vals.size(); i++)
      CPPUNIT_ASSERT_EQUAL( "Processor" + _number[i % 10] , vals[i] );
  }

testAllGatherVectorString()

void ParallelTest::testAllGatherVectorString ( )

inline

Definition at line 246 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    std::vector<std::string> vals;
    vals.push_back("Processor" + _number[TestCommWorld->rank() % 10] + "A");
    vals.push_back("Processor" + _number[TestCommWorld->rank() % 10] + "B");
    TestCommWorld->allgather(vals);

    for (processor_id_type i=0; i<(vals.size()/2); i++)
      {
        CPPUNIT_ASSERT_EQUAL( "Processor" + _number[i % 10] + "A" , vals[2*i] );
        CPPUNIT_ASSERT_EQUAL( "Processor" + _number[i % 10] + "B" , vals[2*i+1] );
      }
  }

testBarrier()

void ParallelTest::testBarrier ( )

inline

Definition at line 447 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    TestCommWorld->barrier();
  }

testBroadcast()

void ParallelTest::testBroadcast ( )

inline

Definition at line 292 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    // Workaround for spurious warning from operator=
    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100366
    std::vector<unsigned int> src{0,1,2}, dest(3,0);

    if (TestCommWorld->rank() == 0)
      dest = src;

    TestCommWorld->broadcast(dest);

    for (std::size_t i=0; i<3; i++)
      CPPUNIT_ASSERT_EQUAL( src[i] , dest[i] );
  }

testBroadcastNestedType()

void ParallelTest::testBroadcastNestedType ( )

inline

Definition at line 311 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    using std::pair;
    typedef pair<pair<pair<pair<int, int>, int>, int>, int> pppp;
    std::vector<pppp> src(3), dest(3);

    src[0].first.first.first.first=0;
    src[0].first.first.first.second=-1;
    src[0].first.second = -2;
    src[0].second = -3;
    src[1].first.first.first.first=10;
    src[1].first.first.first.second=9;
    src[1].first.second = 8;
    src[1].second = 7;
    src[2].first.first.first.first=20;
    src[2].first.first.first.second=19;
    src[2].first.second = 18;
    src[2].second = 17;

    if (TestCommWorld->rank() == 0)
      dest = src;

    TestCommWorld->broadcast(dest);

    for (std::size_t i=0; i<src.size(); i++)
      {
        CPPUNIT_ASSERT_EQUAL(src[i].first.first.first.first,
                             dest[i].first.first.first.first);
        CPPUNIT_ASSERT_EQUAL(src[i].first.first.first.second,
                             dest[i].first.first.first.second);
        CPPUNIT_ASSERT_EQUAL(src[i].first.first.second,
                             dest[i].first.first.second);
        CPPUNIT_ASSERT_EQUAL(src[i].first.second,
                             dest[i].first.second);
        CPPUNIT_ASSERT_EQUAL(src[i].second,
                             dest[i].second);
      }
  }

testGather()

void ParallelTest::testGather ( )

inline

Definition at line 192 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    std::vector<processor_id_type> vals;
    TestCommWorld->gather(0,cast_int<processor_id_type>(TestCommWorld->rank()),vals);

    if (TestCommWorld->rank() == 0)
      for (processor_id_type i=0; i<vals.size(); i++)
        CPPUNIT_ASSERT_EQUAL( i , vals[i] );
  }

testGatherString()

void ParallelTest::testGatherString ( )

inline

Definition at line 206 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    std::vector<std::string> vals;
    TestCommWorld->gather(0, "Processor" + _number[TestCommWorld->rank() % 10], vals);

    if (TestCommWorld->rank() == 0)
      for (processor_id_type i=0; i<vals.size(); i++)
        CPPUNIT_ASSERT_EQUAL( "Processor" + _number[i % 10] , vals[i] );
  }

testInfinityMax()

void ParallelTest::testInfinityMax ( )

inline

Definition at line 564 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    double max = std::numeric_limits<double>::infinity();

    TestCommWorld->max(max);

    CPPUNIT_ASSERT_EQUAL (max, std::numeric_limits<double>::infinity());

    max = -std::numeric_limits<double>::infinity();

    TestCommWorld->max(max);

    CPPUNIT_ASSERT_EQUAL (max, -std::numeric_limits<double>::infinity());
  }

testInfinityMin()

void ParallelTest::testInfinityMin ( )

inline

Definition at line 545 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    double min = std::numeric_limits<double>::infinity();

    TestCommWorld->min(min);

    CPPUNIT_ASSERT_EQUAL (min, std::numeric_limits<double>::infinity());

    min = -std::numeric_limits<double>::infinity();

    TestCommWorld->min(min);

    CPPUNIT_ASSERT_EQUAL (min, -std::numeric_limits<double>::infinity());
  }

testIrecvSend()

void ParallelTest::testIrecvSend ( )

inline

Definition at line 646 of file parallel_test.C.

References TIMPI::Communicator::DEFAULT, TIMPI::Communicator::rank(), TIMPI::Communicator::receive(), TIMPI::Communicator::send(), TIMPI::Communicator::send_mode(), TIMPI::Communicator::size(), TIMPI::Communicator::SYNCHRONOUS, and TestCommWorld.

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

testIsendRecv()

void ParallelTest::testIsendRecv ( )

inline

Definition at line 583 of file parallel_test.C.

References TIMPI::Communicator::DEFAULT, TIMPI::Communicator::rank(), TIMPI::Communicator::receive(), TIMPI::Communicator::send(), TIMPI::Communicator::send_mode(), TIMPI::Communicator::size(), TIMPI::Communicator::SYNCHRONOUS, and TestCommWorld.

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

testMax()

void ParallelTest::testMax ( )

inline

Definition at line 469 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    processor_id_type max = TestCommWorld->rank();

    TestCommWorld->max(max);

    CPPUNIT_ASSERT_EQUAL (cast_int<processor_id_type>(max+1),
                          cast_int<processor_id_type>(TestCommWorld->size()));
  }

testMaxloc()

void ParallelTest::testMaxloc ( )

inline

Definition at line 498 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    int max = TestCommWorld->rank();
    unsigned int maxid = 0;

    TestCommWorld->maxloc(max, maxid);

    CPPUNIT_ASSERT_EQUAL (max+1,
                          cast_int<int>(TestCommWorld->size()));
    CPPUNIT_ASSERT_EQUAL (maxid, static_cast<unsigned int>(TestCommWorld->size()-1));
  }

testMaxlocReal()

void ParallelTest::testMaxlocReal ( )

inline

Definition at line 529 of file parallel_test.C.

References TIMPI::Communicator::maxloc(), TIMPI::Communicator::rank(), libMesh::Real, TIMPI::Communicator::size(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Real max = TestCommWorld->rank();
    unsigned int maxid = 0;

    TestCommWorld->maxloc(max, maxid);

    // Hope nobody uses 1677216 procs with single precision
    CPPUNIT_ASSERT_EQUAL (max+1, Real(TestCommWorld->size()));
    CPPUNIT_ASSERT_EQUAL (maxid, static_cast<unsigned int>(TestCommWorld->size()-1));
  }

testMin()

void ParallelTest::testMin ( )

inline

Definition at line 456 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    unsigned int min = TestCommWorld->rank();

    TestCommWorld->min(min);

    CPPUNIT_ASSERT_EQUAL (min, static_cast<unsigned int>(0));
  }

testMinloc()

void ParallelTest::testMinloc ( )

inline

Definition at line 483 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    int min = (TestCommWorld->rank() + 1) % TestCommWorld->size();
    unsigned int minid = 0;

    TestCommWorld->minloc(min, minid);

    CPPUNIT_ASSERT_EQUAL (min, static_cast<int>(0));
    CPPUNIT_ASSERT_EQUAL (minid, static_cast<unsigned int>(TestCommWorld->size()-1));
  }

testMinlocReal()

void ParallelTest::testMinlocReal ( )

inline

Definition at line 514 of file parallel_test.C.

References TIMPI::Communicator::minloc(), TIMPI::Communicator::rank(), libMesh::Real, TIMPI::Communicator::size(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Real min = (TestCommWorld->rank() + 1) % TestCommWorld->size();
    unsigned int minid = 0;

    TestCommWorld->minloc(min, minid);

    CPPUNIT_ASSERT_EQUAL (min, Real(0));
    CPPUNIT_ASSERT_EQUAL (minid, static_cast<unsigned int>(TestCommWorld->size()-1));
  }

testParallelForThreadSubset()

void ParallelTest::testParallelForThreadSubset ( )

inline

Definition at line 882 of file parallel_test.C.

References libMesh::n_threads(), and libMesh::Threads::parallel_for().

  {
    LOG_UNIT_TEST;

    const unsigned int requested_threads =
      (libMesh::n_threads() > 2) ? 2u : 1u;
    std::vector<unsigned int> values(3);
    std::iota(values.begin(), values.end(), 0u);
    const TestRange range(values.cbegin(), values.cend(),
                          /* grainsize */ 1);
    VisitTracker tracker;

    Threads::parallel_for(range, ForBody(tracker), requested_threads);

    assert_tracker_matches_values(tracker, values);

#ifdef LIBMESH_HAVE_PTHREAD
    CPPUNIT_ASSERT_EQUAL(requested_threads,
                         tracker.invocations.load(std::memory_order_relaxed));
    CPPUNIT_ASSERT(tracker.unique_thread_count() <= requested_threads);
#endif
  }

testParallelReduceThreadSubset()

void ParallelTest::testParallelReduceThreadSubset ( )

inline

Definition at line 905 of file parallel_test.C.

References libMesh::n_threads(), and libMesh::Threads::parallel_reduce().

  {
    LOG_UNIT_TEST;

    const unsigned int requested_threads =
      (libMesh::n_threads() > 2) ? 2u : 1u;
    std::vector<unsigned int> values(3);
    std::iota(values.begin(), values.end(), 0u);
    const TestRange range(values.cbegin(), values.cend(),
                          /* grainsize */ 1);
    auto tracker = std::make_shared<VisitTracker>();
    ReduceBody body(tracker);

    Threads::parallel_reduce(range, body, requested_threads);

    assert_tracker_matches_values(*tracker, values);
    CPPUNIT_ASSERT_EQUAL(static_cast<unsigned int>(values.size()), body.value_count);
    CPPUNIT_ASSERT_EQUAL(tracker->value_sum.load(std::memory_order_relaxed), body.value_sum);
    CPPUNIT_ASSERT_EQUAL(tracker->value_sum_sq.load(std::memory_order_relaxed), body.value_sum_sq);

#ifdef LIBMESH_HAVE_PTHREAD
    CPPUNIT_ASSERT_EQUAL(requested_threads,
                         tracker->invocations.load(std::memory_order_relaxed));
    CPPUNIT_ASSERT(tracker->unique_thread_count() <= requested_threads);
#endif
  }

testRecvIsendSets()

void ParallelTest::testRecvIsendSets ( )

inline

Definition at line 708 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    unsigned int procup = (TestCommWorld->rank() + 1) %
      TestCommWorld->size();
    unsigned int procdown = (TestCommWorld->size() +
                             TestCommWorld->rank() - 1) %
      TestCommWorld->size();

    std::set<unsigned int> src_val, recv_val;

    src_val.insert(4);  // Chosen by fair dice roll
    src_val.insert(42);
    src_val.insert(1337);

    Parallel::Request request;

    if (TestCommWorld->size() > 1)
      {
        TestCommWorld->send (procup, src_val, request);

        TestCommWorld->receive (procdown,
                                recv_val);

        CPPUNIT_ASSERT_EQUAL ( src_val.size() , recv_val.size() );

        for (std::set<unsigned int>::const_iterator
               it = src_val.begin(), end = src_val.end(); it != end;
             ++it)
          CPPUNIT_ASSERT ( recv_val.count(*it) );

        Parallel::wait (request);

        recv_val.clear();
      }
  }

testRecvIsendVecVecs()

void ParallelTest::testRecvIsendVecVecs ( )

inline

Definition at line 748 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    unsigned int procup = (TestCommWorld->rank() + 1) %
      TestCommWorld->size();
    unsigned int procdown = (TestCommWorld->size() +
                             TestCommWorld->rank() - 1) %
      TestCommWorld->size();

    std::vector<std::vector<unsigned int> > src_val(3), recv_val;

    src_val[0].push_back(4);  // Chosen by fair dice roll
    src_val[2].push_back(procup);
    src_val[2].push_back(TestCommWorld->rank());

    Parallel::Request request;

    if (TestCommWorld->size() > 1)
      {
        TestCommWorld->send (procup, src_val, request);

        TestCommWorld->receive (procdown,
                                recv_val);

        CPPUNIT_ASSERT_EQUAL ( src_val.size() , recv_val.size() );

        for (std::size_t i = 0; i != 3; ++i)
          CPPUNIT_ASSERT_EQUAL ( src_val[i].size(), recv_val[i].size() );

        CPPUNIT_ASSERT_EQUAL ( recv_val[0][0], static_cast<unsigned int> (4) );
        CPPUNIT_ASSERT_EQUAL ( recv_val[2][0], static_cast<unsigned int> (TestCommWorld->rank()) );
        CPPUNIT_ASSERT_EQUAL ( recv_val[2][1], procdown );

        Parallel::wait (request);

        recv_val.clear();
      }
  }

testRequestedThreadCountExceedsGlobal()

void ParallelTest::testRequestedThreadCountExceedsGlobal ( )

inline

Definition at line 933 of file parallel_test.C.

References libMesh::n_threads(), libMesh::Threads::parallel_for(), and libMesh::Threads::parallel_reduce().

  {
    LOG_UNIT_TEST;

    std::vector<unsigned int> values(3);
    std::iota(values.begin(), values.end(), 0u);
    const TestRange range(values.cbegin(), values.cend());
    VisitTracker for_tracker;
    auto reduce_tracker = std::make_shared<VisitTracker>();
    ReduceBody reduce_body(reduce_tracker);

    CPPUNIT_ASSERT_THROW(Threads::parallel_for(range,
                                               ForBody(for_tracker),
                                               libMesh::n_threads() + 1u),
                         libMesh::LogicError);
    CPPUNIT_ASSERT_THROW(Threads::parallel_reduce(range,
                                                  reduce_body,
                                                  libMesh::n_threads() + 1u),
                         libMesh::LogicError);
  }

testScatter()

void ParallelTest::testScatter ( )

inline

Definition at line 354 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    // Test Scalar scatter
    {
      std::vector<processor_id_type> src;
      processor_id_type dest;

      if (TestCommWorld->rank() == 0)
        {
          src.resize(TestCommWorld->size());
          for (processor_id_type i=0; i<src.size(); i++)
            src[i] = i;
        }

      TestCommWorld->scatter(src, dest);

      CPPUNIT_ASSERT_EQUAL( TestCommWorld->rank(), dest );
    }

    // Test Vector Scatter (equal-sized chunks)
    {
      std::vector<unsigned int> src;
      std::vector<unsigned int> dest;
      static const unsigned int CHUNK_SIZE = 3;

      if (TestCommWorld->rank() == 0)
        {
          src.resize(TestCommWorld->size() * CHUNK_SIZE);
          for (std::size_t i=0; i<src.size(); i++)
            src[i] = i;
        }

      TestCommWorld->scatter(src, dest);

      for (unsigned int i=0; i<CHUNK_SIZE; i++)
        CPPUNIT_ASSERT_EQUAL( TestCommWorld->rank() * CHUNK_SIZE + i, dest[i] );
    }

    // Test Vector Scatter (jagged chunks)
    {
      std::vector<unsigned int> src;
      std::vector<unsigned int> dest;
      std::vector<int> counts;

      if (TestCommWorld->rank() == 0)
        {
          // Give each processor "rank" number of items ( Sum i=1..n == (n * (n + 1))/2 )
          src.resize((TestCommWorld->size() * (TestCommWorld->size() + 1)) / 2);
          counts.resize(TestCommWorld->size());

          for (std::size_t i=0; i<src.size(); i++)
            src[i] = i;
          for (unsigned int i=0; i<TestCommWorld->size(); i++)
            counts[i] = static_cast<int>(i+1);
        }

      TestCommWorld->scatter(src, counts, dest);

      unsigned int start_value = (TestCommWorld->rank() * (TestCommWorld->rank() + 1)) / 2;
      for (unsigned int i=0; i<=TestCommWorld->rank(); i++)
        CPPUNIT_ASSERT_EQUAL( start_value + i, dest[i] );
    }

    // Test Vector of Vector Scatter
    {
      std::vector<std::vector<unsigned int>> src;
      std::vector<unsigned int> dest;

      if (TestCommWorld->rank() == 0)
        {
          // Give each processor "rank" number of items ( Sum i=1..n == (n * (n + 1))/2 )
          src.resize(TestCommWorld->size());
          for (std::size_t i=0; i<src.size(); ++i)
            src[i].resize(i+1);

          unsigned int global_counter = 0;
          for (std::size_t i=0; i<src.size(); i++)
            for (std::size_t j=0; j<src[i].size(); j++)
              src[i][j] = global_counter++;
        }

      TestCommWorld->scatter(src, dest);

      unsigned int start_value = (TestCommWorld->rank() * (TestCommWorld->rank() + 1)) / 2;
      for (unsigned int i=0; i<=TestCommWorld->rank(); i++)
        CPPUNIT_ASSERT_EQUAL( start_value + i, dest[i] );
    }
  }

testSemiVerify()

void ParallelTest::testSemiVerify ( )

inline

Definition at line 833 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    double inf = std::numeric_limits<double>::infinity();

    double *infptr = TestCommWorld->rank()%2 ? NULL : &inf;

    CPPUNIT_ASSERT (TestCommWorld->semiverify(infptr));

    inf = -std::numeric_limits<double>::infinity();

    CPPUNIT_ASSERT (TestCommWorld->semiverify(infptr));
  }

testSendRecvVecVecs()

void ParallelTest::testSendRecvVecVecs ( )

inline

Definition at line 789 of file parallel_test.C.

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

  {
    LOG_UNIT_TEST;

    unsigned int procup = (TestCommWorld->rank() + 1) %
      TestCommWorld->size();
    unsigned int procdown = (TestCommWorld->size() +
                             TestCommWorld->rank() - 1) %
      TestCommWorld->size();

    // Any odd processor out does nothing
    if ((TestCommWorld->size() % 2) && procup == 0)
      return;

    std::vector<std::vector<unsigned int> > src_val(3), recv_val;

    src_val[0].push_back(4);  // Chosen by fair dice roll
    src_val[2].push_back(procup);
    src_val[2].push_back(TestCommWorld->rank());

    // Other even numbered processors send
    if (TestCommWorld->rank() % 2 == 0)
      TestCommWorld->send (procup, src_val);
    // Other odd numbered processors receive
    else
      {
        TestCommWorld->receive (procdown,
                                recv_val);

        CPPUNIT_ASSERT_EQUAL ( src_val.size() , recv_val.size() );

        for (std::size_t i = 0; i != 3; ++i)
          CPPUNIT_ASSERT_EQUAL ( src_val[i].size(), recv_val[i].size() );

        CPPUNIT_ASSERT_EQUAL ( recv_val[0][0], static_cast<unsigned int> (4) );
        CPPUNIT_ASSERT_EQUAL ( recv_val[2][0], static_cast<unsigned int> (TestCommWorld->rank()) );
        CPPUNIT_ASSERT_EQUAL ( recv_val[2][1], procdown );

        recv_val.clear();
      }
  }

testSplit()

void ParallelTest::testSplit ( )

inline

Definition at line 849 of file parallel_test.C.

References TIMPI::Communicator::rank(), TIMPI::Communicator::size(), libMesh::Parallel::Communicator::size(), TIMPI::Communicator::split(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Parallel::Communicator subcomm;
    unsigned int rank = TestCommWorld->rank();
    unsigned int color = rank % 2;
    TestCommWorld->split(color, rank, subcomm);

    CPPUNIT_ASSERT(subcomm.size() >= 1);
    CPPUNIT_ASSERT(subcomm.size() >= TestCommWorld->size() / 2);
    CPPUNIT_ASSERT(subcomm.size() <= TestCommWorld->size() / 2 + 1);
  }

testSplitByType()

void ParallelTest::testSplitByType ( )

inline

Definition at line 864 of file parallel_test.C.

References TIMPI::Communicator::rank(), TIMPI::Communicator::size(), libMesh::Parallel::Communicator::size(), TIMPI::Communicator::split_by_type(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    Parallel::Communicator subcomm;
    unsigned int rank = TestCommWorld->rank();
    Parallel::info i = 0;
    int type = 0;
#ifdef LIBMESH_HAVE_MPI
    type = MPI_COMM_TYPE_SHARED;
    i = MPI_INFO_NULL;
#endif
    TestCommWorld->split_by_type(type, rank, i, subcomm);

    CPPUNIT_ASSERT(subcomm.size() >= 1);
    CPPUNIT_ASSERT(subcomm.size() <= TestCommWorld->size());
  }

Member Data Documentation

_number

std::vector<std::string> ParallelTest::_number

private

Definition at line 169 of file parallel_test.C.

---

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

• tests/parallel/parallel_test.C