parallel_unit.C File Reference

Go to the source code of this file.

Functions
void	setUp ()
template<class Map >
void	testSum ()
template<class Gettable >
void	testSumOpFunction ()
template<class Map >
void	testNonFixedTypeSum ()
void	testGather ()
void	testGatherString ()
void	testAllGather ()
void	testGatherString2 ()
void	testAllGatherString ()
void	testAllGatherVectorString ()
void	testAllGatherVectorVector ()
void	testAllGatherVectorVectorInPlace ()
void	testAllGatherVectorVectorPacked ()
void	testAllGatherEmptyVectorString ()
void	testAllGatherHalfEmptyVectorString ()
template<class Container >
void	testBroadcast (Container &&src)
void	testBroadcastString ()
void	testBroadcastArrayType ()
void	testBroadcastNestedType ()
void	testScatter ()
void	testBarrier ()
void	testNonblockingTest ()
void	testNonblockingString ()
void	testNonblockingWaitany ()
void	testNonblockingSum ()
void	testNonblockingMin ()
void	testMin ()
void	testMinVecBool ()
void	testMPIULongMin ()
template<typename T >
void	testMinLarge ()
void	testNonblockingMax ()
void	testMax ()
void	testMaxVecBool ()
template<class Map >
void	testMapMax ()
template<class Map >
void	testNonFixedTypeMapMax ()
void	testMinloc ()
void	testMaxloc ()
void	testMinlocBool ()
void	testMinlocDouble ()
void	testMaxlocBool ()
void	testMaxlocDouble ()
void	testMinlocPair ()
void	testMaxlocPair ()
void	testInfinityMin ()
void	testInfinityMax ()
void	testIsendRecv ()
void	testIrecvSend ()
void	testRecvIsendSets ()
void	testRecvIsendVecVecs ()
void	testSendRecvVecVecs ()
void	testSemiVerifyInf ()
void	testSemiVerifyString ()
void	testSemiVerifyVector ()
template<typename T >
void	testSemiVerifyType ()
void	testSplit ()
void	testSplitByType ()
template<typename NonBuiltin >
void	testStandardTypeAssignment ()
int	main (int argc, const char *const *argv)

Variables
Communicator *	TestCommWorld
std::vector< std::string >	pt_number

Function Documentation

main()

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

Definition at line 1215 of file parallel_unit.C.

{
  TIMPI::TIMPIInit init(argc, argv);
  TestCommWorld = &init.comm();
 
  setUp();
 
  testSum<std::map<int,int>>();
  testSum<std::unordered_map<int,int>>();
  testSumOpFunction<std::pair<int,int>>();
  testNonFixedTypeSum<std::map<std::string,int>>();
  testNonFixedTypeSum<std::unordered_map<std::string,int>>();
  testGather();
  testAllGather();
  testGatherString();
  testGatherString2();
  testAllGatherString();
  testAllGatherVectorString();
  testAllGatherVectorVector();
  testAllGatherVectorVectorInPlace();
  testAllGatherVectorVectorPacked();
  testAllGatherEmptyVectorString();
  testAllGatherHalfEmptyVectorString();
  testBroadcast<std::vector<unsigned int>>({0,1,2});
  testBroadcast<std::map<int, int>>({{0,0}, {1,1}, {2,2}});
  testBroadcast<std::map<int, std::string>>({{0,"foo"}, {1,"bar"}, {2,"baz"}});
  testBroadcast<std::unordered_map<int, int>>({{0,0}, {1,1}, {2,2}});
  testBroadcast<std::unordered_map<int, std::string>>({{0,"foo"}, {1,"bar"}, {2,"baz"}});
  testBroadcastString();
  testBroadcastArrayType();
  testBroadcastNestedType();
  testScatter();
  testBarrier();
  testMin();
  testMinVecBool();
  testMax();
  testMaxVecBool();
  testMPIULongMin();
  testMinLarge<char>();
  testMinLarge<unsigned char>();
  testMinLarge<short>();
  testMinLarge<unsigned short>();
  testMinLarge<int>();
  testMinLarge<unsigned int>();
  testMinLarge<long>();
  testMinLarge<unsigned long>();
  testMinLarge<long long>();
  testMinLarge<unsigned long long>();
  testMinLarge<float>();
  testMinLarge<double>();
  testMinLarge<long double>();
  testMapMax<std::map<int, int>>();
  testMapMax<std::unordered_map<int, int>>();
  testNonFixedTypeMapMax<std::map<std::string,int>>();
  testNonFixedTypeMapMax<std::unordered_map<std::string,int>>();
  testMinloc();
  testMaxloc();
  testMinlocBool();
  testMaxlocBool();
  testMinlocDouble();
  testMaxlocDouble();
  testMinlocPair();
  testMaxlocPair();
  testInfinityMin();
  testInfinityMax();
  testIsendRecv();
  testIrecvSend();
  testRecvIsendSets();
  testRecvIsendVecVecs();
  testSendRecvVecVecs();
  testSemiVerifyInf();
  testSemiVerifyString();
  testSemiVerifyVector();
  testSemiVerifyType<bool>();
  testSemiVerifyType<char>();
  testSemiVerifyType<unsigned char>();
  testSemiVerifyType<short>();
  testSemiVerifyType<unsigned short>();
  testSemiVerifyType<int>();
  testSemiVerifyType<unsigned int>();
  testSemiVerifyType<long>();
  testSemiVerifyType<unsigned long>();
  testSemiVerifyType<long long>();
  testSemiVerifyType<unsigned long long>();
  testSemiVerifyType<float>();
  testSemiVerifyType<double>();
  testSemiVerifyType<long double>();
  testSplit();
  testSplitByType();
  testNonblockingTest();
  testNonblockingString();
  testNonblockingWaitany();
  testNonblockingSum();
  testNonblockingMin();
  testNonblockingMax();
  testStandardTypeAssignment<TIMPI_DEFAULT_SCALAR_TYPE>();
  testStandardTypeAssignment<std::pair<unsigned, unsigned>>();
  testStandardTypeAssignment<std::array<unsigned, 1>>();
  testStandardTypeAssignment<std::tuple<unsigned, unsigned, unsigned>>();
 
  return 0;
}

