void EpetraCrsMatrixT<EpetraGlobalOrdinal>::setAllValues(const ArrayRCP<size_t>& rowptr, const ArrayRCP<LocalOrdinal>& colind, const ArrayRCP<Scalar>& values) { XPETRA_MONITOR("EpetraCrsMatrixT::setAllValues"); // Check sizes TEUCHOS_TEST_FOR_EXCEPTION(Teuchos::as<size_t>(rowptr.size()) != getNodeNumRows()+1, Xpetra::Exceptions::RuntimeError, "An exception is thrown to let you know that the size of your rowptr array is incorrect."); TEUCHOS_TEST_FOR_EXCEPTION(values.size() != colind.size(), Xpetra::Exceptions::RuntimeError, "An exception is thrown to let you know that you mismatched your pointers."); // Check pointers if (values.size() > 0) { TEUCHOS_TEST_FOR_EXCEPTION(colind.getRawPtr() != mtx_->ExpertExtractIndices().Values(), Xpetra::Exceptions::RuntimeError, "An exception is thrown to let you know that you mismatched your pointers."); TEUCHOS_TEST_FOR_EXCEPTION(values.getRawPtr() != mtx_->ExpertExtractValues(), Xpetra::Exceptions::RuntimeError, "An exception is thrown to let you know that you mismatched your pointers."); } // We have to make a copy here, it is unavoidable // See comments in allocateAllValues const size_t N = getNodeNumRows(); Epetra_IntSerialDenseVector& myRowptr = mtx_->ExpertExtractIndexOffset(); myRowptr.Resize(N+1); for (size_t i = 0; i < N+1; i++) myRowptr[i] = Teuchos::as<int>(rowptr[i]); }
template <class T> inline void CUDANodeMemoryModel::copyBuffers(size_t size, const ArrayRCP<const T> &buffSrc, const ArrayRCP<T> &buffDest) { CHECK_COMPUTE_BUFFER(buffSrc); CHECK_COMPUTE_BUFFER(buffDest); TEUCHOS_TEST_FOR_EXCEPTION( (size_t)buffDest.size() < size, std::runtime_error, "CUDANodeMemoryModel::copyBuffers<" << Teuchos::TypeNameTraits<T>::name () << ">: invalid copy. Device destination buffer has size " << buffDest.size () << ", which is less than the requested copy size " << size << "."); TEUCHOS_TEST_FOR_EXCEPTION( (size_t)buffSrc.size() < size, std::runtime_error, "CUDANodeMemoryModel::copyBuffers<" << Teuchos::TypeNameTraits<T>::name () << ">: invalid copy. Device source buffer has size " << buffSrc.size () << ", which is less than the requested copy size " << size << "."); #ifdef HAVE_KOKKOSCLASSIC_CUDA_NODE_MEMORY_PROFILING ++numCopiesD2D_; bytesCopiedD2D_ += size*sizeof(T); #endif #ifdef HAVE_KOKKOSCLASSIC_CUDA_NODE_MEMORY_TRACE std::cerr << "copyBuffers<" << Teuchos::TypeNameTraits<T>::name() << "> of size " << sizeof(T) * size << std::endl; #endif cudaError_t err = cudaMemcpy( buffDest.getRawPtr(), buffSrc.getRawPtr(), size*sizeof(T), cudaMemcpyDeviceToDevice); TEUCHOS_TEST_FOR_EXCEPTION( cudaSuccess != err, std::runtime_error, "Kokkos::CUDANodeMemoryModel::copyBuffers<" << Teuchos::TypeNameTraits<T>::name () << ">(): cudaMemcpy() returned error: " << cudaGetErrorString (err) ); }
Teuchos::RCP<const Epetra_MultiVector> Thyra::get_Epetra_MultiVector( const Epetra_Map &map, const MultiVectorBase<double> &mv ) { using Teuchos::rcpWithEmbeddedObj; using Teuchos::rcpFromRef; using Teuchos::outArg; ArrayRCP<const double> mvData; Ordinal mvLeadingDim = -1; const SpmdMultiVectorBase<double> *mvSpmdMv = 0; const SpmdVectorBase<double> *mvSpmdV = 0; if ((mvSpmdMv = dynamic_cast<const SpmdMultiVectorBase<double>*>(&mv))) { mvSpmdMv->getLocalData(outArg(mvData), outArg(mvLeadingDim)); } else if ((mvSpmdV = dynamic_cast<const SpmdVectorBase<double>*>(&mv))) { mvSpmdV->getLocalData(outArg(mvData)); mvLeadingDim = mvSpmdV->spmdSpace()->localSubDim(); } if (nonnull(mvData)) { return rcpWithEmbeddedObj( new Epetra_MultiVector( ::View,map, const_cast<double*>(mvData.getRawPtr()), mvLeadingDim, mv.domain()->dim() ), mvData ); } return ::Thyra::get_Epetra_MultiVector(map, rcpFromRef(mv)); }
void gathervPrint (std::ostream& out, const std::string& s, const Teuchos::Comm<int>& comm) { using Teuchos::ArrayRCP; using Teuchos::CommRequest; using Teuchos::ireceive; using Teuchos::isend; using Teuchos::outArg; using Teuchos::RCP; using Teuchos::wait; const int myRank = comm.getRank (); const int rootRank = 0; if (myRank == rootRank) { out << s; // Proc 0 prints its buffer first } const int numProcs = comm.getSize (); const int sizeTag = 42; const int msgTag = 43; ArrayRCP<size_t> sizeBuf (1); ArrayRCP<char> msgBuf; // to be resized later RCP<CommRequest<int> > req; for (int p = 1; p < numProcs; ++p) { if (myRank == p) { sizeBuf[0] = s.size (); req = isend<int, size_t> (sizeBuf, rootRank, sizeTag, comm); (void) wait<int> (comm, outArg (req)); const size_t msgSize = s.size (); msgBuf.resize (msgSize + 1); // for the '\0' std::copy (s.begin (), s.end (), msgBuf.begin ()); msgBuf[msgSize] = '\0'; req = isend<int, char> (msgBuf, rootRank, msgTag, comm); (void) wait<int> (comm, outArg (req)); } else if (myRank == rootRank) { sizeBuf[0] = 0; // just a precaution req = ireceive<int, size_t> (sizeBuf, p, sizeTag, comm); (void) wait<int> (comm, outArg (req)); const size_t msgSize = sizeBuf[0]; msgBuf.resize (msgSize + 1); // for the '\0' req = ireceive<int, char> (msgBuf, p, msgTag, comm); (void) wait<int> (comm, outArg (req)); std::string msg (msgBuf.getRawPtr ()); out << msg; } } }
int main(int argc, char *argv[]) { Teuchos::GlobalMPISession session(&argc, &argv); RCP<const Comm<int> > comm = Teuchos::DefaultComm<int>::getComm(); int rank = comm->getRank(); Teuchos::RCP<Teuchos::FancyOStream> outStream = Teuchos::VerboseObjectBase::getDefaultOStream(); Teuchos::EVerbosityLevel v=Teuchos::VERB_EXTREME; typedef Tpetra::CrsMatrix<zscalar_t,zlno_t,zgno_t,znode_t> tmatrix_t; typedef Tpetra::CrsGraph<zlno_t,zgno_t,znode_t> tgraph_t; typedef Tpetra::Vector<zscalar_t,zlno_t,zgno_t,znode_t> tvector_t; typedef Tpetra::MultiVector<zscalar_t,zlno_t,zgno_t,znode_t> tmvector_t; typedef Xpetra::CrsMatrix<zscalar_t,zlno_t,zgno_t,znode_t> xmatrix_t; typedef Xpetra::CrsGraph<zlno_t,zgno_t,znode_t> xgraph_t; typedef Xpetra::Vector<zscalar_t,zlno_t,zgno_t,znode_t> xvector_t; typedef Xpetra::MultiVector<zscalar_t,zlno_t,zgno_t,znode_t> xmvector_t; typedef Xpetra::TpetraMap<zlno_t,zgno_t,znode_t> xtmap_t; // Create object that can give us test Tpetra and Xpetra input. RCP<UserInputForTests> uinput; try{ uinput = rcp(new UserInputForTests(testDataFilePath,std::string("simple"), comm, true)); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string("input ")+e.what(), 1); } ///////////////////////////////////////////////////////////////// // Tpetra::CrsMatrix // Tpetra::CrsGraph // Tpetra::Vector // Tpetra::MultiVector ///////////////////////////////////////////////////////////////// // XpetraTraits<Tpetra::CrsMatrix<zscalar_t, zlno_t, zgno_t, znode_t> > { RCP<tmatrix_t> M; try{ M = uinput->getUITpetraCrsMatrix(); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string("getTpetraCrsMatrix ")+e.what(), 1); } if (rank== 0) std::cout << "Original Tpetra matrix " << M->getGlobalNumRows() << " x " << M->getGlobalNumCols() << std::endl; M->describe(*outStream,v); RCP<const xtmap_t> xmap(new xtmap_t(M->getRowMap())); ArrayRCP<zgno_t> newRowIds = roundRobinMap(xmap); zgno_t localNumRows = newRowIds.size(); RCP<const tmatrix_t> newM; try{ newM = Zoltan2::XpetraTraits<tmatrix_t>::doMigration(*M, localNumRows, newRowIds.getRawPtr()); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string(" Zoltan2::XpetraTraits<tmatrix_t>::doMigration ")+e.what(), 1); } if (rank== 0) std::cout << "Migrated Tpetra matrix" << std::endl; newM->describe(*outStream,v); } // XpetraTraits<Tpetra::CrsGraph<zscalar_t, zlno_t, zgno_t, znode_t> > { RCP<tgraph_t> G; try{ G = uinput->getUITpetraCrsGraph(); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string("getTpetraCrsGraph ")+e.what(), 1); } if (rank== 0) std::cout << "Original Tpetra graph" << std::endl; G->describe(*outStream,v); RCP<const xtmap_t> xmap(new xtmap_t(G->getRowMap())); ArrayRCP<zgno_t> newRowIds = roundRobinMap(xmap); zgno_t localNumRows = newRowIds.size(); RCP<const tgraph_t> newG; try{ newG = Zoltan2::XpetraTraits<tgraph_t>::doMigration(*G, localNumRows, newRowIds.getRawPtr()); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string(" Zoltan2::XpetraTraits<tgraph_t>::doMigration ")+e.what(), 1); } if (rank== 0) std::cout << "Migrated Tpetra graph" << std::endl; newG->describe(*outStream,v); } // XpetraTraits<Tpetra::Vector<zscalar_t, zlno_t, zgno_t, znode_t>> { RCP<tvector_t> V; try{ V = rcp(new tvector_t(uinput->getUITpetraCrsGraph()->getRowMap(), 1)); V->randomize(); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string("getTpetraVector")+e.what(), 1); } if (rank== 0) std::cout << "Original Tpetra vector" << std::endl; V->describe(*outStream,v); RCP<const xtmap_t> xmap(new xtmap_t(V->getMap())); ArrayRCP<zgno_t> newRowIds = roundRobinMap(xmap); zgno_t localNumRows = newRowIds.size(); RCP<const tvector_t> newV; try{ newV = Zoltan2::XpetraTraits<tvector_t>::doMigration(*V, localNumRows, newRowIds.getRawPtr()); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string(" Zoltan2::XpetraTraits<tvector_t>::doMigration ")+e.what(), 1); } if (rank== 0) std::cout << "Migrated Tpetra vector" << std::endl; newV->describe(*outStream,v); } // XpetraTraits<Tpetra::MultiVector<zscalar_t, zlno_t, zgno_t, znode_t>> { RCP<tmvector_t> MV; try{ MV = rcp(new tmvector_t(uinput->getUITpetraCrsGraph()->getRowMap(), 3)); MV->randomize(); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string("getTpetraMultiVector")+e.what(), 1); } if (rank== 0) std::cout << "Original Tpetra multivector" << std::endl; MV->describe(*outStream,v); RCP<const xtmap_t> xmap(new xtmap_t(MV->getMap())); ArrayRCP<zgno_t> newRowIds = roundRobinMap(xmap); zgno_t localNumRows = newRowIds.size(); RCP<const tmvector_t> newMV; try{ newMV = Zoltan2::XpetraTraits<tmvector_t>::doMigration(*MV, localNumRows, newRowIds.getRawPtr()); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string(" Zoltan2::XpetraTraits<tmvector_t>::doMigration ")+e.what(), 1); } if (rank== 0) std::cout << "Migrated Tpetra multivector" << std::endl; newMV->describe(*outStream,v); } ///////////////////////////////////////////////////////////////// // Xpetra::CrsMatrix // Xpetra::CrsGraph // Xpetra::Vector // Xpetra::MultiVector ///////////////////////////////////////////////////////////////// // XpetraTraits<Xpetra::CrsMatrix<zscalar_t, zlno_t, zgno_t, znode_t> > { RCP<xmatrix_t> M; try{ M = uinput->getUIXpetraCrsMatrix(); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string("getXpetraCrsMatrix ")+e.what(), 1); } if (rank== 0) std::cout << "Original Xpetra matrix" << std::endl; M->describe(*outStream,v); ArrayRCP<zgno_t> newRowIds = roundRobinMap(M->getRowMap()); zgno_t localNumRows = newRowIds.size(); RCP<const xmatrix_t> newM; try{ newM = Zoltan2::XpetraTraits<xmatrix_t>::doMigration(*M, localNumRows, newRowIds.getRawPtr()); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string(" Zoltan2::XpetraTraits<xmatrix_t>::doMigration ")+e.what(), 1); } if (rank== 0) std::cout << "Migrated Xpetra matrix" << std::endl; newM->describe(*outStream,v); } // XpetraTraits<Xpetra::CrsGraph<zscalar_t, zlno_t, zgno_t, znode_t> > { RCP<xgraph_t> G; try{ G = uinput->getUIXpetraCrsGraph(); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string("getXpetraCrsGraph ")+e.what(), 1); } if (rank== 0) std::cout << "Original Xpetra graph" << std::endl; G->describe(*outStream,v); ArrayRCP<zgno_t> newRowIds = roundRobinMap(G->getRowMap()); zgno_t localNumRows = newRowIds.size(); RCP<const xgraph_t> newG; try{ newG = Zoltan2::XpetraTraits<xgraph_t>::doMigration(*G, localNumRows, newRowIds.getRawPtr()); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string(" Zoltan2::XpetraTraits<xgraph_t>::doMigration ")+e.what(), 1); } if (rank== 0) std::cout << "Migrated Xpetra graph" << std::endl; newG->describe(*outStream,v); } // XpetraTraits<Xpetra::Vector<zscalar_t, zlno_t, zgno_t, znode_t>> { RCP<xvector_t> V; try{ RCP<tvector_t> tV = rcp(new tvector_t(uinput->getUITpetraCrsGraph()->getRowMap(), 1)); tV->randomize(); V = Zoltan2::XpetraTraits<tvector_t>::convertToXpetra(tV); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string("getXpetraVector")+e.what(), 1); } if (rank== 0) std::cout << "Original Xpetra vector" << std::endl; V->describe(*outStream,v); ArrayRCP<zgno_t> newRowIds = roundRobinMap(V->getMap()); zgno_t localNumRows = newRowIds.size(); RCP<const xvector_t> newV; try{ newV = Zoltan2::XpetraTraits<xvector_t>::doMigration(*V, localNumRows, newRowIds.getRawPtr()); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string(" Zoltan2::XpetraTraits<xvector_t>::doMigration ")+e.what(), 1); } if (rank== 0) std::cout << "Migrated Xpetra vector" << std::endl; newV->describe(*outStream,v); } // XpetraTraits<Xpetra::MultiVector<zscalar_t, zlno_t, zgno_t, znode_t>> { RCP<xmvector_t> MV; try{ RCP<tmvector_t> tMV = rcp(new tmvector_t(uinput->getUITpetraCrsGraph()->getRowMap(), 3)); tMV->randomize(); MV = Zoltan2::XpetraTraits<tmvector_t>::convertToXpetra(tMV); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string("getXpetraMultiVector")+e.what(), 1); } if (rank== 0) std::cout << "Original Xpetra multivector" << std::endl; MV->describe(*outStream,v); ArrayRCP<zgno_t> newRowIds = roundRobinMap(MV->getMap()); zgno_t localNumRows = newRowIds.size(); RCP<const xmvector_t> newMV; try{ newMV = Zoltan2::XpetraTraits<xmvector_t>::doMigration(*MV, localNumRows, newRowIds.getRawPtr()); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string(" Zoltan2::XpetraTraits<xmvector_t>::doMigration ")+e.what(), 1); } if (rank== 0) std::cout << "Migrated Xpetra multivector" << std::endl; newMV->describe(*outStream,v); } #ifdef HAVE_EPETRA_DATA_TYPES ///////////////////////////////////////////////////////////////// // Epetra_CrsMatrix // Epetra_CrsGraph // Epetra_Vector // Epetra_MultiVector ///////////////////////////////////////////////////////////////// typedef Epetra_CrsMatrix ematrix_t; typedef Epetra_CrsGraph egraph_t; typedef Epetra_Vector evector_t; typedef Epetra_MultiVector emvector_t; typedef Xpetra::EpetraMap xemap_t; typedef Epetra_BlockMap emap_t; // Create object that can give us test Epetra input. RCP<UserInputForTests> euinput; try{ euinput = rcp(new UserInputForTests(testDataFilePath,std::string("simple"), comm, true)); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string("epetra input ")+e.what(), 1); } // XpetraTraits<Epetra_CrsMatrix> { RCP<ematrix_t> M; try{ M = euinput->getUIEpetraCrsMatrix(); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string("getEpetraCrsMatrix ")+e.what(), 1); } if (rank== 0) std::cout << "Original Epetra matrix" << std::endl; M->Print(std::cout); RCP<const emap_t> emap = Teuchos::rcpFromRef(M->RowMap()); RCP<const xemap_t> xmap(new xemap_t(emap)); ArrayRCP<zgno_t> newRowIds = roundRobinMap(xmap); zgno_t localNumRows = newRowIds.size(); RCP<const ematrix_t> newM; try{ newM = Zoltan2::XpetraTraits<ematrix_t>::doMigration(*M, localNumRows, newRowIds.getRawPtr()); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string(" Zoltan2::XpetraTraits<ematrix_t>::doMigration ")+e.what(), 1); } if (rank== 0) std::cout << "Migrated Epetra matrix" << std::endl; newM->Print(std::cout); } // XpetraTraits<Epetra_CrsGraph> { RCP<egraph_t> G; try{ G = euinput->getUIEpetraCrsGraph(); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string("getEpetraCrsGraph ")+e.what(), 1); } if (rank== 0) std::cout << "Original Epetra graph" << std::endl; G->Print(std::cout); RCP<const emap_t> emap = Teuchos::rcpFromRef(G->RowMap()); RCP<const xemap_t> xmap(new xemap_t(emap)); ArrayRCP<zgno_t> newRowIds = roundRobinMap(xmap); zgno_t localNumRows = newRowIds.size(); RCP<const egraph_t> newG; try{ newG = Zoltan2::XpetraTraits<egraph_t>::doMigration(*G, localNumRows, newRowIds.getRawPtr()); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string(" Zoltan2::XpetraTraits<egraph_t>::doMigration ")+e.what(), 1); } if (rank== 0) std::cout << "Migrated Epetra graph" << std::endl; newG->Print(std::cout); } // XpetraTraits<Epetra_Vector> { RCP<evector_t> V; try{ V = rcp(new Epetra_Vector(euinput->getUIEpetraCrsGraph()->RowMap())); V->Random(); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string("getEpetraVector")+e.what(), 1); } if (rank== 0) std::cout << "Original Epetra vector" << std::endl; V->Print(std::cout); RCP<const emap_t> emap = Teuchos::rcpFromRef(V->Map()); RCP<const xemap_t> xmap(new xemap_t(emap)); ArrayRCP<zgno_t> newRowIds = roundRobinMap(xmap); zgno_t localNumRows = newRowIds.size(); RCP<const evector_t> newV; try{ newV = Zoltan2::XpetraTraits<evector_t>::doMigration(*V, localNumRows, newRowIds.getRawPtr()); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string(" Zoltan2::XpetraTraits<evector_t>::doMigration ")+e.what(), 1); } if (rank== 0) std::cout << "Migrated Epetra vector" << std::endl; newV->Print(std::cout); } // XpetraTraits<Epetra_MultiVector> { RCP<emvector_t> MV; try{ MV = rcp(new Epetra_MultiVector(euinput->getUIEpetraCrsGraph()->RowMap(),3)); MV->Random(); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string("getEpetraMultiVector")+e.what(), 1); } if (rank== 0) std::cout << "Original Epetra multivector" << std::endl; MV->Print(std::cout); RCP<const emap_t> emap = Teuchos::rcpFromRef(MV->Map()); RCP<const xemap_t> xmap(new xemap_t(emap)); ArrayRCP<zgno_t> newRowIds = roundRobinMap(xmap); zgno_t localNumRows = newRowIds.size(); RCP<const emvector_t> newMV; try{ newMV = Zoltan2::XpetraTraits<emvector_t>::doMigration(*MV, localNumRows, newRowIds.getRawPtr()); } catch(std::exception &e){ TEST_FAIL_AND_EXIT(*comm, 0, string(" Zoltan2::XpetraTraits<emvector_t>::doMigration ")+e.what(), 1); } if (rank== 0) std::cout << "Migrated Epetra multivector" << std::endl; newMV->Print(std::cout); } #endif // have epetra data types (int, int, double) ///////////////////////////////////////////////////////////////// // DONE ///////////////////////////////////////////////////////////////// if (rank==0) std::cout << "PASS" << std::endl; }
ArrayView<const T>::ArrayView( const ArrayRCP<const T> &arcp ) : ptr_(arcp.getRawPtr()), size_(arcp.size()), arcp_(arcp) {}