int main(int argc, char *argv[])
{
int total_err=0;
// Initialize MPI
MPI_Init(&argc,&argv);
int rank; // My process ID
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
Epetra_MpiComm Comm( MPI_COMM_WORLD );
bool verbose = false;
// Check if we should print results to standard out
if (argc>1) if (argv[1][0]=='-' && argv[1][1]=='v') verbose = true;
int verbose_int = verbose ? 1 : 0;
Comm.Broadcast(&verbose_int, 1, 0);
verbose = verbose_int==1 ? true : false;
Comm.SetTracebackMode(0); // This should shut down any error traceback reporting
int MyPID = Comm.MyPID();
int NumProc = Comm.NumProc();
if(verbose && MyPID==0)
cout << Epetra_Version() << std::endl << std::endl;
if (verbose) cout << "Processor "<<MyPID<<" of "<< NumProc
<< " is alive."<<endl;
// Redefine verbose to only print on PE 0
if(verbose && rank!=0) verbose = false;
// Matrix & Map pointers
Epetra_CrsMatrix *A, *B, *C;
Epetra_Map* Map1;
Epetra_Import* Import1;
Epetra_Export* Export1;
double diff_tol=1e-12;
#define ENABLE_TEST_1
#define ENABLE_TEST_2
#define ENABLE_TEST_3
#define ENABLE_TEST_4
#define ENABLE_TEST_5
#define ENABLE_TEST_6
/////////////////////////////////////////////////////////
// Test #1: Tridiagonal Matrix; Migrate to Proc 0
/////////////////////////////////////////////////////////
#ifdef ENABLE_TEST_1
{
double diff;
build_test_matrix(Comm,1,A);
int num_global = A->RowMap().NumGlobalElements();
// New map with all on Proc1
if(MyPID==0) Map1=new Epetra_Map(num_global,num_global,0,Comm);
else Map1=new Epetra_Map(num_global,0,0,Comm);
// Execute fused import constructor
Import1 = new Epetra_Import(*Map1,A->RowMap());
B=new Epetra_CrsMatrix(*A,*Import1,0,&A->RangeMap());
diff=test_with_matvec(*A,*B);
if(diff > diff_tol){
if(MyPID==0) cout<<"FusedImport: Test #1 FAILED with norm diff = "<<diff<<"."<<endl;
total_err--;
}
// Execute fused export constructor
delete B;
Export1 = new Epetra_Export(A->RowMap(),*Map1);
B=new Epetra_CrsMatrix(*A,*Export1,0,&A->RangeMap());
diff=test_with_matvec(*A,*B);
if(diff > diff_tol){
if(MyPID==0) cout<<"FusedExport: Test #1 FAILED with norm diff = "<<diff<<"."<<endl;
total_err--;
}
delete A; delete B; delete Map1; delete Import1; delete Export1;
}
#endif
/////////////////////////////////////////////////////////
// Test #2: Tridiagonal Matrix; Locally Reversed Map
/////////////////////////////////////////////////////////
#ifdef ENABLE_TEST_2
{
double diff;
build_test_matrix(Comm,1,A);
int num_local = A->RowMap().NumMyElements();
std::vector<int> MyGIDS(num_local);
for(int i=0; i<num_local; i++)
MyGIDS[i] = A->RowMap().GID(num_local-i-1);
// New map with all on Proc1
Map1=new Epetra_Map(-1,num_local,&MyGIDS[0],0,Comm);
// Execute fused import constructor
Import1 = new Epetra_Import(*Map1,A->RowMap());
B=new Epetra_CrsMatrix(*A,*Import1,0,&A->RangeMap());
diff=test_with_matvec(*A,*B);
if(diff > diff_tol){
if(MyPID==0) cout<<"FusedImport: Test #2 FAILED with norm diff = "<<diff<<"."<<endl;
total_err--;
}
// Execute fused export constructor
delete B;
Export1 = new Epetra_Export(A->RowMap(),*Map1);
B=new Epetra_CrsMatrix(*A,*Export1,0,&A->RangeMap());
diff=test_with_matvec(*A,*B);
if(diff > diff_tol){
if(MyPID==0) cout<<"FusedExport: Test #2 FAILED with norm diff = "<<diff<<"."<<endl;
total_err--;
}
delete A; delete B; delete Map1; delete Import1; delete Export1;
}
#endif
/////////////////////////////////////////////////////////
// Test #3: Tridiagonal Matrix; Globally Reversed Map
/////////////////////////////////////////////////////////
#ifdef ENABLE_TEST_3
{
double diff;
build_test_matrix(Comm,1,A);
int num_local = A->RowMap().NumMyElements();
int num_global = A->RowMap().NumGlobalElements();
int num_scansum = 0;
Comm.ScanSum(&num_local,&num_scansum,1);
// New Map
std::vector<int> MyGIDS(num_local);
for(int i=0; i<num_local; i++)
MyGIDS[i] = num_global - num_scansum + num_local - i - 1;
Map1=new Epetra_Map(-1,num_local,&MyGIDS[0],0,Comm);
// Execute fused import constructor
Import1 = new Epetra_Import(*Map1,A->RowMap());
B=new Epetra_CrsMatrix(*A,*Import1,0,&A->RangeMap());
diff=test_with_matvec(*A,*B);
if(diff > diff_tol){
if(MyPID==0) cout<<"FusedImport: Test #3 FAILED with norm diff = "<<diff<<"."<<endl;
total_err--;
}
// Execute fused export constructor
delete B;
Export1 = new Epetra_Export(A->RowMap(),*Map1);
B=new Epetra_CrsMatrix(*A,*Export1,0,&A->RangeMap());
diff=test_with_matvec(*A,*B);
if(diff > diff_tol){
if(MyPID==0) cout<<"FusedExport: Test #3 FAILED with norm diff = "<<diff<<"."<<endl;
total_err--;
}
delete A; delete B; delete Map1; delete Import1; delete Export1;
}
#endif
/////////////////////////////////////////////////////////
// Test #4: Tridiagonal Matrix; MMM style halo import
/////////////////////////////////////////////////////////
#ifdef ENABLE_TEST_4
{
double diff;
build_test_matrix(Comm,1,A);
// Assume we always own the diagonal
int num_local = A->NumMyCols()-A->NumMyRows();
std::vector<int> MyGIDS(num_local);
for(int i=0, idx=0; i<A->NumMyCols(); i++)
if(A->LRID(A->GCID(i)) == -1){
MyGIDS[idx] = A->GCID(i);
idx++;
}
// New map
const int * MyGIDS_ptr = MyGIDS.size() ? &MyGIDS[0] : 0;
Map1=new Epetra_Map(-1,num_local,MyGIDS_ptr,0,Comm);
// Execute fused import constructor
Import1 = new Epetra_Import(*Map1,A->RowMap());
B=new Epetra_CrsMatrix(*A,*Import1,0,&A->RangeMap());
// Build unfused matrix to compare
C=new Epetra_CrsMatrix(Copy,*Map1,0);
build_matrix_unfused(*A,*Import1,C);
diff=test_with_matvec(*B,*C);
if(diff > diff_tol){
if(MyPID==0) cout<<"FusedImport: Test #4 FAILED with norm diff = "<<diff<<"."<<endl;
total_err--;
}
// Execute fused export constructor
delete B;
Export1 = new Epetra_Export(A->RowMap(),*Map1);
B=new Epetra_CrsMatrix(*A,*Export1,0,&A->RangeMap());
diff=test_with_matvec(*B,*C);
if(diff > diff_tol){
if(MyPID==0) cout<<"FusedExport: Test #4 FAILED with norm diff = "<<diff<<"."<<endl;
total_err--;
}
delete A; delete B; delete C; delete Map1; delete Import1; delete Export1;
}
#endif
/////////////////////////////////////////////////////////
// Test 5: Tridiagonal Matrix; Migrate to Proc 0, Replace Maps
/////////////////////////////////////////////////////////
#ifdef ENABLE_TEST_5
{
double diff;
build_test_matrix(Comm,1,A);
// New map with all on Procs 0 and 2
build_test_map(A->RowMap(),Map1);
// Execute fused import constructor
Import1 = new Epetra_Import(*Map1,A->RowMap());
B=new Epetra_CrsMatrix(*A,*Import1,Map1,Map1);
diff=test_with_matvec(*A,*B);
if(diff > diff_tol){
if(MyPID==0) cout<<"FusedImport: Test #5 FAILED with norm diff = "<<diff<<"."<<endl;
total_err--;
}
// Execute fused export constructor
delete B;
Export1 = new Epetra_Export(A->RowMap(),*Map1);
B=new Epetra_CrsMatrix(*A,*Export1,Map1,Map1);
diff=test_with_matvec(*A,*B);
if(diff > diff_tol){
if(MyPID==0) cout<<"FusedExport: Test #5 FAILED with norm diff = "<<diff<<"."<<endl;
total_err--;
}
delete A; delete B; delete Map1; delete Import1; delete Export1;
}
#endif
/////////////////////////////////////////////////////////
// Test 6: Tridiagonal Matrix; Migrate to Proc 0, Replace Comm
/////////////////////////////////////////////////////////
#ifdef ENABLE_TEST_6
{
double diff;
build_test_matrix(Comm,1,A);
// New map with all on Procs 0 and 2
build_test_map(A->RowMap(),Map1);
// Execute fused import constructor
Import1 = new Epetra_Import(*Map1,A->RowMap());
B=new Epetra_CrsMatrix(*A,*Import1,Map1,Map1,true);
diff=test_with_matvec_reduced_maps(*A,*B,*Map1);
if(diff > diff_tol){
if(MyPID==0) cout<<"FusedImport: Test #6 FAILED with norm diff = "<<diff<<"."<<endl;
total_err--;
}
// Execute fused export constructor
delete B;
Export1 = new Epetra_Export(A->RowMap(),*Map1);
B=new Epetra_CrsMatrix(*A,*Export1,Map1,Map1,true);
diff=test_with_matvec_reduced_maps(*A,*B,*Map1);
if(diff > diff_tol){
if(MyPID==0) cout<<"FusedExport: Test #6 FAILED with norm diff = "<<diff<<"."<<endl;
total_err--;
}
delete A; delete B; delete Map1; delete Import1; delete Export1;
}
#endif
// Final output for OK
if(MyPID==0 && total_err==0)
cout<<"FusedImportExport: All tests PASSED."<<endl;
// Cleanup
MPI_Finalize();
return total_err ;
}
int main (int argc, char* argv[]) {
int n;
double *b;
Cel *A = NULL;
FILE *input;
char opt;
/* Tratamento da entrada */
if(argc < 2) {
error(NO_OPTION);
}
else {
opt = argv[1][0];
switch(opt) {
case '1':
n = MATRIX_TEST_SIZE;
A = malloc_matrix(n);
b = malloc_vector(n);
build_test_matrix(A,0.01,n);
build_test_vector(b,n);
conjugate_gradient(A,b,n);
free_matrix(n,A);
free(b);
break;
case '2':
n = MATRIX_TEST_SIZE;
A = malloc_matrix(n);
b = malloc_vector(n);
build_test_matrix(A,0.05,n);
build_test_vector(b,n);
conjugate_gradient(A,b,n);
free_matrix(n,A);
free(b);
break;
case '3':
n = MATRIX_TEST_SIZE;
A = malloc_matrix(n);
b = malloc_vector(n);
build_test_matrix(A,0.1,n);
build_test_vector(b,n);
conjugate_gradient(A,b,n);
free_matrix(n,A);
free(b);
break;
case '4':
n = MATRIX_TEST_SIZE;
A = malloc_matrix(n);
b = malloc_vector(n);
build_test_matrix(A,0.3,n);
build_test_vector(b,n);
conjugate_gradient(A,b,n);
free_matrix(n,A);
free(b);
break;
case 'r':
if(argc < 3) error(NO_FILE);
else {
input = fopen(argv[2],"r");
if(input == NULL) error(OPENING_FILE);
n = read_dimension(input);
A = malloc_matrix(n);
b = malloc_vector(n);
read_matrix_system(input,n,A,b);
fclose(input);
conjugate_gradient(A,b,n);
free_matrix(n,A);
print_vector(n,b);
free(b);
break;
}
default:
printf("Opcao nao reconhecida\n");
exit(EXIT_FAILURE);
}
}
return 1;
}