References TIMPI::cast_int(), setUp(), testAllGather(), testAllGatherEmptyVectorString(), testAllGatherHalfEmptyVectorString(), testAllGatherString(), testAllGatherVectorString(), testAllGatherVectorVector(), testAllGatherVectorVectorInPlace(), testAllGatherVectorVectorPacked(), testBarrier(), testBroadcastArrayType(), testBroadcastNestedType(), testBroadcastString(), TestCommWorld, testGather(), testGatherString(), testGatherString2(), testInfinityMax(), testInfinityMin(), testIrecvSend(), testIsendRecv(), testMax(), testMaxloc(), testMaxlocBool(), testMaxlocDouble(), testMaxlocPair(), testMaxVecBool(), testMin(), testMinloc(), testMinlocBool(), testMinlocDouble(), testMinlocPair(), testMinVecBool(), testMPIULongMin(), testNonblockingMax(), testNonblockingMin(), testNonblockingString(), testNonblockingSum(), testNonblockingTest(), testNonblockingWaitany(), testRecvIsendSets(), testRecvIsendVecVecs(), testScatter(), testSemiVerifyInf(), testSemiVerifyString(), testSemiVerifyVector(), testSendRecvVecVecs(), testSplit(), and testSplitByType().

setUp()

void setUp

(

)

Definition at line 15 of file parallel_unit.C.

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

References pt_number.

Referenced by main().

testAllGather()

void testAllGather

(

)

Definition at line 112 of file parallel_unit.C.

  {
    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++)
      TIMPI_UNIT_ASSERT( i  == vals[i] );
  }

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

Referenced by main().

testAllGatherEmptyVectorString()

void testAllGatherEmptyVectorString

(

)

Definition at line 219 of file parallel_unit.C.

  {
    std::vector<std::string> vals;
    TestCommWorld->allgather(vals);
 
    TIMPI_UNIT_ASSERT( vals.empty() );
  }

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

Referenced by main().

testAllGatherHalfEmptyVectorString()

void testAllGatherHalfEmptyVectorString

(

)

Definition at line 229 of file parallel_unit.C.

  {
    std::vector<std::string> vals;
 
    if (!TestCommWorld->rank())
      vals.push_back("Proc 0 only");
 
    TestCommWorld->allgather(vals);
 
    TIMPI_UNIT_ASSERT( vals[0] == std::string("Proc 0 only") );
  }

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

Referenced by main().

testAllGatherString()

void testAllGatherString

(

)

Definition at line 131 of file parallel_unit.C.

  {
    std::string send = "Processor" + std::to_string(TestCommWorld->rank());
    std::vector<std::string> gathered;
 
    TestCommWorld->allgather(send, gathered);
 
    TIMPI_UNIT_ASSERT(gathered.size() == TestCommWorld->size());
    for (std::size_t i = 0; i < gathered.size(); ++i)
      TIMPI_UNIT_ASSERT(gathered[i] == "Processor" + std::to_string(i));
  }

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

Referenced by main().

testAllGatherVectorString()

void testAllGatherVectorString

(

)

Definition at line 143 of file parallel_unit.C.

  {
    std::vector<std::string> vals;
    vals.push_back("Processor" + pt_number[TestCommWorld->rank() % 10] + "A");
    vals.push_back("Processor" + pt_number[TestCommWorld->rank() % 10] + "B");
    TestCommWorld->allgather(vals);
 
    for (processor_id_type i=0; i<(vals.size()/2); i++)
      {
        TIMPI_UNIT_ASSERT( "Processor" + pt_number[i % 10] + "A"  == vals[2*i] );
        TIMPI_UNIT_ASSERT( "Processor" + pt_number[i % 10] + "B"  == vals[2*i+1] );
      }
  }

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

Referenced by main().

testAllGatherVectorVector()

void testAllGatherVectorVector

(

)

Definition at line 157 of file parallel_unit.C.

  {
    std::vector<int> vals;
    for (processor_id_type i = 0, iend = TestCommWorld->rank()%10; i != iend; ++i)
      vals.push_back(3*i);
    std::vector<std::vector<int>> allvals;
    TestCommWorld->allgather(vals,allvals);
 
    for (processor_id_type i = 0, iend = TestCommWorld->rank(); i != iend; ++i)
      {
        TIMPI_UNIT_ASSERT(allvals[i].size() == i%10);
        for (processor_id_type j = 0, jend = i%10; j != jend; ++j)
          TIMPI_UNIT_ASSERT(allvals[i][j] == int(3*j));
      }
  }

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

Referenced by main().

testAllGatherVectorVectorInPlace()

void testAllGatherVectorVectorInPlace

(

)

Definition at line 173 of file parallel_unit.C.

  {
    std::vector<std::vector<double>> allvals;
    if (TestCommWorld->rank() == 1)
      {
        // Leave test empty for rank 1
      }
    else
      {
        allvals.push_back(
          {static_cast<double>(TestCommWorld->rank()),
           static_cast<double>(TestCommWorld->rank() * 2)});
      }
 
    TestCommWorld->allgather(allvals, false);
 
    if (TestCommWorld->size() > 1)
      TIMPI_UNIT_ASSERT(allvals.size() == TestCommWorld->size()-1);
    else
      TIMPI_UNIT_ASSERT(allvals.size() == 1);
 
    for (processor_id_type i = 0, iend = TestCommWorld->size()-1; i != iend; ++i)
      {
        int r = i > 0 ? (i+1) : i;
        TIMPI_UNIT_ASSERT(allvals[i].size() == 2);
        TIMPI_UNIT_ASSERT(allvals[i][0] == r);
        TIMPI_UNIT_ASSERT(allvals[i][1] == r*2);
      }
  }

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

