int pmatsetup(void *MM, int m){
plapackM* ctx=(plapackM*)MM;
MPI_Comm rowcomm,colcomm;
int itmp,nprocs,info;
DSDPFunctionBegin;
ctx->global_size=m;
info = MPI_Comm_size(ctx->mpi_comm,&nprocs); DSDPCHKERR(info);
itmp=(m-nprocs+1)/nprocs;
itmp=DSDPMax(2,itmp);
ctx->nb_distr=DSDPMin(ctx->nb_distr,itmp);
info = PLA_Comm_1D_to_2D_ratio(ctx->mpi_comm,ctx->ratio,&ctx->plapack_comm); DSDPCHKERR(info);
info = PLA_Init(ctx->plapack_comm); DSDPCHKERR(info);
info = PLA_Temp_create(ctx->nb_distr, 0, &ctx->templ); DSDPCHKERR(info);
info=PLA_Matrix_create(MPI_DOUBLE, m, m, ctx->templ,
PLA_ALIGN_FIRST, PLA_ALIGN_FIRST, &ctx->AMat);DSDPCHKERR(info);
info=PLA_Mvector_create(MPI_DOUBLE, m, 1, ctx->templ, PLA_ALIGN_FIRST, &ctx->vVec);DSDPCHKERR(info);
info=PLA_Mvector_create(MPI_DOUBLE, m, 1, ctx->templ, PLA_ALIGN_FIRST, &ctx->wVec);DSDPCHKERR(info);
info=PLA_Mscalar_create( MPI_DOUBLE, PLA_ALL_ROWS, PLA_ALL_COLS, 1, 1, ctx->templ, &ctx->dxerror );DSDPCHKERR(info);
info=PLA_Mscalar_create( MPI_DOUBLE, PLA_ALL_ROWS, PLA_ALL_COLS, 1, 1, ctx->templ, &ctx->one );DSDPCHKERR(info);
info=PLA_Mscalar_create( MPI_DOUBLE, PLA_ALL_ROWS, PLA_ALL_COLS, 1, 1, ctx->templ, &ctx->zero );DSDPCHKERR(info);
info=PLA_Obj_set_to_one(ctx->one);DSDPCHKERR(info);
info=PLA_Obj_set_to_zero(ctx->zero);DSDPCHKERR(info);
info = MPI_Comm_rank(ctx->plapack_comm,&ctx->rank); DSDPCHKERR(info);
info = MPI_Comm_size(ctx->plapack_comm,&ctx->nprocs); DSDPCHKERR(info);
info = PLA_Temp_comm_col_info(ctx->templ, &rowcomm, &ctx->rowrank, &ctx->numrownodes); DSDPCHKERR(info);
info = PLA_Temp_comm_row_info(ctx->templ, &colcomm, &ctx->colrank, &ctx->numcolnodes); DSDPCHKERR(info);
ctx->t0=0;ctx->t1=0;ctx->t2=0;
ctx->thessian=0;ctx->tsolve=0;
wallclock(&ctx->t0);
DSDPFunctionReturn(0);
}
int main(int argc, char *argv[])
{
MPI_Comm
comm = MPI_COMM_NULL;
MPI_Datatype
datatype;
PLA_Template
templ = NULL;
PLA_Obj
A_orig = NULL, A = NULL, Q = NULL, diag = NULL, B = NULL,
minus_one = NULL, zero = NULL, one = NULL;
int
n,
nb_distr, nb_alg,
error, parameters, sequential,
me, nprocs, nprows, npcols,
itype;
double
time,
flops,
d_abs_max,
PLA_Local_abs_max();
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &me);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
if (me==0) {
printf("enter mesh size:\n");
scanf("%d%d", &nprows, &npcols );
printf("mesh size = %d x %d \n", nprows, npcols );
printf("enter distr. block size:\n");
scanf("%d", &nb_distr );
printf("nb_distr = %d\n", nb_distr );
printf("enter alg. block size:\n");
scanf("%d", &nb_alg );
printf("nb_alg = %d\n", nb_alg );
printf("turn on error checking? (0 = NO, 1 = YES):\n");
scanf("%d", &error );
printf("error checking = %d\n", error );
printf("turn on parameter checking? (0 = NO, 1 = YES):\n");
scanf("%d", ¶meters );
printf("parameter checking = %d\n", parameters );
printf("turn on sequential checking? (0 = NO, 1 = YES):\n");
scanf("%d", &sequential );
printf("sequential checking = %d\n", sequential );
}
MPI_Bcast(&nprows, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&npcols, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&nb_distr, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&nb_alg, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&error, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(¶meters, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&sequential, 1, MPI_INT, 0, MPI_COMM_WORLD);
pla_Environ_set_nb_alg( PLA_OP_ALL_ALG, nb_alg );
PLA_Set_error_checking( error, parameters, sequential, FALSE );
/* PLA_Comm_1D_to_2D_ratio(MPI_COMM_WORLD, 1.0, &comm); */
PLA_Comm_1D_to_2D(MPI_COMM_WORLD, nprows, npcols, &comm);
PLA_Init(comm);
PLA_Temp_create( nb_distr, 0, &templ );
while ( TRUE ){
if (me==0) {
printf("enter datatype:\n");
printf("-1 = quit\n");
printf(" 0 = float\n");
printf(" 1 = double\n");
printf(" 2 = complex\n");
printf(" 3 = double complex\n");
scanf("%d", &itype );
printf("itype = %d\n", itype );
}
MPI_Bcast(&itype, 1, MPI_INT, 0, MPI_COMM_WORLD);
if ( itype == -1 ) break;
switch( itype ){
case 0:
datatype = MPI_FLOAT;
break;
case 1:
datatype = MPI_DOUBLE;
break;
case 2:
datatype = MPI_COMPLEX;
break;
case 3:
datatype = MPI_DOUBLE_COMPLEX;
break;
default:
PLA_Abort( "unknown datatype", __LINE__, __FILE__ );
}
if (me==0) {
printf("enter n:\n");
scanf("%d", &n );
printf("n = %d\n", n );
}
MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);
PLA_Matrix_create( datatype,
n,
n,
templ,
PLA_ALIGN_FIRST,
PLA_ALIGN_FIRST,
&A_orig );
PLA_Matrix_create_conf_to( A_orig, &Q );
PLA_Matrix_create_conf_to( A_orig, &A );
PLA_Mvector_create( datatype,
n,
1,
templ,
PLA_ALIGN_FIRST,
&diag );
PLA_Create_constants_conf_to( A, &minus_one, &zero, &one );
create_diag( diag );
PLA_Create_sym_eigenproblem( PLA_LOWER_TRIANGULAR, 3, diag, A_orig, Q );
PLA_Copy( A_orig, A );
MPI_Barrier( MPI_COMM_WORLD );
time = MPI_Wtime ();
PLA_Spectral_decomp( PLA_LOWER_TRIANGULAR, A, Q, diag );
MPI_Barrier( MPI_COMM_WORLD );
time = MPI_Wtime () - time;
/******* Check answer *******/
/* Make A_orig symmetric */
PLA_Symmetrize( PLA_LOWER_TRIANGULAR, A_orig );
PLA_Matrix_create_conf_to( A_orig, &B );
PLA_Obj_set_to_zero( A );
PLA_Obj_set_diagonal( A, diag );
/* A_orig = A_orig - Q diag Q^T */
PLA_Gemm( PLA_NO_TRANSPOSE, PLA_NO_TRANSPOSE,
one, Q, A, zero, B );
PLA_Gemm( PLA_NO_TRANSPOSE, PLA_TRANSPOSE,
minus_one, B, Q, one, A_orig );
/* Extract absolute value of entry with largest absolute value in A_orig */
d_abs_max = PLA_Local_abs_max( A_orig );
if ( d_abs_max > 0.000000001 )
printf( "large error detected: %le\n", d_abs_max );
flops = 4.0/3.0 * n * n * n;
if ( me == 0 )
printf("%d time = %f, MFLOPS/node = %10.4lf \n", n, time,
flops / time * 1.0e-6 / nprocs );
PLA_Obj_free( &A_orig );
PLA_Obj_free( &A );
PLA_Obj_free( &Q );
PLA_Obj_free( &diag );
PLA_Obj_free( &B );
PLA_Obj_free( &minus_one );
PLA_Obj_free( &zero );
PLA_Obj_free( &one );
}
PLA_Temp_free(&templ);
PLA_Finalize( );
MPI_Finalize( );
}
int main(int argc, char *argv[])
{
MPI_Comm
comm = MPI_COMM_NULL;
MPI_Datatype
datatype;
PLA_Template
templ = NULL;
PLA_Obj
A = NULL, pivots = NULL,
zero = NULL, one = NULL;
int
n,
nb_distr, nb_alg,
error, parameters, sequential,
me, nprocs, nprows, npcols,
itype;
double
time,
flops;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &me);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
if (me==0) {
printf("enter mesh size:\n");
scanf("%d%d", &nprows, &npcols );
printf("mesh size = %d x %d \n", nprows, npcols );
printf("enter distr. block size:\n");
scanf("%d", &nb_distr );
printf("nb_distr = %d\n", nb_distr );
printf("enter alg. block size:\n");
scanf("%d", &nb_alg );
printf("nb_alg = %d\n", nb_alg );
printf("turn on error checking? (0 = NO, 1 = YES):\n");
scanf("%d", &error );
printf("error checking = %d\n", error );
printf("turn on parameter checking? (0 = NO, 1 = YES):\n");
scanf("%d", ¶meters );
printf("parameter checking = %d\n", parameters );
printf("turn on sequential checking? (0 = NO, 1 = YES):\n");
scanf("%d", &sequential );
printf("sequential checking = %d\n", sequential );
}
MPI_Bcast(&nprows, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&npcols, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&nb_distr, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&nb_alg, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&error, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(¶meters, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&sequential, 1, MPI_INT, 0, MPI_COMM_WORLD);
pla_Environ_set_nb_alg( PLA_OP_ALL_ALG, nb_alg );
PLA_Set_error_checking( error, parameters, sequential, FALSE );
/* PLA_Comm_1D_to_2D_ratio(MPI_COMM_WORLD, 1.0, &comm); */
PLA_Comm_1D_to_2D(MPI_COMM_WORLD, nprows, npcols, &comm);
PLA_Init(comm);
PLA_Temp_create( nb_distr, 0, &templ );
while ( TRUE ){
if (me==0) {
printf("enter datatype:\n");
printf("-1 = quit\n");
printf(" 0 = float\n");
printf(" 1 = double\n");
printf(" 2 = complex\n");
printf(" 3 = double complex\n");
scanf("%d", &itype );
printf("itype = %d\n", itype );
}
MPI_Bcast(&itype, 1, MPI_INT, 0, MPI_COMM_WORLD);
if ( itype == -1 ) break;
switch( itype ){
case 0:
datatype = MPI_FLOAT;
break;
case 1:
datatype = MPI_DOUBLE;
break;
case 2:
datatype = MPI_COMPLEX;
break;
case 3:
datatype = MPI_DOUBLE_COMPLEX;
break;
default:
PLA_Abort( "unknown datatype", __LINE__, __FILE__ );
}
if (me==0) {
printf("enter n:\n");
scanf("%d", &n );
printf("n = %d\n", n );
}
MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);
PLA_Matrix_create( datatype,
n,
n,
templ,
PLA_ALIGN_FIRST,
PLA_ALIGN_FIRST,
&A );
PLA_Mvector_create( MPI_INT,
n,
1,
templ,
PLA_ALIGN_FIRST,
&pivots );
create_problem( A );
MPI_Barrier( MPI_COMM_WORLD );
time = MPI_Wtime ();
PLA_LU( A, pivots );
MPI_Barrier( MPI_COMM_WORLD );
time = MPI_Wtime () - time;
flops = 2.0/3.0 * n * n * n;
if ( me == 0 )
printf("%d time = %f, MFLOPS/node = %10.4lf \n", n, time,
flops / time * 1.0e-6 / nprocs );
}
PLA_Obj_free( &A );
PLA_Obj_free( &pivots );
PLA_Obj_free( &zero );
PLA_Obj_free( &one );
PLA_Temp_free(&templ);
PLA_Finalize( );
MPI_Finalize( );
}
int main(int argc, char *argv[])
{
/* Declarations */
MPI_Comm
comm;
PLA_Template
templ = NULL;
PLA_Obj
A = NULL, rhs = NULL,
A_append = NULL,
pivots = NULL,
x = NULL,
b = NULL,
b_norm = NULL,
index = NULL,
minus_one = NULL;
double
operation_count,
b_norm_value,
time;
int
size,
nb_distr, nb_alg,
me, nprocs,
nprows, npcols,
dummy,
ierror,
info = 0;
MPI_Datatype
datatype;
/* Initialize MPI */
MPI_Init(&argc, &argv);
#if MANUFACTURE == CRAY
set_d_stream( 1 );
#endif
/* Get problem size and distribution block size and broadcast */
MPI_Comm_rank(MPI_COMM_WORLD, &me);
if (0 == me) {
printf("enter processor mesh dimension ( rows cols ):\n");
scanf("%d %d", &nprows, &npcols );
printf("enter matrix size, distr. block size:\n");
scanf("%d %d", &size, &nb_distr );
printf("enter algorithmic blocksize:\n");
scanf("%d", &nb_alg );
printf("Turn on error checking? (1 = YES, 0 = NO):\n");
scanf("%d", &ierror );
}
MPI_Bcast(&nprows, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&npcols, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&size, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&nb_distr, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&nb_alg, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&ierror, 1, MPI_INT, 0, MPI_COMM_WORLD);
if ( ierror )
PLA_Set_error_checking( ierror, TRUE, TRUE, FALSE );
else
PLA_Set_error_checking( ierror, FALSE, FALSE, FALSE );
pla_Environ_set_nb_alg (PLA_OP_ALL_ALG,
nb_alg);
/* Create a 2D communicator */
PLA_Comm_1D_to_2D(MPI_COMM_WORLD, nprows, npcols, &comm);
/* Initialize PLAPACK */
PLA_Init(comm);
/* Create object distribution template */
PLA_Temp_create( nb_distr, 0, &templ );
/* Set the datatype */
datatype = MPI_DOUBLE;
/* Create objects for problem to be solved */
/* Matrix A is big enough to hold the right-hand-side appended */
PLA_Matrix_create( datatype, size, size+1,
templ, PLA_ALIGN_FIRST, PLA_ALIGN_FIRST, &A_append );
PLA_Mvector_create( datatype, size, 1, templ, PLA_ALIGN_FIRST, &x );
PLA_Mvector_create( datatype, size, 1, templ, PLA_ALIGN_FIRST, &b );
PLA_Mvector_create( MPI_INT, size, 1, templ, PLA_ALIGN_FIRST, &pivots );
/* Create 1x1 multiscalars to hold largest (in abs. value) element
of b - x and index of largest value */
PLA_Mscalar_create( MPI_DOUBLE,
PLA_ALL_ROWS, PLA_ALL_COLS,
1, 1, templ, &b_norm );
/* Create duplicated scalar constants with same datatype and template as A */
PLA_Create_constants_conf_to( A_append, &minus_one, NULL, NULL );
/* View the appended system as the matrix and the right-hand-side */
PLA_Obj_vert_split_2( A_append, -1, &A, &rhs );
/* Create a problem to be solved: A x = b */
create_problem( A, x, b );
/* Copy b to the appended column */
PLA_Copy( b, rhs );
/* Start timing */
MPI_Barrier( MPI_COMM_WORLD );
time = MPI_Wtime( );
/* Factor P A_append -> L U overwriting lower triangular portion of A with L, upper, U */
info = PLA_LU( A_append, pivots);
if ( info != 0 ) {
printf("Zero pivot encountered at row %d.\n", info);
}
else {
/* Apply the permutations to the right hand sides */
/* Not necessery since system was appended */
/* PLA_Apply_pivots_to_rows ( b, pivots); */
/* Solve L y = b, overwriting b with y */
/* Not necessary since the system was appended */
/* PLA_Trsv( PLA_LOWER_TRIANGULAR, PLA_NO_TRANSPOSE, PLA_UNIT_DIAG, A, b ); */
PLA_Copy( rhs, b );
/* Solve U x = y (=b), overwriting b with x */
PLA_Trsv( PLA_UPPER_TRIANGULAR, PLA_NO_TRANSPOSE, PLA_NONUNIT_DIAG, A, b );
/* Stop timing */
MPI_Barrier( MPI_COMM_WORLD );
time = MPI_Wtime() - time;
/* Report performance */
if ( me == 0 ) {
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
operation_count = 2.0/3.0 * size * size * size;
printf("n = %d, time = %lf, MFLOPS/node = %lf\n", size, time,
operation_count / time * 1.0e-6 / nprocs );
}
/* Process the answer. As an example, this routine brings
result x (stored in b) to processor 0 and prints first and
last entry */
Process_answer( b );
/* Check answer by overwriting b <- b - x (where b holds computed
approximation to x) */
PLA_Axpy( minus_one, x, b );
PLA_Nrm2( b, b_norm);
/* Report norm of b - x */
if ( me == 0 ) {
PLA_Obj_get_local_contents( b_norm, PLA_NO_TRANS, &dummy, &dummy,
&b_norm_value, 1, 1 );
printf( "Norm2 of x - computed x : %le\n", b_norm_value );
}
}
printf("****************************************************************\n");
printf("* NOTE: while this driver times all operations performed by *\n");
printf("* a LINPACK benchmark, it does not use the ScaLAPACK random *\n");
printf("* matrix generator and thus according to the rules of the *\n");
printf("* LINPACK benchmark is not an official implementation. *\n");
printf("* Contact [email protected] if you are interested in creating *\n");
printf("* a version that does meet the rules. *\n");
printf("****************************************************************\n");
/* Free the linear algebra objects */
PLA_Obj_free(&A); PLA_Obj_free(&x);
PLA_Obj_free(&b); PLA_Obj_free(&minus_one);
PLA_Obj_free(&b_norm); PLA_Obj_free(&pivots);
PLA_Obj_free(&A_append); PLA_Obj_free(&rhs);
/* Free the template */
PLA_Temp_free(&templ);
/* Finalize PLAPACK and MPI */
PLA_Finalize( );
MPI_Finalize( );
}