54#ifdef HAVE_TEUCHOS_MPI
59# include <qd/dd_real.h>
65template <
typename Packet>
66ostream &
operator<< ( ostream& os,
const pair<Packet, Packet>& arg)
68 os <<
"(" << arg.first <<
"," << arg.second <<
")";
79template<
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) ); }
102template<
class Packet,
class ConvertToPacket>
107 return std::pair<Packet,Packet>(t,t);
111 return std::pair<Packet,Packet>(t,t);
130using Teuchos::outArg;
136double 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" );
159template<
class Ordinal>
160RCP<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 =
185 out <<
"comm = " << Teuchos::describe(*comm);
193 ECHO(MPI_Comm rawMpiComm = MPI_COMM_WORLD);
194 ECHO(
const RCP<
const Comm<int> > comm =
196 out <<
"comm = " << Teuchos::describe(*comm);
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);
236 !
is_null(rcp_dynamic_cast<
const SerialComm<Ordinal> >(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>(
277 wait( *comm, outArg(recvRequest) );
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);
331 !
is_null(rcp_dynamic_cast<
const SerialComm<Ordinal> >(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) {
391 wait( *comm, outArg(recvRequest) );
397 wait( *comm, outArg(recvRequest) );
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);
451 !
is_null(rcp_dynamic_cast<
const SerialComm<Ordinal> >(comm))
454 out <<
"\nThis is Teuchos::SerialComm which does not yet support isend/ireceive!\n";
459 Packet orig_input_data = PT::random();
460 broadcast( *comm, 0, &orig_input_data );
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>(
481 *comm, rcpFromRef(output_data), 0);
484 out <<
"Waiting for messages" << endl;
487 wait( *comm, outArg(sendRequest) );
489 if (procRank == numProcs-1) {
490 wait( *comm, outArg(recvRequest) );
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);
528 if (numProcs == 1 && !
is_null(rcp_dynamic_cast<
const SerialComm<Ordinal>>(comm))) {
529 out <<
"\nThis is Teuchos::SerialComm which does not yet support isend/ireceive!\n";
534 Packet input_data = PT::random();
535 broadcast(*comm, 0, &input_data);
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);
567 if (numProcs == 1 && !
is_null(rcp_dynamic_cast<
const SerialComm<Ordinal>>(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;
587template <
class Ordinal>
588bool null_request_is_always_ready_if_mpi_available() {
589#ifdef HAVE_TEUCHOS_MPI
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;
631 RCP<const Comm<Ordinal> > comm = getDefaultComm<Ordinal>();
632 const Ordinal numProcs = size(*comm);
633 const Ordinal procRank = rank(*comm);
638 !
is_null(rcp_dynamic_cast<
const SerialComm<Ordinal> >(comm))
641 out <<
"\nThis is Teuchos::SerialComm which does not yet support isend/ireceive!\n";
645 const int numSendRecv = 4;
646 const int sendLen = 3;
648 cerr <<
"Creating data" << endl;
650 const ArrayRCP<Packet> origInputData = arcp<Packet>(numSendRecv*sendLen);
651 const ArrayRCP<Packet> origOutputData = arcp<Packet>(numSendRecv*sendLen);
654 for (
int i = 0; i < numSendRecv; ++i, offset += sendLen) {
655 const ArrayRCP<Packet> origInputData_i =
656 origInputData.persistingView(offset, sendLen);
657 const ArrayRCP<Packet> origOutputData_i =
658 origOutputData.persistingView(offset, sendLen);
659 for (
int j = 0; j < sendLen; ++j) {
660 origInputData_i[j] = PT::random();
661 origOutputData_i[j] = PT::random();
665 cerr <<
"Broadcasting data" << endl;
666 broadcast<Ordinal, Packet>( *comm, 0, origInputData() );
668 const ArrayRCP<Packet> inputData = arcpClone<Packet>(origInputData());
669 const ArrayRCP<Packet> outputData = arcpClone<Packet>(origOutputData());
671 Array<RCP<Teuchos::CommRequest<Ordinal> > > recvRequests;
672 Array<RCP<Teuchos::CommRequest<Ordinal> > > sendRequests;
674 cerr <<
"Exchanging data" << endl;
681 for (
int i = 0; i < numSendRecv; ++i, offset += sendLen) {
682 sendRequests.push_back(
683 isend<Ordinal, Packet>(
685 arcpClone<Packet>(inputData(offset, sendLen)),
693 if (procRank == numProcs-1) {
696 for (
int i = 0; i < numSendRecv; ++i, offset += sendLen) {
697 recvRequests.push_back(
698 ireceive<Ordinal, Packet>(
699 *comm, outputData.persistingView(offset, sendLen), 0
705 cerr <<
"Waiting on messages" << endl;
708 waitAll( *comm, sendRequests() );
710 if (procRank == numProcs-1) {
711 waitAll( *comm, recvRequests() );
714 cerr <<
"Testing received data" << endl;
716 if (!sendRequests.empty()) {
717 for (
int i = 0; i < numSendRecv; ++i) {
722 if (!recvRequests.empty()) {
723 for (
int i = 0; i < numSendRecv; ++i) {
729 if (procRank == numProcs-1) {
738 int globalSuccess_int = -1;
746 RCP< const Comm<Ordinal> > comm = getDefaultComm<Ordinal>();
747 int initialRank = comm->getRank();
748 int initialSize = comm->getSize();
750 RCP< const Comm<Ordinal> > newComm = comm->duplicate();
758 RCP< const Comm<Ordinal> > comm = getDefaultComm<Ordinal>();
759 int initialRank = comm->getRank();
760 int initialSize = comm->getSize();
765 RCP< const Comm<Ordinal> > newComm = comm->split(initialRank % 2, 0);
768 int halfSize = initialSize / 2;
769 int newSize = newComm->getSize();
770 int newRank = newComm->getRank();
771 if (initialSize % 2 == 0) {
775 TEST_EQUALITY(newSize, initialRank % 2 == 0 ? halfSize + 1 : halfSize);
780 RCP< const Comm<Ordinal> > shouldBeNull = comm->split(-1, 0);
788template<
typename ValueType>
789class MonotoneSequence
791 ValueType currentValue_;
793 typedef ValueType value_type;
795 MonotoneSequence(
const value_type& initialValue) : currentValue_(initialValue)
798 value_type operator()()
800 return currentValue_++;
809 RCP< const Comm<Ordinal> > comm = getDefaultComm<Ordinal>();
810 int initialRank = comm->getRank();
811 int initialSize = comm->getSize();
814 std::vector< int > ranks(initialSize);
815 std::generate(ranks.begin(), ranks.end(), MonotoneSequence<int>(0));
816 std::reverse(ranks.begin(), ranks.end());
817 RCP< const Comm<Ordinal> > newComm = comm->createSubcommunicator(ranks);
819 int expectedNewRank = initialSize - initialRank - 1;
823 std::vector<int> rank0Only(1, 0);
824 RCP< const Comm<Ordinal> > rank0Comm = comm->createSubcommunicator(rank0Only);
826 if (initialRank == 0) {
834#ifdef HAVE_TEUCHOS_MPI
839 using Teuchos::tuple;
using Teuchos::inoutArg;
843 const int comm_size = defaultComm->
getSize();
844 const int comm_rank = defaultComm->
getRank();
855 if (comm_rank <= 1) {
857 const int masterComm_size = masterComm->
getSize();
858 (void) masterComm_size;
859 const int masterComm_rank = masterComm->
getRank();
877 if (masterComm_rank == 0) { tag1 = my_tag; }
879 Teuchos::broadcast( *masterComm, 0, inoutArg(tag1) );
882 if (masterComm_rank == 1) { tag2 = my_tag; }
884 Teuchos::broadcast( *masterComm, 1, inoutArg(tag2) );
902#ifdef HAVE_TEUCHOS_COMPLEX
903# define UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(TEST_GROUP, TEST_NAME, ORDINAL)\
904 typedef std::complex<float> ComplexFloat; \
905 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT(TEST_GROUP, TEST_NAME, ORDINAL, ComplexFloat)
906# define UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(TEST_GROUP, TEST_NAME, ORDINAL)\
907 typedef std::complex<double> ComplexDouble; \
908 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT(TEST_GROUP, TEST_NAME, ORDINAL, ComplexDouble)
910# define UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(TEST_GROUP, TEST_NAME, ORDINAL)
911# define UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(TEST_GROUP, TEST_NAME, ORDINAL)
915#define UNIT_TEST_GROUP_ORDINAL_PACKET( ORDINAL, PACKET ) \
916 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive, ORDINAL, PACKET ) \
917 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive_isReady_true, ORDINAL, PACKET ) \
918 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive_isReady_false, ORDINAL, PACKET ) \
919 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive_isReady_nullIsTrue, ORDINAL, PACKET ) \
920 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceiveSet, ORDINAL, PACKET ) \
921 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, ReadySend1, ORDINAL, PACKET ) \
922 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, ReadySend, ORDINAL, PACKET )
924#ifdef HAVE_TEUCHOS_QD
925# define UNIT_TEST_GROUP_ORDINAL_QD(ORDINAL) \
926 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, dd_real) \
927 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, qd_real)
929# define UNIT_TEST_GROUP_ORDINAL_QD(ORDINAL)
932#define UNIT_TEST_GROUP_ORDINAL_PAIROFPACKETS( ORDINAL, PAIROFPACKETS ) \
933 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive, ORDINAL, PAIROFPACKETS ) \
934 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive_isReady_true, ORDINAL, PAIROFPACKETS ) \
935 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive_isReady_false, ORDINAL, PAIROFPACKETS ) \
936 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceive_isReady_nullIsTrue, ORDINAL, PAIROFPACKETS ) \
937 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, NonblockingSendReceiveSet, ORDINAL, PAIROFPACKETS ) \
938 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, ReadySend1, ORDINAL, PAIROFPACKETS ) \
939 TEUCHOS_UNIT_TEST_TEMPLATE_2_INSTANT( DefaultMpiComm, ReadySend, ORDINAL, PAIROFPACKETS )
941#define UNIT_TEST_GROUP_ORDINAL_SUBCOMMUNICATORS( ORDINAL ) \
942 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( DefaultMpiComm, duplicate, ORDINAL ) \
943 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( DefaultMpiComm, split, ORDINAL ) \
944 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( DefaultMpiComm, createSubcommunicator, ORDINAL )
947typedef std::pair<short, short> PairOfShorts;
948typedef std::pair<int,int> PairOfInts;
949typedef std::pair<float,float> PairOfFloats;
950typedef std::pair<double,double> PairOfDoubles;
958#ifdef FAST_DEVELOPMENT_UNIT_TEST_BUILD
960# define UNIT_TEST_GROUP_ORDINAL( ORDINAL ) \
961 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, double) \
962 UNIT_TEST_GROUP_ORDINAL_PAIROFPACKETS(ORDINAL, PairOfDoubles) \
968# define UNIT_TEST_GROUP_ORDINAL( ORDINAL ) \
969 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( DefaultMpiComm, basic, ORDINAL ) \
970 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, short) \
971 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, int) \
972 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, float) \
973 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, double) \
974 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive, ORDINAL) \
975 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive_isReady_true, ORDINAL) \
976 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive_isReady_false, ORDINAL) \
977 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive_isReady_nullIsTrue, ORDINAL) \
978 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, ReadySend1, ORDINAL) \
979 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, ReadySend, ORDINAL) \
980 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive, ORDINAL) \
981 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive_isReady_true, ORDINAL) \
982 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive_isReady_false, ORDINAL) \
983 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive_isReady_nullIsTrue, ORDINAL) \
984 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, ReadySend1, ORDINAL) \
985 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, ReadySend, ORDINAL) \
986 UNIT_TEST_GROUP_ORDINAL_SUBCOMMUNICATORS(ORDINAL)
988# define UNIT_TEST_GROUP_ORDINAL_WITH_PAIRS_AND_QD( ORDINAL ) \
989 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( DefaultMpiComm, basic, ORDINAL ) \
990 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, short) \
991 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, int) \
992 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, float) \
993 UNIT_TEST_GROUP_ORDINAL_PACKET(ORDINAL, double) \
994 UNIT_TEST_GROUP_ORDINAL_QD(ORDINAL) \
995 UNIT_TEST_GROUP_ORDINAL_PAIROFPACKETS(ORDINAL, PairOfShorts) \
996 UNIT_TEST_GROUP_ORDINAL_PAIROFPACKETS(ORDINAL, PairOfInts) \
997 UNIT_TEST_GROUP_ORDINAL_PAIROFPACKETS(ORDINAL, PairOfFloats) \
998 UNIT_TEST_GROUP_ORDINAL_PAIROFPACKETS(ORDINAL, PairOfDoubles) \
999 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive, ORDINAL) \
1000 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive_isReady_true, ORDINAL) \
1001 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive_isReady_false, ORDINAL) \
1002 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, NonblockingSendReceive_isReady_nullIsTrue, ORDINAL) \
1003 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, ReadySend1, ORDINAL) \
1004 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_FLOAT(DefaultMpiComm, ReadySend, ORDINAL) \
1005 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive, ORDINAL) \
1006 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive_isReady_true, ORDINAL) \
1007 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive_isReady_false, ORDINAL) \
1008 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, NonblockingSendReceive_isReady_nullIsTrue, ORDINAL) \
1009 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, ReadySend1, ORDINAL) \
1010 UNIT_TEST_TEMPLATE_2_INSTANT_COMPLEX_DOUBLE(DefaultMpiComm, ReadySend, ORDINAL)
1012 typedef short int ShortInt;
1015 typedef long int LongInt;
1018 typedef long long int LongLongInt;
#define UNIT_TEST_GROUP_ORDINAL(ORDINAL)
#define UNIT_TEST_GROUP_ORDINAL_WITH_PAIRS_AND_QD(ORDINAL)
Implementation of Teuchos wrappers for MPI.
#define TEST_ASSERT(v1)
Assert the given statement is true.
#define TEST_EQUALITY_CONST(v1, v2)
Assert the equality of v1 and constant v2.
#define TEST_EQUALITY(v1, v2)
Assert the equality of v1 and v2.
#define TEST_COMPARE_ARRAYS(a1, a2)
Assert that a1.size()==a2.size() and a[i]==b[i], i=0....
#define ECHO(statement)
Echo the given statement before it is executed.
#define TEUCHOS_STATIC_SETUP()
Run setup code statically in a translation unit.
#define TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL(TEST_GROUP, TEST_NAME, TYPE)
Macro for defining a templated unit test with one template parameter.
#define TEUCHOS_UNIT_TEST_TEMPLATE_2_DECL(TEST_GROUP, TEST_NAME, TYPE1, TYPE2)
Macro for defining a templated unit test with two template parameters.
#define TEUCHOS_UNIT_TEST(TEST_GROUP, TEST_NAME)
Macro for defining a (non-templated) unit test.
Definition of Teuchos::as, for conversions between types.
Reference-counted smart pointer for managing arrays.
Replacement for std::vector that is compatible with the Teuchos Memory Management classes.
Abstract interface for distributed-memory communication.
Class that helps parse command line input arguments from (argc,argv[]) and set options.
void addOutputSetupOptions(const bool &addOutputSetupOptions)
Set if options will be automatically added to setup Teuchos::VerboseObjectBase::getDefaultOStream().
void setOption(const char option_true[], const char option_false[], bool *option_val, const char documentation[]=NULL)
Set a boolean option.
Return a default global communicator appropriate for the build.
static Teuchos::RCP< const Comm< OrdinalType > > getComm()
Return the default global communicator.
Initialize, finalize, and query the global MPI session.
Smart reference counting pointer class for automatic garbage collection.
Concrete serial communicator subclass.
virtual void barrier() const
virtual RCP< Comm< Ordinal > > createSubcommunicator(const ArrayView< const int > &ranks) const
virtual int getSize() const
virtual int getRank() const
static std::string name()
static CommandLineProcessor & getCLP()
Return the CLP to add options to.
static std::pair< Packet, Packet > safeConvert(const ConvertToPacket t)
static std::pair< Packet, Packet > convert(const ConvertToPacket t)
Default traits class for all conversions between value types.
bool is_null(const boost::shared_ptr< T > &p)
Returns true if p.get()==NULL.
bool is_null(const std::shared_ptr< T > &p)
Returns true if p.get()==NULL.
TypeTo as(const TypeFrom &t)
Convert from one value type to another.
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.
RCP< Teuchos::CommRequest< int > > isend(const ArrayRCP< const double > &sendBuffer, const int destRank, const int tag, const Comm< int > &comm)
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Deprecated.
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).
Scalar defaultSmallNumber()
ostream & operator<<(ostream &os, const pair< Packet, Packet > &arg)
static std::string name()
static magnitudeType magnitude(std::pair< Packet, Packet > a)
static std::pair< Packet, Packet > pow(std::pair< Packet, Packet > x, std::pair< Packet, Packet > y)
static std::pair< Packet, Packet > real(std::pair< Packet, Packet > x)
static bool isnaninf(std::pair< Packet, Packet > x)
std::pair< typename PST::magnitudeType, typename PST::magnitudeType > magnitudeType
static std::pair< Packet, Packet > conjugate(std::pair< Packet, Packet > x)
static std::pair< Packet, Packet > random()
ScalarTraits< Packet > PST
static std::pair< Packet, Packet > squareroot(std::pair< Packet, Packet > x)
static void seedrandom(unsigned int s)
static std::pair< Packet, Packet > zero()
static std::pair< Packet, Packet > one()
static std::pair< Packet, Packet > imag(std::pair< Packet, Packet > x)
This structure defines some basic traits for a scalar field type.
static const bool isComparable
Determines if scalar type supports relational operators such as <, >, <=, >=.
static const bool hasMachineParameters
Determines if scalar type have machine-specific parameters (i.e. eps(), sfmin(), base(),...
static const bool isComplex
Determines if scalar type is std::complex.