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.

References TIMPI::TIMPIInit::comm(), 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().

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

setUp()

void setUp

(

)

Definition at line 15 of file parallel_unit.C.

References pt_number.

Referenced by main().

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

testAllGather()

void testAllGather

(

)

Definition at line 112 of file parallel_unit.C.

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

Referenced by main().

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

testAllGatherEmptyVectorString()

void testAllGatherEmptyVectorString

(

)

Definition at line 219 of file parallel_unit.C.

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

Referenced by main().

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

    TIMPI_UNIT_ASSERT( vals.empty() );
  }

testAllGatherHalfEmptyVectorString()

void testAllGatherHalfEmptyVectorString

(

)

Definition at line 229 of file parallel_unit.C.

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

Referenced by main().

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

testAllGatherString()

void testAllGatherString

(

)

Definition at line 131 of file parallel_unit.C.

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

Referenced by main().

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

testAllGatherVectorString()

void testAllGatherVectorString

(

)

Definition at line 143 of file parallel_unit.C.

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

Referenced by main().

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

testAllGatherVectorVector()

void testAllGatherVectorVector

(

)

Definition at line 157 of file parallel_unit.C.

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

Referenced by main().

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

testAllGatherVectorVectorInPlace()

void testAllGatherVectorVectorInPlace

(

)

Definition at line 173 of file parallel_unit.C.

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

Referenced by main().

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

testAllGatherVectorVectorPacked()

void testAllGatherVectorVectorPacked

(

)

Definition at line 203 of file parallel_unit.C.

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

Referenced by main().

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

testBarrier()

void testBarrier

(

)

Definition at line 446 of file parallel_unit.C.

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

Referenced by main().

  {
    TestCommWorld->barrier();
  }

testBroadcast()

template<class Container >

void testBroadcast

(

Container &&

src

)

Definition at line 244 of file parallel_unit.C.

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

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

testBroadcastArrayType()

void testBroadcastArrayType

(

)

Definition at line 274 of file parallel_unit.C.

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

Referenced by main().

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

testBroadcastNestedType()

void testBroadcastNestedType

(

)

Definition at line 314 of file parallel_unit.C.

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

Referenced by main().

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

testBroadcastString()

void testBroadcastString

(

)

Definition at line 258 of file parallel_unit.C.

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

Referenced by main().

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

testGather()

void testGather

(

)

Definition at line 88 of file parallel_unit.C.

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

Referenced by main().

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

testGatherString()

void testGatherString

(

)

Definition at line 100 of file parallel_unit.C.

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

Referenced by main().

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

testGatherString2()

void testGatherString2

(

)

Definition at line 122 of file parallel_unit.C.

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

Referenced by main().

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

testInfinityMax()

void testInfinityMax

(

)

Definition at line 874 of file parallel_unit.C.

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

Referenced by main().

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

testInfinityMin()

void testInfinityMin

(

)

Definition at line 857 of file parallel_unit.C.

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

Referenced by main().

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

testIrecvSend()

void testIrecvSend

(

)

Definition at line 952 of file parallel_unit.C.

References 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().

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

testIsendRecv()

void testIsendRecv

(

)

Definition at line 891 of file parallel_unit.C.

References 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().

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

testMapMax()

template<class Map >

void testMapMax

(

)

Definition at line 700 of file parallel_unit.C.

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

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

testMax()

void testMax

(

)

Definition at line 657 of file parallel_unit.C.

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

Referenced by main().

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

testMaxloc()

void testMaxloc

(

)

Definition at line 754 of file parallel_unit.C.

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

Referenced by main().

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

testMaxlocBool()

void testMaxlocBool

(

)

Definition at line 794 of file parallel_unit.C.

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

Referenced by main().

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

testMaxlocDouble()

void testMaxlocDouble

(

)

Definition at line 807 of file parallel_unit.C.

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

Referenced by main().

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

testMaxlocPair()

void testMaxlocPair

(

)

Definition at line 838 of file parallel_unit.C.

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

Referenced by main().

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

testMaxVecBool()

void testMaxVecBool

(

)

Definition at line 669 of file parallel_unit.C.

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

Referenced by main().

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

testMin()

void testMin

(

)

Definition at line 572 of file parallel_unit.C.

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

Referenced by main().

  {
    unsigned int min = TestCommWorld->rank();

    TestCommWorld->min(min);

    TIMPI_UNIT_ASSERT (min == static_cast<unsigned int>(0));
  }