Referenced by main().

testAllGatherVectorVectorPacked()

void testAllGatherVectorVectorPacked

(

)

Definition at line 203 of file parallel_unit.C.

  {
    std::vector<std::string> vals;
    for (processor_id_type i = 0, iend = TestCommWorld->rank()%10; i != iend; ++i)
      vals.push_back(pt_number[i]);
    std::vector<std::vector<std::string>> allvals;
    TestCommWorld->allgather(vals,allvals);
 
    for (processor_id_type i = 0, iend = TestCommWorld->rank(); i != iend; ++i)
      {
        TIMPI_UNIT_ASSERT(allvals[i].size() == i%10);
        for (processor_id_type j = 0, jend = i%10; j != jend; ++j)
          TIMPI_UNIT_ASSERT(allvals[i][j] == pt_number[j]);
      }
  }

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

Referenced by main().

testBarrier()

void testBarrier

(

)

Definition at line 446 of file parallel_unit.C.

  {
    TestCommWorld->barrier();
  }

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

Referenced by main().

testBroadcast()

template<class Container >

void testBroadcast

(

Container &&

src

)

Definition at line 244 of file parallel_unit.C.

  {
    Container dest = src;
 
    // Clear dest on non-root ranks
    if (TestCommWorld->rank() != 0)
      dest.clear();
 
    TestCommWorld->broadcast(dest);
 
    for (std::size_t i=0; i<src.size(); i++)
      TIMPI_UNIT_ASSERT( src[i]  == dest[i] );
  }

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

testBroadcastArrayType()

void testBroadcastArrayType

(

)

Definition at line 274 of file parallel_unit.C.

  {
    using std::array;
    typedef array<array<int, 3>, 2> aa;
 
    // Workaround for spurious warning from operator=
    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100366
    aa x{{ {0,1,2},{3,4,5} }};
    std::vector<aa> src(3), dest(3,x);
 
    src[0][0][0] = 0;
    src[0][0][1] = -1;
    src[0][0][2] = -2;
    src[0][1][0] = -3;
    src[0][1][1] = -4;
    src[0][1][2] = -5;
    src[1][0][0] = 10;
    src[1][0][1] = 9;
    src[1][0][2] = 8;
    src[1][1][0] = 7;
    src[1][1][1] = 6;
    src[1][1][2] = 5;
    src[2][0][0] = 20;
    src[2][0][1] = 19;
    src[2][0][2] = 18;
    src[2][1][0] = 17;
    src[2][1][1] = 16;
    src[2][1][2] = 15;
 
    if (TestCommWorld->rank() == 0)
      dest = src;
 
    TestCommWorld->broadcast(dest);
 
    for (std::size_t i=0; i<src.size(); i++)
      for (std::size_t j=0; j<2; j++)
        for (std::size_t k=0; k<3; k++)
          TIMPI_UNIT_ASSERT(src[i][j][k] == dest[i][j][k]);
  }

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

Referenced by main().

testBroadcastNestedType()

void testBroadcastNestedType

(

)

Definition at line 314 of file parallel_unit.C.

  {
    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++)
      {
        TIMPI_UNIT_ASSERT(src[i].first.first.first.first ==
                             dest[i].first.first.first.first);
        TIMPI_UNIT_ASSERT(src[i].first.first.first.second ==
                             dest[i].first.first.first.second);
        TIMPI_UNIT_ASSERT(src[i].first.first.second ==
                             dest[i].first.first.second);
        TIMPI_UNIT_ASSERT(src[i].first.second ==
                             dest[i].first.second);
        TIMPI_UNIT_ASSERT(src[i].second ==
                             dest[i].second);
      }
  }

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

Referenced by main().

testBroadcastString()

void testBroadcastString

(

)

Definition at line 258 of file parallel_unit.C.

  {
    std::string src = "hello";
    std::string dest = src;
 
    // Clear dest on non-root ranks
    if (TestCommWorld->rank() != 0)
      dest.clear();
 
    // By default the root_id is 0
    TestCommWorld->broadcast(dest);
 
    for (std::size_t i=0; i<src.size(); i++)
      TIMPI_UNIT_ASSERT( src[i]  == dest[i] );
  }

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

Referenced by main().

testGather()

void testGather

(

)

Definition at line 88 of file parallel_unit.C.

  {
    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++)
        TIMPI_UNIT_ASSERT( i  == vals[i] );
  }

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

Referenced by main().

testGatherString()

void testGatherString

(

)

Definition at line 100 of file parallel_unit.C.

  {
    std::vector<std::string> vals;
    TestCommWorld->gather(0, "Processor" + pt_number[TestCommWorld->rank() % 10], vals);
 
    if (TestCommWorld->rank() == 0)
      for (processor_id_type i=0; i<vals.size(); i++)
        TIMPI_UNIT_ASSERT( "Processor" + pt_number[i % 10]  == vals[i] );
  }

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

Referenced by main().

testGatherString2()

void testGatherString2

(

)

Definition at line 122 of file parallel_unit.C.

  {
    std::vector<std::string> vals;
    TestCommWorld->gather(0, "Processor" + pt_number[TestCommWorld->rank() % 10], vals);
 
    for (processor_id_type i=0; i<vals.size(); i++)
      TIMPI_UNIT_ASSERT( "Processor" + pt_number[i % 10]  == vals[i] );
  }

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

