Kokkos Node API and Local Linear Algebra Kernels Version of the Day
CrsMatrix_DefaultSolve.cpp
00001 //@HEADER
00002 // ************************************************************************
00003 //
00004 //          Kokkos: Node API and Parallel Node Kernels
00005 //              Copyright (2008) Sandia Corporation
00006 //
00007 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
00008 // the U.S. Government retains certain rights in this software.
00009 //
00010 // Redistribution and use in source and binary forms, with or without
00011 // modification, are permitted provided that the following conditions are
00012 // met:
00013 //
00014 // 1. Redistributions of source code must retain the above copyright
00015 // notice, this list of conditions and the following disclaimer.
00016 //
00017 // 2. Redistributions in binary form must reproduce the above copyright
00018 // notice, this list of conditions and the following disclaimer in the
00019 // documentation and/or other materials provided with the distribution.
00020 //
00021 // 3. Neither the name of the Corporation nor the names of the
00022 // contributors may be used to endorse or promote products derived from
00023 // this software without specific prior written permission.
00024 //
00025 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
00026 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00027 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
00028 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
00029 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
00030 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
00031 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
00032 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
00033 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
00034 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
00035 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00036 //
00037 // Questions? Contact Michael A. Heroux (maherou@sandia.gov)
00038 //
00039 // ************************************************************************
00040 //@HEADER
00041 
00042 #include <Teuchos_UnitTestHarness.hpp>
00043 #include <Teuchos_TimeMonitor.hpp>
00044 #include <Teuchos_Time.hpp>
00045 #include <Teuchos_TypeNameTraits.hpp>
00046 #include <Teuchos_ScalarTraits.hpp>
00047 
00048 #include "Kokkos_ConfigDefs.hpp"
00049 #include "Kokkos_DefaultArithmetic.hpp"
00050 #include "Kokkos_DefaultKernels.hpp"
00051 #include "Kokkos_Version.hpp"
00052 
00053 #include "Kokkos_SerialNode.hpp"
00054 #ifdef HAVE_KOKKOS_TBB
00055 #include "Kokkos_TBBNode.hpp"
00056 #endif
00057 #ifdef HAVE_KOKKOS_THREADPOOL
00058 #include "Kokkos_TPINode.hpp"
00059 #endif
00060 #ifdef HAVE_KOKKOS_OPENMP
00061 #include "Kokkos_OpenMPNode.hpp"
00062 #endif
00063 
00064 namespace {
00065 
00066   using Kokkos::MultiVector;
00067   using Kokkos::DefaultArithmetic;
00068   using Kokkos::DefaultKernels;
00069   using Kokkos::SerialNode;
00070   using Teuchos::ArrayRCP;
00071   using Teuchos::RCP;
00072   using Teuchos::rcp;
00073   using Teuchos::null;
00074   using std::endl;
00075 
00076   RCP<SerialNode> snode;
00077 #ifdef HAVE_KOKKOS_TBB
00078   using Kokkos::TBBNode;
00079   RCP<TBBNode> tbbnode;
00080 #endif
00081 #ifdef HAVE_KOKKOS_THREADPOOL
00082   using Kokkos::TPINode;
00083   RCP<TPINode> tpinode;
00084 #endif
00085 #ifdef HAVE_KOKKOS_OPENMP
00086   using Kokkos::OpenMPNode;
00087   RCP<OpenMPNode> ompnode;
00088 #endif
00089 
00090   int N = 1000;
00091 
00092   TEUCHOS_STATIC_SETUP()
00093   {
00094     Teuchos::CommandLineProcessor &clp = Teuchos::UnitTestRepository::getCLP();
00095     clp.addOutputSetupOptions(true);
00096     clp.setOption("test-size",&N,"Vector length for tests.");
00097   }
00098 
00099   template <class Node>
00100   RCP<Node> getNode() {
00101     assert(false);
00102   }
00103 
00104   template <>
00105   RCP<SerialNode> getNode<SerialNode>() {
00106     if (snode == null) {
00107       Teuchos::ParameterList pl;
00108       snode = rcp(new SerialNode(pl));
00109     }
00110     return snode;
00111   }
00112 
00113 #ifdef HAVE_KOKKOS_TBB
00114   template <>
00115   RCP<TBBNode> getNode<TBBNode>() {
00116     if (tbbnode == null) {
00117       Teuchos::ParameterList pl;
00118       pl.set<int>("Num Threads",0);
00119       tbbnode = rcp(new TBBNode(pl));
00120     }
00121     return tbbnode;
00122   }
00123 #endif
00124 
00125 #ifdef HAVE_KOKKOS_THREADPOOL
00126   template <>
00127   RCP<TPINode> getNode<TPINode>() {
00128     if (tpinode == null) {
00129       Teuchos::ParameterList pl;
00130       pl.set<int>("Num Threads",0);
00131       tpinode = rcp(new TPINode(pl));
00132     }
00133     return tpinode;
00134   }
00135 #endif
00136 
00137 #ifdef HAVE_KOKKOS_OPENMP
00138   template <>
00139   RCP<OpenMPNode> getNode<OpenMPNode>() {
00140     if (ompnode == null) {
00141       Teuchos::ParameterList pl;
00142       pl.set<int>("Num Threads",0);
00143       ompnode = rcp(new OpenMPNode(pl));
00144     }
00145     return ompnode;
00146   }
00147 #endif
00148 
00149   //
00150   // UNIT TESTS
00151   //
00152 
00153 #define TEST_DATA_FOR_ONES(dat) {                                               \
00154     ArrayRCP<const Scalar> view = node->template viewBuffer<Scalar>(N,dat);     \
00155     Scalar err = ZERO;                                                          \
00156     for (int i=0; i<N; ++i) {                                                   \
00157       err += ST::magnitude(ONE - view[i]);                                    \
00158     }                                                                           \
00159     TEST_EQUALITY_CONST(err, ZERO);                                             \
00160   }
00161 
00162   TEUCHOS_UNIT_TEST_TEMPLATE_3_DECL( CrsMatrix, SparseSolveIdentityLower, Ordinal, Scalar, Node )
00163   {
00164     RCP<Node> node = getNode<Node>();
00165     typedef typename DefaultKernels<Scalar,Ordinal,Node>::SparseOps          DSM;
00166     typedef typename DSM::template bind_scalar<Scalar>::other_type           OPS;
00167     typedef typename OPS::template matrix<Scalar,Ordinal,Node>::matrix_type  MAT;
00168     typedef typename OPS::template graph<Ordinal,Node>::graph_type          GRPH;
00169     typedef MultiVector<Scalar,Node>                                          MV;
00170     typedef Teuchos::ScalarTraits<Scalar>                                     ST;
00171     const Scalar ONE = ST::one(),
00172                 ZERO = ST::zero();
00173     // generate lower triangular identity matrix:
00174     // [ 1           ]
00175     // [ 0 1         ]
00176     // [   0 1       ]
00177     // [     . .     ]
00178     // [        0 1  ]
00179     // [          0 1]
00180     if (N<2) return;
00181     RCP<GRPH> G = rcp(new GRPH (N,node,null) );
00182     RCP<MAT>  A = rcp(new MAT  (G,null) );
00183     // allocate buffers for ptrs, indices and values
00184     const size_t totalNNZ = 2*N-1;
00185     ArrayRCP<size_t>    ptrs(N+1);
00186     ArrayRCP<Ordinal>   inds(totalNNZ);
00187     ArrayRCP<Scalar>    vals(totalNNZ);
00188     // fill the buffers on the host
00189     {
00190       size_t num = 0;
00191       ptrs[0] = num;
00192       inds[num] = 0;
00193       vals[num] = 1;
00194       num += 1;
00195       for (int i=1; i < N; ++i) {
00196         ptrs[i] = num;
00197         inds[num] = i-1; inds[num+1] = i;
00198         vals[num] = 0; vals[num+1] = 1;
00199         num += 2;
00200       }
00201       ptrs[N] = num;
00202     }
00203     G->setStructure(ptrs, inds);
00204     ptrs = Teuchos::null;
00205     inds = Teuchos::null;
00206     A->setValues(vals);
00207     vals = Teuchos::null;
00208     OPS::finalizeGraphAndMatrix(Teuchos::LOWER_TRI,Teuchos::NON_UNIT_DIAG,*G,*A,null);
00209     Teuchos::EDiag diag;
00210     Teuchos::EUplo uplo;
00211     G->getMatDesc(uplo,diag);
00212     TEST_EQUALITY_CONST( uplo, Teuchos::LOWER_TRI );
00213     TEST_EQUALITY_CONST( diag, Teuchos::NON_UNIT_DIAG );
00214     OPS dsm(node);
00215     out << "Testing with sparse ops: " << Teuchos::typeName(dsm) << std::endl;
00216     dsm.setGraphAndMatrix(G,A);
00217 
00218     // A is the identity, which allows us to easily test transpose and non-transpose, upper and lower tri
00219     ArrayRCP<Scalar> ydat, x1dat, x3dat;
00220     ydat  = node->template allocBuffer<Scalar>(N);
00221     x1dat = node->template allocBuffer<Scalar>(N);
00222     x3dat = node->template allocBuffer<Scalar>(N);
00223     MV Y(node), X1(node), X3(node);
00224     Y.initializeValues(N,1, ydat,N);
00225     X1.initializeValues(N,1,x1dat,N);
00226     X3.initializeValues(N,1,x3dat,N);
00227     // solve A*X=Y
00228     DefaultArithmetic<MV>::Init(Y,1);
00229     dsm.solve(Teuchos::NO_TRANS,Y,X1);
00230     TEST_DATA_FOR_ONES(x1dat)
00231     dsm.solve(Teuchos::CONJ_TRANS,Y,X3);
00232     TEST_DATA_FOR_ONES(x3dat)
00233   }
00234 
00235   TEUCHOS_UNIT_TEST_TEMPLATE_3_DECL( CrsMatrix, SparseSolveImplicitIdentityLower, Ordinal, Scalar, Node )
00236   {
00237     RCP<Node> node = getNode<Node>();
00238     typedef typename DefaultKernels<Scalar,Ordinal,Node>::SparseOps          DSM;
00239     typedef typename DSM::template bind_scalar<Scalar>::other_type           OPS;
00240     typedef typename OPS::template matrix<Scalar,Ordinal,Node>::matrix_type  MAT;
00241     typedef typename OPS::template graph<Ordinal,Node>::graph_type          GRPH;
00242     typedef MultiVector<Scalar,Node>                                          MV;
00243     typedef Teuchos::ScalarTraits<Scalar>                                     ST;
00244     const Scalar ONE = ST::one(),
00245                 ZERO = ST::zero();
00246     // generate lower triangular identity matrix:
00247     // [ 1           ]
00248     // [ 0 1         ]
00249     // [   0 1       ]
00250     // [     . .     ]
00251     // [        0 1  ]
00252     // [          0 1]
00253     // but don't store the diagonal
00254     if (N<2) return;
00255     RCP<GRPH> G = rcp(new GRPH (N,node,null) );
00256     RCP<MAT>  A = rcp(new MAT  (G,null) );
00257     // allocate buffers for ptrs, indices and values
00258     const size_t totalNNZ = N-1;
00259     ArrayRCP<size_t> ptrs(N+1);
00260     ArrayRCP<Ordinal>   inds(totalNNZ);
00261     ArrayRCP<Scalar>    vals(totalNNZ);
00262     // fill the buffers on the host
00263     {
00264       size_t num = 0;
00265       ptrs[0] = num;
00266       for (int i=1; i < N; ++i) {
00267         ptrs[i] = num;
00268         inds[num] = i-1;
00269         vals[num] = 0;
00270         num += 1;
00271       }
00272       ptrs[N] = num;
00273     }
00274     G->setStructure(ptrs, inds);
00275     ptrs = Teuchos::null;
00276     inds = Teuchos::null;
00277     A->setValues(vals);
00278     vals = Teuchos::null;
00279     OPS::finalizeGraphAndMatrix(Teuchos::LOWER_TRI,Teuchos::UNIT_DIAG,*G,*A,null);
00280     Teuchos::EDiag diag;
00281     Teuchos::EUplo uplo;
00282     G->getMatDesc(uplo,diag);
00283     TEST_EQUALITY_CONST( uplo, Teuchos::LOWER_TRI );
00284     TEST_EQUALITY_CONST( diag, Teuchos::UNIT_DIAG );
00285     OPS dsm(node);
00286     out << "Testing with sparse ops: " << Teuchos::typeName(dsm) << std::endl;
00287     dsm.setGraphAndMatrix(G,A);
00288 
00289     // A is the identity, which allows us to easily test transpose and non-transpose, upper and lower tri
00290     ArrayRCP<Scalar> ydat, x1dat, x3dat;
00291     ydat  = node->template allocBuffer<Scalar>(N);
00292     x1dat = node->template allocBuffer<Scalar>(N);
00293     x3dat = node->template allocBuffer<Scalar>(N);
00294     MV Y(node), X1(node), X3(node);
00295     Y.initializeValues(N,1, ydat,N);
00296     X1.initializeValues(N,1,x1dat,N);
00297     X3.initializeValues(N,1,x3dat,N);
00298     // solve A*X=Y
00299     DefaultArithmetic<MV>::Init(Y,1);
00300     dsm.solve(Teuchos::NO_TRANS,Y,X1);
00301     TEST_DATA_FOR_ONES(x1dat)
00302     dsm.solve(Teuchos::CONJ_TRANS,Y,X3);
00303     TEST_DATA_FOR_ONES(x3dat)
00304   }
00305 
00306   TEUCHOS_UNIT_TEST_TEMPLATE_3_DECL( CrsMatrix, SparseSolveIdentityUpper, Ordinal, Scalar, Node )
00307   {
00308     RCP<Node> node = getNode<Node>();
00309     typedef typename DefaultKernels<Scalar,Ordinal,Node>::SparseOps          DSM;
00310     typedef typename DSM::template bind_scalar<Scalar>::other_type           OPS;
00311     typedef typename OPS::template matrix<Scalar,Ordinal,Node>::matrix_type  MAT;
00312     typedef typename OPS::template graph<Ordinal,Node>::graph_type          GRPH;
00313     typedef MultiVector<Scalar,Node>                                          MV;
00314     typedef Teuchos::ScalarTraits<Scalar>                                     ST;
00315     const Scalar ONE = ST::one(),
00316                 ZERO = ST::zero();
00317     // generate upper triangular identity matrix:
00318     // [ 1 0           ]
00319     // [   1 0         ]
00320     // [     1 0       ]
00321     // [         . .   ]
00322     // [            1 0]
00323     // [              1]
00324     if (N<2) return;
00325     RCP<GRPH> G = rcp(new GRPH (N,node,null) );
00326     RCP<MAT>  A = rcp(new MAT  (G,null) );
00327     // allocate buffers for ptrs, indices and values
00328     const size_t totalNNZ = 2*N-1;
00329     ArrayRCP<size_t> ptrs(N+1);
00330     ArrayRCP<Ordinal>   inds(totalNNZ);
00331     ArrayRCP<Scalar>    vals(totalNNZ);
00332     // fill the buffers on the host
00333     {
00334       size_t num = 0;
00335       for (int i=0; i < N-1; ++i) {
00336         ptrs[i] = num;
00337         inds[num] = i; inds[num+1] = i+1;
00338         vals[num] = 1; vals[num+1] = 0;
00339         num += 2;
00340       }
00341       ptrs[N-1] = num;
00342       inds[num] = N-1;
00343       vals[num] = 1;
00344       num += 1;
00345       ptrs[N] = num;
00346     }
00347     G->setStructure(ptrs, inds);
00348     ptrs = Teuchos::null;
00349     inds = Teuchos::null;
00350     A->setValues(vals);
00351     vals = Teuchos::null;
00352     OPS::finalizeGraphAndMatrix(Teuchos::UPPER_TRI,Teuchos::NON_UNIT_DIAG,*G,*A,null);
00353     Teuchos::EDiag diag;
00354     Teuchos::EUplo uplo;
00355     G->getMatDesc(uplo,diag);
00356     TEST_EQUALITY_CONST( uplo, Teuchos::UPPER_TRI );
00357     TEST_EQUALITY_CONST( diag, Teuchos::NON_UNIT_DIAG );
00358     OPS dsm(node);
00359     out << "Testing with sparse ops: " << Teuchos::typeName(dsm) << std::endl;
00360     dsm.setGraphAndMatrix(G,A);
00361 
00362     // A is the identity, which allows us to easily test transpose and non-transpose, upper and lower tri
00363     ArrayRCP<Scalar> ydat, x1dat, x3dat;
00364     ydat  = node->template allocBuffer<Scalar>(N);
00365     x1dat = node->template allocBuffer<Scalar>(N);
00366     x3dat = node->template allocBuffer<Scalar>(N);
00367     MV Y(node), X1(node), X3(node);
00368     Y.initializeValues(N,1, ydat,N);
00369     X1.initializeValues(N,1,x1dat,N);
00370     X3.initializeValues(N,1,x3dat,N);
00371     // solve A*X=Y
00372     DefaultArithmetic<MV>::Init(Y,1);
00373     dsm.solve(Teuchos::NO_TRANS,Y,X1);
00374     TEST_DATA_FOR_ONES(x1dat)
00375     dsm.solve(Teuchos::CONJ_TRANS,Y,X3);
00376     TEST_DATA_FOR_ONES(x3dat)
00377   }
00378 
00379   TEUCHOS_UNIT_TEST_TEMPLATE_3_DECL( CrsMatrix, SparseSolveImplicitIdentityUpper, Ordinal, Scalar, Node )
00380   {
00381     RCP<Node> node = getNode<Node>();
00382     typedef typename DefaultKernels<Scalar,Ordinal,Node>::SparseOps          DSM;
00383     typedef typename DSM::template bind_scalar<Scalar>::other_type           OPS;
00384     typedef typename OPS::template matrix<Scalar,Ordinal,Node>::matrix_type  MAT;
00385     typedef typename OPS::template graph<Ordinal,Node>::graph_type          GRPH;
00386     typedef MultiVector<Scalar,Node>                                          MV;
00387     typedef Teuchos::ScalarTraits<Scalar>                                     ST;
00388     const Scalar ONE = ST::one(),
00389                 ZERO = ST::zero();
00390     // generate upper triangular identity matrix:
00391     // [ 1 0           ]
00392     // [   1 0         ]
00393     // [     1 0       ]
00394     // [         . .   ]
00395     // [            1 0]
00396     // [              1]
00397     // but don't store the diagonal
00398     if (N<2) return;
00399     RCP<GRPH> G = rcp(new GRPH (N,node,null) );
00400     RCP<MAT>  A = rcp(new MAT  (G,null) );
00401     // allocate buffers for ptrs, indices and values
00402     const size_t totalNNZ = N-1;
00403     ArrayRCP<size_t> ptrs(N+1);
00404     ArrayRCP<Ordinal>   inds(totalNNZ);
00405     ArrayRCP<Scalar>    vals(totalNNZ);
00406     // fill the buffers on the host
00407     {
00408       size_t num = 0;
00409       for (int i=0; i < N-1; ++i) {
00410         ptrs[i] = num;
00411         inds[i] = i+1;
00412         vals[i] = 0;
00413         num += 1;
00414       }
00415       ptrs[N-1] = num;
00416       ptrs[N]   = num;
00417     }
00418     G->setStructure(ptrs, inds);
00419     ptrs = Teuchos::null;
00420     inds = Teuchos::null;
00421     A->setValues(vals);
00422     vals = Teuchos::null;
00423     OPS::finalizeGraphAndMatrix(Teuchos::UPPER_TRI,Teuchos::UNIT_DIAG,*G,*A,null);
00424     Teuchos::EDiag diag;
00425     Teuchos::EUplo uplo;
00426     G->getMatDesc(uplo,diag);
00427     TEST_EQUALITY_CONST( uplo, Teuchos::UPPER_TRI );
00428     TEST_EQUALITY_CONST( diag, Teuchos::UNIT_DIAG );
00429     OPS dsm(node);
00430     out << "Testing with sparse ops: " << Teuchos::typeName(dsm) << std::endl;
00431     dsm.setGraphAndMatrix(G,A);
00432 
00433     // A is the identity, which allows us to easily test transpose and non-transpose, upper and lower tri
00434     ArrayRCP<Scalar> ydat, x1dat, x3dat;
00435     ydat  = node->template allocBuffer<Scalar>(N);
00436     x1dat = node->template allocBuffer<Scalar>(N);
00437     x3dat = node->template allocBuffer<Scalar>(N);
00438     MV Y(node), X1(node), X3(node);
00439     Y.initializeValues(N,1, ydat,N);
00440     X1.initializeValues(N,1,x1dat,N);
00441     X3.initializeValues(N,1,x3dat,N);
00442     // solve A*X=Y
00443     DefaultArithmetic<MV>::Init(Y,1);
00444     dsm.solve(Teuchos::NO_TRANS,Y,X1);
00445     TEST_DATA_FOR_ONES(x1dat)
00446     dsm.solve(Teuchos::CONJ_TRANS,Y,X3);
00447     TEST_DATA_FOR_ONES(x3dat)
00448   }
00449 
00450 #define ALL_UNIT_TESTS_ORDINAL_SCALAR_NODE( ORDINAL, SCALAR, NODE ) \
00451       TEUCHOS_UNIT_TEST_TEMPLATE_3_INSTANT( CrsMatrix,          SparseSolveIdentityLower, ORDINAL, SCALAR, NODE ) \
00452       TEUCHOS_UNIT_TEST_TEMPLATE_3_INSTANT( CrsMatrix,          SparseSolveIdentityUpper, ORDINAL, SCALAR, NODE ) \
00453       TEUCHOS_UNIT_TEST_TEMPLATE_3_INSTANT( CrsMatrix,  SparseSolveImplicitIdentityLower, ORDINAL, SCALAR, NODE ) \
00454       TEUCHOS_UNIT_TEST_TEMPLATE_3_INSTANT( CrsMatrix,  SparseSolveImplicitIdentityUpper, ORDINAL, SCALAR, NODE )
00455 
00456 #define UNIT_TEST_SERIALNODE(ORDINAL, SCALAR) \
00457       ALL_UNIT_TESTS_ORDINAL_SCALAR_NODE( ORDINAL, SCALAR, SerialNode )
00458 
00459 #ifdef HAVE_KOKKOS_TBB
00460 #define UNIT_TEST_TBBNODE(ORDINAL, SCALAR) \
00461       ALL_UNIT_TESTS_ORDINAL_SCALAR_NODE( ORDINAL, SCALAR, TBBNode )
00462 #else
00463 #define UNIT_TEST_TBBNODE(ORDINAL, SCALAR)
00464 #endif
00465 
00466 #ifdef HAVE_KOKKOS_OPENMP
00467 #define UNIT_TEST_OPENMPNODE(ORDINAL, SCALAR) \
00468       ALL_UNIT_TESTS_ORDINAL_SCALAR_NODE( ORDINAL, SCALAR, OpenMPNode )
00469 #else
00470 #define UNIT_TEST_OPENMPNODE(ORDINAL, SCALAR)
00471 #endif
00472 
00473 #ifdef HAVE_KOKKOS_THREADPOOL
00474 #define UNIT_TEST_TPINODE(ORDINAL, SCALAR) \
00475       ALL_UNIT_TESTS_ORDINAL_SCALAR_NODE( ORDINAL, SCALAR, TPINode )
00476 #else
00477 #define UNIT_TEST_TPINODE(ORDINAL, SCALAR)
00478 #endif
00479 
00480 #define UNIT_TEST_GROUP_ORDINAL_SCALAR( ORDINAL, SCALAR ) \
00481         UNIT_TEST_SERIALNODE( ORDINAL, SCALAR ) \
00482         UNIT_TEST_TBBNODE( ORDINAL, SCALAR ) \
00483         UNIT_TEST_OPENMPNODE( ORDINAL, SCALAR ) \
00484         UNIT_TEST_TPINODE( ORDINAL, SCALAR )
00485 
00486 #define UNIT_TEST_GROUP_ORDINAL( ORDINAL ) \
00487         UNIT_TEST_GROUP_ORDINAL_SCALAR(ORDINAL, int) \
00488         UNIT_TEST_GROUP_ORDINAL_SCALAR(ORDINAL, float)
00489 
00490      UNIT_TEST_GROUP_ORDINAL(int)
00491      typedef short int ShortInt; UNIT_TEST_GROUP_ORDINAL(ShortInt)
00492 
00493 }
00494 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends