int main(int argc, char *argv[])
{
superlu_dist_options_t options;
SuperLUStat_t stat;
SuperMatrix A;
ScalePermstruct_t ScalePermstruct;
LUstruct_t LUstruct;
gridinfo_t grid;
double *berr;
double *a, *a1, *b, *b1, *xtrue;
int_t *asub, *asub1, *xa, *xa1;
int_t i, j, m, n, nnz;
int_t nprow, npcol;
int iam, info, ldb, ldx, nrhs;
char trans[1];
char **cpp, c;
FILE *fp, *fopen();
extern int cpp_defs();
/* prototypes */
extern void LUstructInit(const int_t, LUstruct_t *);
extern void LUstructFree(LUstruct_t *);
extern void Destroy_LU(int_t, gridinfo_t *, LUstruct_t *);
nprow = 1; /* Default process rows. */
npcol = 1; /* Default process columns. */
nrhs = 1; /* Number of right-hand side. */
/* ------------------------------------------------------------
INITIALIZE MPI ENVIRONMENT.
------------------------------------------------------------*/
MPI_Init( &argc, &argv );
/* Parse command line argv[]. */
for (cpp = argv+1; *cpp; ++cpp) {
if ( **cpp == '-' ) {
c = *(*cpp+1);
++cpp;
switch (c) {
case 'h':
printf("Options:\n");
printf("\t-r <int>: process rows (default %d)\n", nprow);
printf("\t-c <int>: process columns (default %d)\n", npcol);
exit(0);
break;
case 'r': nprow = atoi(*cpp);
break;
case 'c': npcol = atoi(*cpp);
break;
}
} else { /* Last arg is considered a filename */
if ( !(fp = fopen(*cpp, "r")) ) {
ABORT("File does not exist");
}
break;
}
}
/* ------------------------------------------------------------
INITIALIZE THE SUPERLU PROCESS GRID.
------------------------------------------------------------*/
superlu_gridinit(MPI_COMM_WORLD, nprow, npcol, &grid);
/* Bail out if I do not belong in the grid. */
iam = grid.iam;
if ( iam >= nprow * npcol )
goto out;
#if ( DEBUGlevel>=1 )
CHECK_MALLOC(iam, "Enter main()");
#endif
/* ------------------------------------------------------------
Process 0 reads the matrix A, and then broadcasts it to all
the other processes.
------------------------------------------------------------*/
if ( !iam ) {
/* Print the CPP definitions. */
cpp_defs();
/* Read the matrix stored on disk in Harwell-Boeing format. */
dreadhb_dist(iam, fp, &m, &n, &nnz, &a, &asub, &xa);
printf("Input matrix file: %s\n", *cpp);
printf("\tDimension\t%dx%d\t # nonzeros %d\n", m, n, nnz);
printf("\tProcess grid\t%d X %d\n", (int) grid.nprow, (int) grid.npcol);
/* Broadcast matrix A to the other PEs. */
MPI_Bcast( &m, 1, mpi_int_t, 0, grid.comm );
MPI_Bcast( &n, 1, mpi_int_t, 0, grid.comm );
MPI_Bcast( &nnz, 1, mpi_int_t, 0, grid.comm );
MPI_Bcast( a, nnz, MPI_DOUBLE, 0, grid.comm );
MPI_Bcast( asub, nnz, mpi_int_t, 0, grid.comm );
MPI_Bcast( xa, n+1, mpi_int_t, 0, grid.comm );
} else {
/* Receive matrix A from PE 0. */
MPI_Bcast( &m, 1, mpi_int_t, 0, grid.comm );
MPI_Bcast( &n, 1, mpi_int_t, 0, grid.comm );
MPI_Bcast( &nnz, 1, mpi_int_t, 0, grid.comm );
/* Allocate storage for compressed column representation. */
dallocateA_dist(n, nnz, &a, &asub, &xa);
MPI_Bcast( a, nnz, MPI_DOUBLE, 0, grid.comm );
MPI_Bcast( asub, nnz, mpi_int_t, 0, grid.comm );
MPI_Bcast( xa, n+1, mpi_int_t, 0, grid.comm );
}
/* Create compressed column matrix for A. */
dCreate_CompCol_Matrix_dist(&A, m, n, nnz, a, asub, xa,
SLU_NC, SLU_D, SLU_GE);
/* Generate the exact solution and compute the right-hand side. */
if (!(b=doubleMalloc_dist(m * nrhs))) ABORT("Malloc fails for b[]");
if (!(xtrue=doubleMalloc_dist(n*nrhs))) ABORT("Malloc fails for xtrue[]");
*trans = 'N';
ldx = n;
ldb = m;
dGenXtrue_dist(n, nrhs, xtrue, ldx);
dFillRHS_dist(trans, nrhs, xtrue, ldx, &A, b, ldb);
/* Save a copy of the right-hand side. */
if ( !(b1 = doubleMalloc_dist(m * nrhs)) ) ABORT("Malloc fails for b1[]");
for (j = 0; j < nrhs; ++j)
for (i = 0; i < m; ++i) b1[i+j*ldb] = b[i+j*ldb];
if ( !(berr = doubleMalloc_dist(nrhs)) )
ABORT("Malloc fails for berr[].");
/* Save a copy of the matrix A. */
dallocateA_dist(n, nnz, &a1, &asub1, &xa1);
for (i = 0; i < nnz; ++i) { a1[i] = a[i]; asub1[i] = asub[i]; }
for (i = 0; i < n+1; ++i) xa1[i] = xa[i];
/* ------------------------------------------------------------
WE SOLVE THE LINEAR SYSTEM FOR THE FIRST TIME.
------------------------------------------------------------*/
/* Set the default input options:
options.Fact = DOFACT;
options.Equil = YES;
options.ColPerm = METIS_AT_PLUS_A;
options.RowPerm = LargeDiag;
options.ReplaceTinyPivot = YES;
options.Trans = NOTRANS;
options.IterRefine = DOUBLE;
options.SolveInitialized = NO;
options.RefineInitialized = NO;
options.PrintStat = YES;
*/
set_default_options_dist(&options);
if (!iam) {
print_sp_ienv_dist(&options);
print_options_dist(&options);
}
/* Initialize ScalePermstruct and LUstruct. */
ScalePermstructInit(m, n, &ScalePermstruct);
LUstructInit(n, &LUstruct);
/* Initialize the statistics variables. */
PStatInit(&stat);
/* Call the linear equation solver: factorize and solve. */
pdgssvx_ABglobal(&options, &A, &ScalePermstruct, b, ldb, nrhs, &grid,
&LUstruct, berr, &stat, &info);
/* Check the accuracy of the solution. */
if ( !iam ) {
dinf_norm_error_dist(n, nrhs, b, ldb, xtrue, ldx, &grid);
}
PStatPrint(&options, &stat, &grid); /* Print the statistics. */
PStatFree(&stat);
Destroy_CompCol_Matrix_dist(&A); /* Deallocate storage of matrix A. */
Destroy_LU(n, &grid, &LUstruct); /* Deallocate storage associated with
the L and U matrices. */
SUPERLU_FREE(b); /* Free storage of right-hand side. */
/* ------------------------------------------------------------
NOW WE SOLVE ANOTHER LINEAR SYSTEM.
ONLY THE SPARSITY PATTERN OF MATRIX A IS THE SAME.
------------------------------------------------------------*/
options.Fact = SamePattern;
PStatInit(&stat); /* Initialize the statistics variables. */
/* Create compressed column matrix for A. */
dCreate_CompCol_Matrix_dist(&A, m, n, nnz, a1, asub1, xa1,
SLU_NC, SLU_D, SLU_GE);
/* Solve the linear system. */
pdgssvx_ABglobal(&options, &A, &ScalePermstruct, b1, ldb, nrhs, &grid,
&LUstruct, berr, &stat, &info);
/* Check the accuracy of the solution. */
if ( !iam ) {
printf("Solve the system with the same sparsity pattern.\n");
dinf_norm_error_dist(n, nrhs, b1, ldb, xtrue, ldx, &grid);
}
/* Print the statistics. */
PStatPrint(&options, &stat, &grid);
/* ------------------------------------------------------------
DEALLOCATE STORAGE.
------------------------------------------------------------*/
PStatFree(&stat);
Destroy_CompCol_Matrix_dist(&A); /* Deallocate storage of matrix A. */
Destroy_LU(n, &grid, &LUstruct); /* Deallocate storage associated with
the L and U matrices. */
ScalePermstructFree(&ScalePermstruct);
LUstructFree(&LUstruct); /* Deallocate the structure of L and U.*/
SUPERLU_FREE(b1); /* Free storage of right-hand side. */
SUPERLU_FREE(xtrue); /* Free storage of the exact solution. */
SUPERLU_FREE(berr);
/* ------------------------------------------------------------
RELEASE THE SUPERLU PROCESS GRID.
------------------------------------------------------------*/
out:
superlu_gridexit(&grid);
/* ------------------------------------------------------------
TERMINATES THE MPI EXECUTION ENVIRONMENT.
------------------------------------------------------------*/
MPI_Finalize();
#if ( DEBUGlevel>=1 )
CHECK_MALLOC(iam, "Exit main()");
#endif
}
int main(int argc, char *argv[])
{
superlu_dist_options_t options;
SuperLUStat_t stat;
SuperMatrix A;
ScalePermstruct_t ScalePermstruct;
LUstruct_t LUstruct;
gridinfo_t grid1, grid2;
double *berr;
double *a, *b, *xtrue;
int_t *asub, *xa;
int_t i, j, m, n, nnz;
int_t nprow, npcol, ldumap, p;
int_t usermap[6];
int iam, info, ldb, ldx, nprocs;
int nrhs = 1; /* Number of right-hand side. */
char trans[1];
char **cpp, c;
FILE *fp, *fopen();
/* prototypes */
extern void LUstructInit(const int_t, LUstruct_t *);
extern void LUstructFree(LUstruct_t *);
extern void Destroy_LU(int_t, gridinfo_t *, LUstruct_t *);
/* ------------------------------------------------------------
INITIALIZE MPI ENVIRONMENT.
------------------------------------------------------------*/
MPI_Init( &argc, &argv );
MPI_Comm_size( MPI_COMM_WORLD, &nprocs );
if ( nprocs < 10 ) {
fprintf(stderr, "Requires at least 10 processes\n");
exit(-1);
}
/* Parse command line argv[]. */
for (cpp = argv+1; *cpp; ++cpp) {
if ( **cpp == '-' ) {
c = *(*cpp+1);
++cpp;
switch (c) {
case 'h':
printf("Options:\n");
printf("\t-r <int>: process rows (default %d)\n", nprow);
printf("\t-c <int>: process columns (default %d)\n", npcol);
exit(0);
break;
case 'r': nprow = atoi(*cpp);
break;
case 'c': npcol = atoi(*cpp);
break;
}
} else { /* Last arg is considered a filename */
if ( !(fp = fopen(*cpp, "r")) ) {
ABORT("File does not exist");
}
break;
}
}
/* ------------------------------------------------------------
INITIALIZE THE SUPERLU PROCESS GRID 1.
------------------------------------------------------------*/
nprow = 2;
npcol = 3;
ldumap = 2;
p = 0; /* Grid 1 starts from process 0. */
for (i = 0; i < nprow; ++i)
for (j = 0; j < npcol; ++j) usermap[i+j*ldumap] = p++;
superlu_gridmap(MPI_COMM_WORLD, nprow, npcol, usermap, ldumap, &grid1);
/* ------------------------------------------------------------
INITIALIZE THE SUPERLU PROCESS GRID 2.
------------------------------------------------------------*/
nprow = 2;
npcol = 2;
ldumap = 2;
p = 6; /* Grid 2 starts from process 6. */
for (i = 0; i < nprow; ++i)
for (j = 0; j < npcol; ++j) usermap[i+j*ldumap] = p++;
superlu_gridmap(MPI_COMM_WORLD, nprow, npcol, usermap, ldumap, &grid2);
/* Bail out if I do not belong in any of the 2 grids. */
MPI_Comm_rank( MPI_COMM_WORLD, &iam );
if ( iam >= 10 ) goto out;
#if ( DEBUGlevel>=1 )
CHECK_MALLOC(iam, "Enter main()");
#endif
if ( iam >= 0 && iam < 6 ) { /* I am in grid 1. */
iam = grid1.iam; /* Get the logical number in the new grid. */
/* ------------------------------------------------------------
PROCESS 0 READS THE MATRIX A, AND THEN BROADCASTS IT TO ALL
THE OTHER PROCESSES.
------------------------------------------------------------*/
if ( !iam ) {
/* Read the matrix stored on disk in Harwell-Boeing format. */
dreadhb_dist(iam, fp, &m, &n, &nnz, &a, &asub, &xa);
printf("\tDimension\t%dx%d\t # nonzeros %d\n", m, n, nnz);
printf("\tProcess grid\t%d X %d\n", (int) grid1.nprow, (int) grid1.npcol);
/* Broadcast matrix A to the other PEs. */
MPI_Bcast( &m, 1, mpi_int_t, 0, grid1.comm );
MPI_Bcast( &n, 1, mpi_int_t, 0, grid1.comm );
MPI_Bcast( &nnz, 1, mpi_int_t, 0, grid1.comm );
MPI_Bcast( a, nnz, MPI_DOUBLE, 0, grid1.comm );
MPI_Bcast( asub, nnz, mpi_int_t, 0, grid1.comm );
MPI_Bcast( xa, n+1, mpi_int_t, 0, grid1.comm );
} else {
/* Receive matrix A from PE 0. */
MPI_Bcast( &m, 1, mpi_int_t, 0, grid1.comm );
MPI_Bcast( &n, 1, mpi_int_t, 0, grid1.comm );
MPI_Bcast( &nnz, 1, mpi_int_t, 0, grid1.comm );
/* Allocate storage for compressed column representation. */
dallocateA_dist(n, nnz, &a, &asub, &xa);
MPI_Bcast( a, nnz, MPI_DOUBLE, 0, grid1.comm );
MPI_Bcast( asub, nnz, mpi_int_t, 0, grid1.comm );
MPI_Bcast( xa, n+1, mpi_int_t, 0, grid1.comm );
}
/* Create compressed column matrix for A. */
dCreate_CompCol_Matrix_dist(&A, m, n, nnz, a, asub, xa,
SLU_NC, SLU_D, SLU_GE);
/* Generate the exact solution and compute the right-hand side. */
if (!(b=doubleMalloc_dist(m*nrhs))) ABORT("Malloc fails for b[]");
if (!(xtrue=doubleMalloc_dist(n*nrhs))) ABORT("Malloc fails for xtrue[]");
*trans = 'N';
ldx = n;
ldb = m;
dGenXtrue_dist(n, nrhs, xtrue, ldx);
dFillRHS_dist(trans, nrhs, xtrue, ldx, &A, b, ldb);
if ( !(berr = doubleMalloc_dist(nrhs)) )
ABORT("Malloc fails for berr[].");
/* ------------------------------------------------------------
NOW WE SOLVE THE LINEAR SYSTEM.
------------------------------------------------------------*/
/* Set the default input options:
options.Fact = DOFACT;
options.Equil = YES;
options.ColPerm = METIS_AT_PLUS_A;
options.RowPerm = LargeDiag;
options.ReplaceTinyPivot = YES;
options.Trans = NOTRANS;
options.IterRefine = DOUBLE;
options.SolveInitialized = NO;
options.RefineInitialized = NO;
options.PrintStat = YES;
*/
set_default_options_dist(&options);
if (!iam) {
print_sp_ienv_dist(&options);
print_options_dist(&options);
}
/* Initialize ScalePermstruct and LUstruct. */
ScalePermstructInit(m, n, &ScalePermstruct);
LUstructInit(n, &LUstruct);
/* Initialize the statistics variables. */
PStatInit(&stat);
/* Call the linear equation solver: factorize and solve. */
pdgssvx_ABglobal(&options, &A, &ScalePermstruct, b, ldb, nrhs, &grid1,
&LUstruct, berr, &stat, &info);
/* Check the accuracy of the solution. */
if ( !iam ) {
dinf_norm_error_dist(n, nrhs, b, ldb, xtrue, ldx, &grid1);
}
/* Print the statistics. */
PStatPrint(&options, &stat, &grid1);
/* ------------------------------------------------------------
DEALLOCATE STORAGE.
------------------------------------------------------------*/
PStatFree(&stat);
Destroy_CompCol_Matrix_dist(&A);
Destroy_LU(n, &grid1, &LUstruct);
ScalePermstructFree(&ScalePermstruct);
LUstructFree(&LUstruct);
SUPERLU_FREE(b);
SUPERLU_FREE(xtrue);
SUPERLU_FREE(berr);
} else { /* I am in grid 2. */
iam = grid2.iam; /* Get the logical number in the new grid. */
/* ------------------------------------------------------------
PROCESS 0 READS THE MATRIX A, AND THEN BROADCASTS IT TO ALL
THE OTHER PROCESSES.
------------------------------------------------------------*/
if ( !iam ) {
/* Read the matrix stored on disk in Harwell-Boeing format. */
dreadhb_dist(iam, fp, &m, &n, &nnz, &a, &asub, &xa);
printf("\tDimension\t%dx%d\t # nonzeros %d\n", m, n, nnz);
printf("\tProcess grid\t%d X %d\n", (int) grid2.nprow, (int) grid2.npcol);
/* Broadcast matrix A to the other PEs. */
MPI_Bcast( &m, 1, mpi_int_t, 0, grid2.comm );
MPI_Bcast( &n, 1, mpi_int_t, 0, grid2.comm );
MPI_Bcast( &nnz, 1, mpi_int_t, 0, grid2.comm );
MPI_Bcast( a, nnz, MPI_DOUBLE, 0, grid2.comm );
MPI_Bcast( asub, nnz, mpi_int_t, 0, grid2.comm );
MPI_Bcast( xa, n+1, mpi_int_t, 0, grid2.comm );
} else {
/* Receive matrix A from PE 0. */
MPI_Bcast( &m, 1, mpi_int_t, 0, grid2.comm );
MPI_Bcast( &n, 1, mpi_int_t, 0, grid2.comm );
MPI_Bcast( &nnz, 1, mpi_int_t, 0, grid2.comm );
/* Allocate storage for compressed column representation. */
dallocateA_dist(n, nnz, &a, &asub, &xa);
MPI_Bcast( a, nnz, MPI_DOUBLE, 0, grid2.comm );
MPI_Bcast( asub, nnz, mpi_int_t, 0, grid2.comm );
MPI_Bcast( xa, n+1, mpi_int_t, 0, grid2.comm );
}
/* Create compressed column matrix for A. */
dCreate_CompCol_Matrix_dist(&A, m, n, nnz, a, asub, xa,
SLU_NC, SLU_D, SLU_GE);
/* Generate the exact solution and compute the right-hand side. */
if (!(b=doubleMalloc_dist(m*nrhs))) ABORT("Malloc fails for b[]");
if (!(xtrue=doubleMalloc_dist(n*nrhs))) ABORT("Malloc fails for xtrue[]");
*trans = 'N';
ldx = n;
ldb = m;
dGenXtrue_dist(n, nrhs, xtrue, ldx);
dFillRHS_dist(trans, nrhs, xtrue, ldx, &A, b, ldb);
if ( !(berr = doubleMalloc_dist(nrhs)) )
ABORT("Malloc fails for berr[].");
/* ------------------------------------------------------------
NOW WE SOLVE THE LINEAR SYSTEM.
------------------------------------------------------------*/
/* Set the default input options:
options.Fact = DOFACT;
options.Equil = YES;
options.ColPerm = MMD_AT_PLUS_A;
options.RowPerm = LargeDiag;
options.ReplaceTinyPivot = YES;
options.Trans = NOTRANS;
options.IterRefine = DOUBLE;
options.SolveInitialized = NO;
options.RefineInitialized = NO;
options.PrintStat = YES;
*/
set_default_options_dist(&options);
/* Initialize ScalePermstruct and LUstruct. */
ScalePermstructInit(m, n, &ScalePermstruct);
LUstructInit(n, &LUstruct);
/* Initialize the statistics variables. */
PStatInit(&stat);
/* Call the linear equation solver: factorize and solve. */
pdgssvx_ABglobal(&options, &A, &ScalePermstruct, b, ldb, nrhs, &grid2,
&LUstruct, berr, &stat, &info);
/* Check the accuracy of the solution. */
if ( !iam ) {
dinf_norm_error_dist(n, nrhs, b, ldb, xtrue, ldx, &grid2);
}
/* Print the statistics. */
PStatPrint(&options, &stat, &grid2);
/* ------------------------------------------------------------
DEALLOCATE STORAGE.
------------------------------------------------------------*/
PStatFree(&stat);
Destroy_CompCol_Matrix_dist(&A);
Destroy_LU(n, &grid2, &LUstruct);
ScalePermstructFree(&ScalePermstruct);
LUstructFree(&LUstruct);
SUPERLU_FREE(b);
SUPERLU_FREE(xtrue);
SUPERLU_FREE(berr);
}
/* ------------------------------------------------------------
RELEASE THE SUPERLU PROCESS GRIDS.
------------------------------------------------------------*/
superlu_gridexit(&grid1);
superlu_gridexit(&grid2);
out:
/* ------------------------------------------------------------
TERMINATES THE MPI EXECUTION ENVIRONMENT.
------------------------------------------------------------*/
MPI_Finalize();
#if ( DEBUGlevel>=1 )
CHECK_MALLOC(iam, "Exit main()");
#endif
}
void
dreadMM(FILE *fp, int_t *m, int_t *n, int_t *nonz,
double **nzval, int_t **rowind, int_t **colptr)
{
int_t j, k, jsize, nnz, nz, new_nonz;
double *a, *val;
int_t *asub, *xa, *row, *col;
int_t zero_base = 0;
char *p, line[512], banner[64], mtx[64], crd[64], arith[64], sym[64];
int expand;
/* File format:
* %%MatrixMarket matrix coordinate real general/symmetric/...
* % ...
* % (optional comments)
* % ...
* #rows #non-zero
* Triplet in the rest of lines: row col value
*/
/* 1/ read header */
fgets(line,512,fp);
for (p=line; *p!='\0'; *p=tolower(*p),p++);
if (sscanf(line, "%s %s %s %s %s", banner, mtx, crd, arith, sym) != 5) {
printf("Invalid header (first line does not contain 5 tokens)\n");
exit;
}
if(strcmp(banner,"%%matrixmarket")) {
printf("Invalid header (first token is not \"%%%%MatrixMarket\")\n");
exit(-1);
}
if(strcmp(mtx,"matrix")) {
printf("Not a matrix; this driver cannot handle that.\n");
exit(-1);
}
if(strcmp(crd,"coordinate")) {
printf("Not in coordinate format; this driver cannot handle that.\n");
exit(-1);
}
if(strcmp(arith,"real")) {
if(!strcmp(arith,"complex")) {
printf("Complex matrix; use zreadtriple instead!\n");
exit(-1);
}
else if(!strcmp(arith, "pattern")) {
printf("Pattern matrix; values are needed!\n");
exit(-1);
}
else {
printf("Unknown arithmetic\n");
exit(-1);
}
}
if(strcmp(sym,"general")) {
printf("Symmetric matrix: will be expanded\n");
expand=1;
} else
expand=0;
/* 2/ Skip comments */
while(banner[0]=='%') {
fgets(line,512,fp);
sscanf(line,"%s",banner);
}
/* 3/ Read n and nnz */
#ifdef _LONGINT
sscanf(line, "%ld%ld%ld",m, n, nonz);
#else
sscanf(line, "%d%d%d",m, n, nonz);
#endif
if(*m!=*n) {
printf("Rectangular matrix!. Abort\n");
exit(-1);
}
if(expand)
new_nonz = 2 * *nonz - *n;
else
new_nonz = *nonz;
*m = *n;
printf("m %ld, n %ld, nonz %ld\n", (long long) *m, (long long) *n, (long long) *nonz);
dallocateA_dist(*n, new_nonz, nzval, rowind, colptr); /* Allocate storage */
a = *nzval;
asub = *rowind;
xa = *colptr;
if ( !(val = (double *) SUPERLU_MALLOC(new_nonz * sizeof(double))) )
ABORT("Malloc fails for val[]");
if ( !(row = (int_t *) SUPERLU_MALLOC(new_nonz * sizeof(int_t))) )
ABORT("Malloc fails for row[]");
if ( !(col = (int_t *) SUPERLU_MALLOC(new_nonz * sizeof(int_t))) )
ABORT("Malloc fails for col[]");
for (j = 0; j < *n; ++j) xa[j] = 0;
/* 4/ Read triplets of values */
for (nnz = 0, nz = 0; nnz < *nonz; ++nnz) {
#ifdef _LONGINT
fscanf(fp, "%ld%ld%lf\n", &row[nz], &col[nz], &val[nz]);
#else
fscanf(fp, "%d%d%lf\n", &row[nz], &col[nz], &val[nz]);
#endif
if ( nnz == 0 ) /* first nonzero */
if ( row[0] == 0 || col[0] == 0 ) {
zero_base = 1;
printf("triplet file: row/col indices are zero-based.\n");
} else
printf("triplet file: row/col indices are one-based.\n");
if ( !zero_base ) {
/* Change to 0-based indexing. */
--row[nz];
--col[nz];
}
if (row[nz] < 0 || row[nz] >= *m || col[nz] < 0 || col[nz] >= *n
/*|| val[nz] == 0.*/) {
fprintf(stderr, "nz " IFMT ", (" IFMT ", " IFMT ") = %e out of bound, removed\n",
nz, row[nz], col[nz], val[nz]);
exit(-1);
} else {
++xa[col[nz]];
if(expand) {
if ( row[nz] != col[nz] ) { /* Excluding diagonal */
++nz;
row[nz] = col[nz-1];
col[nz] = row[nz-1];
val[nz] = val[nz-1];
++xa[col[nz]];
}
}
++nz;
}
}
*nonz = nz;
if(expand) {
printf("new_nonz after symmetric expansion:\t" IFMT "\n", *nonz);
}
/* Initialize the array of column pointers */
k = 0;
jsize = xa[0];
xa[0] = 0;
for (j = 1; j < *n; ++j) {
k += jsize;
jsize = xa[j];
xa[j] = k;
}
/* Copy the triplets into the column oriented storage */
for (nz = 0; nz < *nonz; ++nz) {
j = col[nz];
k = xa[j];
asub[k] = row[nz];
a[k] = val[nz];
++xa[j];
}
/* Reset the column pointers to the beginning of each column */
for (j = *n; j > 0; --j)
xa[j] = xa[j-1];
xa[0] = 0;
SUPERLU_FREE(val);
SUPERLU_FREE(row);
SUPERLU_FREE(col);
#ifdef CHK_INPUT
int i;
for (i = 0; i < *n; i++) {
printf("Col %d, xa %d\n", i, xa[i]);
for (k = xa[i]; k < xa[i+1]; k++)
printf("%d\t%16.10f\n", asub[k], a[k]);
}
#endif
}
int main(int argc, char *argv[])
{
superlu_options_t options;
SuperLUStat_t stat;
SuperMatrix A;
ScalePermstruct_t ScalePermstruct;
LUstruct_t LUstruct;
gridinfo_t grid;
double *berr;
double *a, *b, *xtrue;
int_t *asub, *xa;
int_t m, n, nnz;
int_t nprow, npcol;
int iam, info, ldb, ldx, nrhs;
char trans[1];
char **cpp, c;
FILE *fp, *fopen();
extern int cpp_defs();
/* prototypes */
extern void LUstructInit(const int_t, LUstruct_t *);
extern void LUstructFree(LUstruct_t *);
extern void Destroy_LU(int_t, gridinfo_t *, LUstruct_t *);
nprow = 1; /* Default process rows. */
npcol = 1; /* Default process columns. */
nrhs = 1; /* Number of right-hand side. */
/* ------------------------------------------------------------
INITIALIZE MPI ENVIRONMENT.
------------------------------------------------------------*/
MPI_Init( &argc, &argv );
/* Parse command line argv[]. */
for (cpp = argv+1; *cpp; ++cpp) {
if ( **cpp == '-' ) {
c = *(*cpp+1);
++cpp;
switch (c) {
case 'h':
printf("Options:\n");
printf("\t-r <int>: process rows (default " IFMT ")\n", nprow);
printf("\t-c <int>: process columns (default " IFMT ")\n", npcol);
exit(0);
break;
case 'r': nprow = atoi(*cpp);
break;
case 'c': npcol = atoi(*cpp);
break;
}
} else { /* Last arg is considered a filename */
if ( !(fp = fopen(*cpp, "r")) ) {
ABORT("File does not exist");
}
break;
}
}
/* ------------------------------------------------------------
INITIALIZE THE SUPERLU PROCESS GRID.
------------------------------------------------------------*/
superlu_gridinit(MPI_COMM_WORLD, nprow, npcol, &grid);
/* Bail out if I do not belong in the grid. */
iam = grid.iam;
if ( iam >= nprow * npcol )
goto out;
#if ( VAMPIR>=1 )
VT_traceoff();
#endif
#if ( DEBUGlevel>=1 )
CHECK_MALLOC(iam, "Enter main()");
#endif
/* ------------------------------------------------------------
PROCESS 0 READS THE MATRIX A, AND THEN BROADCASTS IT TO ALL
THE OTHER PROCESSES.
------------------------------------------------------------*/
if ( !iam ) {
/* Print the CPP definitions. */
cpp_defs();
#if 1
/* Read the matrix stored on disk in Harwell-Boeing format. */
dreadhb_dist(iam, fp, &m, &n, &nnz, &a, &asub, &xa);
#else
/* Read the matrix stored on disk in Harwell-Boeing format. */
printf(".. reading triplet file\n");
dreadtriple(fp, &m, &n, &nnz, &a, &asub, &xa);
#endif
printf("Input matrix file: %s\n", *cpp);
printf("\tDimension\t" IFMT "x" IFMT "\t # nonzeros " IFMT "\n", m, n, nnz);
printf("\tProcess grid\t%d X %d\n", (int) grid.nprow, (int) grid.npcol);
/* Broadcast matrix A to the other PEs. */
MPI_Bcast( &m, 1, mpi_int_t, 0, grid.comm );
MPI_Bcast( &n, 1, mpi_int_t, 0, grid.comm );
MPI_Bcast( &nnz, 1, mpi_int_t, 0, grid.comm );
MPI_Bcast( a, nnz, MPI_DOUBLE, 0, grid.comm );
MPI_Bcast( asub, nnz, mpi_int_t, 0, grid.comm );
MPI_Bcast( xa, n+1, mpi_int_t, 0, grid.comm );
} else {
/* Receive matrix A from PE 0. */
MPI_Bcast( &m, 1, mpi_int_t, 0, grid.comm );
MPI_Bcast( &n, 1, mpi_int_t, 0, grid.comm );
MPI_Bcast( &nnz, 1, mpi_int_t, 0, grid.comm );
/* Allocate storage for compressed column representation. */
dallocateA_dist(n, nnz, &a, &asub, &xa);
MPI_Bcast( a, nnz, MPI_DOUBLE, 0, grid.comm );
MPI_Bcast( asub, nnz, mpi_int_t, 0, grid.comm );
MPI_Bcast( xa, n+1, mpi_int_t, 0, grid.comm );
}
/* Create compressed column matrix for A. */
dCreate_CompCol_Matrix_dist(&A, m, n, nnz, a, asub, xa,
SLU_NC, SLU_D, SLU_GE);
/* Generate the exact solution and compute the right-hand side. */
if (!(b=doubleMalloc_dist(m*nrhs))) ABORT("Malloc fails for b[]");
if (!(xtrue=doubleMalloc_dist(n*nrhs))) ABORT("Malloc fails for xtrue[]");
*trans = 'N';
ldx = n;
ldb = m;
dGenXtrue_dist(n, nrhs, xtrue, ldx);
dFillRHS_dist(trans, nrhs, xtrue, ldx, &A, b, ldb);
if ( !(berr = doubleMalloc_dist(nrhs)) )
ABORT("Malloc fails for berr[].");
/* ------------------------------------------------------------
NOW WE SOLVE THE LINEAR SYSTEM.
------------------------------------------------------------*/
/* Set the default input options:
options.Fact = DOFACT;
options.Equil = YES;
options.ColPerm = METIS_AT_PLUS_A;
options.RowPerm = LargeDiag;
options.Trans = NOTRANS;
options.IterRefine = DOUBLE;
options.SolveInitialized = NO;
options.RefineInitialized = NO;
options.PrintStat = YES;
*/
set_default_options_dist(&options);
if (!iam) {
print_sp_ienv_dist(&options);
print_options_dist(&options);
}
/* Initialize ScalePermstruct and LUstruct. */
ScalePermstructInit(m, n, &ScalePermstruct);
LUstructInit(n, &LUstruct);
/* Initialize the statistics variables. */
PStatInit(&stat);
/* Call the linear equation solver. */
pdgssvx_ABglobal(&options, &A, &ScalePermstruct, b, ldb, nrhs, &grid,
&LUstruct, berr, &stat, &info);
/* Check the accuracy of the solution. */
if ( !iam ) {
dinf_norm_error_dist(n, nrhs, b, ldb, xtrue, ldx, &grid);
}
PStatPrint(&options, &stat, &grid); /* Print the statistics. */
/* ------------------------------------------------------------
DEALLOCATE STORAGE.
------------------------------------------------------------*/
PStatFree(&stat);
Destroy_CompCol_Matrix_dist(&A);
Destroy_LU(n, &grid, &LUstruct);
ScalePermstructFree(&ScalePermstruct);
LUstructFree(&LUstruct);
SUPERLU_FREE(b);
SUPERLU_FREE(xtrue);
SUPERLU_FREE(berr);
/* ------------------------------------------------------------
RELEASE THE SUPERLU PROCESS GRID.
------------------------------------------------------------*/
out:
superlu_gridexit(&grid);
/* ------------------------------------------------------------
TERMINATES THE MPI EXECUTION ENVIRONMENT.
------------------------------------------------------------*/
MPI_Finalize();
#if ( DEBUGlevel>=1 )
CHECK_MALLOC(iam, "Exit main()");
#endif
}
void
dreadrb_dist(int iam, FILE *fp, int_t *nrow, int_t *ncol, int_t *nonz,
double **nzval, int_t **rowind, int_t **colptr)
{
register int_t i, numer_lines = 0;
int_t tmp, colnum, colsize, rownum, rowsize, valnum, valsize;
char buf[100], type[4];
int sym;
/* Line 1 */
fgets(buf, 100, fp);
fputs(buf, stdout);
/* Line 2 */
for (i=0; i<4; i++) {
fscanf(fp, "%14c", buf); buf[14] = 0;
tmp = atoi(buf); /*sscanf(buf, "%d", &tmp);*/
if (i == 3) numer_lines = tmp;
}
DumpLine(fp);
/* Line 3 */
fscanf(fp, "%3c", type);
fscanf(fp, "%11c", buf); /* pad */
type[3] = 0;
#if (DEBUGlevel >= 1)
if ( !iam ) printf("Matrix type %s\n", type);
#endif
fscanf(fp, "%14c", buf); *nrow = atoi(buf);
fscanf(fp, "%14c", buf); *ncol = atoi(buf);
fscanf(fp, "%14c", buf); *nonz = atoi(buf);
fscanf(fp, "%14c", buf); tmp = atoi(buf);
if (tmp != 0)
if ( !iam ) printf("This is not an assembled matrix!\n");
if (*nrow != *ncol)
if ( !iam ) printf("Matrix is not square.\n");
DumpLine(fp);
/* Allocate storage for the three arrays ( nzval, rowind, colptr ) */
dallocateA_dist(*ncol, *nonz, nzval, rowind, colptr);
/* Line 4: format statement */
fscanf(fp, "%16c", buf);
ParseIntFormat(buf, &colnum, &colsize);
fscanf(fp, "%16c", buf);
ParseIntFormat(buf, &rownum, &rowsize);
fscanf(fp, "%20c", buf);
ParseFloatFormat(buf, &valnum, &valsize);
DumpLine(fp);
#if (DEBUGlevel >= 1)
if ( !iam ) {
printf(IFMT " rows, " IFMT " nonzeros\n", *nrow, *nonz);
printf("colnum " IFMT ", colsize " IFMT "\n", colnum, colsize);
printf("rownum " IFMT ", rowsize " IFMT "\n", rownum, rowsize);
printf("valnum " IFMT ", valsize " IFMT "\n", valnum, valsize);
}
#endif
ReadVector(fp, *ncol+1, *colptr, colnum, colsize);
ReadVector(fp, *nonz, *rowind, rownum, rowsize);
if ( numer_lines ) {
dReadValues(fp, *nonz, *nzval, valnum, valsize);
}
sym = (type[1] == 'S' || type[1] == 's');
if ( sym ) {
FormFullA(*ncol, nonz, nzval, rowind, colptr);
}
fclose(fp);
}
void
dreadhb_dist(int iam, FILE *fp, int_t *nrow, int_t *ncol, int_t *nonz,
double **nzval, int_t **rowind, int_t **colptr)
{
/*
* -- Distributed SuperLU routine (version 1.0) --
* Lawrence Berkeley National Lab, Univ. of California Berkeley.
* September 1, 1999
*
*
* Purpose
* =======
*
* Read a DOUBLE PRECISION matrix stored in Harwell-Boeing format
* as described below.
*
* Line 1 (A72,A8)
* Col. 1 - 72 Title (TITLE)
* Col. 73 - 80 Key (KEY)
*
* Line 2 (5I14)
* Col. 1 - 14 Total number of lines excluding header (TOTCRD)
* Col. 15 - 28 Number of lines for pointers (PTRCRD)
* Col. 29 - 42 Number of lines for row (or variable) indices (INDCRD)
* Col. 43 - 56 Number of lines for numerical values (VALCRD)
* Col. 57 - 70 Number of lines for right-hand sides (RHSCRD)
* (including starting guesses and solution vectors
* if present)
* (zero indicates no right-hand side data is present)
*
* Line 3 (A3, 11X, 4I14)
* Col. 1 - 3 Matrix type (see below) (MXTYPE)
* Col. 15 - 28 Number of rows (or variables) (NROW)
* Col. 29 - 42 Number of columns (or elements) (NCOL)
* Col. 43 - 56 Number of row (or variable) indices (NNZERO)
* (equal to number of entries for assembled matrices)
* Col. 57 - 70 Number of elemental matrix entries (NELTVL)
* (zero in the case of assembled matrices)
* Line 4 (2A16, 2A20)
* Col. 1 - 16 Format for pointers (PTRFMT)
* Col. 17 - 32 Format for row (or variable) indices (INDFMT)
* Col. 33 - 52 Format for numerical values of coefficient matrix (VALFMT)
* Col. 53 - 72 Format for numerical values of right-hand sides (RHSFMT)
*
* Line 5 (A3, 11X, 2I14) Only present if there are right-hand sides present
* Col. 1 Right-hand side type:
* F for full storage or M for same format as matrix
* Col. 2 G if a starting vector(s) (Guess) is supplied. (RHSTYP)
* Col. 3 X if an exact solution vector(s) is supplied.
* Col. 15 - 28 Number of right-hand sides (NRHS)
* Col. 29 - 42 Number of row indices (NRHSIX)
* (ignored in case of unassembled matrices)
*
* The three character type field on line 3 describes the matrix type.
* The following table lists the permitted values for each of the three
* characters. As an example of the type field, RSA denotes that the matrix
* is real, symmetric, and assembled.
*
* First Character:
* R Real matrix
* C Complex matrix
* P Pattern only (no numerical values supplied)
*
* Second Character:
* S Symmetric
* U Unsymmetric
* H Hermitian
* Z Skew symmetric
* R Rectangular
*
* Third Character:
* A Assembled
* E Elemental matrices (unassembled)
*
*/
register int_t i, numer_lines, rhscrd = 0;
int_t tmp, colnum, colsize, rownum, rowsize, valnum, valsize;
char buf[100], type[4];
int_t sym;
#if ( DEBUGlevel>=1 )
CHECK_MALLOC(0, "Enter dreadhb_dist()");
#endif
/* Line 1 */
fgets(buf, 100, fp);
/*dDumpLine(fp);*/
/*if ( !iam ) fflush(stdout);*/
/* Line 2 */
for (i=0; i<5; i++) {
fscanf(fp, "%14c", buf); buf[14] = 0;
tmp = atoi(buf); /*sscanf(buf, "%d", &tmp);*/
if (i == 3) numer_lines = tmp;
if (i == 4 && tmp) rhscrd = tmp;
}
dDumpLine(fp);
/* Line 3 */
fscanf(fp, "%3c", type);
fscanf(fp, "%11c", buf); /* pad */
type[3] = 0;
#if ( DEBUGlevel>=1 )
if ( !iam ) printf("Matrix type %s\n", type);
#endif
fscanf(fp, "%14c", buf); *nrow = atoi(buf); /*sscanf(buf, "%d", nrow);*/
fscanf(fp, "%14c", buf); *ncol = atoi(buf); /*sscanf(buf, "%d", ncol);*/
fscanf(fp, "%14c", buf); *nonz = atoi(buf); /*sscanf(buf, "%d", nonz);*/
fscanf(fp, "%14c", buf); tmp = atoi(buf); /*sscanf(buf, "%d", &tmp);*/
if (tmp != 0)
if ( !iam ) printf("This is not an assembled matrix!\n");
if (*nrow != *ncol)
if ( !iam ) printf("Matrix is not square.\n");
dDumpLine(fp);
/* Allocate storage for the three arrays ( nzval, rowind, colptr ) */
dallocateA_dist(*ncol, *nonz, nzval, rowind, colptr);
/* Line 4: format statement */
fscanf(fp, "%16c", buf);
dParseIntFormat(buf, &colnum, &colsize);
fscanf(fp, "%16c", buf);
dParseIntFormat(buf, &rownum, &rowsize);
fscanf(fp, "%20c", buf);
dParseFloatFormat(buf, &valnum, &valsize);
fscanf(fp, "%20c", buf);
dDumpLine(fp);
/* Line 5: right-hand side */
if ( rhscrd ) dDumpLine(fp); /* skip RHSFMT */
#if ( DEBUGlevel>=1 )
if ( !iam ) {
printf("%d rows, %d nonzeros\n", *nrow, *nonz);
printf("colnum %d, colsize %d\n", colnum, colsize);
printf("rownum %d, rowsize %d\n", rownum, rowsize);
printf("valnum %d, valsize %d\n", valnum, valsize);
}
#endif
ReadVector(fp, *ncol+1, *colptr, colnum, colsize);
#if ( DEBUGlevel>=1 )
if ( !iam ) printf("read colptr[%d] = %d\n", *ncol, (*colptr)[*ncol]);
#endif
ReadVector(fp, *nonz, *rowind, rownum, rowsize);
#if ( DEBUGlevel>=1 )
if ( !iam ) printf("read rowind[%d] = %d\n", *nonz-1, (*rowind)[*nonz-1]);
#endif
if ( numer_lines ) {
dReadValues(fp, *nonz, *nzval, valnum, valsize);
#if ( DEBUGlevel>=1 )
if ( !iam ) printf("read nzval[%d] = %e\n", *nonz-1, (*nzval)[*nonz-1]);
#endif
}
sym = (type[1] == 'S' || type[1] == 's');
if ( sym ) {
FormFullA(*ncol, nonz, nzval, rowind, colptr);
}
/*if ( !iam ) fflush(stdout);*/
fclose(fp);
#if ( DEBUGlevel>=1 )
CHECK_MALLOC(0, "Exit dreadhb_dist()");
#endif
}
PetscErrorCode MatLUFactorNumeric_SuperLU_DIST(Mat F,Mat A,const MatFactorInfo *info)
{
Mat *tseq,A_seq = NULL;
Mat_SeqAIJ *aa,*bb;
Mat_SuperLU_DIST *lu = (Mat_SuperLU_DIST*)(F)->spptr;
PetscErrorCode ierr;
PetscInt M=A->rmap->N,N=A->cmap->N,i,*ai,*aj,*bi,*bj,nz,rstart,*garray,
m=A->rmap->n, colA_start,j,jcol,jB,countA,countB,*bjj,*ajj;
int sinfo; /* SuperLU_Dist info flag is always an int even with long long indices */
PetscMPIInt size;
SuperLUStat_t stat;
double *berr=0;
IS isrow;
Mat F_diag=NULL;
#if defined(PETSC_USE_COMPLEX)
doublecomplex *av, *bv;
#else
double *av, *bv;
#endif
PetscFunctionBegin;
ierr = MPI_Comm_size(PetscObjectComm((PetscObject)A),&size);CHKERRQ(ierr);
if (lu->MatInputMode == GLOBAL) { /* global mat input */
if (size > 1) { /* convert mpi A to seq mat A */
ierr = ISCreateStride(PETSC_COMM_SELF,M,0,1,&isrow);CHKERRQ(ierr);
ierr = MatGetSubMatrices(A,1,&isrow,&isrow,MAT_INITIAL_MATRIX,&tseq);CHKERRQ(ierr);
ierr = ISDestroy(&isrow);CHKERRQ(ierr);
A_seq = *tseq;
ierr = PetscFree(tseq);CHKERRQ(ierr);
aa = (Mat_SeqAIJ*)A_seq->data;
} else {
PetscBool flg;
ierr = PetscObjectTypeCompare((PetscObject)A,MATMPIAIJ,&flg);CHKERRQ(ierr);
if (flg) {
Mat_MPIAIJ *At = (Mat_MPIAIJ*)A->data;
A = At->A;
}
aa = (Mat_SeqAIJ*)A->data;
}
/* Convert Petsc NR matrix to SuperLU_DIST NC.
Note: memories of lu->val, col and row are allocated by CompRow_to_CompCol_dist()! */
if (lu->options.Fact != DOFACT) {/* successive numeric factorization, sparsity pattern is reused. */
PetscStackCall("SuperLU_DIST:Destroy_CompCol_Matrix_dist",Destroy_CompCol_Matrix_dist(&lu->A_sup));
if (lu->FactPattern == SamePattern_SameRowPerm) {
lu->options.Fact = SamePattern_SameRowPerm; /* matrix has similar numerical values */
} else { /* lu->FactPattern == SamePattern */
PetscStackCall("SuperLU_DIST:Destroy_LU",Destroy_LU(N, &lu->grid, &lu->LUstruct));
lu->options.Fact = SamePattern;
}
}
#if defined(PETSC_USE_COMPLEX)
PetscStackCall("SuperLU_DIST:zCompRow_to_CompCol_dist",zCompRow_to_CompCol_dist(M,N,aa->nz,(doublecomplex*)aa->a,(int_t*)aa->j,(int_t*)aa->i,&lu->val,&lu->col, &lu->row));
#else
PetscStackCall("SuperLU_DIST:dCompRow_to_CompCol_dist",dCompRow_to_CompCol_dist(M,N,aa->nz,aa->a,(int_t*)aa->j,(int_t*)aa->i,&lu->val, &lu->col, &lu->row));
#endif
/* Create compressed column matrix A_sup. */
#if defined(PETSC_USE_COMPLEX)
PetscStackCall("SuperLU_DIST:zCreate_CompCol_Matrix_dist",zCreate_CompCol_Matrix_dist(&lu->A_sup, M, N, aa->nz, lu->val, lu->col, lu->row, SLU_NC, SLU_Z, SLU_GE));
#else
PetscStackCall("SuperLU_DIST:dCreate_CompCol_Matrix_dist",dCreate_CompCol_Matrix_dist(&lu->A_sup, M, N, aa->nz, lu->val, lu->col, lu->row, SLU_NC, SLU_D, SLU_GE));
#endif
} else { /* distributed mat input */
Mat_MPIAIJ *mat = (Mat_MPIAIJ*)A->data;
aa=(Mat_SeqAIJ*)(mat->A)->data;
bb=(Mat_SeqAIJ*)(mat->B)->data;
ai=aa->i; aj=aa->j;
bi=bb->i; bj=bb->j;
#if defined(PETSC_USE_COMPLEX)
av=(doublecomplex*)aa->a;
bv=(doublecomplex*)bb->a;
#else
av=aa->a;
bv=bb->a;
#endif
rstart = A->rmap->rstart;
nz = aa->nz + bb->nz;
garray = mat->garray;
if (lu->options.Fact == DOFACT) { /* first numeric factorization */
#if defined(PETSC_USE_COMPLEX)
PetscStackCall("SuperLU_DIST:zallocateA_dist",zallocateA_dist(m, nz, &lu->val, &lu->col, &lu->row));
#else
PetscStackCall("SuperLU_DIST:dallocateA_dist",dallocateA_dist(m, nz, &lu->val, &lu->col, &lu->row));
#endif
} else { /* successive numeric factorization, sparsity pattern and perm_c are reused. */
/* Destroy_CompRowLoc_Matrix_dist(&lu->A_sup); */ /* this leads to crash! However, see SuperLU_DIST_2.5/EXAMPLE/pzdrive2.c */
if (lu->FactPattern == SamePattern_SameRowPerm) {
lu->options.Fact = SamePattern_SameRowPerm; /* matrix has similar numerical values */
} else {
PetscStackCall("SuperLU_DIST:Destroy_LU",Destroy_LU(N, &lu->grid, &lu->LUstruct)); /* Deallocate storage associated with the L and U matrices. */
lu->options.Fact = SamePattern;
}
}
nz = 0;
for (i=0; i<m; i++) {
lu->row[i] = nz;
countA = ai[i+1] - ai[i];
countB = bi[i+1] - bi[i];
ajj = aj + ai[i]; /* ptr to the beginning of this row */
bjj = bj + bi[i];
/* B part, smaller col index */
colA_start = rstart + ajj[0]; /* the smallest global col index of A */
jB = 0;
for (j=0; j<countB; j++) {
jcol = garray[bjj[j]];
if (jcol > colA_start) {
jB = j;
break;
}
lu->col[nz] = jcol;
lu->val[nz++] = *bv++;
if (j==countB-1) jB = countB;
}
/* A part */
for (j=0; j<countA; j++) {
lu->col[nz] = rstart + ajj[j];
lu->val[nz++] = *av++;
}
/* B part, larger col index */
for (j=jB; j<countB; j++) {
lu->col[nz] = garray[bjj[j]];
lu->val[nz++] = *bv++;
}
}
lu->row[m] = nz;
#if defined(PETSC_USE_COMPLEX)
PetscStackCall("SuperLU_DIST:zCreate_CompRowLoc_Matrix_dist",zCreate_CompRowLoc_Matrix_dist(&lu->A_sup, M, N, nz, m, rstart,lu->val, lu->col, lu->row, SLU_NR_loc, SLU_Z, SLU_GE));
#else
PetscStackCall("SuperLU_DIST:dCreate_CompRowLoc_Matrix_dist",dCreate_CompRowLoc_Matrix_dist(&lu->A_sup, M, N, nz, m, rstart,lu->val, lu->col, lu->row, SLU_NR_loc, SLU_D, SLU_GE));
#endif
}
/* Factor the matrix. */
PetscStackCall("SuperLU_DIST:PStatInit",PStatInit(&stat)); /* Initialize the statistics variables. */
if (lu->MatInputMode == GLOBAL) { /* global mat input */
#if defined(PETSC_USE_COMPLEX)
PetscStackCall("SuperLU_DIST:pzgssvx_ABglobal",pzgssvx_ABglobal(&lu->options, &lu->A_sup, &lu->ScalePermstruct, 0, M, 0,&lu->grid, &lu->LUstruct, berr, &stat, &sinfo));
#else
PetscStackCall("SuperLU_DIST:pdgssvx_ABglobal",pdgssvx_ABglobal(&lu->options, &lu->A_sup, &lu->ScalePermstruct, 0, M, 0,&lu->grid, &lu->LUstruct, berr, &stat, &sinfo));
#endif
} else { /* distributed mat input */
#if defined(PETSC_USE_COMPLEX)
PetscStackCall("SuperLU_DIST:pzgssvx",pzgssvx(&lu->options, &lu->A_sup, &lu->ScalePermstruct, 0, m, 0, &lu->grid,&lu->LUstruct, &lu->SOLVEstruct, berr, &stat, &sinfo));
if (sinfo) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"pzgssvx fails, info: %d\n",sinfo);
#else
PetscStackCall("SuperLU_DIST:pdgssvx",pdgssvx(&lu->options, &lu->A_sup, &lu->ScalePermstruct, 0, m, 0, &lu->grid,&lu->LUstruct, &lu->SOLVEstruct, berr, &stat, &sinfo));
if (sinfo) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"pdgssvx fails, info: %d\n",sinfo);
#endif
}
if (lu->MatInputMode == GLOBAL && size > 1) {
ierr = MatDestroy(&A_seq);CHKERRQ(ierr);
}
if (lu->options.PrintStat) {
PStatPrint(&lu->options, &stat, &lu->grid); /* Print the statistics. */
}
PStatFree(&stat);
if (size > 1) {
F_diag = ((Mat_MPIAIJ*)(F)->data)->A;
F_diag->assembled = PETSC_TRUE;
}
(F)->assembled = PETSC_TRUE;
(F)->preallocated = PETSC_TRUE;
lu->options.Fact = FACTORED; /* The factored form of A is supplied. Local option used by this func. only */
PetscFunctionReturn(0);
}