Referenced by main().

testInfinityMax()

void testInfinityMax

(

)

Definition at line 874 of file parallel_unit.C.

  {
    double max = std::numeric_limits<double>::infinity();
 
    TestCommWorld->max(max);
 
    TIMPI_UNIT_ASSERT (max == std::numeric_limits<double>::infinity());
 
    max = -std::numeric_limits<double>::infinity();
 
    TestCommWorld->max(max);
 
    TIMPI_UNIT_ASSERT (max == -std::numeric_limits<double>::infinity());
  }

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

Referenced by main().

testInfinityMin()

void testInfinityMin

(

)

Definition at line 857 of file parallel_unit.C.

  {
    double min = std::numeric_limits<double>::infinity();
 
    TestCommWorld->min(min);
 
    TIMPI_UNIT_ASSERT (min == std::numeric_limits<double>::infinity());
 
    min = -std::numeric_limits<double>::infinity();
 
    TestCommWorld->min(min);
 
    TIMPI_UNIT_ASSERT (min == -std::numeric_limits<double>::infinity());
  }

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

Referenced by main().

testIrecvSend()

void testIrecvSend

(

)

Definition at line 952 of file parallel_unit.C.

  {
    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;
 
    TIMPI::Request request;
 
    if (TestCommWorld->size() > 1)
      {
        // Default communication
        TestCommWorld->send_mode(TIMPI::Communicator::DEFAULT);
 
        TestCommWorld->receive (procdown,
                                recv_val,
                                request);
 
        TestCommWorld->send (procup,
                             src_val);
 
        TIMPI::wait (request);
 
        TIMPI_UNIT_ASSERT ( src_val.size()  == recv_val.size() );
 
        for (std::size_t i=0; i<src_val.size(); i++)
          TIMPI_UNIT_ASSERT( src_val[i]  == recv_val[i] );
 
        // Synchronous communication
        TestCommWorld->send_mode(TIMPI::Communicator::SYNCHRONOUS);
        std::fill (recv_val.begin(), recv_val.end(), 0);
 
 
        TestCommWorld->receive (procdown,
                                recv_val,
                                request);
 
        TestCommWorld->send (procup,
                             src_val);
 
        TIMPI::wait (request);
 
        TIMPI_UNIT_ASSERT ( src_val.size()  == recv_val.size() );
 
        for (std::size_t i=0; i<src_val.size(); i++)
          TIMPI_UNIT_ASSERT( src_val[i]  == recv_val[i] );
 
        // Restore default communication
        TestCommWorld->send_mode(TIMPI::Communicator::DEFAULT);
      }
  }

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

Referenced by main().

testIsendRecv()

void testIsendRecv

(

)

Definition at line 891 of file parallel_unit.C.

  {
    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;
 
    TIMPI::Request request;
 
    if (TestCommWorld->size() > 1)
      {
        // Default communication
        TestCommWorld->send_mode(TIMPI::Communicator::DEFAULT);
 
        TestCommWorld->send (procup,
                             src_val,
                             request);
 
        TestCommWorld->receive (procdown,
                                recv_val);
 
        TIMPI::wait (request);
 
        TIMPI_UNIT_ASSERT ( src_val.size()  == recv_val.size() );
 
        for (std::size_t i=0; i<src_val.size(); i++)
          TIMPI_UNIT_ASSERT( src_val[i]  == recv_val[i] );
 
 
        // Synchronous communication
        TestCommWorld->send_mode(TIMPI::Communicator::SYNCHRONOUS);
        std::fill (recv_val.begin(), recv_val.end(), 0);
 
        TestCommWorld->send (procup,
                             src_val,
                             request);
 
        TestCommWorld->receive (procdown,
                                recv_val);
 
        TIMPI::wait (request);
 
        TIMPI_UNIT_ASSERT ( src_val.size()  == recv_val.size() );
 
        for (std::size_t i=0; i<src_val.size(); i++)
          TIMPI_UNIT_ASSERT( src_val[i]  == recv_val[i] );
 
        // Restore default communication
        TestCommWorld->send_mode(TIMPI::Communicator::DEFAULT);
      }
  }

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

Referenced by main().

testMapMax()

template<class Map >

void testMapMax

(

)

Definition at line 700 of file parallel_unit.C.

  {
    Map data;
 
    int rank = TestCommWorld->rank();
    int N = TestCommWorld->size();
 
    // On each proc, the map has the single entry (rank, rank)
    data[rank] = rank;
 
    // Compute the max
    TestCommWorld->max(data);
 
    // After calling max, there should be an entry for each rank
    for (int p=0; p<N; ++p)
      TIMPI_UNIT_ASSERT (data[p] == p);
  }

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

testMax()

void testMax

(

)

Definition at line 657 of file parallel_unit.C.

  {
    processor_id_type max = TestCommWorld->rank();
 
    TestCommWorld->max(max);
 
    TIMPI_UNIT_ASSERT (cast_int<processor_id_type>(max+1) ==
                          cast_int<processor_id_type>(TestCommWorld->size()));
  }

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

Referenced by main().

testMaxloc()

void testMaxloc

(

)

Definition at line 754 of file parallel_unit.C.

  {
    int max = TestCommWorld->rank();
    unsigned int maxid = 0;
 
    TestCommWorld->maxloc(max, maxid);
 
    TIMPI_UNIT_ASSERT (max+1 ==
                          cast_int<int>(TestCommWorld->size()));
    TIMPI_UNIT_ASSERT (maxid == static_cast<unsigned int>(TestCommWorld->size()-1));
  }

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

Referenced by main().

testMaxlocBool()

void testMaxlocBool

(

)

