54 #ifdef HAVE_TEUCHOS_MPI
58 #ifdef HAVE_TEUCHOS_QD
59 # include <qd/dd_real.h>
65 template <
typename Packet>
66 ostream & operator<< ( ostream& os, const pair<Packet, Packet>& arg)
68 os <<
"(" << arg.first <<
"," << arg.second <<
")";
79 template<
typename Packet>
83 typedef std::pair<typename PST::magnitudeType, typename PST::magnitudeType>
magnitudeType;
88 static inline magnitudeType magnitude(std::pair<Packet,Packet> a) {
return std::pair<Packet,Packet>( PST::magnitude(a.first), PST::magnitude(a.second) ); }
89 static inline std::pair<Packet,Packet>
zero() {
return std::pair<Packet,Packet>(PST::zero(),PST::zero()); }
90 static inline std::pair<Packet,Packet>
one() {
return std::pair<Packet,Packet>(PST::one(), PST::one()); }
91 static inline std::pair<Packet,Packet>
conjugate(std::pair<Packet,Packet> x) {
return std::pair<Packet,Packet>(PST::conjugate(x.first), PST::conjugate(x.second) ); }
92 static inline std::pair<Packet,Packet>
real(std::pair<Packet,Packet> x) {
return std::pair<Packet,Packet>(PST::real(x.first), PST::real(x.second) ); }
93 static inline std::pair<Packet,Packet>
imag(std::pair<Packet,Packet> x) {
return std::pair<Packet,Packet>(PST::imag(x.first), PST::imag(x.second) ); }
94 static inline bool isnaninf(std::pair<Packet,Packet> x) {
return PST::isnaninf(x.first) || PST::isnaninf(x.second); }
95 static inline void seedrandom(
unsigned int s) { PST::seedrandom(s); }
96 static inline std::pair<Packet,Packet>
random() {
return std::pair<Packet,Packet>( PST::random(), PST::random() ); }
98 static inline std::pair<Packet,Packet>
squareroot(std::pair<Packet,Packet> x) {
return std::pair<Packet,Packet>(PST::squareroot(x.first), PST::squareroot(x.second)); }
99 static inline std::pair<Packet,Packet>
pow(std::pair<Packet,Packet> x, std::pair<Packet,Packet> y) {
return std::pair<Packet,Packet>( PST::pow(x.first,y.first), PST::pow(x.second,y.second) ); }
102 template<
class Packet,
class ConvertToPacket>
105 static std::pair<Packet,Packet>
convert(
const ConvertToPacket t )
107 return std::pair<Packet,Packet>(t,t);
109 static std::pair<Packet,Packet>
safeConvert(
const ConvertToPacket t )
111 return std::pair<Packet,Packet>(t,t);
130 using Teuchos::outArg;
136 double errorTolSlack = 1e+1;
148 "test-mpi",
"test-serial", &testMpi,
149 "Test MPI (if available) or force test of serial. In a serial build,"
150 " this option is ignored and a serial comm is always used." );
153 "error-tol-slack", &errorTolSlack,
154 "Slack off of machine epsilon used to check test results" );
159 template<
class Ordinal>
160 RCP<const Comm<Ordinal> > getDefaultComm()
163 return DefaultComm<Ordinal>::getComm();
171 RCP<const Comm<Ordinal> > comm = getDefaultComm<Ordinal>();
172 out <<
"comm = " << Teuchos::describe(*comm);
177 #ifdef HAVE_TEUCHOS_MPI
182 ECHO(MPI_Comm rawMpiComm = MPI_COMM_WORLD);
183 ECHO(
const RCP<
const Comm<int> > comm =
184 Teuchos::createMpiComm<int>(Teuchos::opaqueWrapper(rawMpiComm)));
185 out <<
"comm = " << Teuchos::describe(*comm);
186 ECHO(MPI_Comm rawMpiComm2 = Teuchos::getRawMpiComm<int>(*comm));
193 ECHO(MPI_Comm rawMpiComm = MPI_COMM_WORLD);
194 ECHO(
const RCP<
const Comm<int> > comm =
195 Teuchos::createMpiComm<int>(Teuchos::opaqueWrapper(rawMpiComm), 123));
196 out <<
"comm = " << Teuchos::describe(*comm);
197 ECHO(MPI_Comm rawMpiComm2 = Teuchos::getRawMpiComm<int>(*comm));
203 #endif // HAVE_TEUCHOS_MPI
209 using Teuchos::broadcast;
213 using Teuchos::rcpFromRef;
214 using Teuchos::outArg;
221 using Teuchos::arcpClone;
222 using Teuchos::rcp_dynamic_cast;
229 RCP<const Comm<Ordinal> > comm = getDefaultComm<Ordinal>();
230 const Ordinal numProcs =
size(*comm);
231 const Ordinal procRank =
rank(*comm);
239 out <<
"\nThis is Teuchos::SerialComm which does not support readySend!\n";
243 PT::seedrandom(as<unsigned int>(procRank));
244 Packet origSendData = PT::random();
245 Packet origRecvData = PT::random();
246 broadcast<Ordinal, Packet>( *comm, 0,
outArg(origSendData) );
248 Packet sendData = origSendData;
249 Packet recvData = origRecvData;
251 RCP<Teuchos::CommRequest<Ordinal> > recvRequest;
256 recvRequest = ireceive<Ordinal, Packet>(
258 rcp(&recvData,
false),
264 if (procRank == numProcs-1) {
267 readySend<Ordinal, Packet>(
296 int globalSuccess_int = -1;
305 using Teuchos::broadcast;
309 using Teuchos::rcpFromRef;
310 using Teuchos::outArg;
317 using Teuchos::arcpClone;
318 using Teuchos::rcp_dynamic_cast;
324 RCP<const Comm<Ordinal> > comm = getDefaultComm<Ordinal>();
325 const Ordinal numProcs =
size(*comm);
326 const Ordinal procRank =
rank(*comm);
334 out <<
"\nThis is Teuchos::SerialComm which does not support readySend!\n";
338 const int dataLen = 3;
340 const ArrayRCP<Packet> origSendData = arcp<Packet>(dataLen);
341 const ArrayRCP<Packet> origRecvData = arcp<Packet>(dataLen);
342 PT::seedrandom(as<unsigned int>(procRank));
343 for (
int j = 0; j < dataLen; ++j) {
344 origSendData[j] = PT::random();
345 origRecvData[j] = PT::random();
347 broadcast<Ordinal, Packet>( *comm, 0, origSendData() );
349 const ArrayRCP<Packet> sendData = arcpClone<Packet>(origSendData());
350 const ArrayRCP<Packet> recvData = arcpClone<Packet>(origRecvData());
352 RCP<Teuchos::CommRequest<Ordinal> > recvRequest;
364 recvRequest = ireceive<Ordinal, Packet>(
366 recvData.persistingView(0, dataLen),
370 else if (procRank == numProcs-1) {
372 recvRequest = ireceive<Ordinal, Packet>(
374 recvData.persistingView(0, dataLen),
383 readySend<Ordinal, Packet>(
389 else if (procRank == numProcs-1) {
399 else if (procRank == numProcs-1) {
402 readySend<Ordinal, Packet>(
414 if (procRank == 0 || procRank == numProcs-1) {
425 int globalSuccess_int = -1;
434 using Teuchos::rcpFromRef;
435 using Teuchos::outArg;
440 using Teuchos::rcp_dynamic_cast;
444 RCP<const Comm<Ordinal> > comm = getDefaultComm<Ordinal>();
445 const Ordinal numProcs =
size(*comm);
446 const Ordinal procRank =
rank(*comm);
454 out <<
"\nThis is Teuchos::SerialComm which does not yet support isend/ireceive!\n";
459 Packet orig_input_data = PT::random();
462 const Packet orig_output_data = as<Packet>(-1);
464 const Packet input_data = orig_input_data;
465 Packet output_data = orig_output_data;
467 RCP<Teuchos::CommRequest<Ordinal> > recvRequest;
468 RCP<Teuchos::CommRequest<Ordinal> > sendRequest;
470 out <<
"Exchanging messages" << endl;
475 sendRequest = isend<Ordinal, Packet>(
476 *comm,
Teuchos::rcp(
new Packet(input_data)), numProcs-1);
478 if (procRank == numProcs-1) {
480 recvRequest = ireceive<Ordinal, Packet>(
484 out <<
"Waiting for messages" << endl;
489 if (procRank == numProcs-1) {
496 out <<
"Testing message correctness" << endl;
498 if (procRank == numProcs-1) {
507 int globalSuccess_int = -1;
516 using Teuchos::rcpFromRef;
517 using Teuchos::outArg;
521 using Teuchos::rcp_dynamic_cast;
524 RCP<const Comm<Ordinal>> comm = getDefaultComm<Ordinal>();
525 const Ordinal numProcs =
size(*comm);
526 const Ordinal procRank =
rank(*comm);
529 out <<
"\nThis is Teuchos::SerialComm which does not yet support isend/ireceive!\n";
534 Packet input_data = PT::random();
536 Packet output_data = as<Packet>(-1);
538 const Ordinal sendRank = (procRank + 1) % numProcs;
539 const Ordinal recvRank = (procRank + numProcs - 1) % numProcs;
541 RCP<Teuchos::CommRequest<Ordinal>> recvRequest = ireceive<Ordinal, Packet>(*comm,
rcpFromRef(output_data), recvRank);
542 RCP<Teuchos::CommRequest<Ordinal>> sendRequest = isend<Ordinal, Packet>(*comm,
rcpFromRef(input_data), sendRank);
548 int globalSuccess_int = -1;
557 using Teuchos::rcpFromRef;
558 using Teuchos::outArg;
561 using Teuchos::rcp_dynamic_cast;
563 RCP<const Comm<Ordinal>> comm = getDefaultComm<Ordinal>();
564 const Ordinal numProcs =
size(*comm);
565 const Ordinal procRank =
rank(*comm);
568 out <<
"\nThis is Teuchos::SerialComm which does not yet support isend/ireceive!\n";
572 Packet output_data = as<Packet>(-1);
574 RCP<Teuchos::CommRequest<Ordinal>> recvRequest;
575 const Ordinal recvRank = (procRank + numProcs - 1) % numProcs;
577 recvRequest = ireceive<Ordinal, Packet>(*comm,
rcpFromRef(output_data), recvRank);
581 int globalSuccess_int = -1;
587 template <
class Ordinal>
588 bool null_request_is_always_ready_if_mpi_available() {
589 #ifdef HAVE_TEUCHOS_MPI
590 Teuchos::MpiCommRequestBase<Ordinal> nullRequest;
591 return nullRequest.isReady();
599 using Teuchos::outArg;
601 RCP<const Comm<Ordinal>> comm = getDefaultComm<Ordinal>();
602 TEST_ASSERT(null_request_is_always_ready_if_mpi_available<Ordinal>());
605 int globalSuccess_int = -1;
614 using Teuchos::rcpFromRef;
615 using Teuchos::outArg;
617 using Teuchos::arcpClone;
622 using Teuchos::broadcast;
624 using Teuchos::rcp_dynamic_cast;
630 RCP<const Comm<Ordinal> > comm = getDefaultComm<Ordinal>();
631 const Ordinal numProcs =
size(*comm);
632 const Ordinal procRank =
rank(*comm);
640 out <<
"\nThis is Teuchos::SerialComm which does not yet support isend/ireceive!\n";
644 const int numSendRecv = 4;
645 const int sendLen = 3;
647 out <<
"Creating data" << endl;
649 const ArrayRCP<Packet> origInputData = arcp<Packet>(numSendRecv*sendLen);
650 const ArrayRCP<Packet> origOutputData = arcp<Packet>(numSendRecv*sendLen);
653 for (
int i = 0; i < numSendRecv; ++i, offset += sendLen) {
654 const ArrayRCP<Packet> origInputData_i =
655 origInputData.persistingView(offset, sendLen);
656 const ArrayRCP<Packet> origOutputData_i =
657 origOutputData.persistingView(offset, sendLen);
658 for (
int j = 0; j < sendLen; ++j) {
659 origInputData_i[j] = PT::random();
660 origOutputData_i[j] = PT::random();
664 out <<
"Broadcasting data" << endl;
665 broadcast<Ordinal, Packet>( *comm, 0, origInputData() );
667 const ArrayRCP<Packet> inputData = arcpClone<Packet>(origInputData());
668 const ArrayRCP<Packet> outputData = arcpClone<Packet>(origOutputData());
670 Array<RCP<Teuchos::CommRequest<Ordinal> > > recvRequests;
671 Array<RCP<Teuchos::CommRequest<Ordinal> > > sendRequests;
673 out <<
"Exchanging data" << endl;
680 for (
int i = 0; i < numSendRecv; ++i, offset += sendLen) {
681 sendRequests.push_back(
682 isend<Ordinal, Packet>(
684 arcpClone<Packet>(inputData(offset, sendLen)),
692 if (procRank == numProcs-1) {
695 for (
int i = 0; i < numSendRecv; ++i, offset += sendLen) {
696 recvRequests.push_back(
697 ireceive<Ordinal, Packet>(
698 *comm, outputData.persistingView(offset, sendLen), 0
704 out <<
"Waiting on messages" << endl;
707 waitAll( *comm, sendRequests() );
709 if (procRank == numProcs-1) {
710 waitAll( *comm, recvRequests() );
713 out <<
"Testing received data" << endl;
715 if (!sendRequests.empty()) {
716 for (
int i = 0; i < numSendRecv; ++i) {
721 if (!recvRequests.empty()) {
722 for (
int i = 0; i < numSendRecv; ++i) {
728 if (procRank == numProcs-1) {
737 int globalSuccess_int = -1;
745 RCP< const Comm<Ordinal> > comm = getDefaultComm<Ordinal>();
746 int initialRank = comm->getRank();
747 int initialSize = comm->getSize();
749 RCP< const Comm<Ordinal> > newComm = comm->duplicate();
757 RCP< const Comm<Ordinal> > comm = getDefaultComm<Ordinal>();
758 int initialRank = comm->getRank();
759 int initialSize = comm->getSize();
764 RCP< const Comm<Ordinal> > newComm = comm->split(initialRank % 2, 0);
767 int halfSize = initialSize / 2;
768 int newSize = newComm->getSize();
769 int newRank = newComm->getRank();
770 if (initialSize % 2 == 0) {
774 TEST_EQUALITY(newSize, initialRank % 2 == 0 ? halfSize + 1 : halfSize);
779 RCP< const Comm<Ordinal> > shouldBeNull = comm->split(-1, 0);
787 template<
typename ValueType>
788 class MonotoneSequence
790 ValueType currentValue_;
792 typedef ValueType value_type;
794 MonotoneSequence(
const value_type& initialValue) : currentValue_(initialValue)
797 value_type operator()()
799 return currentValue_++;
808 RCP< const Comm<Ordinal> > comm = getDefaultComm<Ordinal>();
809 int initialRank = comm->getRank();
810 int initialSize = comm->getSize();
813 std::vector< int > ranks(initialSize);
814 std::generate(ranks.begin(), ranks.end(), MonotoneSequence<int>(0));
815 std::reverse(ranks.begin(), ranks.end());
816 RCP< const Comm<Ordinal> > newComm = comm->createSubcommunicator(ranks);
818 int expectedNewRank = initialSize - initialRank - 1;
822 std::vector<int> rank0Only(1, 0);
823 RCP< const Comm<Ordinal> > rank0Comm = comm->createSubcommunicator(rank0Only);
825 if (initialRank == 0) {
833 #ifdef HAVE_TEUCHOS_MPI
838 using Teuchos::tuple;
using Teuchos::inoutArg;
842 const int comm_size = defaultComm->getSize();
843 const int comm_rank = defaultComm->getRank();
852 defaultComm->createSubcommunicator(tuple<int>(0, 1)());
854 if (comm_rank <= 1) {
856 const int masterComm_size = masterComm->getSize();
857 (void) masterComm_size;
858 const int masterComm_rank = masterComm->getRank();
862 masterComm->createSubcommunicator(tuple<int>(0, 1)());
864 masterComm->createSubcommunicator(tuple<int>(0)());
868 masterComm->createSubcommunicator(tuple<int>(0, 1)());
871 int my_tag = Teuchos::rcp_dynamic_cast<
const Teuchos::MpiComm<int> >(
876 if (masterComm_rank == 0) { tag1 = my_tag; }
877 masterComm->barrier();
878 Teuchos::broadcast( *masterComm, 0,
inoutArg(tag1) );
881 if (masterComm_rank == 1) { tag2 = my_tag; }
882 masterComm->barrier();
883 Teuchos::broadcast( *masterComm, 1,
inoutArg(tag2) );
893 #endif // HAVE_TEUCHOS_MPI
901 #ifdef HAVE_TEUCHOS_COMPLEX
902 # define UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(TEST_GROUP, TEST_NAME, ORDINAL)\
903 typedef std::complex<float> ComplexFloat; \
904 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT(TEST_GROUP, TEST_NAME, ORDINAL, ComplexFloat)
905 # define UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(TEST_GROUP, TEST_NAME, ORDINAL)\
906 typedef std::complex<double> ComplexDouble; \
907 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT(TEST_GROUP, TEST_NAME, ORDINAL, ComplexDouble)
909 # define UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(TEST_GROUP, TEST_NAME, ORDINAL)
910 # define UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(TEST_GROUP, TEST_NAME, ORDINAL)
914 #define UNIT_TEST_GROUP_ORDINAL_PACKET( ORDINAL, PACKET ) \
915 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive, ORDINAL, PACKET ) \
916 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive_isReady_true, ORDINAL, PACKET ) \
917 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive_isReady_false, ORDINAL, PACKET ) \
918 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive_isReady_nullIsTrue, ORDINAL, PACKET ) \
919 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceiveSet, ORDINAL, PACKET ) \
920 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, ReadySend1, ORDINAL, PACKET ) \
921 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, ReadySend, ORDINAL, PACKET )
923 #ifdef HAVE_TEUCHOS_QD
924 # define UNIT_TEST_GROUP_ORDINAL_QD(ORDINAL) \
925 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, dd_real) \
926 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, qd_real)
928 # define UNIT_TEST_GROUP_ORDINAL_QD(ORDINAL)
931 #define UNIT_TEST_GROUP_ORDINAL_PAIROFPACKETS( ORDINAL, PAIROFPACKETS ) \
932 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive, ORDINAL, PAIROFPACKETS ) \
933 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive_isReady_true, ORDINAL, PAIROFPACKETS ) \
934 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive_isReady_false, ORDINAL, PAIROFPACKETS ) \
935 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive_isReady_nullIsTrue, ORDINAL, PAIROFPACKETS ) \
936 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceiveSet, ORDINAL, PAIROFPACKETS ) \
937 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, ReadySend1, ORDINAL, PAIROFPACKETS ) \
938 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, ReadySend, ORDINAL, PAIROFPACKETS )
940 #define UNIT_TEST_GROUP_ORDINAL_SUBCOMMUNICATORS( ORDINAL ) \
941 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( DefaultMpiComm, duplicate, ORDINAL ) \
942 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( DefaultMpiComm, split, ORDINAL ) \
943 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( DefaultMpiComm, createSubcommunicator, ORDINAL )
946 typedef std::pair<short, short> PairOfShorts;
947 typedef std::pair<int,int> PairOfInts;
948 typedef std::pair<float,float> PairOfFloats;
949 typedef std::pair<double,double> PairOfDoubles;
957 #ifdef FAST_DEVELOPMENT_UNIT_TEST_BUILD
959 # define UNIT_TEST_GROUP_ORDINAL( ORDINAL ) \
960 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, double) \
961 UNIT_TEST_GROUP_ORDINAL_PAIROFPACKETS(ORDINAL, PairOfDoubles) \
965 #else // FAST_DEVELOPMENT_UNIT_TEST_BUILD
967 # define UNIT_TEST_GROUP_ORDINAL( ORDINAL ) \
968 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( DefaultMpiComm, basic, ORDINAL ) \
969 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, short) \
970 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, int) \
971 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, float) \
972 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, double) \
973 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive, ORDINAL) \
974 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive_isReady_true, ORDINAL) \
975 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive_isReady_false, ORDINAL) \
976 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive_isReady_nullIsTrue, ORDINAL) \
977 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, ReadySend1, ORDINAL) \
978 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, ReadySend, ORDINAL) \
979 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive, ORDINAL) \
980 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive_isReady_true, ORDINAL) \
981 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive_isReady_false, ORDINAL) \
982 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive_isReady_nullIsTrue, ORDINAL) \
983 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, ReadySend1, ORDINAL) \
984 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, ReadySend, ORDINAL) \
985 UNIT_TEST_GROUP_ORDINAL_SUBCOMMUNICATORS(ORDINAL)
987 # define UNIT_TEST_GROUP_ORDINAL_WITH_PAIRS_AND_QD( ORDINAL ) \
988 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( DefaultMpiComm, basic, ORDINAL ) \
989 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, short) \
990 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, int) \
991 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, float) \
992 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, double) \
993 UNIT_TEST_GROUP_ORDINAL_QD(ORDINAL) \
994 UNIT_TEST_GROUP_ORDINAL_PAIROFPACKETS(ORDINAL, PairOfShorts) \
995 UNIT_TEST_GROUP_ORDINAL_PAIROFPACKETS(ORDINAL, PairOfInts) \
996 UNIT_TEST_GROUP_ORDINAL_PAIROFPACKETS(ORDINAL, PairOfFloats) \
997 UNIT_TEST_GROUP_ORDINAL_PAIROFPACKETS(ORDINAL, PairOfDoubles) \
998 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive, ORDINAL) \
999 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive_isReady_true, ORDINAL) \
1000 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive_isReady_false, ORDINAL) \
1001 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive_isReady_nullIsTrue, ORDINAL) \
1002 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, ReadySend1, ORDINAL) \
1003 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, ReadySend, ORDINAL) \
1004 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive, ORDINAL) \
1005 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive_isReady_true, ORDINAL) \
1006 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive_isReady_false, ORDINAL) \
1007 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive_isReady_nullIsTrue, ORDINAL) \
1008 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, ReadySend1, ORDINAL) \
1009 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, ReadySend, ORDINAL)
1011 typedef short int ShortInt;
1014 typedef
long int LongInt;
1017 typedef
long long int LongLongInt;
1020 #endif // FAST_DEVELOPMENT_UNIT_TEST_BUILD
RCP< T > rcp(const boost::shared_ptr< T > &sptr)
Conversion function that takes in a boost::shared_ptr object and spits out a Teuchos::RCP object...
static std::pair< Packet, Packet > real(std::pair< Packet, Packet > x)
#define TEST_ASSERT(v1)
Assert the given statement is true.
void addOutputSetupOptions(const bool &addOutputSetupOptions)
Set if options will be automatically added to setup Teuchos::VerboseObjectBase::getDefaultOStream().
#define UNIT_TEST_GROUP_ORDINAL_WITH_PAIRS_AND_QD(ORDINAL)
Scalar defaultSmallNumber()
void broadcast(const Comm< Ordinal > &comm, const int rootRank, const Ordinal count, Packet buffer[])
Broadcast array of objects that use value semantics.
#define ECHO(statement)
Echo the given statement before it is executed.
RCP< T2 > rcp_dynamic_cast(const RCP< T1 > &p1, bool throw_on_fail=false)
Dynamic cast of underlying RCP type from T1* to T2*.
static bool isnaninf(std::pair< Packet, Packet > x)
static CommandLineProcessor & getCLP()
Return the CLP to add options to.
static magnitudeType magnitude(std::pair< Packet, Packet > a)
bool is_null(const std::shared_ptr< T > &p)
Returns true if p.get()==NULL.
static std::pair< Packet, Packet > zero()
static const bool isComparable
Determines if scalar type supports relational operators such as <, >, <=, >=.
#define TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL(TEST_GROUP, TEST_NAME, TYPE)
Macro for defining a templated unit test with one template parameter.
int rank(const Comm< Ordinal > &comm)
Get the process rank.
#define TEST_EQUALITY(v1, v2)
Assert the equality of v1 and v2.
#define TEUCHOS_UNIT_TEST_TEMPLATE_2_DECL(TEST_GROUP, TEST_NAME, TYPE1, TYPE2)
Macro for defining a templated unit test with two template parameters.
static void seedrandom(unsigned int s)
Concrete serial communicator subclass.
#define TEUCHOS_UNIT_TEST(TEST_GROUP, TEST_NAME)
Macro for defining a (non-templated) unit test.
static std::pair< Packet, Packet > squareroot(std::pair< Packet, Packet > x)
static Teuchos::RCP< const Comm< OrdinalType > > getComm()
Return the default global communicator.
Initialize, finalize, and query the global MPI session.
static const bool hasMachineParameters
Determines if scalar type have machine-specific parameters (i.e. eps(), sfmin(), base(), prec(), t(), rnd(), emin(), rmin(), emax(), rmax() are supported).
bool is_null(const ArrayRCP< T > &p)
Returns true if p.get()==NULL.
static std::pair< Packet, Packet > imag(std::pair< Packet, Packet > x)
void reduceAll(const Comm< Ordinal > &comm, const ValueTypeReductionOp< Ordinal, Packet > &reductOp, const Ordinal count, const Packet sendBuffer[], Packet globalReducts[])
Wrapper for MPI_Allreduce that takes a custom reduction operator.
static std::pair< Packet, Packet > pow(std::pair< Packet, Packet > x, std::pair< Packet, Packet > y)
This structure defines some basic traits for a scalar field type.
std::vector< std::string > split(const std::string &str, const std::string &delimiters, const size_t start)
Split the given string using the given set of delimiters.
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Deprecated.
void setOption(const char option_true[], const char option_false[], bool *option_val, const char documentation[]=NULL)
Set a boolean option.
static std::pair< Packet, Packet > convert(const ConvertToPacket t)
void waitAll(const Comm< Ordinal > &comm, const ArrayView< RCP< CommRequest< Ordinal > > > &requests)
Wait for an array of Teuchos::CommRequest objects.
static std::pair< Packet, Packet > safeConvert(const ConvertToPacket t)
#define UNIT_TEST_GROUP_ORDINAL(ORDINAL)
Implementation of Teuchos wrappers for MPI.
#define TEST_EQUALITY_CONST(v1, v2)
Assert the equality of v1 and constant v2.
void barrier(const Comm< Ordinal > &comm)
Barrier.
Ptr< T > inoutArg(T &arg)
create a non-persisting (required or optional) input/output argument for a function call...
Return a default global communicator appropriate for the build.
int size(const Comm< Ordinal > &comm)
Get the number of processes in the communicator.
Default traits class for all conversions between value types.
TypeTo as(const TypeFrom &t)
Convert from one value type to another.
RCP< CommRequest< Ordinal > > ireceive(const ArrayRCP< Packet > &recvBuffer, const int sourceRank, const int tag, const Comm< Ordinal > &comm)
Variant of ireceive that takes a tag argument (and restores the correct order of arguments).
Abstract interface for distributed-memory communication.
#define TEST_COMPARE_ARRAYS(a1, a2)
Assert that a1.size()==a2.size() and a[i]==b[i], i=0....
ScalarTraits< Packet > PST
std::pair< typename PST::magnitudeType, typename PST::magnitudeType > magnitudeType
RCP< Teuchos::CommRequest< int > > isend(const ArrayRCP< const double > &sendBuffer, const int destRank, const int tag, const Comm< int > &comm)
static std::string name()
RCP< T > rcpFromRef(T &r)
Return a non-owning weak RCP object from a raw object reference for a defined type.
RCP< CommStatus< Ordinal > > wait(const Comm< Ordinal > &comm, const Ptr< RCP< CommRequest< Ordinal > > > &request)
Wait on a single communication request, and return its status.
Smart reference counting pointer class for automatic garbage collection.
static std::pair< Packet, Packet > conjugate(std::pair< Packet, Packet > x)
static std::pair< Packet, Packet > one()
static const bool isComplex
Determines if scalar type is std::complex.
static std::pair< Packet, Packet > random()
Ptr< T > outArg(T &arg)
create a non-persisting (required or optional) output argument for a function call.
Definition of Teuchos::as, for conversions between types.
void readySend(const Packet sendBuffer[], const Ordinal count, const int destRank, const int tag, const Comm< Ordinal > &comm)
Variant of readySend() that accepts a message tag.
Class that helps parse command line input arguments from (argc,argv[]) and set options.
static std::string name()
Reference-counted smart pointer for managing arrays.
Replacement for std::vector that is compatible with the Teuchos Memory Management classes...