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);
}
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);
}
main(int argc, char **argv)
{
int rank, nprocs, i, j;
int g_A, g_B, g_C, local_C[DIM][DIM], dims[DIM]={5,5};
int val_A=5, val_B=3, ld=DIM, max;
int lo[DIM]={2,2}, hi[DIM]={4,4}, blo[DIM]={0,0}, bhi[DIM]={2,2}, clo[DIM]={1,1}, chi[DIM]={3,3};
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();
g_A = NGA_Create(C_INT, DIM, dims, "array_A", NULL);
g_B = NGA_Create(C_INT, DIM, dims, "array_B", NULL);
g_C = NGA_Create(C_INT, DIM, dims, "array_C", NULL);
GA_Fill(g_A, &val_A);
GA_Fill(g_B, &val_B);
GA_Zero(g_C);
GA_Elem_maximum_patch(g_A, lo, hi, g_B, blo, bhi, g_C, clo, chi);
GA_Print(g_C);
GA_Sync();
NGA_Get(g_C, clo, chi, local_C, &ld);
if(rank==1)
{
for(i=0; i<DIM; i++)
{
for(j=0; j<DIM; j++)printf("%d ", local_C[i][j]);
printf("\n");
}
if(val_A>val_B) max=val_A;
else max=val_B;
for(i=0; i<DIM; i++)
{
for(j=0; j<DIM; j++)
if(local_C[i][j]!=max) printf("GA Error : \n");
}
}
GA_Sync();
if(rank == 0)
printf("Test Completed \n");
GA_Terminate();
MPI_Finalize();
}
int main(int argc, char **argv)
{
int size_dst = 15;
int g_a = 0;
int I_NEG_ONE = -1;
long L_NEG_ONE = -1;
long long LL_NEG_ONE = -1;
int FIVE = 5;
int TEN = 10;
int lo;
int hi;
int *ptr;
int i;
MP_INIT(argc,argv);
GA_INIT(argc,argv);
for (i=0; i<3; ++i) {
if (0 == i) {
g_a = NGA_Create(C_INT, 1, &size_dst, "dst", NULL);
GA_Fill(g_a, &I_NEG_ONE);
} else if (1 == i) {
g_a = NGA_Create(C_LONG, 1, &size_dst, "dst", NULL);
GA_Fill(g_a, &L_NEG_ONE);
} else if (2 == i) {
g_a = NGA_Create(C_LONGLONG, 1, &size_dst, "dst", NULL);
GA_Fill(g_a, &LL_NEG_ONE);
}
GA_Sync();
GA_Print(g_a);
NGA_Print_patch(g_a, &FIVE, &TEN, 0);
NGA_Print_patch(g_a, &FIVE, &TEN, 1);
NGA_Distribution(g_a, GA_Nodeid(), &lo, &hi);
NGA_Access(g_a, &lo, &hi, &ptr, NULL);
printf("[%d] (%d)=%d\n", GA_Nodeid(), lo, *ptr);
NGA_Release(g_a, &lo, &hi);
}
GA_Terminate();
MP_FINALIZE();
exit(EXIT_SUCCESS);
}
main(int argc, char **argv)
{
int rank, nprocs;
int g_A, dims[D]={SIZE,SIZE}, *local_A=NULL, *local_G=NULL, **sub_array=NULL, **s_array=NULL;
int i, j, value=5;
MPI_Init(&argc, &argv);
GA_Initialize();
MA_init(C_INT, 1000, 1000);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
s_array=(int**)malloc(N*sizeof(int*));
for(i=0; i<N; i++)
{
s_array[i]=(int*)malloc(D*sizeof(int));
for(j=0; j<D; j++) s_array[i][j]=rand()%10;
}
sub_array=(int**)malloc(N*sizeof(int*));
for(i=0; i<N; i++)
{
sub_array[i]=(int*)malloc(D*sizeof(int));
for(j=0; j<D; j++) sub_array[i][j]=rand()%10;
}
for(i=0; i<N; i++) local_A=(int*)malloc(N*sizeof(int));
for(i=0; i<N; i++) local_G=(int*)malloc(N*sizeof(int));
g_A=NGA_Create(C_INT, D, dims, "array_A", NULL);
GA_Fill(g_A, &value);
GA_Sync();
NGA_Scatter(g_A, local_A, s_array, N);
NGA_Gather(g_A, local_G, s_array, N);
GA_Sync();
GA_Print(g_A);
if(rank==0)
{
for(i=0; i<N; i++)
if(local_G[i]!=local_A[i]) printf("GA Error: \n");
}
GA_Sync();
if(rank==0)
GA_PRINT_MSG();
GA_Terminate();
MPI_Finalize();
return 0;
}
integer_dot(int rank, int nprocs)
{
int g_A, g_B;
int dims[DIM]={SIZE,SIZE}, val_A=5, val_B=10, op;
MA_init(C_INT, 1000, 1000);
g_A = NGA_Create(C_INT, DIM, dims, "array_A", NULL);
g_B = NGA_Create(C_INT, DIM, dims, "array_B", NULL);
GA_Fill(g_A, &val_A);
GA_Fill(g_B, &val_B);
if(rank==0)
{
op=GA_Idot(g_A, g_B);
printf("%d \n", op);
}
}
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();
}
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);
}
main(int argc, char **argv)
{
int rank, nprocs;
int g_A, g_V, val1=5, val2=5, local_A[SIZE][SIZE], dims_V=SIZE, local_V[dims_V];
int dims[DIM]={SIZE,SIZE}, dims2[DIM], lo[DIM]={1,1}, hi[DIM]={2,2}, ld=5, i, j;
int loV=0, hiV=dims_V-1;
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();
g_A = NGA_Create(C_INT, DIM, dims, "array_A", NULL);
g_V = NGA_Create(C_INT, 1, &dims_V, "array_A", NULL);
GA_Fill(g_A, &val1);
GA_Print(g_A);
printf("\n");
GA_Scale(g_A, &val2);
GA_Print(g_A);
GA_Get_diag(g_A, g_V);
GA_Print(g_V);
NGA_Get(g_A, lo, hi, local_A, &ld);
NGA_Get(g_V, &loV, &hiV, local_V, &ld);
if(rank==1)
{
for(i=0; i<dims_V; i++)
if(local_V[i]!=val1*val2) printf(" GA Error: \n");
}
if(rank == 0)
printf("Test Completed \n");
GA_Terminate();
MPI_Finalize();
}
// -------------------------------------------------------------
// CreateMatGA
// -------------------------------------------------------------
static
PetscErrorCode
CreateMatGA(int pgroup, int lrows, int lcols, int grows, int gcols, int *ga)
{
PetscErrorCode ierr = 0;
/* Try to honor local ownership request (of rows). */
int nprocs = GA_Pgroup_nnodes(pgroup);
int me = GA_Pgroup_nodeid(pgroup);
int tmapc[nprocs+1];
int mapc[nprocs+1];
int i;
for (i = 0; i < nprocs+1; i++) tmapc[i] = 0;
tmapc[me] = lrows;
GA_Pgroup_igop(pgroup, tmapc, nprocs+1, "+");
mapc[0] = 0;
for (i = 1; i < nprocs; i++) mapc[i] = mapc[i-1]+tmapc[i-1];
mapc[nprocs] = 0;
int dims[2] = {grows, gcols};
int blocks[2] = { nprocs, 1 };
*ga = GA_Create_handle();
GA_Set_data(*ga, 2, dims, MT_PETSC_SCALAR);
GA_Set_irreg_distr(*ga, mapc, blocks);
GA_Set_pgroup(*ga, pgroup);
if (!GA_Allocate(*ga)) {
ierr = 1;
}
PetscScalar z(0.0);
GA_Fill(*ga, &z);
return ierr;
}
// -------------------------------------------------------------
// MatDuplicate_DenseGA
// -------------------------------------------------------------
static
PetscErrorCode
MatDuplicate_DenseGA(Mat mat, MatDuplicateOption op, Mat *M)
{
PetscErrorCode ierr = 0;
struct MatGACtx *ctx, *newctx;
ierr = MatShellGetContext(mat, &ctx); CHKERRQ(ierr);
MPI_Comm comm;
ierr = PetscObjectGetComm((PetscObject)mat, &comm); CHKERRQ(ierr);
PetscInt lrows, grows, lcols, gcols;
ierr = MatGetSize(mat, &grows, &gcols); CHKERRQ(ierr);
ierr = MatGetLocalSize(mat, &lrows, &lcols); CHKERRQ(ierr);
ierr = PetscMalloc(sizeof(struct MatGACtx), &newctx); CHKERRQ(ierr);
newctx->gaGroup = ctx->gaGroup;
newctx->ga = GA_Duplicate(ctx->ga, "PETSc Dense Matrix");
ierr = MatCreateShell(comm, lrows, lcols, grows, gcols, newctx, M); CHKERRQ(ierr);
ierr = MatSetOperations_DenseGA(*M);
PetscScalar z(0.0);
switch (op) {
case (MAT_COPY_VALUES):
GA_Copy(ctx->ga, newctx->ga);
break;
default:
GA_Fill(newctx->ga, &z);
break;
}
GA_Pgroup_sync(newctx->gaGroup);
return ierr;
}
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
}
main(int argc, char **argv)
{
int rank, nprocs;
int g_A, dims[D]={5,10}, local_A[N], local_G[N], **sub_array=NULL, **s_array=NULL;
int i, j, value=5;
MPI_Init(&argc, &argv);
GA_Initialize();
MA_init(C_INT, 1000, 1000);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
s_array=(int**)malloc(N*sizeof(int*));
for(i=0; i<N; i++)
{
s_array[i]=(int*)malloc(D*sizeof(int));
for(j=0; j<D; j++) s_array[i][j]=rand()%5;
}
sub_array=(int**)malloc(N*sizeof(int*));
for(i=0; i<N; i++)
{
sub_array[i]=(int*)malloc(D*sizeof(int));
for(j=0; j<D; j++) sub_array[i][j]=rand()%5;
}
for(i=0; i<N; i++)
//local_A=(int*)malloc(N*sizeof(int));
/*
* depends on the value of array ..we can generate the location values in randon
* we can also use the if-condition
*/
// PRINTing all the genrated array for reference
for(i=0; i<N; i++)
{
for(j=0; j<D; j++)printf("%d ",s_array[i][j]);
printf("\n");
}
printf("\n");
for(i=0; i<N; i++)
{
for(j=0; j<D; j++)printf("%d ",sub_array[i][j]);
printf("\n");
}
printf("\n");
for(i=0; i<N; i++)printf("%d \n",local_A[i]=rand()%5+1);
// PRINT done - now creating array
g_A=NGA_Create(C_INT, D, dims, "array_A", NULL);
GA_Fill(g_A, &value);
GA_Sync();
NGA_Scatter(g_A, local_A, s_array, N);
NGA_Gather(g_A, local_G, s_array, N);
GA_Sync();
GA_Print(g_A);
for(i=0; i<N; i++)printf("%d \n",local_G[i]);
printf("\n");
if(rank==0)
{
for(i=0; i<N; i++)
if(local_G[i]!=local_A[i]) printf("GA Error: \n");
}
GA_Sync();
if(rank==0)
GA_PRINT_MSG();
GA_Terminate();
MPI_Finalize();
return 0;
}
main(int argc, char **argv)
{
int rank, nprocs, i, j;
int g_A, g_B, g_C, local_C[DIM][DIM], dims[DIM]={5,5}, val1=5, val2=4, alpha=3, beta=2, ld=5;
int alo[DIM]={2,2}, ahi[DIM]={3,3}, blo[DIM]={2,2}, bhi[DIM]={3,3}, clo[DIM]={1,1}, chi[DIM]={2,2};
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();
g_A = NGA_Create(C_INT, DIM, dims, "array_A", NULL);
g_B = GA_Duplicate(g_A, "array_B");
g_C = GA_Duplicate(g_A, "array_C");
GA_Fill(g_A, &val1);
GA_Fill(g_B, &val2);
GA_Zero(g_C);
NGA_Add_patch(&alpha, g_A, clo, chi, &beta, g_B, blo, bhi, g_C, clo, chi);
GA_Sync();
GA_Print(g_A);
GA_Print(g_B);
GA_Print(g_C);
NGA_Get(g_C, clo, chi, local_C, &ld);
//printf("check 1 \n");
for(i=0; i<DIM; i++)
{
for(j=0; j<DIM; j++)printf("%d ", local_C[i][j]);
printf("\n");
}
if(rank == 0)
{
printf("check 2\n");
for(i=0; i<DIM; i++)
{
for(j=0; j<DIM; j++)
if(local_C[i][j]!=(alpha*val1)+(beta*val2)) printf("GA Error : \n");
}
}
if(rank==0)
GA_PRINT_MSG();
GA_Sync();
/*
GA_Destroy(g_A);
GA_Destroy(g_B);
GA_Destroy(g_C);
*/
//*******************************************************************
/* what would be the possible reason for GA_destroy to get failed ..,
* solve this before consolidate the whole
*/
GA_Terminate();
MPI_Finalize();
}
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;
//int value=0;
#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);
local_B=(int*)malloc(SIZE*SIZE*sizeof(int));
memset (local_B, 0, SIZE*SIZE*sizeof(int));
#if defined(USE_ELEMENTAL)
ElGlobalArraysCreate_i( eliga, DIM, dims, "array_A", NULL, NULL, &g_A );
ElGlobalArraysFill_i( eliga, g_A, &value );
ElGlobalArraysPrint_i( eliga, g_A );
// acc data
ElGlobalArraysPut_i( eliga, g_A, lo, hi, local_A, &ld );
ElGlobalArraysSync_i( eliga );
// get
ElGlobalArraysGet_i( eliga, g_A, lo, hi, local_B, &ld );
ElGlobalArraysSync_i( eliga );
ElGlobalArraysPrint_i( eliga, g_A );
#else
g_A = NGA_Create(C_INT, DIM, dims, "array_A", NULL);
GA_Fill(g_A, &value);
GA_Print(g_A);
NGA_Put(g_A, lo, hi, local_A, &ld);
GA_Sync();
NGA_Get(g_A, lo, hi, local_B, &ld);
GA_Sync();
GA_Print(g_A);
#endif
// updated output
MPI_Reduce (local_A, output_A, SIZE*SIZE, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD);
if(rank==0)
{
printf(" Original local buffer to be accumulated: \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]!=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
}
int main(int argc, char**argv)
{
int nprocs, me;
int i,j;
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD,&nprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&me);
GA_Initialize();
int flag=1;
int Nx=108; int Ny=108; int Nz = 108;
Nx+=3; Ny+=3; Nz+=3;
int data[Nx*Ny*Nz];
int num_splines = 32;
int g_a,dims[4]={Nx,Ny,Nz,num_splines},chunk[4]={-1,-1,-1,num_splines};
int type=C_INT;
g_a=NGA_Create(type,4,dims,"Coefs",chunk);
int lo[4],hi[4],ld[3];
double value=9.0;
GA_Fill(g_a,&value);
GA_Print_distribution(g_a);
fflush(stdout);
if(me==0)
{
for (i=0; i<num_splines; i++)
{
for (j=0; j<Nx*Ny*Nz; j++)
data[j] = rand()%1000;
lo[0]=lo[1]=lo[2]=0;
hi[0]=Nx-1;hi[1]=Ny-1;hi[2]=Nz-1;
lo[3]=hi[3]=i%num_splines;
ld[0]=Ny;ld[1]=Nz;ld[2]=1;
NGA_Put(g_a,lo,hi,data,ld);
}
}
printf("done\n"),fflush(stdout);
GA_Sync();
ga_coefs_t *ga_coefs = malloc(sizeof(ga_coefs_t));
ga_coefs->Mx = Nx;
ga_coefs->My = Ny;
ga_coefs->Mz = Nz;
ga_coefs->nsplines = num_splines;
ga_coefs->g_a=g_a;
int *coefs1 = (int*)malloc((size_t)1*sizeof(int)*4*4*4*num_splines);
int ix,iy,iz;
Nx-=3; Ny-=3; Nz-=3;
ga_coefs->sumt=ga_coefs->amount=0;
NGA_Distribution(g_a,me,lo,hi);
int low[16][4],high[16][4];
for(i=0;i<nprocs;i++)
NGA_Distribution(g_a,i,low[i],high[i]);
srand ( time(NULL) );
int k;
for(k=0;k<nprocs;k++)
{
ga_coefs->sumt=ga_coefs->amount=0;
{
for(i=0;i<1000;i++)
{
ix=rand_index(low[k][0],high[k][0]);
iy=rand_index(low[k][1],high[k][1]);
iz=rand_index(low[k][2],high[k][2]);
coefs_ga_get_3d(ga_coefs,coefs1,ix,iy,iz);
mini_cube_sum(coefs1, ga_coefs->nsplines);
}
}
printf("<%d,%d>\t %lf \t %d \t %lf\n", me,k, ga_coefs->sumt, ga_coefs->amount, ga_coefs->sumt/ga_coefs->amount),fflush(stdout);
}
free(coefs1);
GA_Terminate();
MPI_Finalize();
return 0;
}
main(int argc, char **argv)
{
int rank, nprocs, i, j;
int g_A, g_B, g_C, **local_C=NULL, dims[DIM]={SIZE,SIZE}, val1=5, val2=4, alpha=3, beta=2;
int clo[DIM]={SIZE-SIZE,SIZE-SIZE}, chi[DIM]={SIZE-1,SIZE-1}, ld=SIZE;
int **local_tm=NULL;
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_C=(int**)malloc(SIZE*sizeof(int*));
for(i=0; i<SIZE; i++)
local_C[i]=(int*)malloc(SIZE*sizeof(int));
local_tm=(int**)malloc(SIZE*sizeof(int*));
for(i=0; i<SIZE; i++)
local_tm[i]=(int*)malloc(SIZE*sizeof(int));
g_A = NGA_Create(C_INT, DIM, dims, "array_A", NULL);
g_B = GA_Duplicate(g_A, "array_B");
g_C = GA_Duplicate(g_A, "array_C");
GA_Fill(g_A, &val1);
GA_Fill(g_B, &val2);
GA_Add(&alpha, g_A, &beta, g_B, g_C);
GA_Sync();
GA_Print(g_A);
GA_Print(g_B);
GA_Print(g_C);
//printf("check 1\n");
NGA_Get(g_C, clo, chi, local_tm, &ld);
//printf("check 2\n");
// GA_Sync();
if(rank==0)
{
for(i=0; i<SIZE; i++)
{
for(j=0; j<SIZE; j++)printf("%d ", local_tm[i][j]);
printf("\n");
}
}
/*
if(rank==0)
{
NGA_Get(g_C, clo, chi, local_C, &ld);
printf("check 1 \n");
for(i=0; i<SIZE; i++)
{
for(j=0; j<SIZE; j++)printf("%d ", local_C[i][j]);
printf("\n");
}
printf("check 2\n");
for(i=0; i<SIZE; i++)
{
for(j=0; j<SIZE; j++)
if(local_C[i][j]!=(alpha*val1)+(beta*val2)) printf("GA Error : \n");
}
}
*/
//GA_Sync();
if(rank==0)
printf("Test Completed \n");
// GA_Sync();
/*
GA_Destroy(g_A);
GA_Destroy(g_B);
GA_Destroy(g_C);
*/
//*******************************************************************
/* what would be the possible reason for GA_destroy to get failed ..,
* solve this before consolidate the whole
*/
GA_Terminate();
MPI_Finalize();
}
int main(int argc, char**argv)
{
int nprocs, me;
int i,j;
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD,&nprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&me);
GA_Initialize();
const int heap=3000000, stack=300000;
if(! MA_init(C_INT,stack,heap) ) GA_Error((char *) "MA_init failed",stack+heap /*error code*/);
int flag=1;
int Nx=97; int Ny=97; int Nz = 97;
Nx+=3; Ny+=3; Nz+=3;
int data[Nx*Ny*Nz];
int num_splines = 32;
int g_a,dims[4]={Nx,Ny,Nz,num_splines},chunk[4]={-1,-1,-1,num_splines};
int width[4] = {3, 3, 3, 0};
int type=C_INT;
//g_a=NGA_Create(type,4,dims,"Coefs",chunk);
g_a=NGA_Create_ghosts(type, 4, dims, width, "Coefs", chunk);
int lo[4],hi[4],ld[3];
double value=9.0;
GA_Fill(g_a,&value);
GA_Print_distribution(g_a);
fflush(stdout);
if(me==0)
{
for (i=0; i<num_splines; i++)
{
int x, y, z;
for (x=0; x<Nx; x++)
for (y=0; y<Ny; y++)
for (z=0; z<Nz; z++)
{ j=x*(Ny*Nz)+y*Nz+z;
data[j] = (x*100*100+y*100+z)*100+i;}
lo[0]=lo[1]=lo[2]=0;
hi[0]=Nx-1;hi[1]=Ny-1;hi[2]=Nz-1;
lo[3]=hi[3]=i%num_splines;
ld[0]=Ny;ld[1]=Nz;ld[2]=1;
NGA_Put(g_a,lo,hi,data,ld);
}
}
GA_Update_ghosts(g_a);
GA_Sync();
printf("done\n"),fflush(stdout);
ga_coefs_t *ga_coefs = malloc(sizeof(ga_coefs_t));
ga_coefs->Mx = Nx;
ga_coefs->My = Ny;
ga_coefs->Mz = Nz;
ga_coefs->nsplines = num_splines;
ga_coefs->g_a=g_a;
int *coefs1 = (int*)malloc((size_t)1*sizeof(int)*4*4*4*num_splines);
int ix,iy,iz;
Nx-=3; Ny-=3; Nz-=3;
ga_coefs->sumt=ga_coefs->amount=0;
NGA_Distribution(g_a,me,lo,hi);
GA_Print_distribution(g_a);
int low[16][4],high[16][4];
for(i=0;i<nprocs;i++)
NGA_Distribution(g_a,i,low[i],high[i]);
srand ( time(NULL) );
int k=GA_Nodeid();
printf("%d: low[k]=%d high[k]=%d\n", GA_Nodeid(), low[k][2], high[k][2]);
int unequal=0;
for(i=0;i<1000;i++) {
ix=rand_index(low[k][0],high[k][0]);
if(ix+3>=dims[0]) ix=low[k][0];
iy=rand_index(low[k][1],high[k][1]);
if(iy+3>=dims[1]) iy=low[k][1];
iz=rand_index(low[k][2],high[k][2]);
if(iz+3>=dims[2]) iz=low[k][2];
coefs_ga_get_3d(ga_coefs,coefs1,ix,iy,iz);
long get_sum=mini_cube_sum(coefs1, ga_coefs->nsplines);
long ghost_sum=coefs_ghost_access_3d(ga_coefs, coefs1, ix, iy, iz);
if(get_sum!=ghost_sum) {
printf("ixyz=\t%d\t%d\t%d\t", ix, iy, iz);
printf("get_sum=%ld ghost_sum=%ld\n", get_sum, ghost_sum);
unequal++;
}
}
printf("unequal count=%d\n", unequal);
free(coefs1);
GA_Terminate();
MPI_Finalize();
return 0;
}
int main(int argc, char **argv)
{
int rank, nprocs, i, j;
int g_A, g_B, dims[DIM]={SIZE,SIZE}, val1=5, val2=4;
int lo[DIM]={SIZE-SIZE,SIZE-SIZE}, hi[DIM]={SIZE-1,SIZE-1}, ld=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
// create global arrays
#if defined(USE_ELEMENTAL)
ElGlobalArraysCreate_i( eliga, DIM, dims, "array_A", NULL, &g_A );
#else
g_A = NGA_Create(C_INT, DIM, dims, "array_A", NULL);
#endif
#if defined(USE_ELEMENTAL)
ElGlobalArraysDuplicate_i( eliga, g_A, "array_B", &g_B );
#else
g_B = GA_Duplicate(g_A, "array_B");
#endif
#if defined(USE_ELEMENTAL)
ElGlobalArraysFill_i( eliga, g_A, &val1 );
ElGlobalArraysFill_i( eliga, g_B, &val2 );
#else
GA_Fill(g_A, &val1);
GA_Fill(g_B, &val2);
#endif
int dot_AB = -99;
#if defined(USE_ELEMENTAL)
ElGlobalArraysDot_i( eliga, g_A, g_B, &dot_AB );
#else
dot_AB = GA_Idot(g_A, g_B);
#endif
#if defined(USE_ELEMENTAL)
ElGlobalArraysSync_i( eliga );
#else
GA_Sync();
#endif
#if defined(USE_ELEMENTAL)
ElGlobalArraysPrint_i( eliga, g_A );
ElGlobalArraysPrint_i( eliga, g_B );
#else
GA_Print(g_A);
GA_Print(g_B);
#endif
// Check
#if defined(USE_ELEMENTAL)
ElGlobalArraysSync_i( eliga );
#else
GA_Sync();
#endif
if(rank==0)
printf ("Integer dot product of g_A and g_B: %d\n", dot_AB);
#if defined(USE_ELEMENTAL)
ElGlobalArraysSync_i( eliga );
#else
GA_Sync();
#endif
if(rank==0)
printf("Test Completed \n");
#if defined(USE_ELEMENTAL)
ElGlobalArraysDestroy_i( eliga, g_A );
ElGlobalArraysDestroy_i( eliga, g_B );
#else
GA_Destroy(g_A);
GA_Destroy(g_B);
#endif
#if defined(USE_ELEMENTAL)
ElGlobalArraysTerminate_i( eliga );
// call el::global arrays destructor
ElGlobalArraysDestruct_i( eliga );
ElFinalize();
#else
GA_Terminate();
MPI_Finalize();
#endif
return 0;
}