Definition at line 794 of file parallel_unit.C.

  {
    bool max = ((TestCommWorld->rank() + TestCommWorld->size()) % 2);
    unsigned int maxid = 0;
 
    TestCommWorld->maxloc(max, maxid);
 
    TIMPI_UNIT_ASSERT (max == static_cast<int>(1));
    TIMPI_UNIT_ASSERT (maxid == static_cast<unsigned int>((TestCommWorld->size()-1)%2));
  }

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

Referenced by main().

testMaxlocDouble()

void testMaxlocDouble

(

)

Definition at line 807 of file parallel_unit.C.

  {
    double max = TestCommWorld->rank();
    unsigned int maxid = 0;
 
    TestCommWorld->maxloc(max, maxid);
 
    // Hope nobody uses 1677216 procs with single precision
    TIMPI_UNIT_ASSERT (max+1 == double(TestCommWorld->size()));
    TIMPI_UNIT_ASSERT (maxid == static_cast<unsigned int>(TestCommWorld->size()-1));
  }

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

Referenced by main().

testMaxlocPair()

void testMaxlocPair

(

)

Definition at line 838 of file parallel_unit.C.

  {
    int max = TestCommWorld->rank();
    int max_tag = max + 3;
    unsigned int maxid = 0;
 
    std::pair<int, int> p{max, max_tag};
 
    TestCommWorld->maxloc(p, maxid);
 
    TIMPI_UNIT_ASSERT (p.first+1 ==
                       cast_int<int>(TestCommWorld->size()));
    TIMPI_UNIT_ASSERT (p.second+1 ==
                       cast_int<int>(TestCommWorld->size())+3);
    TIMPI_UNIT_ASSERT (maxid == static_cast<unsigned int>(TestCommWorld->size()-1));
  }

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

Referenced by main().

testMaxVecBool()

void testMaxVecBool

(

)

Definition at line 669 of file parallel_unit.C.

  {
    const processor_id_type rank = TestCommWorld->rank();
    const processor_id_type N = TestCommWorld->size();
 
    // Use a long vector, so we can be sure it extends over multiple
    // unsigned integers; use a weird size to test the
    // not-evenly-divisible case.
    constexpr std::size_t vec_size = 2345;
    std::vector<bool> vec_bool(vec_size, false);
    for (std::size_t i=0; i < vec_size; i += (rank+2))
      vec_bool[i] = true;
 
    TestCommWorld->max(vec_bool);
 
    for (std::size_t i=0; i != vec_size; ++i)
      {
        bool should_be_true = false;
        for (processor_id_type p=0; p < N; ++p)
          if (i % (p+2) == 0)
          {
            should_be_true = true;
            break;
          }
        TIMPI_UNIT_ASSERT (vec_bool[i] == should_be_true);
      }
  }

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

Referenced by main().

testMin()

void testMin

(

)

Definition at line 572 of file parallel_unit.C.

  {
    unsigned int min = TestCommWorld->rank();
 
    TestCommWorld->min(min);
 
    TIMPI_UNIT_ASSERT (min == static_cast<unsigned int>(0));
  }

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

Referenced by main().

testMinLarge()

template<typename T >

void testMinLarge

(

)

Definition at line 628 of file parallel_unit.C.

  {
    T min = 1;
 
    if (TestCommWorld->rank() % 2)
      min = std::numeric_limits<T>::max();
 
    TestCommWorld->min(min);
 
    TIMPI_UNIT_ASSERT (min == 1);
  }

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

testMinloc()

void testMinloc

(

)

Definition at line 741 of file parallel_unit.C.

  {
    int min = (TestCommWorld->rank() + 1) % TestCommWorld->size();
    unsigned int minid = 0;
 
    TestCommWorld->minloc(min, minid);
 
    TIMPI_UNIT_ASSERT (min == static_cast<int>(0));
    TIMPI_UNIT_ASSERT (minid == static_cast<unsigned int>(TestCommWorld->size()-1));
  }

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

Referenced by main().

testMinlocBool()

void testMinlocBool

(

)

Definition at line 768 of file parallel_unit.C.

  {
    bool min = ((TestCommWorld->rank() + TestCommWorld->size()-1) % 2);
    unsigned int minid = 0;
 
    TestCommWorld->minloc(min, minid);
 
    TIMPI_UNIT_ASSERT (min == static_cast<int>(0));
    TIMPI_UNIT_ASSERT (minid == static_cast<unsigned int>((TestCommWorld->size()-1)%2));
  }

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

Referenced by main().

testMinlocDouble()

void testMinlocDouble

(

)

Definition at line 781 of file parallel_unit.C.

  {
    double min = (TestCommWorld->rank() + 1) % TestCommWorld->size();
    unsigned int minid = 0;
 
    TestCommWorld->minloc(min, minid);
 
    TIMPI_UNIT_ASSERT (min == double(0));
    TIMPI_UNIT_ASSERT (minid == static_cast<unsigned int>(TestCommWorld->size()-1));
  }

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

Referenced by main().

testMinlocPair()

void testMinlocPair

(

)

Definition at line 821 of file parallel_unit.C.

  {
    int min = (TestCommWorld->rank() + 1) % TestCommWorld->size();
    int min_tag = min + 3;
    unsigned int minid = 0;
 
    std::pair<int, int> p{min, min_tag};
 
    TestCommWorld->minloc(p, minid);
 
    TIMPI_UNIT_ASSERT (p.first == static_cast<int>(0));
    TIMPI_UNIT_ASSERT (p.second == static_cast<int>(3));
    TIMPI_UNIT_ASSERT (minid == static_cast<unsigned int>(TestCommWorld->size()-1));
  }

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

Referenced by main().

testMinVecBool()

void testMinVecBool

(

)

