irregular_array1(int rank)
{
int g_A, g_B;
int dims[DIM]={5,10}, dims2[DIM], ndim, type, value=5, block[DIM]={2,3}, map[5]={0,2,0,4,6}, val=7;
int n_block[DIM], block_dims[DIM], i;
g_A = NGA_Create(C_INT, DIM, dims, "array_A", NULL);
g_B = NGA_Create_irreg(C_INT, DIM, dims, "array_B", block, map);
GA_Fill(g_A, &value);
GA_Print(g_A);
GA_Fill(g_B, &val);
GA_Print(g_B);
GA_Sync();
NGA_Inquire(g_A, &type, &ndim, dims2);
//printf(" %d -- %d,,\n", type, ndim);
/*
GA_Get_block_info(g_B, n_block, block_dims);
for(i=0; i<DIM; i++)
printf(" %d: %d ___ %d --- \n", rank, n_block[i], block_dims[i]);
*/
GA_Destroy(g_A);
GA_Destroy(g_B);
}
irregular_array2(int rank)
{
int g_A, g_B;
int dims[DIM]={GSIZE,GSIZE}, dims2[DIM], block[DIM]={3,2}, map[5]={0,2,6,0,4}, val_A=4, val_B=7;
int n_block[DIM], block_dims[DIM], i;
g_A = NGA_Create(C_INT, DIM, dims, "array_A", NULL);
g_B = NGA_Create_irreg(C_INT, DIM, dims, "array_B", block, map);
GA_Fill(g_A, &val_A);
GA_Print(g_A);
GA_Fill(g_B, &val_B);
GA_Print(g_B);
GA_Sync();
/*
GA_Get_block_info(g_B, n_block, block_dims);
for(i=0; i<DIM; i++)
printf(" %d: %d ___ %d --- \n", rank, n_block[i], block_dims[i]);
*/
GA_Destroy(g_A);
GA_Destroy(g_B);
}
/**
* Based on previously calculated offsets, set indices for a buses and branches.
* It is up to the individual bus and branch implementations to store these
* values.
*/
void setIndices(void)
{
// Construct lists of indices that need to be collected
int **bus_index = new int*[p_nBuses];
int **branch_index = new int*[p_nBranches];
int *bus_index_buf = new int[p_nBuses];
int *branch_index_buf = new int[p_nBranches];
int *i_bus_value_buf = new int[p_nBuses];
int *i_branch_value_buf = new int[p_nBranches];
int i, j;
// Get offsets for all buses and branches;
for (i=0; i<p_nBuses; i++) {
bus_index_buf[i] = p_network->getGlobalBusIndex(i);
bus_index[i] = &bus_index_buf[i];
}
for (i=0; i<p_nBranches; i++) {
branch_index_buf[i] = p_network->getGlobalBranchIndex(i);
branch_index[i] = &branch_index_buf[i];
}
NGA_Gather(g_bus_offsets, i_bus_value_buf, bus_index, p_nBuses);
NGA_Gather(g_branch_offsets, i_branch_value_buf, branch_index, p_nBranches);
// Offsets are now available. Set indices in all network components
int offset, nrows, ncols, idx;
for (i=0; i<p_nBuses; i++) {
nrows = p_network->getBus(i)->vectorNumElements();
if (nrows > 0) {
offset = i_bus_value_buf[i];
for (j=0; j<nrows; j++) {
idx = offset+j;
p_network->getBus(i)->vectorSetElementIndex(j,idx);
}
}
}
for (i=0; i<p_nBranches; i++) {
nrows = p_network->getBranch(i)->vectorNumElements();
if (nrows > 0) {
offset = i_branch_value_buf[i];
for (j=0; j<nrows; j++) {
idx = offset+j;
p_network->getBranch(i)->vectorSetElementIndex(j,idx);
}
}
}
delete [] bus_index;
delete [] branch_index;
delete [] bus_index_buf;
delete [] branch_index_buf;
delete [] i_bus_value_buf;
delete [] i_branch_value_buf;
// Global arrays are no longer needed so we can get rid of them
GA_Destroy(g_bus_offsets);
GA_Destroy(g_branch_offsets);
}
main(int argc, char **argv)
{
int rank, nprocs, i, j;
int g_A, g_B;
int dims[MAX_DIM], val=4, ndim, re;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
MA_init(C_INT, 1000, 1000);
GA_Initialize();
for(i=1; i<=MAX_DIM; i++)
{
ndim=i;
dims[i]=SIZE;
// for(j=0; j<ndim; j++)
g_A = NGA_Create(C_INT, ndim, dims, "array_A", NULL);
g_B = NGA_Create(C_INT, ndim, dims, "array_B", NULL);
if(!g_A)
GA_Error("GA Error: no global array exists \n", ndim);
if(!g_B)
GA_Error("GA Error: no global array exists \n", ndim);
}
GA_Sync();
GA_Fill(g_A, &val);
re=GA_Solve(g_A, g_B);
if(re==0)
printf("Cholesky Fact is Successful \n");
else if (re >0)
printf("Cholesky Fact couldn't be completed \n");
else
printf("An Error occured\n");
if(rank == 0)
GA_PRINT_MSG();
GA_Destroy(g_A);
GA_Destroy(g_B);
GA_Terminate();
MPI_Finalize();
}
int main(int argc, char** argv)
{
int nprocs,myid,nprocssq;
int dims[2],chunk[2];
int i,j,k;
int stack = 100000, heap = 100000;
MPI_Init(&argc,&argv);
GA_Initialize();
MA_init(C_DBL,stack,heap);
nprocssq = GA_Nnodes();
nprocs = sqrt(nprocssq);
myid = GA_Nodeid();
dims[0] = N; dims[1] = N;
chunk[0] = N/nprocs;
chunk[1] = N/nprocs;
int g_a = NGA_Create(C_DBL,2,dims,"Array A",chunk);
int lo[2],hi[2];
NGA_Distribution(g_a,myid,lo,hi);
int ld[1] = {N/nprocs};
void *ptr;
double *local;
printf("Myid = %d, lo = [%d,%d] , hi = [%d,%d] , ld = %d \n",myid,lo[0],lo[1],hi[0],hi[1],ld[0]);
NGA_Access(g_a,lo,hi,&ptr,ld);
local = (double*) ptr;
printf("Myid = %d , local[0][0] = %f\n",*local);
GA_Sync();
GA_Destroy(g_a);
GA_Terminate();
MPI_Finalize();
return 0;
}
Integer util_gnxtval_(Integer *val) {
if(*val > 0) {
if(!initialized) ga_error("nxtval: not yet initialized", 0L);
return (Integer) NGA_Read_inc(g_T, &subscript, 1);
}
else if(*val==0) {
int n = 1;
initialized=1;
/* create task array */
g_T = NGA_Create(C_LONG, 1, &n,"Atomic Task", NULL);
/* Initialize the task array */
if(GA_Nodeid()==0) {
int lo=0, hi=0;
NGA_Put (g_T, &lo, &hi, &initval, &hi);
initval=0;
}
GA_Sync();
return 0;
}
else if (*val < 0) { GA_Destroy(g_T); initialized=0; initval=0; return 0;}
ga_error("nxtval: invalid value passed", 0L);
return -1;
}
fillandscale(int rank, int nprocs)
{
int g_A, val1=5, val2=5, local_A[SIZE][SIZE], i, j;
int dims[DIM]={SIZE,SIZE}, alo[DIM]={1,1}, ahi[DIM]={2,2}, ld=5;
g_A = NGA_Create(C_INT, DIM, dims, "array_A", NULL);
GA_Zero(g_A);
NGA_Fill_patch(g_A, alo, ahi, &val1);
GA_Print(g_A);
GA_Scale(g_A, &val2);
GA_Print(g_A);
NGA_Get(g_A, alo, ahi, local_A, &ld);
if(rank == 1)
{
for(i=0; i<DIM; i++)
{
for(j=0; j<DIM; j++) if(local_A[i][j]!=val1*val2)
printf(" GA ERROR: \n");
}
}
GA_Destroy(g_A);
}
void verify(int g_a, int g_b, int g_c, int *lo, int *hi, int *ld, int N)
{
double rchk, alpha=1.0, beta=0.0;
int g_chk, me=GA_Nodeid();
g_chk = GA_Duplicate(g_a, "array Check");
if(!g_chk) GA_Error("duplicate failed",NDIMS);
GA_Sync();
GA_Dgemm('n', 'n', N, N, N, 1.0, g_a,
g_b, 0.0, g_chk);
GA_Sync();
alpha=1.0, beta=-1.0;
GA_Add(&alpha, g_c, &beta, g_chk, g_chk);
rchk = GA_Ddot(g_chk, g_chk);
if (me==0) {
printf("Normed difference in matrices: %12.4e\n", rchk);
if(rchk < -TOLERANCE || rchk > TOLERANCE)
GA_Error("Matrix multiply verify failed",0);
else
printf("Matrix Mutiply OK\n");
}
GA_Destroy(g_chk);
}
// -------------------------------------------------------------
// MatMult_DenseGA
// -------------------------------------------------------------
static
PetscErrorCode
MatMult_DenseGA(Mat mat, Vec x, Vec y)
{
// FIXME: I'm assuming the Mat and Vec's are compatible and that's
// been checked somewhere else. Probably a mistake.
PetscErrorCode ierr = 0;
struct MatGACtx *ctx;
ierr = MatShellGetContext(mat, &ctx); CHKERRQ(ierr);
PetscInt Arows, Acols;
ierr = MatGetSize(mat, &Arows, &Acols); CHKERRQ(ierr);
int g_x, g_y;
ierr = Vec2GA(x, ctx->gaGroup, &g_x, false); CHKERRQ(ierr);
ierr = Vec2GA(y, ctx->gaGroup, &g_y, false); CHKERRQ(ierr);
PetscScalarGA alpha(one), beta(zero);
int ndim, itype, lo[2] = {0,0}, ahi[2], xhi[2], yhi[2];
NGA_Inquire(ctx->ga, &itype, &ndim, ahi);
ahi[0] -= 1; ahi[1] -= 1;
NGA_Inquire(g_x, &itype, &ndim, xhi);
xhi[0] -= 1; xhi[1] -= 1;
NGA_Inquire(g_y, &itype, &ndim, yhi);
yhi[0] -= 1; yhi[1] -= 1;
// GA_Print(ctx->ga);
// GA_Print(g_x);
NGA_Matmul_patch('N', 'N', &alpha, &beta,
ctx->ga, lo, ahi,
g_x, lo, xhi,
g_y, lo, yhi);
GA_Pgroup_sync(ctx->gaGroup);
// GA_Print(g_y);
ierr = GA2Vec(g_y, y); CHKERRQ(ierr);
GA_Destroy(g_y);
GA_Destroy(g_x);
MPI_Comm comm;
ierr = PetscObjectGetComm((PetscObject)mat,&comm); CHKERRQ(ierr);
ierr = MPI_Barrier(comm);
return ierr;
}
PetscErrorCode testCreate2D()
{
int ga;
DA da;
DALocalInfo info;
Vec vec;
PetscErrorCode ierr;
PetscFunctionBegin;
int d1 = 1453, d2 = 1451;
ierr = DACreate2d(PETSC_COMM_WORLD,DA_NONPERIODIC,DA_STENCIL_STAR,
d1,d2,PETSC_DECIDE,PETSC_DECIDE,1,1,0,0, &da); CHKERRQ(ierr);
ierr = DAGetLocalInfo(da,&info); CHKERRQ(ierr);
ierr = DACreateGlobalArray( da, &ga, &vec); CHKERRQ(ierr);
PetscReal **v;
ierr = DAVecGetArray(da,vec,&v); CHKERRQ(ierr);
int xe = info.xs+info.xm,
ye = info.ys+info.ym;
for (int j = info.ys; j < ye; ++j) {
for (int i = info.xs; i < xe; ++i) {
v[j][i] = 1.*i + d1 * j;
}
}
ierr = DAVecRestoreArray(da,vec,&v); CHKERRQ(ierr);
PetscPrintf(PETSC_COMM_WORLD,"Updated local portion with DAVec\n");
PetscBarrier(0);
{
double *da_ptr;
VecGetArray(vec, &da_ptr);
double *ptr;
int low[2],hi[2],ld;
NGA_Distribution(ga,GA_Nodeid(),low,hi);
NGA_Access(ga,low,hi,&ptr,&ld);
printf("[%d] ga:%p\tda:%p\tdiff:%p\n", GA_Nodeid(), ptr, da_ptr, (ptr-da_ptr) );
NGA_Release_update(ga,low,hi);
}
int lo[2],ld;
double val;
for (int j = 0; j < d2; ++j) {
for (int i = 0; i < d1; ++i) {
lo[0] = j;
lo[1] = i;
NGA_Get(ga,lo,lo,&val,&ld);
if( PetscAbs( i + d1*j - val) > .1 )
printf(".");
// printf("[%d] (%3.0f,%3.0f)\n", GA_Nodeid(), 1.*i + d1*j, val);
}
}
GA_Print_stats();
ierr = VecDestroy(vec); CHKERRQ(ierr);
GA_Destroy(ga);
PetscFunctionReturn(0);
}
verify_ga_dim(int ndim)
{
int g_A, dims[ndim], i;
for(i=0; i<ndim; i++) dims[i]=SIZE;
g_A = NGA_Create(C_INT, ndim, dims, "array_A", NULL);
if(GA_Ndim(g_A) != ndim)
printf("ERROR: GA_Ndim -- %d returned wrong \n", ndim);
GA_Destroy(g_A);
}
main(int argc, char **argv)
{
int rank, nprocs, i, j;
int g_A, **local_A=NULL, **local_B=NULL;
int dims[DIM]={SIZE,SIZE}, dims2[DIM], lo[DIM]={SIZE-SIZE,SIZE-SIZE}, hi[DIM]={SIZE-1,SIZE-1}, ld=5, value=5;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
MA_init(C_INT, 1000, 1000);
GA_Initialize();
local_A=(int**)malloc(SIZE*sizeof(int*));
for(i=0; i<SIZE; i++)
{
local_A[i]=(int*)malloc(SIZE*sizeof(int));
for(j=0; j<SIZE; j++) local_A[i][j]=rand()%10;
}
local_B=(int**)malloc(SIZE*sizeof(int*));
for(i=0; i<SIZE; i++)
{
local_B[i]=(int*)malloc(SIZE*sizeof(int));
for(j=0; j<SIZE; j++) local_B[i][j]=rand()%10;
}
g_A = NGA_Create(C_INT, DIM, dims, "array_A", NULL);
GA_Zero(g_A);
if(rank==0)
{
NGA_Put(g_A, lo, hi, local_A, &ld);
NGA_Get(g_A, lo, hi, local_B, &ld);
for(i=0; i<SIZE; i++)
{
for(j=0; j<SIZE; j++)
if(local_A[i][j]!=local_B[i][j]) GA_ERROR_MSG();
}
}
GA_Sync();
GA_Destroy(g_A);
if(rank == 0) GA_PRINT_MSG();
GA_Terminate();
MPI_Finalize();
}
auto_number2(int rank, int nprocs)
{
int g_A, g_B;
int dims[DIM]={GSIZE, GSIZE}, dims2[DIM], block[DIM], *map=NULL, val=7;
int n_block[DIM], block_dims[DIM], b_temp, i;
int b1, b2, inc=0;
do{
b2=DIM+inc;
b1=nprocs/b2;
inc++;
}while(nprocs/b2>=GSIZE);
block[0]=b1;
block[1]=b2;
map=(int*)malloc(nprocs*sizeof(int));
for(i=0; i<b1; i++)
map[i]=i;
for(i=b1; i<(b2+b1); i++)
map[i]=i-b1;
if(rank==0)
{
for(i=0; i<(b1+b2); i++)
printf("map[%d] - %d\n", i, map[i]);
for(i=0; i<DIM; i++)
printf("BLOCK[%d] - %d\n", i, block[i]);
}
g_B = NGA_Create_irreg(C_INT, DIM, dims, "array_B", block, map);
GA_Fill(g_B, &val);
GA_Print(g_B);
GA_Sync();
if(rank==1)
{
GA_Get_block_info(g_B, n_block, block_dims);
for(i=0; i<DIM; i++)
printf(" %d: %d --- %d ... %d\n", rank, n_block[i], block_dims[i], b_temp);
}
GA_Destroy(g_B);
}
// -------------------------------------------------------------
// MatDestroy_DenseGA
// -------------------------------------------------------------
static
PetscErrorCode
MatDestroy_DenseGA(Mat A)
{
PetscErrorCode ierr = 0;
MPI_Comm comm;
ierr = PetscObjectGetComm((PetscObject)A,&comm); CHKERRQ(ierr);
ierr = MPI_Barrier(comm);
struct MatGACtx *ctx;
ierr = MatShellGetContext(A, &ctx); CHKERRQ(ierr);
GA_Pgroup_sync(ctx->gaGroup);
GA_Destroy(ctx->ga);
// GA_Pgroup_destroy(ctx->gaGroup);
ierr = PetscFree(ctx);
return ierr;
}
Integer util_tcesublock_(Integer *val,Integer *p_handle) {
// if(*p_handle==0) exit(1);
//ga_error("nxtask: p_handle is zero", 1);
if(*val > 0) {
// if(!initialized) exit(1);
//ga_error("nxtask: not yet initialized", 1);
return (Integer) NGA_Read_inc(g_T, &subscript, 1);
}
else if(*val==0) {
int n = 1;
initialized=1;
int p_h = (int)*p_handle;
/* create task array */
// g_T = NGA_Create(C_LONG, 1, &n,"Atomic Task", NULL);
g_T = NGA_Create_config(C_LONG,1,&n,"Atomic Task",NULL,p_h);
/* Initialize the task array */
if(GA_Pgroup_nodeid(p_h)==0) {
int lo=0, hi=0;
NGA_Put (g_T, &lo, &hi, &initval, &hi);
// printf("PUT %i %i %i\n",sizeof(*p_handle),sizeof(Integer),sizeof(int));
initval=0;
}
GA_Pgroup_sync(p_h);
// printf("CREATE %i %i \n",*p_handle,g_T);
return 0;
}
else if (*val < 0) {
GA_Destroy(g_T);
// printf("DELETE %i %i \n",*p_handle,g_T);
// ga_pgroup_sync_(p_handle);
initialized=0;
initval=0;
return 0;
}
// ga_error("nxtval: invalid value passed", 0L);
return -1;
}
PetscErrorCode FluidFieldDestroy(FluidField f)
{
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = DMDestroy(&f->daV); CHKERRQ(ierr);
ierr = MatDestroy(&f->mat); CHKERRQ(ierr);
ierr = KSPDestroy(&f->ksp); CHKERRQ(ierr);
ierr = VecDestroy(&f->rhs); CHKERRQ(ierr);
ierr = VecDestroy(&f->vel); CHKERRQ(ierr);
ierr = VecDestroy(&f->vel0); CHKERRQ(ierr);
ierr = ArrayDestroy(f->dirichletBC); CHKERRQ(ierr);
GA_Destroy(f->ga);
ierr = DMDestroy(&f->daE); CHKERRQ(ierr);
// ierr = VecDestroy(f->E); CHKERRQ(ierr);
ierr = DMDestroy(&f->daB); CHKERRQ(ierr);
ierr = VecDestroy(&f->buf); CHKERRQ(ierr);
ierr = PetscFree(f); CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode testCreate3D( )
{
int ga;
DA da;
DALocalInfo info;
Vec vec;
PetscErrorCode ierr;
PetscFunctionBegin;
int d1 = 229, d2 = 229, d3 = 229;
int rank;
MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
ierr = DACreate3d(PETSC_COMM_WORLD,DA_NONPERIODIC,DA_STENCIL_STAR,
d1,d2,d3,
PETSC_DECIDE,PETSC_DECIDE,PETSC_DECIDE,
1,1,
0,0,0, &da); CHKERRQ(ierr);
ierr = DAGetLocalInfo(da,&info); CHKERRQ(ierr);
ierr = DACreateGlobalArray( da, &ga, &vec); CHKERRQ(ierr);
PetscReal ***v;
ierr = DAVecGetArray(da,vec,&v); CHKERRQ(ierr);
int xe = info.xs+info.xm,
ye = info.ys+info.ym,
ze = info.zs+info.zm;
for (int k = info.zs; k < ze; ++k) {
for (int j = info.ys; j < ye; ++j) {
for (int i = info.xs; i < xe; ++i) {
v[k][j][i] = 1.*i + d1*j + d1*d2*k;
}
}
}
ierr = DAVecRestoreArray(da,vec,&v); CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "Sequential values filled in petsc vec.\n"); CHKERRQ(ierr);
ierr = PetscBarrier(0); CHKERRQ(ierr);
int lo[3],ld, p = 10;
int patch[10][10][10];
double val;
for (int k = 0; k < d3; k+=p) {
for (int j = 0; j < d2; j+=p) {
for (int i = 0; i < d1; i+=p) {
lo[0] = k;
lo[1] = j;
lo[2] = i;
NGA_Get(ga,lo,lo,&val,&ld);
if( PetscAbs( i + d1*j + d1*d2*k - val) > .1 )
// printf(".");
printf("(%3.0f,%3.0f) ", 1.*i + d1*j + d1*d2*k, val);
}
}
}
ierr = PetscPrintf(PETSC_COMM_WORLD, "Ended NGA_Get() test.\n"); CHKERRQ(ierr);
ierr = PetscBarrier(0); CHKERRQ(ierr);
if( rank == 0 )
{
for (int k = 0; k < d3; ++k) {
printf(">%d\n",k);
for (int j = 0; j < d2; ++j) {
for (int i = 0; i < d1; ++i) {
lo[0] = k; lo[1] = j; lo[2] = i;
val = 1.*i + d1*j + d1*d2*k;
val *= -1;
NGA_Put(ga,lo,lo,&val,&ld);
}
}
}
}
ierr = PetscPrintf(PETSC_COMM_WORLD, "Ended NGA_Put() negative seq values.\n"); CHKERRQ(ierr);
ierr = PetscBarrier(0); CHKERRQ(ierr);
ierr = DAVecGetArray(da,vec,&v); CHKERRQ(ierr);
for (int k = info.zs; k < ze; ++k) {
for (int j = info.ys; j < ye; ++j) {
for (int i = info.xs; i < xe; ++i) {
val = -1 * (1.*i + d1*j + d1*d2*k);
if( PetscAbs( val - v[k][j][i] ) > .1 )
printf(".");
}
}
}
ierr = DAVecRestoreArray(da,vec,&v); CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "Ended petsc vec update test.\n"); CHKERRQ(ierr);
if( rank == 0 )
GA_Print_stats();
ierr = VecDestroy(vec); CHKERRQ(ierr);
GA_Destroy(ga);
PetscFunctionReturn(0);
}
PetscErrorCode vizGA2DA()
{
PetscErrorCode ierr;
int rank;
MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
int d1 = 40, d2 = 50;
DA da;
Vec vec;
const PetscInt *lx, *ly, *lz;
PetscInt m,n,p;
DALocalInfo info;
ierr = DACreate2d(PETSC_COMM_WORLD,DA_NONPERIODIC,DA_STENCIL_STAR,
d1,d2,PETSC_DECIDE,PETSC_DECIDE,1,1,0,0, &da); CHKERRQ(ierr);
ierr = DACreateGlobalVector(da, &vec); CHKERRQ(ierr);
ierr = DAGetOwnershipRanges(da, &lx, &ly, &lz); CHKERRQ(ierr);
ierr = DAGetLocalInfo(da,&info); CHKERRQ(ierr);
ierr = DAGetInfo(da,0,0,0,0,&m,&n,&p,0,0,0,0); CHKERRQ(ierr);
/**/
ierr = DAView(da, PETSC_VIEWER_STDOUT_WORLD); CHKERRQ(ierr);
for (int i = 0; i < m; ++i) {
PetscPrintf(PETSC_COMM_WORLD,"%d\tlx: %d\n",i,lx[i]);
}
for (int i = 0; i < n; ++i) {
PetscPrintf(PETSC_COMM_WORLD,"%d\tly: %d\n",i,ly[i]);
}
/**/
int ga = GA_Create_handle();
int ndim = 2;
int dims[2] = {d2,d1};
GA_Set_data(ga,2,dims,MT_DBL);
int *map;
PetscMalloc( sizeof(int)*(m+n), &map);
map[0] = 0;
for( int i = 1; i < n; i++ )
{
map[i] = ly[i-1] + map[i-1];
}
map[n] = 0;
for( int i = n+1; i < m+n; i++ )
{
map[i] = lx[i-n-1] + map[i-1];
}
/* correct ordering, but nodeid's dont line up with mpi rank for petsc's da
* DA: +---+---+ GA: +---+---+
* +-2-+-3-+ +-1-+-3-+
* +---+---+ +---+---+
* +-0-+-1-+ +-0-+-2-+
* +---+---+ +---+---+
int *map;
PetscMalloc( sizeof(int)*(m+n), &map);
map[0] = 0;
for( int i = 1; i < m; i++ )
{
map[i] = lx[i] + map[i-1];
}
map[m] = 0;
for( int i = m+1; i < m+n; i++ )
{
map[i] = ly[i-m] + map[i-1];
}
*/
int block[2] = {n,m};
GA_Set_irreg_distr(ga,map,block);
ierr = GA_Allocate( ga );
if( !ierr ) GA_Error("\n\n\nga allocaltion failed\n\n",ierr);
if( !ga ) GA_Error("\n\n\n ga null \n\n",ierr);
if( rank != GA_Nodeid() ) GA_Error("MPI rank does not match GA_Nodeid()",1);
GA_Print_distribution(ga);
int lo[2], hi[2];
NGA_Distribution(ga,rank,lo,hi);
if( lo[1] != info.xs || hi[1] != info.xs+info.xm-1 ||
lo[0] != info.ys || hi[0] != info.ys+info.ym-1 )
{
PetscSynchronizedPrintf(PETSC_COMM_SELF,"[%d] lo:(%2d,%2d) hi:(%2d,%2d) \t DA: (%2d,%2d), (%2d, %2d)\n",
rank, lo[1], lo[0], hi[1], hi[0], info.xs, info.ys, info.xs+info.xm-1, info.ys+info.ym-1);
}
PetscBarrier(0);
PetscSynchronizedFlush(PETSC_COMM_WORLD);
AO ao;
DAGetAO(da,&ao);
if( rank == 0 )
{
int *idx, len = d1*d2;
PetscReal *val;
PetscMalloc(sizeof(PetscReal)*len, &val);
PetscMalloc(sizeof(int)*len, &idx);
for (int j = 0; j < d2; ++j)
{
for (int i = 0; i < d1; ++i)
{
idx[i + d1*j] = i + d1*j;
val[i + d1*j] = i + d1*j;
}
}
AOApplicationToPetsc(ao,len,idx);
VecSetValues(vec,len,idx,val,INSERT_VALUES);
int a[2], b[2],ld[1]={0};
double c = 0;
for (int j = 0; j < d2; ++j)
{
for (int i = 0; i < d1; ++i)
{
a[0] = j;
a[1] = i;
// printf("%5.0f ",c);
NGA_Put(ga,a,a,&c,ld);
c++;
}
}
}
// GA_Print(ga);
VecAssemblyBegin(vec);
VecAssemblyEnd(vec);
int ld;
double *ptr;
NGA_Access(ga,lo,hi,&ptr,&ld);
PetscReal **d;
int c=0;
ierr = DAVecGetArray(da,vec,&d); CHKERRQ(ierr);
for (int j = info.ys; j < info.ys+info.ym; ++j)
{
for (int i = info.xs; i < info.xs+info.xm; ++i)
{
if( d[j][i] != ptr[(i-info.xs)+ld*(j-info.ys)] )
GA_Error("DA array is not equal to GA array",1);
// printf("%d (%d,%d):\t%3.0f\t%3.0f\n", c, i, j, d[j][i], ptr[(i-info.xs)+ld*(j-info.ys)]);
c++;
}
}
ierr = DAVecRestoreArray(da,vec,&d); CHKERRQ(ierr);
c=0;
PetscReal *v;
int start, end;
VecGetOwnershipRange(vec, &start, &end);
VecGetArray( vec, &v );
for( int i = start; i < end; i++)
{
// printf("%d:\t%3.0f\t%3.0f\t%s\n", start, v[i-start], ptr[i-start], (v[i-start]-ptr[i-start]==0?"":"NO") );
}
VecRestoreArray( vec, &v );
NGA_Release_update(ga,lo,hi);
Vec gada;
VecCreateMPIWithArray(((PetscObject)da)->comm,da->Nlocal,PETSC_DETERMINE,ptr,&gada);
VecView(gada,PETSC_VIEWER_STDOUT_SELF);
GA_Destroy(ga);
ierr = VecDestroy(vec); CHKERRQ(ierr);
ierr = DADestroy(da); CHKERRQ(ierr);
PetscFunctionReturn(0);
}
int schwartz_screening(PFock_t pfock, BasisSet_t basis)
{
int myrank;
MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
// create shell pairs values
//ERD_t erd;
int nthreads = omp_get_max_threads();
//CInt_createERD(basis, &erd, nthreads);
int nshells = pfock->nshells;
// create global arrays for screening
int nprow = pfock->nprow;
int npcol = pfock->npcol;
int dims[2];
int block[2];
int map[nprow + npcol];
for (int i = 0; i < nprow; i++) {
map[i] = pfock->rowptr_sh[i];
}
for (int i = 0; i < npcol; i++) {
map[i + nprow] = pfock->colptr_sh[i];
}
dims[0] = nshells;
dims[1] = nshells;
block[0] = nprow;
block[1] = npcol;
pfock->ga_screening =
NGA_Create_irreg(C_DBL, 2, dims, "array Screening", block, map);
if (0 == pfock->ga_screening) {
return -1;
}
// compute the max shell value
double *sq_values = (double *)PFOCK_MALLOC(sizeof(double) *
pfock->nshells_row * pfock->nshells_col);
if (NULL == sq_values) {
return -1;
}
int startM = pfock->sshell_row;
int startN = pfock->sshell_col;
int endM = pfock->eshell_row;
int endN = pfock->eshell_col;
double maxtmp = 0.0;
#pragma omp parallel
{
int tid = omp_get_thread_num();
#pragma omp for reduction(max:maxtmp)
for (int M = startM; M <= endM; M++) {
int dimM = CInt_getShellDim(basis, M);
for (int N = startN; N <= endN; N++) {
int dimN = CInt_getShellDim(basis, N);
double *integrals;
int nints=
ComputeShellQuartet(basis,tid,M,N,M,N,&integrals);
//CInt_computeShellQuartet(basis, erd, tid, M, N, M, N,
// &integrals, &nints);
double maxvalue = 0.0;
if (nints != 0) {
for (int iM = 0; iM < dimM; iM++) {
for (int iN = 0; iN < dimN; iN++) {
int index =
iM * (dimN*dimM*dimN+dimN) + iN * (dimM*dimN+1);
if (maxvalue < fabs(integrals[index])) {
maxvalue = fabs(integrals[index]);
}
}
}
}
sq_values[(M - startM) * (endN - startN + 1) + (N - startN)]
= maxvalue;
if (maxvalue > maxtmp) {
maxtmp = maxvalue;
}
}
}
}
int lo[2];
int hi[2];
lo[0] = startM;
hi[0] = endM;
lo[1] = startN;
hi[1] = endN;
int ld = endN - startN + 1;
NGA_Put(pfock->ga_screening, lo, hi, sq_values, &ld);
// max value
MPI_Allreduce(&maxtmp, &(pfock->maxvalue), 1,
MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
//CInt_destroyERD(erd);
PFOCK_FREE(sq_values);
// init shellptr
sq_values = (double *)PFOCK_MALLOC(sizeof(double) * nshells);
if (NULL == sq_values) {
return -1;
}
int nnz = 0;
double eta = pfock->tolscr2 / pfock->maxvalue;
pfock->shellptr = (int *)PFOCK_MALLOC(sizeof(int) * (nshells + 1));
pfock->mem_cpu += 1.0 * sizeof(int) * (nshells + 1);
if (NULL == pfock->shellptr) {
return -1;
}
memset(pfock->shellptr, 0, sizeof(int) * (nshells + 1));
for (int M = 0; M < nshells; M++) {
pfock->shellptr[M] = nnz;
lo[0] = M;
hi[0] = M;
lo[1] = 0;
hi[1] = nshells - 1;
ld = nshells;
NGA_Get(pfock->ga_screening, lo, hi, sq_values, &ld);
for (int N = 0; N < nshells; N++) {
double maxvalue = sq_values[N];
if (maxvalue > eta) {
if (M > N && (M + N) % 2 == 1 || M < N && (M + N) % 2 == 0) {
continue;
} else {
nnz++;
}
}
}
pfock->shellptr[M + 1] = nnz;
}
pfock->nnz = nnz;
double maxvalue;
pfock->shellvalue = (double *)PFOCK_MALLOC(sizeof(double) * nnz);
pfock->shellid = (int *)PFOCK_MALLOC(sizeof(int) * nnz);
pfock->shellrid = (int *)PFOCK_MALLOC(sizeof(int) * nnz);
pfock->mem_cpu += 1.0 * sizeof(double) * nnz + 2.0 * sizeof(int) * nnz;
nshells = pfock->nshells;
if (pfock->shellvalue == NULL ||
pfock->shellid == NULL ||
pfock->shellrid == NULL) {
return -1;
}
nnz = 0;
for (int A = 0; A < nshells; A++) {
pfock->shellptr[A] = nnz;
lo[0] = A;
hi[0] = A;
lo[1] = 0;
hi[1] = nshells - 1;
ld = nshells;
NGA_Get(pfock->ga_screening, lo, hi, sq_values, &ld);
for (int B = 0; B < nshells; B++) {
maxvalue = sq_values[B];
if (maxvalue > eta) {
if (A > B && (A + B) % 2 == 1 || A < B && (A + B) % 2 == 0)
continue;
if (A == B) {
pfock->shellvalue[nnz] = maxvalue;
} else {
pfock->shellvalue[nnz] = -maxvalue;
}
pfock->shellid[nnz] = B;
pfock->shellrid[nnz] = A;
nnz++;
}
}
}
PFOCK_FREE(sq_values);
GA_Destroy(pfock->ga_screening);
return 0;
}
int main(int argc, char **argv)
{
int me;
int nproc;
int status;
int g_a;
int dims[NDIM];
int chunk[NDIM];
int pg_world;
size_t num = 10;
double *p1 = NULL;
double *p2 = NULL;
size_t i;
int num_mutex;
int lo[1];
int hi[1];
int ld[1]={1};
MPI_Comm comm;
MP_INIT(argc,argv);
GA_INIT(argc,argv);
me = GA_Nodeid();
nproc = GA_Nnodes();
comm = GA_MPI_Comm_pgroup_default();
printf("%d: Hello world!\n",me);
if (me==0) printf("%d: GA_Initialize\n",me);
/*if (me==0) printf("%d: ARMCI_Init\n",me);*/
/*ARMCI_Init();*/
/*if (me==0) printf("%d: MA_Init\n",me);*/
/*MA_init(MT_DBL, 8*1024*1024, 2*1024*1024);*/
if (me==0) printf("%d: GA_Create_handle\n",me);
g_a = GA_Create_handle();
if (me==0) printf("%d: GA_Set_array_name\n",me);
GA_Set_array_name(g_a,"test array A");
dims[0] = 30;
if (me==0) printf("%d: GA_Set_data\n",me);
GA_Set_data(g_a,NDIM,dims,MT_DBL);
chunk[0] = -1;
if (me==0) printf("%d: GA_Set_chunk\n",me);
GA_Set_chunk(g_a,chunk);
if (me==0) printf("%d: GA_Pgroup_get_world\n",me);
pg_world = GA_Pgroup_get_world();
if (me==0) printf("%d: GA_Set_pgroup\n",me);
GA_Set_pgroup(g_a,pg_world);
if (me==0) printf("%d: GA_Allocate\n",me);
status = GA_Allocate(g_a);
if(0 == status) MPI_Abort(comm,100);
if (me==0) printf("%d: GA_Zero\n",me);
GA_Zero(g_a);
if (me==0) printf("%d: GA_Sync\n",me);
GA_Sync();
num = 10;
p1 = malloc(num*sizeof(double));
/*double* p1 = ARMCI_Malloc_local(num*sizeof(double));*/
if (p1==NULL) MPI_Abort(comm,1000);
p2 = malloc(num*sizeof(double));
/*double* p2 = ARMCI_Malloc_local(num*sizeof(double));*/
if (p2==NULL) MPI_Abort(comm,2000);
for ( i=0 ; i<num ; i++ ) p1[i] = 7.0;
for ( i=0 ; i<num ; i++ ) p2[i] = 3.0;
num_mutex = 17;
status = GA_Create_mutexes(num_mutex);
if (me==0) printf("%d: GA_Create_mutexes = %d\n",me,status);
/***************************************************************/
if (me==0) {
printf("%d: before GA_Lock\n",me);
GA_Lock(0);
lo[0] = 0;
hi[0] = num-1;
GA_Init_fence();
NGA_Put(g_a,lo,hi,p1,ld);
GA_Fence();
GA_Unlock(0);
printf("%d: after GA_Unlock\n",me);
}
GA_Print(g_a);
if (me==1) {
printf("%d: before GA_Lock\n",me);
GA_Lock(0);
lo[0] = 0;
hi[0] = num-1;
GA_Init_fence();
NGA_Get(g_a,lo,hi,p2,ld);
GA_Fence();
GA_Unlock(0);
printf("%d: after GA_Unlock\n",me);
for ( i=0 ; i<num ; i++ ) printf("p2[%2lu] = %20.10f\n",
(long unsigned)i,p2[i]);
}
/***************************************************************/
status = GA_Destroy_mutexes();
if (me==0) printf("%d: GA_Destroy_mutexes = %d\n",me,status);
/*ARMCI_Free(p2);*/
/*ARMCI_Free(p1);*/
free(p2);
free(p1);
if (me==0) printf("%d: GA_Destroy\n",me);
GA_Destroy(g_a);
/*if (me==0) printf("%d: ARMCI_Finalize\n",me);*/
/*ARMCI_Finalize();*/
if (me==0) printf("%d: GA_Terminate\n",me);
GA_Terminate();
if (me==0) printf("%d: MPI_Finalize\n",me);
MPI_Finalize();
return(0);
}
int main( int argc, char **argv ) {
int g_a, g_b, i, j, size, size_me;
int icnt, idx, jdx, ld;
int n=N, type=MT_C_INT, one;
int *values, *ptr;
int **indices;
int dims[2]={N,N};
int lo[2], hi[2];
int heap=3000000, stack=2000000;
int me, nproc;
int datatype, elements;
double *prealloc_mem;
MP_INIT(argc,argv);
#if 1
GA_INIT(argc,argv); /* initialize GA */
me=GA_Nodeid();
nproc=GA_Nnodes();
if(me==0) {
if(GA_Uses_fapi())GA_Error("Program runs with C array API only",1);
printf("\nUsing %ld processes\n",(long)nproc);
fflush(stdout);
}
heap /= nproc;
stack /= nproc;
if(! MA_init(MT_F_DBL, stack, heap))
GA_Error("MA_init failed",stack+heap); /* initialize memory allocator*/
/* Create a regular matrix. */
if(me==0)printf("\nCreating matrix A of size %d x %d\n",N,N);
g_a = NGA_Create(type, 2, dims, "A", NULL);
if(!g_a) GA_Error("create failed: A",n);
/* Fill matrix using scatter routines */
size = N*N;
if (size%nproc == 0) {
size_me = size/nproc;
} else {
i = size - size%nproc;
size_me = i/nproc;
if (me < size%nproc) size_me++;
}
/* Check that sizes are all okay */
i = size_me;
GA_Igop(&i,1,"+");
if (i != size) {
GA_Error("Sizes don't add up correctly: ",i);
} else if (me==0) {
printf("\nSizes add up correctly\n");
}
/* Allocate index and value arrays */
indices = (int**)malloc(size_me*sizeof(int*));
values = (int*)malloc(size_me*sizeof(int));
icnt = me;
for (i=0; i<size_me; i++) {
values[i] = icnt;
idx = icnt%N;
jdx = (icnt-idx)/N;
if (idx >= N || idx < 0) {
printf("p[%d] Bogus index i: %d\n",me,idx);
}
if (jdx >= N || jdx < 0) {
printf("p[%d] Bogus index j: %d\n",me,jdx);
}
indices[i] = (int*)malloc(2*sizeof(int));
(indices[i])[0] = idx;
(indices[i])[1] = jdx;
icnt += nproc;
}
/* Scatter values into g_a */
NGA_Scatter(g_a, values, indices, size_me);
GA_Sync();
/* Check to see if contents of g_a are correct */
NGA_Distribution( g_a, me, lo, hi );
NGA_Access(g_a, lo, hi, &ptr, &ld);
for (i=lo[0]; i<hi[0]; i++) {
idx = i-lo[0];
for (j=lo[1]; j<hi[1]; j++) {
jdx = j-lo[1];
if (ptr[idx*ld+jdx] != j*N+i) {
printf("p[%d] (Scatter) expected: %d actual: %d\n",me,j*N+i,ptr[idx*ld+jdx]);
}
}
}
if (me==0) printf("\nCompleted test of NGA_Scatter\n");
for (i=0; i<size_me; i++) {
values[i] = 0;
}
GA_Sync();
NGA_Gather(g_a, values, indices, size_me);
icnt = me;
for (i=0; i<size_me; i++) {
if (icnt != values[i]) {
printf("p[%d] (Gather) expected: %d actual: %d\n",me,icnt,values[i]);
}
icnt += nproc;
}
if (me==0) printf("\nCompleted test of NGA_Gather\n");
GA_Sync();
/* Scatter-accumulate values back into GA*/
one = 1;
NGA_Scatter_acc(g_a, values, indices, size_me, &one);
GA_Sync();
/* Check to see if contents of g_a are correct */
for (i=lo[0]; i<hi[0]; i++) {
idx = i-lo[0];
for (j=lo[1]; j<hi[1]; j++) {
jdx = j-lo[1];
if (ptr[idx*ld+jdx] != 2*(j*N+i)) {
printf("p[%d] (Scatter_acc) expected: %d actual: %d\n",me,2*(j*N+i),ptr[idx*ld+jdx]);
}
}
}
if (me==0) printf("\nCompleted test of NGA_Scatter_acc\n");
NGA_Release(g_a, lo, hi);
/* Test fixed buffer size */
NGA_Alloc_gatscat_buf(size_me);
/* Scatter-accumulate values back into GA*/
GA_Sync();
NGA_Scatter_acc(g_a, values, indices, size_me, &one);
GA_Sync();
/* Check to see if contents of g_a are correct */
for (i=lo[0]; i<hi[0]; i++) {
idx = i-lo[0];
for (j=lo[1]; j<hi[1]; j++) {
jdx = j-lo[1];
if (ptr[idx*ld+jdx] != 3*(j*N+i)) {
printf("p[%d] (Scatter_acc) expected: %d actual: %d\n",me,3*(j*N+i),ptr[idx*ld+jdx]);
}
}
}
if (me==0) printf("\nCompleted test of NGA_Scatter_acc using fixed buffers\n");
NGA_Release(g_a, lo, hi);
NGA_Free_gatscat_buf();
GA_Destroy(g_a);
if(me==0)printf("\nSuccess\n");
GA_Terminate();
#endif
MP_FINALIZE();
return 0;
}
static int test(int shape_idx, int type_idx, int dist_idx)
{
int type = TYPES[type_idx];
int *dims = SHAPES[shape_idx];
int ndim = SHAPES_NDIM[shape_idx];
mock_ga_t *mock_a, *result_a;
int g_a;
void *alpha = NULL;
int buffer[100];
int lo[GA_MAX_DIM], hi[GA_MAX_DIM], ld[GA_MAX_DIM], shape[GA_MAX_DIM];
int result=0, error_index=-1, error_proc=-1;
int ival = 6;
long lval = 7;
long long llval = 8;
float fval = 9;
double dval = 10;
SingleComplex cval = {11,12};
DoubleComplex zval = {13,14};
/* create the local array and result array */
mock_a = Mock_Create(type, ndim, dims, "mock", NULL);
result_a = Mock_Create(type, ndim, dims, "mock", NULL);
/* create the global array */
g_a = create_function[dist_idx](type, ndim, dims);
/* create meaningful data for local array */
mock_data(mock_a, g_a);
/* init global array with same data as local array */
mock_to_global(mock_a, g_a);
switch (type) {
case C_INT: alpha = &ival; break;
case C_LONG: alpha = &lval; break;
case C_LONGLONG: alpha = &llval; break;
case C_FLOAT: alpha = &fval; break;
case C_DBL: alpha = &dval; break;
case C_SCPL: alpha = &cval; break;
case C_DCPL: alpha = &zval; break;
}
/* call the local routine */
Mock_Add_constant(mock_a, alpha);
/* call the global routine */
GA_Add_constant(g_a, alpha);
/* get the results from the global array */
global_to_mock(g_a, result_a);
/* compare the results */
result = neq_mock(mock_a, result_a, &error_index);
if (0 != result) {
error_proc = GA_Nodeid();
}
/* make sure all procs get same result so they can die gracefully */
GA_Igop(&result, 1, "+");
/* if error occured, find the highest failing node ID */
GA_Igop(&error_proc, 1, "max");
/* clear the error index for all but the highest failing node ID */
if (error_proc != GA_Nodeid()) {
error_index = 0;
}
/* make sure all procs get the error index on the highest failing node ID */
GA_Igop(&error_index, 1, "+");
if (0 != result) {
if (error_proc == GA_Nodeid()) {
printf("ERROR: local result failed to compare to global result\n");
printf("\terror_proc=%d\n", error_proc);
printf("\terror_index=%d\n", error_index);
printf("***LOCAL RESULT***\n");
Mock_Print(mock_a);
printf("***GLOBAL RESULT***\n");
Mock_Print(result_a);
printf("\tprinting array distribution\n");
}
GA_Sync();
GA_Print(g_a);
GA_Print_distribution(g_a);
return 1;
}
/* clean up */
Mock_Destroy(mock_a);
Mock_Destroy(result_a);
GA_Destroy(g_a);
return 0;
}
void
test(int data_type) {
int me=GA_Nodeid();
int nproc = GA_Nnodes();
int g_a, g_b, g_c;
int ndim = 2;
int dims[2]={N,N};
int lo[2]={0,0};
int hi[2]={N-1,N-1};
int block_size[2]={NB,NB-1};
int proc_grid[2];
int i,j,l,k,m,n, ld;
double alpha_dbl = 1.0, beta_dbl = 0.0;
double dzero = 0.0;
double ddiff;
float alpha_flt = 1.0, beta_flt = 0.0;
float fzero = 0.0;
float fdiff;
float ftmp;
double dtmp;
SingleComplex ctmp;
DoubleComplex ztmp;
DoubleComplex alpha_dcpl = {1.0, 0.0} , beta_dcpl = {0.0, 0.0};
DoubleComplex zzero = {0.0,0.0};
DoubleComplex zdiff;
SingleComplex alpha_scpl = {1.0, 0.0} , beta_scpl = {0.0, 0.0};
SingleComplex czero = {0.0,0.0};
SingleComplex cdiff;
void *alpha=NULL, *beta=NULL;
void *abuf=NULL, *bbuf=NULL, *cbuf=NULL, *c_ptr=NULL;
switch (data_type) {
case C_FLOAT:
alpha = (void *)&alpha_flt;
beta = (void *)&beta_flt;
abuf = (void*)malloc(N*N*sizeof(float));
bbuf = (void*)malloc(N*N*sizeof(float));
cbuf = (void*)malloc(N*N*sizeof(float));
if(me==0) printf("Single Precision: Testing GA_Sgemm,NGA_Matmul_patch for %d-Dimension", ndim);
break;
case C_DBL:
alpha = (void *)&alpha_dbl;
beta = (void *)&beta_dbl;
abuf = (void*)malloc(N*N*sizeof(double));
bbuf = (void*)malloc(N*N*sizeof(double));
cbuf = (void*)malloc(N*N*sizeof(double));
if(me==0) printf("Double Precision: Testing GA_Dgemm,NGA_Matmul_patch for %d-Dimension", ndim);
break;
case C_DCPL:
alpha = (void *)&alpha_dcpl;
beta = (void *)&beta_dcpl;
abuf = (void*)malloc(N*N*sizeof(DoubleComplex));
bbuf = (void*)malloc(N*N*sizeof(DoubleComplex));
cbuf = (void*)malloc(N*N*sizeof(DoubleComplex));
if(me==0) printf("Double Complex: Testing GA_Zgemm,NGA_Matmul_patch for %d-Dimension", ndim);
break;
case C_SCPL:
alpha = (void *)&alpha_scpl;
beta = (void *)&beta_scpl;
abuf = (void*)malloc(N*N*sizeof(SingleComplex));
bbuf = (void*)malloc(N*N*sizeof(SingleComplex));
cbuf = (void*)malloc(N*N*sizeof(SingleComplex));
if(me==0) printf("Single Complex: Testing GA_Cgemm,NGA_Matmul_patch for %d-Dimension", ndim);
break;
default:
GA_Error("wrong data type", data_type);
}
if (me==0) printf("\nCreate A, B, C\n");
#ifdef USE_REGULAR
g_a = NGA_Create(data_type, ndim, dims, "array A", NULL);
#endif
#ifdef USE_SIMPLE_CYCLIC
g_a = NGA_Create_handle();
NGA_Set_data(g_a,ndim,dims,data_type);
NGA_Set_array_name(g_a,"array A");
NGA_Set_block_cyclic(g_a,block_size);
if (!GA_Allocate(g_a)) {
GA_Error("Failed: create: g_a",40);
}
#endif
#ifdef USE_SCALAPACK
g_a = NGA_Create_handle();
NGA_Set_data(g_a,ndim,dims,data_type);
NGA_Set_array_name(g_a,"array A");
grid_factor(nproc,&i,&j);
proc_grid[0] = i;
proc_grid[1] = j;
NGA_Set_block_cyclic_proc_grid(g_a,block_size,proc_grid);
if (!GA_Allocate(g_a)) {
GA_Error("Failed: create: g_a",40);
}
#endif
#ifdef USE_TILED
g_a = NGA_Create_handle();
NGA_Set_data(g_a,ndim,dims,data_type);
NGA_Set_array_name(g_a,"array A");
grid_factor(nproc,&i,&j);
proc_grid[0] = i;
proc_grid[1] = j;
NGA_Set_tiled_proc_grid(g_a,block_size,proc_grid);
if (!GA_Allocate(g_a)) {
GA_Error("Failed: create: g_a",40);
}
#endif
g_b = GA_Duplicate(g_a, "array B");
g_c = GA_Duplicate(g_a, "array C");
if(!g_a || !g_b || !g_c) GA_Error("Create failed: a, b or c",1);
ld = N;
if (me==0) printf("\nInitialize A\n");
/* Set up matrix A */
if (me == 0) {
for (i=0; i<N; i++) {
for (j=0; j<N; j++) {
switch (data_type) {
case C_FLOAT:
((float*)abuf)[i*N+j] = (float)(i*N+j);
break;
case C_DBL:
((double*)abuf)[i*N+j] = (double)(i*N+j);
break;
case C_DCPL:
((DoubleComplex*)abuf)[i*N+j].real = (double)(i*N+j);
((DoubleComplex*)abuf)[i*N+j].imag = 1.0;
break;
case C_SCPL:
((SingleComplex*)abuf)[i*N+j].real = (float)(i*N+j);
((SingleComplex*)abuf)[i*N+j].imag = 1.0;
break;
default:
GA_Error("wrong data type", data_type);
}
}
}
NGA_Put(g_a,lo,hi,abuf,&ld);
}
GA_Sync();
if (me==0) printf("\nInitialize B\n");
/* Set up matrix B */
if (me == 0) {
for (i=0; i<N; i++) {
for (j=0; j<N; j++) {
switch (data_type) {
case C_FLOAT:
((float*)bbuf)[i*N+j] = (float)(j*N+i);
break;
case C_DBL:
((double*)bbuf)[i*N+j] = (double)(j*N+i);
break;
case C_DCPL:
((DoubleComplex*)bbuf)[i*N+j].real = (double)(j*N+i);
((DoubleComplex*)bbuf)[i*N+j].imag = 1.0;
break;
case C_SCPL:
((SingleComplex*)bbuf)[i*N+j].real = (float)(j*N+i);
((SingleComplex*)bbuf)[i*N+j].imag = 1.0;
break;
default:
GA_Error("wrong data type", data_type);
}
}
}
NGA_Put(g_b,lo,hi,bbuf,&ld);
}
GA_Sync();
if (me==0) printf("\nPerform matrix multiply\n");
switch (data_type) {
case C_FLOAT:
NGA_Matmul_patch('N','N',&alpha_flt,&beta_flt,g_a,lo,hi,
g_b,lo,hi,g_c,lo,hi);
break;
case C_DBL:
NGA_Matmul_patch('N','N',&alpha_dbl,&beta_dbl,g_a,lo,hi,
g_b,lo,hi,g_c,lo,hi);
break;
case C_SCPL:
NGA_Matmul_patch('N','N',&alpha_scpl,&beta_scpl,g_a,lo,hi,
g_b,lo,hi,g_c,lo,hi);
break;
case C_DCPL:
NGA_Matmul_patch('N','N',&alpha_dcpl,&beta_dcpl,g_a,lo,hi,
g_b,lo,hi,g_c,lo,hi);
break;
default:
GA_Error("wrong data type", data_type);
}
GA_Sync();
#if 0
if (me==0) printf("\nCheck answer\n");
/*
GA_Print(g_a);
if (me == 0) printf("\n\n\n\n");
GA_Print(g_b);
if (me == 0) printf("\n\n\n\n");
GA_Print(g_c);
*/
/* Check answer */
NGA_Get(g_a,lo,hi,abuf,&ld);
NGA_Get(g_b,lo,hi,bbuf,&ld);
for (i=0; i<N; i++) {
for (j=0; j<N; j++) {
switch (data_type) {
case C_FLOAT:
((float*)cbuf)[i*N+j] = fzero;
break;
case C_DBL:
((double*)cbuf)[i*N+j] = dzero;
break;
case C_DCPL:
((DoubleComplex*)cbuf)[i*N+j] = zzero;
break;
case C_SCPL:
((SingleComplex*)cbuf)[i*N+j] = czero;
break;
default:
GA_Error("wrong data type", data_type);
}
for (k=0; k<N; k++) {
switch (data_type) {
case C_FLOAT:
((float*)cbuf)[i*N+j] += ((float*)abuf)[i*N+k]
*((float*)bbuf)[k*N+j];
break;
case C_DBL:
((double*)cbuf)[i*N+j] += ((double*)abuf)[i*N+k]
*((double*)bbuf)[k*N+j];
break;
case C_DCPL:
((DoubleComplex*)cbuf)[i*N+j].real +=
(((DoubleComplex*)abuf)[i*N+k].real
*((DoubleComplex*)bbuf)[k*N+j].real
-(((DoubleComplex*)abuf)[i*N+k].imag
*((DoubleComplex*)bbuf)[k*N+j].imag));
((DoubleComplex*)cbuf)[i*N+j].imag +=
(((DoubleComplex*)abuf)[i*N+k].real
*((DoubleComplex*)bbuf)[k*N+j].imag
+(((DoubleComplex*)abuf)[i*N+k].imag
*((DoubleComplex*)bbuf)[k*N+j].real));
break;
case C_SCPL:
((SingleComplex*)cbuf)[i*N+j].real +=
(((SingleComplex*)abuf)[i*N+k].real
*((SingleComplex*)bbuf)[k*N+j].real
-(((SingleComplex*)abuf)[i*N+k].imag
*((SingleComplex*)bbuf)[k*N+j].imag));
((SingleComplex*)cbuf)[i*N+j].imag +=
(((SingleComplex*)abuf)[i*N+k].real
*((SingleComplex*)bbuf)[k*N+j].imag
+(((SingleComplex*)abuf)[i*N+k].imag
*((SingleComplex*)bbuf)[k*N+j].real));
break;
default:
GA_Error("wrong data type", data_type);
}
}
}
}
GA_Sync();
if (me == 0) {
NGA_Get(g_c,lo,hi,abuf,&ld);
for (i=0; i<N; i++) {
for (j=0; j<N; j++) {
switch (data_type) {
case C_FLOAT:
fdiff = ((float*)abuf)[i*N+j]-((float*)cbuf)[i*N+j];
if (((float*)abuf)[i*N+j] != 0.0) {
fdiff /= ((float*)abuf)[i*N+j];
}
if (fabs(fdiff) > TOLERANCE) {
printf("p[%d] [%d,%d] Actual: %f Expected: %f\n",me,i,j,
((float*)abuf)[i*N+j],((float*)cbuf)[i*N+j]);
}
break;
case C_DBL:
ddiff = ((double*)abuf)[i*N+j]-((double*)cbuf)[i*N+j];
if (((double*)abuf)[i*N+j] != 0.0) {
ddiff /= ((double*)abuf)[i*N+j];
}
if (fabs(ddiff) > TOLERANCE) {
printf("p[%d] [%d,%d] Actual: %f Expected: %f\n",me,i,j,
((double*)abuf)[i*N+j],((double*)cbuf)[i*N+j]);
}
break;
case C_DCPL:
zdiff.real = ((DoubleComplex*)abuf)[i*N+j].real
-((DoubleComplex*)cbuf)[i*N+j].real;
zdiff.imag = ((DoubleComplex*)abuf)[i*N+j].imag
-((DoubleComplex*)cbuf)[i*N+j].imag;
if (((DoubleComplex*)abuf)[i*N+j].real != 0.0 ||
((DoubleComplex*)abuf)[i*N+j].imag != 0.0) {
ztmp = ((DoubleComplex*)abuf)[i*N+j];
ddiff = sqrt((zdiff.real*zdiff.real+zdiff.imag*zdiff.imag)
/(ztmp.real*ztmp.real+ztmp.imag*ztmp.imag));
} else {
ddiff = sqrt(zdiff.real*zdiff.real+zdiff.imag*zdiff.imag);
}
if (fabs(ddiff) > TOLERANCE) {
printf("p[%d] [%d,%d] Actual: (%f,%f) Expected: (%f,%f)\n",me,i,j,
((DoubleComplex*)abuf)[i*N+j].real,
((DoubleComplex*)abuf)[i*N+j].imag,
((DoubleComplex*)cbuf)[i*N+j].real,
((DoubleComplex*)cbuf)[i*N+j].imag);
}
break;
case C_SCPL:
cdiff.real = ((SingleComplex*)abuf)[i*N+j].real
-((SingleComplex*)cbuf)[i*N+j].real;
cdiff.imag = ((SingleComplex*)abuf)[i*N+j].imag
-((SingleComplex*)cbuf)[i*N+j].imag;
if (((SingleComplex*)abuf)[i*N+j].real != 0.0 ||
((SingleComplex*)abuf)[i*N+j].imag != 0.0) {
ctmp = ((SingleComplex*)abuf)[i*N+j];
fdiff = sqrt((cdiff.real*cdiff.real+cdiff.imag*cdiff.imag)
/(ctmp.real*ctmp.real+ctmp.imag*ctmp.imag));
} else {
fdiff = sqrt(cdiff.real*cdiff.real+cdiff.imag*cdiff.imag);
}
if (fabs(fdiff) > TOLERANCE) {
printf("p[%d] [%d,%d] Actual: (%f,%f) Expected: (%f,%f)\n",me,i,j,
((SingleComplex*)abuf)[i*N+j].real,
((SingleComplex*)abuf)[i*N+j].imag,
((SingleComplex*)cbuf)[i*N+j].real,
((SingleComplex*)cbuf)[i*N+j].imag);
}
break;
default:
GA_Error("wrong data type", data_type);
}
}
}
}
GA_Sync();
/* copy cbuf back to g_a */
if (me == 0) {
NGA_Put(g_a,lo,hi,cbuf,&ld);
}
GA_Sync();
/* Get norm of g_a */
switch (data_type) {
case C_FLOAT:
ftmp = GA_Fdot(g_a,g_a);
break;
case C_DBL:
dtmp = GA_Ddot(g_a,g_a);
break;
case C_DCPL:
ztmp = GA_Zdot(g_a,g_a);
break;
case C_SCPL:
ctmp = GA_Cdot(g_a,g_a);
break;
default:
GA_Error("wrong data type", data_type);
}
/* subtract C from A and put the results in B */
beta_flt = -1.0;
beta_dbl = -1.0;
beta_scpl.real = -1.0;
beta_dcpl.real = -1.0;
GA_Zero(g_b);
GA_Add(alpha,g_a,beta,g_c,g_b);
/* evaluate the norm of the difference between the two matrices */
switch (data_type) {
case C_FLOAT:
fdiff = GA_Fdot(g_b, g_b);
if (ftmp != 0.0) {
fdiff /= ftmp;
}
if(fabs(fdiff) > TOLERANCE) {
printf("\nabs(result) = %f > %f\n", fabsf(fdiff), TOLERANCE);
GA_Error("GA_Sgemm Failed", 1);
} else if (me == 0) {
printf("\nGA_Sgemm OK\n\n");
}
break;
case C_DBL:
ddiff = GA_Ddot(g_b, g_b);
if (dtmp != 0.0) {
ddiff /= dtmp;
}
if(fabs(ddiff) > TOLERANCE) {
printf("\nabs(result) = %f > %f\n", fabsf(ddiff), TOLERANCE);
GA_Error("GA_Dgemm Failed", 1);
} else if (me == 0) {
printf("\nGA_Dgemm OK\n\n");
}
break;
case C_DCPL:
zdiff = GA_Zdot(g_b, g_b);
if (ztmp.real != 0.0 || ztmp.imag != 0.0) {
ddiff = sqrt((zdiff.real*zdiff.real+zdiff.imag*zdiff.imag)
/(ztmp.real*ztmp.real+ztmp.imag*ztmp.imag));
} else {
ddiff = sqrt(zdiff.real*zdiff.real+zdiff.imag*zdiff.imag);
}
if(fabs(ddiff) > TOLERANCE) {
printf("\nabs(result) = %f > %f\n", fabsf(zdiff.real), TOLERANCE);
GA_Error("GA_Zgemm Failed", 1);
} else if (me == 0) {
printf("\nGA_Zgemm OK\n\n");
}
break;
case C_SCPL:
cdiff = GA_Cdot(g_b, g_b);
if (ctmp.real != 0.0 || ctmp.imag != 0.0) {
fdiff = sqrt((cdiff.real*cdiff.real+cdiff.imag*cdiff.imag)
/(ctmp.real*ctmp.real+ctmp.imag*ctmp.imag));
} else {
fdiff = sqrt(cdiff.real*cdiff.real+cdiff.imag*cdiff.imag);
}
if(fabs(fdiff) > TOLERANCE) {
printf("\nabs(result) = %f > %f\n", fabsf(cdiff.real), TOLERANCE);
GA_Error("GA_Cgemm Failed", 1);
} else if (me == 0) {
printf("\nGA_Cgemm OK\n\n");
}
break;
default:
GA_Error("wrong data type", data_type);
}
#endif
free(abuf);
free(bbuf);
free(cbuf);
switch (data_type) {
case C_FLOAT:
abuf = (void*)malloc(N*N*sizeof(float)/4);
bbuf = (void*)malloc(N*N*sizeof(float)/4);
cbuf = (void*)malloc(N*N*sizeof(float)/4);
break;
case C_DBL:
abuf = (void*)malloc(N*N*sizeof(double)/4);
bbuf = (void*)malloc(N*N*sizeof(double)/4);
cbuf = (void*)malloc(N*N*sizeof(double)/4);
break;
case C_DCPL:
abuf = (void*)malloc(N*N*sizeof(DoubleComplex)/4);
bbuf = (void*)malloc(N*N*sizeof(DoubleComplex)/4);
cbuf = (void*)malloc(N*N*sizeof(DoubleComplex)/4);
break;
case C_SCPL:
abuf = (void*)malloc(N*N*sizeof(SingleComplex)/4);
bbuf = (void*)malloc(N*N*sizeof(SingleComplex)/4);
cbuf = (void*)malloc(N*N*sizeof(SingleComplex)/4);
break;
default:
GA_Error("wrong data type", data_type);
}
/* Test multiply on a fraction of matrix. Start by reinitializing
* A and B */
GA_Zero(g_a);
GA_Zero(g_b);
GA_Zero(g_c);
if (me==0) printf("\nTest patch multiply\n");
lo[0] = N/4;
lo[1] = N/4;
hi[0] = 3*N/4-1;
hi[1] = 3*N/4-1;
ld = N/2;
/* Set up matrix A */
if (me==0) printf("\nInitialize A\n");
if (me == 0) {
for (i=N/4; i<3*N/4; i++) {
for (j=N/4; j<3*N/4; j++) {
switch (data_type) {
case C_FLOAT:
((float*)abuf)[(i-N/4)*N/2+(j-N/4)] = (float)(i*N+j);
break;
case C_DBL:
((double*)abuf)[(i-N/4)*N/2+(j-N/4)] = (double)(i*N+j);
break;
case C_DCPL:
((DoubleComplex*)abuf)[(i-N/4)*N/2+(j-N/4)].real = (double)(i*N+j);
((DoubleComplex*)abuf)[(i-N/4)*N/2+(j-N/4)].imag = 1.0;
break;
case C_SCPL:
((SingleComplex*)abuf)[(i-N/4)*N/2+(j-N/4)].real = (float)(i*N+j);
((SingleComplex*)abuf)[(i-N/4)*N/2+(j-N/4)].imag = 1.0;
break;
default:
GA_Error("wrong data type", data_type);
}
}
}
NGA_Put(g_a,lo,hi,abuf,&ld);
}
GA_Sync();
if (me==0) printf("\nInitialize B\n");
/* Set up matrix B */
if (me == 0) {
for (i=N/4; i<3*N/4; i++) {
for (j=N/4; j<3*N/4; j++) {
switch (data_type) {
case C_FLOAT:
((float*)bbuf)[(i-N/4)*N/2+(j-N/4)] = (float)(j*N+i);
break;
case C_DBL:
((double*)bbuf)[(i-N/4)*N/2+(j-N/4)] = (double)(j*N+i);
break;
case C_DCPL:
((DoubleComplex*)bbuf)[(i-N/4)*N/2+(j-N/4)].real = (double)(j*N+i);
((DoubleComplex*)bbuf)[(i-N/4)*N/2+(j-N/4)].imag = 1.0;
break;
case C_SCPL:
((SingleComplex*)bbuf)[(i-N/4)*N/2+(j-N/4)].real = (float)(j*N+i);
((SingleComplex*)bbuf)[(i-N/4)*N/2+(j-N/4)].imag = 1.0;
break;
default:
GA_Error("wrong data type", data_type);
}
}
}
NGA_Put(g_b,lo,hi,bbuf,&ld);
}
GA_Sync();
beta_flt = 0.0;
beta_dbl = 0.0;
beta_scpl.real = 0.0;
beta_dcpl.real = 0.0;
if (me==0) printf("\nPerform matrix multiply on sub-blocks\n");
switch (data_type) {
case C_FLOAT:
NGA_Matmul_patch('N','N',&alpha_flt,&beta_flt,g_a,lo,hi,
g_b,lo,hi,g_c,lo,hi);
break;
case C_DBL:
NGA_Matmul_patch('N','N',&alpha_dbl,&beta_dbl,g_a,lo,hi,
g_b,lo,hi,g_c,lo,hi);
break;
case C_SCPL:
NGA_Matmul_patch('N','N',&alpha_scpl,&beta_scpl,g_a,lo,hi,
g_b,lo,hi,g_c,lo,hi);
break;
case C_DCPL:
NGA_Matmul_patch('N','N',&alpha_dcpl,&beta_dcpl,g_a,lo,hi,
g_b,lo,hi,g_c,lo,hi);
break;
default:
GA_Error("wrong data type", data_type);
}
GA_Sync();
#if 0
if (0) {
/*
if (data_type != C_SCPL && data_type != C_DCPL) {
*/
if (me==0) printf("\nCheck answer\n");
/* Multiply buffers by hand */
if (me == 0) {
for (i=0; i<N/2; i++) {
for (j=0; j<N/2; j++) {
switch (data_type) {
case C_FLOAT:
((float*)cbuf)[i*N/2+j] = fzero;
break;
case C_DBL:
((double*)cbuf)[i*N/2+j] = dzero;
break;
case C_DCPL:
((DoubleComplex*)cbuf)[i*N/2+j] = zzero;
break;
case C_SCPL:
((SingleComplex*)cbuf)[i*N/2+j] = czero;
break;
default:
GA_Error("wrong data type", data_type);
}
for (k=0; k<N/2; k++) {
switch (data_type) {
case C_FLOAT:
((float*)cbuf)[i*N/2+j] += ((float*)abuf)[i*N/2+k]
*((float*)bbuf)[k*N/2+j];
break;
case C_DBL:
((double*)cbuf)[i*N/2+j] += ((double*)abuf)[i*N/2+k]
*((double*)bbuf)[k*N/2+j];
break;
case C_DCPL:
((DoubleComplex*)cbuf)[i*N/2+j].real +=
(((DoubleComplex*)abuf)[i*N/2+k].real
*((DoubleComplex*)bbuf)[k*N/2+j].real
-(((DoubleComplex*)abuf)[i*N/2+k].imag
*((DoubleComplex*)bbuf)[k*N/2+j].imag));
((DoubleComplex*)cbuf)[i*N/2+j].imag +=
(((DoubleComplex*)abuf)[i*N/2+k].real
*((DoubleComplex*)bbuf)[k*N/2+j].imag
+(((DoubleComplex*)abuf)[i*N/2+k].imag
*((DoubleComplex*)bbuf)[k*N/2+j].real));
break;
case C_SCPL:
((SingleComplex*)cbuf)[i*N/2+j].real +=
(((SingleComplex*)abuf)[i*N/2+k].real
*((SingleComplex*)bbuf)[k*N/2+j].real
-(((SingleComplex*)abuf)[i*N/2+k].imag
*((SingleComplex*)bbuf)[k*N/2+j].imag));
((SingleComplex*)cbuf)[i*N/2+j].imag +=
(((SingleComplex*)abuf)[i*N/2+k].real
*((SingleComplex*)bbuf)[k*N/2+j].imag
+(((SingleComplex*)abuf)[i*N/2+k].imag
*((SingleComplex*)bbuf)[k*N/2+j].real));
break;
default:
GA_Error("wrong data type", data_type);
}
}
}
}
NGA_Put(g_a,lo,hi,cbuf,&ld);
}
if (me == 0) printf("\n\n\n\n");
/* Get norm of g_a */
switch (data_type) {
case C_FLOAT:
ftmp = NGA_Fdot_patch(g_a,'N',lo,hi,g_a,'N',lo,hi);
break;
case C_DBL:
dtmp = NGA_Ddot_patch(g_a,'N',lo,hi,g_a,'N',lo,hi);
break;
case C_DCPL:
ztmp = NGA_Zdot_patch(g_a,'N',lo,hi,g_a,'N',lo,hi);
break;
case C_SCPL:
ctmp = NGA_Cdot_patch(g_a,'N',lo,hi,g_a,'N',lo,hi);
break;
default:
GA_Error("wrong data type", data_type);
}
/* subtract C from A and put the results in B */
beta_flt = -1.0;
beta_dbl = -1.0;
beta_scpl.real = -1.0;
beta_dcpl.real = -1.0;
NGA_Zero_patch(g_b,lo,hi);
NGA_Add_patch(alpha,g_a,lo,hi,beta,g_c,lo,hi,g_b,lo,hi);
/* evaluate the norm of the difference between the two matrices */
switch (data_type) {
case C_FLOAT:
fdiff = NGA_Fdot_patch(g_b,'N',lo,hi,g_b,'N',lo,hi);
if (ftmp != 0.0) {
fdiff /= ftmp;
}
if(fabs(fdiff) > TOLERANCE) {
printf("\nabs(result) = %f > %f\n", fabsf(fdiff), TOLERANCE);
GA_Error("GA_Sgemm Failed", 1);
} else if (me == 0) {
printf("\nGA_Sgemm OK\n\n");
}
break;
case C_DBL:
ddiff = NGA_Ddot_patch(g_b,'N',lo,hi,g_b,'N',lo,hi);
if (dtmp != 0.0) {
ddiff /= dtmp;
}
if(fabs(ddiff) > TOLERANCE) {
printf("\nabs(result) = %f > %f\n", fabsf(ddiff), TOLERANCE);
GA_Error("GA_Dgemm Failed", 1);
} else if (me == 0) {
printf("\nGA_Dgemm OK\n\n");
}
break;
case C_DCPL:
zdiff = NGA_Zdot_patch(g_b,'N',lo,hi,g_b,'N',lo,hi);
if (ztmp.real != 0.0 || ztmp.imag != 0.0) {
ddiff = sqrt((zdiff.real*zdiff.real+zdiff.imag*zdiff.imag)
/(ztmp.real*ztmp.real+ztmp.imag*ztmp.imag));
} else {
ddiff = sqrt(zdiff.real*zdiff.real+zdiff.imag*zdiff.imag);
}
if(fabs(ddiff) > TOLERANCE) {
printf("\nabs(result) = %f > %f\n", fabsf(zdiff.real), TOLERANCE);
GA_Error("GA_Zgemm Failed", 1);
} else if (me == 0) {
printf("\nGA_Zgemm OK\n\n");
}
break;
case C_SCPL:
cdiff = NGA_Cdot_patch(g_b,'N',lo,hi,g_b,'N',lo,hi);
if (ctmp.real != 0.0 || ctmp.imag != 0.0) {
fdiff = sqrt((cdiff.real*cdiff.real+cdiff.imag*cdiff.imag)
/(ctmp.real*ctmp.real+ctmp.imag*ctmp.imag));
} else {
fdiff = sqrt(cdiff.real*cdiff.real+cdiff.imag*cdiff.imag);
}
if(fabs(fdiff) > TOLERANCE) {
printf("\nabs(result) = %f > %f\n", fabsf(cdiff.real), TOLERANCE);
GA_Error("GA_Cgemm Failed", 1);
} else if (me == 0) {
printf("\nGA_Cgemm OK\n\n");
}
break;
default:
GA_Error("wrong data type", data_type);
}
}
#endif
free(abuf);
free(bbuf);
free(cbuf);
GA_Destroy(g_a);
GA_Destroy(g_b);
GA_Destroy(g_c);
}
void test_io_dbl()
{
int n, ndim = NDIM;
double err, tt0, tt1, mbytes;
int g_a, g_b, d_a;
int i, itmp, j, req, loop;
int glo[MAXDIM],ghi[MAXDIM];
dra_size_t dlo[MAXDIM],dhi[MAXDIM];
dra_size_t ddims[MAXDIM],reqdims[MAXDIM];
dra_size_t m;
int index[MAXDIM], dims[MAXDIM];
int me, nproc, isize;
double *ptr;
double plus, minus;
int ld[MAXDIM], chunk[MAXDIM];
char filename[80];
FILE *fd;
n = SIZE;
m = ((dra_size_t)NFACTOR)*((dra_size_t)SIZE);
loop = 1;
for (i=0; i<ndim; i++) loop *= NFACTOR;
req = -1;
nproc = GA_Nnodes();
me = GA_Nodeid();
if (me == 0) {
printf("Creating temporary global arrays %d",n);
for (i=1; i<ndim; i++) {
printf(" x %d",n);
}
printf("\n");
}
if (me == 0) fflush(stdout);
GA_Sync();
for (i=0; i<ndim; i++) {
dims[i] = n;
chunk[i] = 1;
}
g_a = NGA_Create(MT_DBL, ndim, dims, "a", chunk);
if (!g_a) GA_Error("NGA_Create failed: a", 0);
g_b = NGA_Create(MT_DBL, ndim, dims, "b", chunk);
if (!g_b) GA_Error("NGA_Create failed: b", 0);
if (me == 0) printf("done\n");
if (me == 0) fflush(stdout);
/* initialize g_a, g_b with random values
... use ga_access to avoid allocating local buffers for ga_put */
GA_Sync();
NGA_Distribution(g_a, me, glo, ghi);
NGA_Access(g_a, glo, ghi, &ptr, ld);
isize = 1;
for (i=0; i<ndim; i++) isize *= (ghi[i]-glo[i]+1);
fill_random(ptr, isize);
GA_Sync();
GA_Zero(g_b);
/*.......................................................................*/
if (me == 0) {
printf("Creating Disk array %ld",m);
for (i=1; i<ndim; i++) {
printf(" x %ld",m);
}
printf("\n");
}
if (me == 0) fflush(stdout);
for (i=0; i<ndim; i++) {
ddims[i] = m;
reqdims[i] = (dra_size_t)n;
}
GA_Sync();
strcpy(filename,FNAME);
if (! (fd = fopen(filename, "w"))) {
strcpy(filename,FNAME_ALT);
if (! (fd = fopen(filename, "w"))) {
GA_Error("open failed",0);
}
}
fclose(fd);
if (NDRA_Create(MT_DBL, ndim, ddims, "A", filename, DRA_RW,
reqdims, &d_a) != 0) {
GA_Error("NDRA_Create failed(d_a): ",0);
}
if (me == 0) printf("testing write\n");
fflush(stdout);
tt1 = 0.0;
for (i=0; i<loop; i++) {
itmp=i;
for (j=0; j<ndim; j++) {
index[j] = itmp%NFACTOR;
itmp = (itmp - index[j])/NFACTOR;
}
for (j=0; j<ndim; j++) {
glo[j] = 0;
ghi[j] = SIZE - 1;
dlo[j] = ((dra_size_t)index[j])*((dra_size_t)SIZE);
dhi[j] = (((dra_size_t)index[j])+(dra_size_t)1)
* ((dra_size_t)SIZE) - (dra_size_t)1;
}
tt0 = MP_TIMER();
if (NDRA_Write_section(FALSE, g_a, glo, ghi,
d_a, dlo, dhi, &req) != 0) {
GA_Error("ndra_write_section failed:",0);
}
if (DRA_Wait(req) != 0) {
GA_Error("DRA_Wait failed(d_a): ",req);
}
tt1 += (MP_TIMER() - tt0);
}
GA_Dgop(&tt1,1,"+");
tt1 = tt1/((double)nproc);
mbytes = 1.e-6 * (double)(pow(m,ndim)*sizeof(double));
if (me == 0) {
printf("%11.2f MB time = %11.2f rate = %11.3f MB/s\n",
mbytes,tt1,mbytes/tt1);
}
if (DRA_Close(d_a) != 0) {
GA_Error("DRA_Close failed(d_a): ",d_a);
}
if (me == 0) printf("\n");
if (me == 0) printf("disk array closed\n");
if (me == 0) fflush(stdout);
/*..........................................................*/
if (me == 0) printf("\n");
if (me == 0) printf("opening disk array\n");
if (DRA_Open(filename, DRA_R, &d_a) != 0) {
GA_Error("DRA_Open failed",0);
}
if (me == 0) printf("testing read\n");
/* printf("testing read on proc %d\n",me); */
if (me == 0) fflush(stdout);
tt1 = 0.0;
for (i=0; i<loop; i++) {
itmp=i;
for (j=0; j<ndim; j++) {
index[j] = itmp%NFACTOR;
itmp = (itmp - index[j])/NFACTOR;
}
for (j=0; j<ndim; j++) {
glo[j] = 0;
ghi[j] = SIZE - 1;
dlo[j] = ((dra_size_t)index[j])*((dra_size_t)SIZE);
dhi[j] = (((dra_size_t)index[j])+(dra_size_t)1)
* ((dra_size_t)SIZE) - (dra_size_t)1;
}
tt0 = MP_TIMER();
if (NDRA_Read_section(FALSE, g_b, glo, ghi,
d_a, dlo, dhi, &req) != 0) {
GA_Error("ndra_read_section failed:",0);
}
if (DRA_Wait(req) != 0) {
GA_Error("DRA_Wait failed(d_a): ",req);
}
tt1 += (MP_TIMER() - tt0);
plus = 1.0;
minus = -1.0;
GA_Add(&plus, g_a, &minus, g_b, g_b);
err = GA_Ddot(g_b, g_b);
if (err != 0) {
if (me == 0) {
printf("BTW, we have error = %f on loop value %d\n",
err,i);
}
GA_Error(" bye",0);
}
}
GA_Dgop(&tt1,1,"+");
tt1 = tt1/((double)nproc);
if (me == 0) {
printf("%11.2f MB time = %11.2f rate = %11.3f MB/s\n",
mbytes,tt1,mbytes/tt1);
}
if (DRA_Delete(d_a) != 0) GA_Error("DRA_Delete failed",0);
/*.......................................................................*/
GA_Destroy(g_a);
GA_Destroy(g_b);
}
int main(int argc, char **argv)
{
int rank, nprocs;
int g_A;
int *local_A=NULL, *local_B=NULL, *output_A=NULL;
int dims[DIM]={SIZE,SIZE}, dims2[DIM], lo[DIM]={SIZE-SIZE,SIZE-SIZE}, hi[DIM]={SIZE-1,SIZE-1}, ld=SIZE;
int value=SIZE;
#if defined(USE_ELEMENTAL)
// initialize Elemental (which will initialize MPI)
ElInitialize( &argc, &argv );
ElMPICommRank( MPI_COMM_WORLD, &rank );
ElMPICommSize( MPI_COMM_WORLD, &nprocs );
// instantiate el::global array
ElGlobalArraysConstruct_i( &eliga );
// initialize global arrays
ElGlobalArraysInitialize_i( eliga );
#else
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
MA_init(C_INT, 1000, 1000);
GA_Initialize();
#endif
local_A=(int*)malloc(SIZE*SIZE*sizeof(int));
output_A=(int*)malloc(SIZE*SIZE*sizeof(int));
memset (output_A, 0, SIZE*SIZE*sizeof(int));
for(int j=0; j<SIZE; j++)
for(int i=0; i<SIZE; i++) local_A[i+j*ld]=(i + j);
//for(int i=0; i<SIZE; i++) local_A[i+j*ld]=(rand()%10);
local_B=(int*)malloc(SIZE*SIZE*sizeof(int));
memset (local_B, 0, SIZE*SIZE*sizeof(int));
// nb handle
#if defined(USE_ELEMENTAL)
typedef ElInt ga_nbhdl_t;
#endif
ga_nbhdl_t nbnb;
#if defined(USE_ELEMENTAL)
ElGlobalArraysCreate_i( eliga, DIM, dims, "array_A", NULL, &g_A );
ElGlobalArraysFill_i( eliga, g_A, &value );
#else
g_A = NGA_Create(C_INT, DIM, dims, "array_A", NULL);
GA_Fill(g_A, &value);
#endif
if (rank == 0) printf ("Initial global array:\n");
#if defined(USE_ELEMENTAL)
ElGlobalArraysPrint_i( eliga, g_A );
#else
GA_Print(g_A);
#endif
for (int i = 0; i < NITERS; i++)
{
// acc data
#if defined(USE_ELEMENTAL)
ElGlobalArraysNBAccumulate_i( eliga, g_A, lo, hi, local_A, &ld, &value, &nbnb );
#else
NGA_NbAcc(g_A, lo, hi, local_A, &ld, &value, &nbnb);
#endif
// updated output
MPI_Reduce (local_A, output_A, SIZE*SIZE, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
#if defined(USE_ELEMENTAL)
ElGlobalArraysNBWait_i( eliga, &nbnb );
#else
NGA_NbWait (&nbnb);
#endif
// get
if (rank == 0) printf ("Get in iter #%d\n", i);
#if defined(USE_ELEMENTAL)
ElGlobalArraysSync_i( eliga );
ElGlobalArraysGet_i( eliga, g_A, lo, hi, local_B, &ld );
ElGlobalArraysPrint_i( eliga, g_A );
#else
GA_Sync();
NGA_Get(g_A, lo, hi, local_B, &ld);
GA_Print(g_A);
#endif
} // end of iters
if(rank==0)
{
printf(" Alpha (multiplier): %d\n", value);
printf(" Original local buffer (before accumulation): \n");
for(int i=0; i<SIZE; i++)
{
for(int j=0; j<SIZE; j++)
printf("%d ", local_A[i*ld+j]);
printf("\n");
}
printf("\n");
printf(" Get returns: \n");
for(int i=0; i<SIZE; i++)
{
for(int j=0; j<SIZE; j++)
printf("%d ", local_B[i*ld + j]);
printf("\n");
}
printf("\n");
for(int i=0; i<SIZE; i++)
{
for(int j=0; j<SIZE; j++)
{
if(local_B[i*ld+j]!=(value + (NITERS * value * (output_A[i*ld+j]))))
GA_Error("ERROR", -99);
}
}
}
#if defined(USE_ELEMENTAL)
ElGlobalArraysDestroy_i( eliga, g_A );
#else
GA_Destroy(g_A);
#endif
if(rank == 0)
printf ("OK. Test passed\n");
free (local_A);
free (local_B);
free (output_A);
#if defined(USE_ELEMENTAL)
ElGlobalArraysTerminate_i( eliga );
// call el::global arrays destructor
ElGlobalArraysDestruct_i( eliga );
ElFinalize();
#else
GA_Terminate();
MPI_Finalize();
#endif
}
void do_work()
{
int ZERO=0; /* useful constants */
int g_a, g_b;
int n=N, ndim=2,type=MT_F_DBL,dims[2]={N,N},coord[2];
int me=GA_Nodeid(), nproc=GA_Nnodes();
int row, i, j;
int lo[2], hi[2];
/* Note: on all current platforms DoublePrecision = double */
DoublePrecision buf[N], *max_row=NULL;
MPI_Comm WORLD_COMM;
MPI_Comm ROW_COMM;
int ilo,ihi, jlo,jhi, ld, prow, pcol;
int root=0, grp_me=-1;
WORLD_COMM = GA_MPI_Comm_pgroup_default();
if(me==0)printf("Creating matrix A\n");
dims[0]=n; dims[1]=n;
g_a = NGA_Create(type, ndim, dims, "A", NULL);
if(!g_a) GA_Error("create failed: A",n);
if(me==0)printf("OK\n");
if(me==0)printf("Creating matrix B\n");
dims[0]=n;
g_b = NGA_Create(type, 1, dims, "B", NULL);
if(!g_b) GA_Error("create failed: B",n);
if(me==0)printf("OK\n");
GA_Zero(g_a); /* zero the matrix */
if(me==0)printf("Initializing matrix A\n");
/* fill in matrix A with values: A(i,j) = (i+j) */
for(row=me; row<n; row+= nproc){
/**
* simple load balancing:
* each process works on a different row in MIMD style
*/
for(i=0; i<n; i++) buf[i]=(DoublePrecision)(i+row+1);
lo[0]=hi[0]=row;
lo[1]=ZERO; hi[1]=n-1;
NGA_Put(g_a, lo, hi, buf, &n);
}
/* GA_print(&g_a);*/
NGA_Distribution(g_a, me, lo, hi);
ilo=lo[0]; ihi=hi[0];
jlo=lo[1]; jhi=hi[1];
GA_Sync();
if(ihi-ilo+1 >0){
max_row=(DoublePrecision*)malloc(sizeof(DoublePrecision)*(ihi-ilo+1));
if (!max_row) GA_Error("malloc 3 failed",(ihi-ilo+1));
for (i=0; i<(ihi-ilo+1); i++) {
max_row[i] = 0.0;
}
}
NGA_Proc_topology(g_a, me, coord); /* block coordinates */
prow = coord[0];
pcol = coord[1];
if(me==0)printf("Splitting comm according to distribution of A\n");
/* GA on SP1 requires synchronization before & after message-passing !!*/
GA_Sync();
if(me==0)printf("Computing max row elements\n");
/* create communicator for processes that 'own' A[:,jlo:jhi] */
MPI_Barrier(WORLD_COMM);
if(pcol < 0 || prow <0)
MPI_Comm_split(WORLD_COMM,MPI_UNDEFINED,MPI_UNDEFINED, &ROW_COMM);
else
MPI_Comm_split(WORLD_COMM, (int)pcol, (int)prow, &ROW_COMM);
if(ROW_COMM != MPI_COMM_NULL){
double *ptr;
MPI_Comm_rank(ROW_COMM, &grp_me);
/* each process computes max elements in the block it 'owns' */
lo[0]=ilo; hi[0]=ihi;
lo[1]=jlo; hi[1]=jhi;
NGA_Access(g_a, lo, hi, &ptr, &ld);
for(i=0; i<ihi-ilo+1; i++){
for(j=0; j<jhi-jlo+1; j++)
if(max_row[i] < ptr[i*ld + j]){
max_row[i] = ptr[i*ld + j];
}
}
MPI_Reduce(max_row, buf, ihi-ilo+1, MPI_DOUBLE, MPI_MAX,
root, ROW_COMM);
}else fprintf(stderr,"process %d not participating\n",me);
GA_Sync();
/* processes with rank=root in ROW_COMM put results into g_b */
ld = 1;
if(grp_me == root) {
lo[0]=ilo; hi[0]=ihi;
NGA_Put(g_b, lo, hi, buf, &ld);
}
GA_Sync();
if(me==0)printf("Checking the result\n");
if(me==0){
lo[0]=ZERO; hi[0]=n-1;
NGA_Get(g_b, lo, hi, buf, &n);
for(i=0; i< n; i++)if(buf[i] != (double)n+i){
fprintf(stderr,"error:%d max=%f should be:%d\n",i,buf[i],n+i);
GA_Error("terminating...",1);
}
}
if(me==0)printf("OK\n");
GA_Destroy(g_a);
GA_Destroy(g_b);
}
static int test(int shape_idx, int type_idx, int dist_idx)
{
int type = TYPES[type_idx];
int *dims = SHAPES[shape_idx];
int ndim = SHAPES_NDIM[shape_idx];
mock_ga_t *mock_a, *result_a;
int g_a;
int buffer[100];
int lo[GA_MAX_DIM], hi[GA_MAX_DIM], ld[GA_MAX_DIM], shape[GA_MAX_DIM];
int result=0, error_index=-1, error_proc=-1;
mock_a = Mock_Create(type, ndim, dims, "mock", NULL);
result_a = Mock_Create(type, ndim, dims, "mock", NULL);
g_a = create_function[dist_idx](type, ndim, dims);
mock_data(mock_a, g_a);
mock_to_global(mock_a, g_a);
Mock_Zero(mock_a);
GA_Zero(g_a);
global_to_mock(g_a, result_a);
result = neq_mock(mock_a, result_a, &error_index);
if (0 != result) {
error_proc = GA_Nodeid();
}
GA_Igop(&result, 1, "+");
GA_Igop(&error_proc, 1, "max");
if (error_proc != GA_Nodeid()) {
error_index = 0;
}
GA_Igop(&error_index, 1, "+");
if (0 != result) {
if (error_proc == GA_Nodeid()) {
printf("ERROR: local result failed to compare to global result\n");
printf("\terror_proc=%d\n", error_proc);
printf("\terror_index=%d\n", error_index);
printf("***LOCAL RESULT***\n");
Mock_Print(mock_a);
printf("***GLOBAL RESULT***\n");
Mock_Print(result_a);
printf("\tprinting array distribution\n");
}
GA_Sync();
GA_Print(g_a);
GA_Print_distribution(g_a);
return 1;
}
Mock_Destroy(mock_a);
Mock_Destroy(result_a);
GA_Destroy(g_a);
return 0;
}
int main (int argc, char **argv)
{
double startTime;
int info; /* used to check for functions returning nonzeros */
GAVec ga_x; /* solution vector */
TAO_SOLVER tao; /* TAO_SOLVER solver context */
TAO_GA_APPLICATION taoapp; /* TAO application context */
TaoTerminateReason reason;
AppCtx user; /* user-defined application context */
/*initialize GA and MPI */
int heap = 400000, stack = 400000;
MPI_Init (&argc, &argv); /* initialize MPI */
GA_Initialize (); /* initialize GA */
user.me = GA_Nodeid ();
user.nproc = GA_Nnodes ();
startTime = MPI_Wtime();
if (user.me == 0) {
if (GA_Uses_fapi ())
GA_Error ("Program runs with C array API only", 0);
printf ("Using %ld processes\n", (long) user.nproc);
fflush (stdout);
}
heap /= user.nproc;
stack /= user.nproc;
if (!MA_init (MT_F_DBL, stack, heap))
GA_Error ("MA_init failed", stack + heap); /* initialize memory allocator */
/* Initialize TAO */
TaoInitialize (&argc, &argv, (char *) 0, help);
/* Initialize problem parameters */
user.ndim = NDIM;
user.natoms = NATOMS;
user.BlockSize = BLOCKSIZE;
/* Allocate vectors for the solution and gradient */
int dims[2];
dims[0] = user.ndim*user.natoms;
ga_x = NGA_Create (C_DBL, 1, dims, "GA_X", NULL);
if (!ga_x) GA_Error ("lennard-jones.main::NGA_Create ga_x", ga_x);
/* Set up structures for data distribution */
info = SetupBlocks(&user); CHKERRQ(info);
/* The TAO code begins here */
/* Create TAO solver with desired solution method */
info = TaoCreate (MPI_COMM_WORLD, "tao_lmvm", &tao); CHKERRQ(info);
info = TaoGAApplicationCreate (MPI_COMM_WORLD, &taoapp); CHKERRQ(info);
/* Set the initial solution */
info = InitializeVariables(ga_x, &user); CHKERRQ(info);
info = TaoGAAppSetInitialSolutionVec(taoapp, ga_x); CHKERRQ(info);
/* Set routines for function, gradient */
info = TaoGAAppSetObjectiveAndGradientRoutine (taoapp, FormFunctionGradient,
(void *) &user); CHKERRQ(info);
/* Check for TAO command line options */
info = TaoSetFromOptions (tao); CHKERRQ(info);
/* SOLVE THE APPLICATION */
info = TaoSolveGAApplication (taoapp, tao); CHKERRQ(info);
/* To View TAO solver information use */
info = TaoView(tao); CHKERRQ(info);
/* Get termination information */
info = TaoGetTerminationReason (tao, &reason);
if(info) GA_Error("lennard-jones.main.TaoGetTerminationReason",info);
if (user.me == 0) {
if (reason <= 0)
printf("Try a different TAO method, adjust some parameters, or check the function evaluation routines\n");
printf("WALL TIME TAKEN = %lf\n", MPI_Wtime()-startTime);
/*output the solutions */
printf ("The solution is :\n");
}
GA_Print (ga_x);
/* Free TAO data structures */
info = TaoDestroy (tao); CHKERRQ(info);
info = TaoGAAppDestroy (taoapp); CHKERRQ(info);
/* Free GA data structures */
GA_Destroy (ga_x);
if (!MA_pop_stack(user.memHandle))
ga_error("Main::MA_pop_stack for memHandle failed",0);
/* Finalize TAO, GA, and MPI */
TaoFinalize ();
GA_Terminate ();
MPI_Finalize ();
return 0;
}
// -------------------------------------------------------------
// AdjacencyList::ready
// -------------------------------------------------------------
void
AdjacencyList::ready(void)
{
#if 1
int grp = this->communicator().getGroup();
int me = GA_Pgroup_nodeid(grp);
int nprocs = GA_Pgroup_nnodes(grp);
p_adjacency.clear();
p_adjacency.resize(p_global_nodes.size());
// Find total number of nodes and edges. Assume no duplicates
int nedges = p_edges.size();
int total_edges = nedges;
char plus[2];
strcpy(plus,"+");
GA_Pgroup_igop(grp,&total_edges, 1, plus);
int nnodes = p_original_nodes.size();
int total_nodes = nnodes;
GA_Pgroup_igop(grp,&total_nodes, 1, plus);
// Create a global array containing original indices of all nodes and indexed
// by the global index of the node
int i, p;
int dist[nprocs];
for (p=0; p<nprocs; p++) {
dist[p] = 0;
}
dist[me] = nnodes;
GA_Pgroup_igop(grp,dist,nprocs,plus);
int *mapc = new int[nprocs+1];
mapc[0] = 0;
for (p=1; p<nprocs; p++) {
mapc[p] = mapc[p-1] + dist[p-1];
}
mapc[nprocs] = total_nodes;
int g_nodes = GA_Create_handle();
int dims = total_nodes;
NGA_Set_data(g_nodes,1,&dims,C_INT);
NGA_Set_pgroup(g_nodes, grp);
if (!GA_Allocate(g_nodes)) {
char buf[256];
sprintf(buf,"AdjacencyList::ready: Unable to allocate distributed array"
" for bus indices\n");
printf(buf);
throw gridpack::Exception(buf);
}
int lo, hi;
lo = mapc[me];
hi = mapc[me+1]-1;
int size = hi - lo + 1;
int o_idx[size], g_idx[size];
for (i=0; i<size; i++) o_idx[i] = p_original_nodes[i];
for (i=0; i<size; i++) g_idx[i] = p_global_nodes[i];
int **indices= new int*[size];
int *iptr = g_idx;
for (i=0; i<size; i++) {
indices[i] = iptr;
iptr++;
}
if (size > 0) NGA_Scatter(g_nodes,o_idx,indices,size);
GA_Pgroup_sync(grp);
delete [] indices;
delete [] mapc;
// Cycle through all nodes and match them up with nodes at end of edges.
for (p=0; p<nprocs; p++) {
int iproc = (me+p)%nprocs;
// Get node data from process iproc
NGA_Distribution(g_nodes,iproc,&lo,&hi);
size = hi - lo + 1;
if (size <= 0) continue;
int *buf = new int[size];
int ld = 1;
NGA_Get(g_nodes,&lo,&hi,buf,&ld);
// Create a map of the nodes from process p
std::map<int,int> nmap;
std::map<int,int>::iterator it;
std::pair<int,int> pr;
for (i=lo; i<=hi; i++){
pr = std::pair<int,int>(buf[i-lo],i);
nmap.insert(pr);
}
delete [] buf;
// scan through the edges looking for matches. If there is a match, set the
// global index
int idx;
for (i=0; i<nedges; i++) {
idx = static_cast<int>(p_edges[i].original_conn.first);
it = nmap.find(idx);
if (it != nmap.end()) {
p_edges[i].global_conn.first = static_cast<Index>(it->second);
}
idx = static_cast<int>(p_edges[i].original_conn.second);
it = nmap.find(idx);
if (it != nmap.end()) {
p_edges[i].global_conn.second = static_cast<Index>(it->second);
}
}
}
GA_Destroy(g_nodes);
// All edges now have global indices assigned to them. Begin constructing
// adjacency list. Start by creating a global array containing all edges
dist[0] = 0;
for (p=1; p<nprocs; p++) {
double max = static_cast<double>(total_edges);
max = (static_cast<double>(p))*(max/(static_cast<double>(nprocs)));
dist[p] = 2*(static_cast<int>(max));
}
int g_edges = GA_Create_handle();
dims = 2*total_edges;
NGA_Set_data(g_edges,1,&dims,C_INT);
NGA_Set_irreg_distr(g_edges,dist,&nprocs);
NGA_Set_pgroup(g_edges, grp);
if (!GA_Allocate(g_edges)) {
char buf[256];
sprintf(buf,"AdjacencyList::ready: Unable to allocate distributed array"
" for branch indices\n");
printf(buf);
throw gridpack::Exception(buf);
}
// Add edge information to global array. Start by figuring out how much data
// is associated with each process
for (p=0; p<nprocs; p++) {
dist[p] = 0;
}
dist[me] = nedges;
GA_Pgroup_igop(grp,dist, nprocs, plus);
int offset[nprocs];
offset[0] = 0;
for (p=1; p<nprocs; p++) {
offset[p] = offset[p-1] + 2*dist[p-1];
}
// Figure out where local data goes in GA and then copy it to GA
lo = offset[me];
hi = lo + 2*nedges - 1;
int edge_ids[2*nedges];
for (i=0; i<nedges; i++) {
edge_ids[2*i] = static_cast<int>(p_edges[i].global_conn.first);
edge_ids[2*i+1] = static_cast<int>(p_edges[i].global_conn.second);
}
if (lo <= hi) {
int ld = 1;
NGA_Put(g_edges,&lo,&hi,edge_ids,&ld);
}
GA_Pgroup_sync(grp);
// Cycle through all edges and find out how many are attached to the nodes on
// your process. Start by creating a map between the global node indices and
// the local node indices
std::map<int,int> gmap;
std::map<int,int>::iterator it;
std::pair<int,int> pr;
for (i=0; i<nnodes; i++){
pr = std::pair<int,int>(static_cast<int>(p_global_nodes[i]),i);
gmap.insert(pr);
}
// Cycle through edge information on each processor
for (p=0; p<nprocs; p++) {
int iproc = (me+p)%nprocs;
NGA_Distribution(g_edges,iproc,&lo,&hi);
int size = hi - lo + 1;
int *buf = new int[size];
int ld = 1;
NGA_Get(g_edges,&lo,&hi,buf,&ld);
BOOST_ASSERT(size%2 == 0);
size = size/2;
int idx1, idx2;
Index idx;
for (i=0; i<size; i++) {
idx1 = buf[2*i];
idx2 = buf[2*i+1];
it = gmap.find(idx1);
if (it != gmap.end()) {
idx = static_cast<Index>(idx2);
p_adjacency[it->second].push_back(idx);
}
it = gmap.find(idx2);
if (it != gmap.end()) {
idx = static_cast<Index>(idx1);
p_adjacency[it->second].push_back(idx);
}
}
delete [] buf;
}
GA_Destroy(g_edges);
GA_Pgroup_sync(grp);
#else
int me(this->processor_rank());
int nproc(this->processor_size());
p_adjacency.clear();
p_adjacency.resize(p_nodes.size());
IndexVector current_indexes;
IndexVector connected_indexes;
for (int p = 0; p < nproc; ++p) {
// broadcast the node indexes owned by process p to all processes,
// all processes work on these at once
current_indexes.clear();
if (me == p) {
std::copy(p_nodes.begin(), p_nodes.end(),
std::back_inserter(current_indexes));
// std::cout << me << ": node indexes: ";
// std::copy(current_indexes.begin(), current_indexes.end(),
// std::ostream_iterator<Index>(std::cout, ","));
// std::cout << std::endl;
}
boost::mpi::broadcast(this->communicator(), current_indexes, p);
// make a copy of the local edges in a list (so it's easier to
// remove those completely accounted for)
std::list<p_Edge> tmpedges;
std::copy(p_edges.begin(), p_edges.end(),
std::back_inserter(tmpedges));
// loop over the process p's node index set
int local_index(0);
for (IndexVector::iterator n = current_indexes.begin();
n != current_indexes.end(); ++n, ++local_index) {
// determine the local edges that refer to the current node index
connected_indexes.clear();
std::list<p_Edge>::iterator e(tmpedges.begin());
// std::cout << me << ": current node index: " << *n
// << ", edges: " << tmpedges.size()
// << std::endl;
while (e != tmpedges.end()) {
if (*n == e->conn.first && e->conn.second != bogus) {
connected_indexes.push_back(e->conn.second);
e->found.first = true;
// std::cout << me << ": found connection: edge " << e->index
// << " (" << e->conn.first << ", " << e->conn.second << ")"
// << std::endl;
}
if (*n == e->conn.second && e->conn.first != bogus) {
connected_indexes.push_back(e->conn.first);
e->found.second = true;
// std::cout << me << ": found connection: edge " << e->index
// << " (" << e->conn.first << ", " << e->conn.second << ")"
// << std::endl;
}
if (e->found.first && e->found.second) {
e = tmpedges.erase(e);
} else if (e->conn.first == bogus ||
e->conn.second == bogus) {
e = tmpedges.erase(e);
} else {
++e;
}
}
// gather all connections for the current node index to the
// node's owner process, we have to gather the vectors because
// processes will have different numbers of connections
if (me == p) {
size_t allsize;
boost::mpi::reduce(this->communicator(),
connected_indexes.size(), allsize, std::plus<size_t>(), p);
std::vector<IndexVector> all_connected_indexes;
boost::mpi::gather(this->communicator(),
connected_indexes, all_connected_indexes, p);
p_adjacency[local_index].clear();
for (std::vector<IndexVector>::iterator k = all_connected_indexes.begin();
k != all_connected_indexes.end(); ++k) {
std::copy(k->begin(), k->end(),
std::back_inserter(p_adjacency[local_index]));
}
} else {
boost::mpi::reduce(this->communicator(),
connected_indexes.size(), std::plus<size_t>(), p);
boost::mpi::gather(this->communicator(), connected_indexes, p);
}
this->communicator().barrier();
}
this->communicator().barrier();
}
#endif
}
void do_work()
{
int ONE=1 ; /* useful constants */
int g_a, g_b;
int n=N, type=MT_F_DBL;
int me=GA_Nodeid(), nproc=GA_Nnodes();
int i, row;
int dims[2]={N,N};
int lo[2], hi[2], ld;
/* Note: on all current platforms DoublePrecision == double */
double buf[N], err, alpha, beta;
if(me==0)printf("Creating matrix A\n");
g_a = NGA_Create(type, 2, dims, "A", NULL);
if(!g_a) GA_Error("create failed: A",n);
if(me==0)printf("OK\n");
if(me==0)printf("Creating matrix B\n");
/* create matrix B so that it has dims and distribution of A*/
g_b = GA_Duplicate(g_a, "B");
if(! g_b) GA_Error("duplicate failed",n);
if(me==0)printf("OK\n");
GA_Zero(g_a); /* zero the matrix */
if(me==0)printf("Initializing matrix A\n");
/* fill in matrix A with random values in range 0.. 1 */
lo[1]=0; hi[1]=n-1;
for(row=me; row<n; row+= nproc){
/* each process works on a different row in MIMD style */
lo[0]=hi[0]=row;
for(i=0; i<n; i++) buf[i]=sin((double)i + 0.1*(row+1));
NGA_Put(g_a, lo, hi, buf, &n);
}
if(me==0)printf("Symmetrizing matrix A\n");
GA_Symmetrize(g_a); /* symmetrize the matrix A = 0.5*(A+A') */
/* check if A is symmetric */
if(me==0)printf("Checking if matrix A is symmetric\n");
GA_Transpose(g_a, g_b); /* B=A' */
alpha=1.; beta=-1.;
GA_Add(&alpha, g_a, &beta, g_b, g_b); /* B= A - B */
err= GA_Ddot(g_b, g_b);
if(me==0)printf("Error=%f\n",(double)err);
if(me==0)printf("\nChecking atomic accumulate \n");
GA_Zero(g_a); /* zero the matrix */
for(i=0; i<n; i++) buf[i]=(double)i;
/* everybody accumulates to the same location/row */
alpha = 1.0;
row = n/2;
lo[0]=hi[0]=row;
lo[1]=0; hi[1]=n-1;
ld = hi[1]-lo[1]+1;
NGA_Acc(g_a, lo, hi, buf, &ld, &alpha );
GA_Sync();
if(me==0){ /* node 0 is checking the result */
NGA_Get(g_a, lo, hi, buf,&ld);
for(i=0; i<n; i++) if(buf[i] != (double)nproc*i)
GA_Error("failed: column=",i);
printf("OK\n\n");
}
GA_Destroy(g_a);
GA_Destroy(g_b);
}