testMinLarge()

template<typename T >

void testMinLarge

(

)

Definition at line 628 of file parallel_unit.C.

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

  {
    T min = 1;

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

    TestCommWorld->min(min);

    TIMPI_UNIT_ASSERT (min == 1);
  }

testMinloc()

void testMinloc

(

)

Definition at line 741 of file parallel_unit.C.

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

Referenced by main().

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

testMinlocBool()

void testMinlocBool

(

)

Definition at line 768 of file parallel_unit.C.

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

Referenced by main().

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

testMinlocDouble()

void testMinlocDouble

(

)

Definition at line 781 of file parallel_unit.C.

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

Referenced by main().

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

testMinlocPair()

void testMinlocPair

(

)

Definition at line 821 of file parallel_unit.C.

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

Referenced by main().

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

testMinVecBool()

void testMinVecBool

(

)

Definition at line 582 of file parallel_unit.C.

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

Referenced by main().

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

testMPIULongMin()

void testMPIULongMin

(

)

Definition at line 613 of file parallel_unit.C.

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

Referenced by main().

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

testNonblockingMax()

void testNonblockingMax

(

)

Definition at line 642 of file parallel_unit.C.

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

Referenced by main().

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

testNonblockingMin()

void testNonblockingMin

(

)

Definition at line 558 of file parallel_unit.C.

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

Referenced by main().

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

testNonblockingString()

void testNonblockingString

(

)

Definition at line 473 of file parallel_unit.C.

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

Referenced by main().

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

testNonblockingSum()

void testNonblockingSum

(

)

Definition at line 540 of file parallel_unit.C.

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

Referenced by main().

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

testNonblockingTest()

void testNonblockingTest

(

)

Definition at line 452 of file parallel_unit.C.

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

Referenced by main().

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

testNonblockingWaitany()

void testNonblockingWaitany

(

)

Definition at line 500 of file parallel_unit.C.

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

Referenced by main().

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

testNonFixedTypeMapMax()

template<class Map >

void testNonFixedTypeMapMax

(

)

Definition at line 721 of file parallel_unit.C.

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

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

testNonFixedTypeSum()

template<class Map >

void testNonFixedTypeSum

(

)

Definition at line 69 of file parallel_unit.C.

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

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

testRecvIsendSets()

void testRecvIsendSets

(

)

Definition at line 1012 of file parallel_unit.C.

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

Referenced by main().

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

testRecvIsendVecVecs()

void testRecvIsendVecVecs

(

)

Definition at line 1050 of file parallel_unit.C.

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

Referenced by main().

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

testScatter()

void testScatter

(

)

Definition at line 355 of file parallel_unit.C.

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

Referenced by main().

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

testSemiVerifyInf()

void testSemiVerifyInf

(

)

Definition at line 1131 of file parallel_unit.C.

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

Referenced by main().

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

testSemiVerifyString()

void testSemiVerifyString

(

)

Definition at line 1145 of file parallel_unit.C.

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

Referenced by main().

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

testSemiVerifyType()

template<typename T >

void testSemiVerifyType

(

)

Definition at line 1166 of file parallel_unit.C.

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

  {
    const T one = 1;

    const T * tptr = TestCommWorld->rank()%2 ? NULL : &one;

    TIMPI_UNIT_ASSERT (TestCommWorld->semiverify(tptr));
  }

testSemiVerifyVector()

void testSemiVerifyVector

(

)

Definition at line 1155 of file parallel_unit.C.

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

Referenced by main().

  {
    const std::vector<int> v = {1, 2, 3};

    const std::vector<int> *vptr = TestCommWorld->rank()%2 ? NULL : &v;

    TIMPI_UNIT_ASSERT (TestCommWorld->semiverify(vptr));
  }

testSendRecvVecVecs()

void testSendRecvVecVecs

(

)

Definition at line 1089 of file parallel_unit.C.

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

Referenced by main().

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

testSplit()

void testSplit

(

)

Definition at line 1176 of file parallel_unit.C.

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

Referenced by main().

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

testSplitByType()

void testSplitByType

(

)

Definition at line 1189 of file parallel_unit.C.

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

Referenced by main().

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

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

testSum()

template<class Map >

void testSum

(

)

Definition at line 31 of file parallel_unit.C.

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

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

testSumOpFunction()

template<class Gettable >

void testSumOpFunction

(

)

Definition at line 51 of file parallel_unit.C.

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

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

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().