Definition at line 582 of file parallel_unit.C.

  {
    const processor_id_type rank = TestCommWorld->rank();
    const processor_id_type N = TestCommWorld->size();
 
    // Use a long vector, so we can be sure that many bits extends
    // over multiple unsigned integers; use a weird size to test the
    // not-evenly-divisible case.
    constexpr std::size_t vec_size = 2345;
    std::vector<bool> vec_bool(vec_size, true);
    for (std::size_t i=0; i < vec_size; i += (rank+2))
      vec_bool[i] = false;
 
    TestCommWorld->min(vec_bool);
 
    for (std::size_t i=0; i != vec_size; ++i)
      {
        bool should_be_true = true;
        for (processor_id_type p=0; p < N; ++p)
          if (i % (p+2) == 0)
          {
            should_be_true = false;
            break;
          }
        TIMPI_UNIT_ASSERT (vec_bool[i] == should_be_true);
      }
  }

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

Referenced by main().

testMPIULongMin()

void testMPIULongMin

(

)

Definition at line 613 of file parallel_unit.C.

  {
    unsigned long min = 1;
    if (TestCommWorld->rank() % 2)
      min = std::numeric_limits<unsigned long>::max();
 
    timpi_call_mpi
      (MPI_Allreduce (MPI_IN_PLACE, &min, 1,
                      MPI_UNSIGNED_LONG, MPI_MIN,
                      TestCommWorld->get()));
 
    TIMPI_UNIT_ASSERT (min == 1);
  }

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

Referenced by main().

testNonblockingMax()

void testNonblockingMax

(

)

Definition at line 642 of file parallel_unit.C.

  {
    processor_id_type local_val = TestCommWorld->rank();
    processor_id_type max = std::numeric_limits<processor_id_type>::min();
 
    Request req;
    TestCommWorld->max(local_val, max, req);
    req.wait();
 
    TIMPI_UNIT_ASSERT (cast_int<processor_id_type>(max+1) ==
                       cast_int<processor_id_type>(TestCommWorld->size()));
  }

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

Referenced by main().

testNonblockingMin()

void testNonblockingMin

(

)

Definition at line 558 of file parallel_unit.C.

  {
    unsigned int local_val = TestCommWorld->rank();
    unsigned int min = std::numeric_limits<unsigned int>::max();
 
    Request req;
    TestCommWorld->min(local_val, min, req);
    req.wait();
 
    TIMPI_UNIT_ASSERT (min == static_cast<unsigned int>(0));
  }

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

Referenced by main().

testNonblockingString()

void testNonblockingString

(

)

Definition at line 473 of file parallel_unit.C.

  {
    // We don't support non-blocking I/O in serial
    if (TestCommWorld->size() < 2)
      return;
 
    const std::string send_string =
      "More than 64 bytes to avoid false positives with Small String Optimization libraries";
 
    // We need pre-sized buffers for non-blocking receive.
    std::string recv_string(send_string.size(), ' ');
 
    const processor_id_type dest_pid =
      (TestCommWorld->rank() + 1) % TestCommWorld->size();
 
    Request send_req, recv_req;
    TestCommWorld->send(dest_pid, send_string, send_req);
    TestCommWorld->receive(any_source, recv_string, recv_req);
 
    recv_req.wait();
 
    TIMPI_UNIT_ASSERT (send_string == recv_string);
 
    send_req.wait();
  }

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

Referenced by main().

testNonblockingSum()

void testNonblockingSum

(

)

Definition at line 540 of file parallel_unit.C.

  {
    int true_sum = 0;
    for (int rank = 0; rank < (int)TestCommWorld->size(); ++rank)
      true_sum += rank + 1;
 
    int local_val = TestCommWorld->rank() + 1;
    int sum;
 
    Request request;
    TestCommWorld->sum(local_val, sum, request);
    request.wait();
 
    TIMPI_UNIT_ASSERT (true_sum == sum);
  }

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

Referenced by main().

testNonblockingTest()

void testNonblockingTest

(

)

Definition at line 452 of file parallel_unit.C.

  {
    const unsigned int local_val = TestCommWorld->rank() + 3;
    unsigned int min = std::numeric_limits<unsigned int>::max();
 
    Request req;
    TestCommWorld->min(local_val, min, req);
 
    // not sure what I can safely test here; test() could return true
    // immediately or could loop an arbitrarily long time first...
    while(!req.test()) {}
 
    TIMPI_UNIT_ASSERT (min == static_cast<unsigned int>(3));
 
    // We could get away with destruct-before-wait since there's no
    // post-wait-work attached to req, but that's not really
    // *supported* behavior...
    req.wait();
  }

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

Referenced by main().

testNonblockingWaitany()

void testNonblockingWaitany

(

)

Definition at line 500 of file parallel_unit.C.

  {
    constexpr std::size_t N=5;
    std::vector<unsigned int> local_vals(N),
                              min_vals(N, std::numeric_limits<unsigned int>::max());
    std::iota(local_vals.begin(), local_vals.end(), TestCommWorld->rank()+4);
 
    std::size_t tests_done = 0;
 
    std::vector<Request> reqs;
    for (std::size_t i=0; i != N; ++i)
    {
      Request req;
      TestCommWorld->min(local_vals[i], min_vals[i], req);
 
      // We might have finished immediately, e.g. if we're on one
      // processor
      if (*req.get() == Request::null_request)
      {
        TIMPI_UNIT_ASSERT (min_vals[i] == static_cast<unsigned int>(4+i));
        ++tests_done;
      }
      reqs.push_back(req);
    }
 
    std::size_t i = std::size_t(-1);
    if (tests_done != N)
      i = waitany(reqs);
    while (i != std::size_t(-1))
    {
      TIMPI_UNIT_ASSERT (min_vals[i] == static_cast<unsigned int>(4+i));
      ++tests_done;
      i = waitany(reqs);
    }
 
    TIMPI_UNIT_ASSERT (tests_done == N);
  }

