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