References TIMPI::cast_int(), TIMPI::Communicator::min(), TIMPI::Request::null_request, TIMPI::Communicator::rank(), TestCommWorld, and TIMPI::waitany().

Referenced by main().

testNonFixedTypeMapMax()

template<class Map >

void testNonFixedTypeMapMax

(

)

Definition at line 721 of file parallel_unit.C.

  {
    Map data;
 
    int rank = TestCommWorld->rank();
    int N = TestCommWorld->size();
 
    // On each proc, the map has a single entry, e.g. ("key0", 0)
    data[std::string("key") + std::to_string(rank)] = rank;
 
    // Compute the max
    TestCommWorld->max(data);
 
    // After calling max, there should be an entry for each rank
    for (int p=0; p<N; ++p)
      TIMPI_UNIT_ASSERT (data[std::string("key") + std::to_string(p)] == p);
  }

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

testNonFixedTypeSum()

template<class Map >

void testNonFixedTypeSum

(

)

Definition at line 69 of file parallel_unit.C.

  {
    Map data;
 
    int N = TestCommWorld->size();
 
    for (int p=0; p<N; ++p)
      data[std::string("key") + std::to_string(p)] = TestCommWorld->rank();
 
    TestCommWorld->sum(data);
 
    // Each map entry should now contain the sum:
    // 0 + 1 + ... + N-1 = N*(N-1)/2
    for (int p=0; p<N; ++p)
      TIMPI_UNIT_ASSERT( data[std::string("key") + std::to_string(p)] == N*(N-1)/2 );
  }

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

testRecvIsendSets()

void testRecvIsendSets

(

)

Definition at line 1012 of file parallel_unit.C.

  {
    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);
 
    TIMPI::Request request;
 
    if (TestCommWorld->size() > 1)
      {
        TestCommWorld->send (procup, src_val, request);
 
        TestCommWorld->receive (procdown,
                                recv_val);
 
        TIMPI_UNIT_ASSERT ( src_val.size()  == recv_val.size() );
 
        for (std::set<unsigned int>::const_iterator
               it = src_val.begin(), end = src_val.end(); it != end;
             ++it)
          TIMPI_UNIT_ASSERT ( recv_val.count(*it) );
 
        TIMPI::wait (request);
 
        recv_val.clear();
      }
  }

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

Referenced by main().

testRecvIsendVecVecs()

void testRecvIsendVecVecs

(

)

Definition at line 1050 of file parallel_unit.C.

  {
    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());
 
    TIMPI::Request request;
 
    if (TestCommWorld->size() > 1)
      {
        TestCommWorld->send (procup, src_val, request);
 
        TestCommWorld->receive (procdown,
                                recv_val);
 
        TIMPI_UNIT_ASSERT ( src_val.size()  == recv_val.size() );
 
        for (std::size_t i = 0; i != 3; ++i)
          TIMPI_UNIT_ASSERT ( src_val[i].size() == recv_val[i].size() );
 
        TIMPI_UNIT_ASSERT ( recv_val[0][0] == static_cast<unsigned int> (4) );
        TIMPI_UNIT_ASSERT ( recv_val[2][0] == static_cast<unsigned int> (TestCommWorld->rank()) );
        TIMPI_UNIT_ASSERT ( recv_val[2][1] == procdown );
 
        TIMPI::wait (request);
 
        recv_val.clear();
      }
  }

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

Referenced by main().

testScatter()

void testScatter

(

)

Definition at line 355 of file parallel_unit.C.

  {
    // Test Scalar scatter
    {
      std::vector<processor_id_type> src;
      processor_id_type dest = 0;
 
      if (TestCommWorld->rank() == 0)
        {
          src.resize(TestCommWorld->size());
          for (processor_id_type i=0; i<src.size(); i++)
            src[i] = i + 1;
        }
 
      TestCommWorld->scatter(src, dest);
 
      TIMPI_UNIT_ASSERT( TestCommWorld->rank() + 1 == 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++)
        TIMPI_UNIT_ASSERT( 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++)
        TIMPI_UNIT_ASSERT( 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++)
        TIMPI_UNIT_ASSERT( start_value + i == dest[i] );
    }
  }

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

Referenced by main().

testSemiVerifyInf()

void testSemiVerifyInf

(

)

Definition at line 1131 of file parallel_unit.C.

  {
    double inf = std::numeric_limits<double>::infinity();
 
    double *infptr = TestCommWorld->rank()%2 ? NULL : &inf;
 
    TIMPI_UNIT_ASSERT (TestCommWorld->semiverify(infptr));
 
    inf = -std::numeric_limits<double>::infinity();
 
    TIMPI_UNIT_ASSERT (TestCommWorld->semiverify(infptr));
  }

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

Referenced by main().

testSemiVerifyString()

void testSemiVerifyString

(

)

Definition at line 1145 of file parallel_unit.C.

  {
    const std::string s = "Violin"; // Test requires a string instrument
 
    const std::string *sptr = TestCommWorld->rank()%2 ? NULL : &s;
 
    TIMPI_UNIT_ASSERT (TestCommWorld->semiverify(sptr));
  }

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

Referenced by main().

testSemiVerifyType()

template<typename T >

void testSemiVerifyType

(

)

Definition at line 1166 of file parallel_unit.C.

  {
    const T one = 1;
 
    const T * tptr = TestCommWorld->rank()%2 ? NULL : &one;
 
    TIMPI_UNIT_ASSERT (TestCommWorld->semiverify(tptr));
  }

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

testSemiVerifyVector()

void testSemiVerifyVector

(

)

Definition at line 1155 of file parallel_unit.C.

  {
    const std::vector<int> v = {1, 2, 3};
 
    const std::vector<int> *vptr = TestCommWorld->rank()%2 ? NULL : &v;
 
    TIMPI_UNIT_ASSERT (TestCommWorld->semiverify(vptr));
  }

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

Referenced by main().

testSendRecvVecVecs()

void testSendRecvVecVecs

(

)

Definition at line 1089 of file parallel_unit.C.

  {
    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);
 
        TIMPI_UNIT_ASSERT ( src_val.size()  == recv_val.size() );
 
        for (std::size_t i = 0; i != 3; ++i)
          TIMPI_UNIT_ASSERT ( src_val[i].size() == recv_val[i].size() );
 
        TIMPI_UNIT_ASSERT ( recv_val[0][0] == static_cast<unsigned int> (4) );
        TIMPI_UNIT_ASSERT ( recv_val[2][0] == static_cast<unsigned int> (TestCommWorld->rank()) );
        TIMPI_UNIT_ASSERT ( recv_val[2][1] == procdown );
 
        recv_val.clear();
      }
  }

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

Referenced by main().

testSplit()

void testSplit

(

)

Definition at line 1176 of file parallel_unit.C.

  {
    TIMPI::Communicator subcomm;
    unsigned int rank = TestCommWorld->rank();
    unsigned int color = rank % 2;
    TestCommWorld->split(color, rank, subcomm);
 
    TIMPI_UNIT_ASSERT(subcomm.size() >= 1);
    TIMPI_UNIT_ASSERT(subcomm.size() >= TestCommWorld->size() / 2);
    TIMPI_UNIT_ASSERT(subcomm.size() <= TestCommWorld->size() / 2 + 1);
  }

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

Referenced by main().

testSplitByType()

void testSplitByType

(

)

Definition at line 1189 of file parallel_unit.C.

  {
    TIMPI::Communicator subcomm;
    unsigned int rank = TestCommWorld->rank();
    TIMPI::info i = 0;
    int type = 0;
#ifdef TIMPI_HAVE_MPI
    type = MPI_COMM_TYPE_SHARED;
    i = MPI_INFO_NULL;
#endif
    TestCommWorld->split_by_type(type, rank, i, subcomm);
 
    TIMPI_UNIT_ASSERT(subcomm.size() >= 1);
    TIMPI_UNIT_ASSERT(subcomm.size() <= TestCommWorld->size());
  }

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

Referenced by main().

testStandardTypeAssignment()

template<typename NonBuiltin >

void testStandardTypeAssignment

(

)

Definition at line 1206 of file parallel_unit.C.

  {
    NonBuiltin ex{};
    StandardType<NonBuiltin> a(&ex);
    StandardType<NonBuiltin> b(&ex);
    a = b;
  }

References TIMPI::cast_int().

testSum()

template<class Map >

void testSum

(

)

Definition at line 31 of file parallel_unit.C.

  {
    Map data;
 
    int N = TestCommWorld->size();
 
    for (int p=0; p<N; ++p)
      data[p] = TestCommWorld->rank();
 
    TestCommWorld->sum(data);
 
    // Each map entry should now contain the sum:
    // 0 + 1 + ... + N-1 = N*(N-1)/2
    for (int p=0; p<N; ++p)
      TIMPI_UNIT_ASSERT( data[p] == N*(N-1)/2 );
  }

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

testSumOpFunction()

template<class Gettable >

void testSumOpFunction

(

)

Definition at line 51 of file parallel_unit.C.

  {
    Gettable data;
 
    int N = TestCommWorld->size();
 
    std::get<0>(data) = TestCommWorld->rank();
    std::get<1>(data) = TestCommWorld->rank()*2;
 
    TestCommWorld->sum(data);
 
    TIMPI_UNIT_ASSERT(std::get<0>(data) == N*(N-1)/2);
    TIMPI_UNIT_ASSERT(std::get<1>(data) == N*(N-1));
  }

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

Variable Documentation

pt_number

std::vector<std::string> pt_number

Definition at line 13 of file parallel_unit.C.

Referenced by setUp(), testAllGatherVectorString(), testAllGatherVectorVectorPacked(), testGatherString(), and testGatherString2().

TestCommWorld

Communicator* TestCommWorld

Definition at line 11 of file parallel_unit.C.

Referenced by main(), testAllGather(), testAllGatherEmptyVectorString(), testAllGatherHalfEmptyVectorString(), testAllGatherString(), testAllGatherVectorString(), testAllGatherVectorVector(), testAllGatherVectorVectorInPlace(), testAllGatherVectorVectorPacked(), testBarrier(), testBroadcast(), testBroadcastArrayType(), testBroadcastNestedType(), testBroadcastString(), testGather(), testGatherString(), testGatherString2(), testInfinityMax(), testInfinityMin(), testIrecvSend(), testIsendRecv(), testMapMax(), testMax(), testMaxloc(), testMaxlocBool(), testMaxlocDouble(), testMaxlocPair(), testMaxVecBool(), testMin(), testMinLarge(), testMinloc(), testMinlocBool(), testMinlocDouble(), testMinlocPair(), testMinVecBool(), testMPIULongMin(), testNonblockingMax(), testNonblockingMin(), testNonblockingString(), testNonblockingSum(), testNonblockingTest(), testNonblockingWaitany(), testNonFixedTypeMapMax(), testNonFixedTypeSum(), testRecvIsendSets(), testRecvIsendVecVecs(), testScatter(), testSemiVerifyInf(), testSemiVerifyString(), testSemiVerifyType(), testSemiVerifyVector(), testSendRecvVecVecs(), testSplit(), testSplitByType(), testSum(), and testSumOpFunction().