void test4_1()
{
std::cout << "==================== test4_1 ====================\n";
const unsigned asize = 1;
Digipen::Utils::srand(2, 1);
BList<int, asize> bl;
std::cout << "nodesize is " << bl.nodesize() << std::endl;
unsigned low = 10;
unsigned high = 99;
unsigned range = high - low;
unsigned size = 16;
int *ia = new int[range];
for (unsigned i = low; i < high; i++)
ia[i - low] = i + 1;
Shuffle(ia, range);
for (unsigned i = 0; i < size; i++)
{
bl.insert(ia[i]);
//DumpList(bl, true);
//DumpList(bl);
//std::cout << "==========================\n";
}
DumpList(bl, false);
print_subscript(bl);
std::cout << std::endl << std::endl;
DumpList(bl, false);
DumpList(bl, true);
DumpStats(bl);
std::cout << std::endl;
delete [] ia;
}
void compare_patches(double eps, int ndim, double *patch1, int lo1[], int hi1[],
int dims1[],double *patch2, int lo2[], int hi2[],
int dims2[])
{
int i,j, elems=1;
int subscr1[MAXDIMS], subscr2[MAXDIMS];
double diff,max;
for(i=0;i<ndim;i++){
int diff = hi1[i]-lo1[i];
assert(diff == (hi2[i]-lo2[i]));
assert(diff < dims1[i]);
assert(diff < dims2[i]);
elems *= diff+1;
subscr1[i]= lo1[i];
subscr2[i]=lo2[i];
}
for(j=0; j< elems; j++){
int idx1=0, idx2=0, offset1=0, offset2=0;
idx1 = Index(ndim, subscr1, dims1);
idx2 = Index(ndim, subscr2, dims2);
if(j==0){
offset1 =idx1;
offset2 =idx2;
}
idx1 -= offset1;
idx2 -= offset2;
diff = patch1[idx1] - patch2[idx2];
max = ARMCI_MAX(ARMCI_ABS(patch1[idx1]),ARMCI_ABS(patch2[idx2]));
if(max == 0. || max <eps) max = 1.;
if(eps < ARMCI_ABS(diff)/max){
char msg[48];
sprintf(msg,"(proc=%d):%f",me,patch1[idx1]);
print_subscript("ERROR: a",ndim,subscr1,msg);
sprintf(msg,"%f\n",patch2[idx2]);
print_subscript(" b",ndim,subscr2,msg);
fflush(stdout);
sleep(1);
ARMCI_Error("Bailing out",0);
}
update_subscript(ndim, subscr1, lo1,hi1, dims1);
update_subscript(ndim, subscr2, lo2,hi2, dims2);
}
}
void compare_patches(double eps, int ndim, double *patch1, int lo1[], int hi1[],
int dims1[], double *patch2, int lo2[], int hi2[],
int dims2[])
{
int i, j, elems = 1;
int subscr1[MAXDIMS], subscr2[MAXDIMS];
double diff, max;
int idx1, idx2, offset1, offset2;
for (i = 0; i < ndim; i++) { /* count # of elements & verify consistency of both patches */
int diff = hi1[i] - lo1[i];
assert(diff == (hi2[i] - lo2[i]));
assert(diff < dims1[i]);
assert(diff < dims2[i]);
elems *= diff + 1;
subscr1[i] = lo1[i];
subscr2[i] = lo2[i];
}
/* compare element values in both patches */
for (j = 0; j < elems; j++) {
idx1 = Index(ndim, subscr1, dims1); /* calculate element Index from a subscript */
idx2 = Index(ndim, subscr2, dims2);
if (j == 0) {
offset1 = idx1;
offset2 = idx2;
}
idx1 -= offset1;
idx2 -= offset2;
diff = patch1[idx1] - patch2[idx2];
max = ARMCI_MAX(ARMCI_ABS(patch1[idx1]), ARMCI_ABS(patch2[idx2]));
if (max == 0. || max < eps) {
max = 1.;
}
if (eps < ARMCI_ABS(diff) / max) {
char msg[48];
sprintf(msg, "(proc=%d):%f", me, patch1[idx1]);
print_subscript("ERROR: a", ndim, subscr1, msg);
sprintf(msg, "%f\n", patch2[idx2]);
print_subscript(" b", ndim, subscr2, msg);
fflush(stdout);
sleep(1);
ARMCI_Error("Bailing out", 0);
}
{ /* update subscript for the patches */
update_subscript(ndim, subscr1, lo1, hi1, dims1);
update_subscript(ndim, subscr2, lo2, hi2, dims2);
}
}
/* make sure we reached upper limit */
/*for(i=0;i<ndim;i++){
assert(subscr1[i]==hi1[i]);
assert(subscr2[i]==hi2[i]);
}*/
}
int compare_patches(int me, double eps, int ndim, double *array1,
int lo1[], int hi1[], int dims1[],
double *array2, int lo2[], int hi2[],
int dims2[])
{
int i,j, elems=1;
int subscr1[MAXDIM], subscr2[MAXDIM];
double diff,max;
double *patch1, *patch2;
/* compute pointer to first element in patch */
patch1 = array1 + Index(ndim, lo1, dims1);
patch2 = array2 + Index(ndim, lo2, dims2);
/* count # of elements & verify consistency of both patches */
for(i=0;i<ndim;i++){
Integer diff = hi1[i]-lo1[i];
assert(diff == (hi2[i]-lo2[i]));
assert(diff < dims1[i]);
assert(diff < dims2[i]);
elems *= diff+1;
subscr1[i]= lo1[i];
subscr2[i]=lo2[i];
}
/* compare element values in both patches */
for(j=0; j< elems; j++){
Integer idx1, idx2, offset1, offset2;
/* calculate element Index from a subscript */
idx1 = Index(ndim, subscr1, dims1);
idx2 = Index(ndim, subscr2, dims2);
if(j==0){
offset1 =idx1;
offset2 =idx2;
}
idx1 -= offset1;
idx2 -= offset2;
diff = patch1[idx1] - patch2[idx2];
max = MAX(ABS(patch1[idx1]),ABS(patch2[idx2]));
if(max == 0. || max <eps) max = 1.;
if(eps < ABS(diff)/max){
char msg[48], val[48];
sprintf(msg,"ERROR (proc=%d): a",me);
sprintf(val,"=%lf, ",patch1[idx1]);
print_subscript(msg,ndim,subscr1,val);
sprintf(msg,"=%lf\n",patch2[idx2]);
print_subscript(" b",ndim,subscr2,msg);
sleep(1);
return(1);
}
{ /* update subscript for the patches */
update_subscript(ndim, subscr1, lo1,hi1, dims1);
update_subscript(ndim, subscr2, lo2,hi2, dims2);
}
}
return(0);
}
void do_work()
{
int g_a, g_b;
int me=GA_Nodeid(), nproc=GA_Nnodes(), proc, loop;
int dims[NDIM], lo[NDIM], hi[NDIM], block[NDIM], ld[NDIM-1];
int i,d,*proclist, offset;
int adims[NDIM], ndim,type;
typedef struct {
int lo[NDIM];
int hi[NDIM];
} patch_t;
patch_t *regions;
int *map;
double *buf;
/***** create array A with default distribution *****/
if(me==0){printf("Creating array A\n"); fflush(stdout);}
for(i = 0; i<NDIM; i++)dims[i] = N*(i+1);
#ifdef NEW_API
g_a = GA_Create_handle();
GA_Set_data(g_a,NDIM,dims,MT_F_DBL);
GA_Set_array_name(g_a,"array A");
(void)GA_Allocate(g_a);
#else
g_a = NGA_Create(MT_F_DBL, NDIM, dims, "array A", NULL);
#endif
if(!g_a) GA_Error("create failed: A",0);
if(me==0)printf("OK\n\n");
/* print info about array we got */
NGA_Inquire(g_a, &type, &ndim, adims);
GA_Print_distribution(g_a);
GA_Sync();
/* duplicate array A with ga_create irreg rather than ga_duplicate
* -- want to show distribution control
* -- with ga_duplicate it would be g_b=GA_Duplicate(g_a,name)
*/
if(me==0)printf("\nReconstructing distribution description for A\n");
/* get memory for arrays describing distribution */
proclist = (int*)malloc(nproc*sizeof(int));
if(!proclist)GA_Error("malloc failed for proclist",0);
regions = (patch_t*)malloc(nproc*sizeof(patch_t));
if(!regions)GA_Error("malloc failed for regions",0);
map = (int*)malloc((nproc+ndim)*sizeof(int)); /* ubound= nproc+mdim */
if(!map)GA_Error("malloc failed for map",0);
/* first find out how array g_a is distributed */
for(i=0;i<ndim;i++)lo[i]=BASE;
for(i=0;i<ndim;i++)hi[i]=adims[i] -1 + BASE;
proc = NGA_Locate_region(g_a, lo, hi, (int*)regions, proclist);
if(proc<1) GA_Error("error in NGA_Locate_region",proc);
/* determine blocking for each dimension */
for(i=0;i<ndim;i++)block[i]=0;
for(i=0;i<ndim;i++)adims[i]=0;
offset =0;
for(d=0; d<ndim; d++)
for(i=0;i<proc;i++)
if( regions[i].hi[d]>adims[d] ){
map[offset] = regions[i].lo[d];
offset++;
block[d]++;
adims[d]= regions[i].hi[d];
}
if(me==0){
printf("Distribution map contains %d elements\n",offset);
print_subscript("number of blocks for each dimension",ndim,block,"\n");
print_subscript("distribution map",offset,map,"\n\n");
fflush(stdout);
}
if(me==0)printf("Creating array B applying distribution of A\n");
# ifdef USE_DUPLICATE
g_b = GA_Duplicate(g_a,"array B");
# else
g_b = NGA_Create_irreg(MT_F_DBL, NDIM, dims, "array B", block,map);
# endif
if(!g_b) GA_Error("create failed: B",0);
if(me==0)printf("OK\n\n");
free(proclist); free(regions); free(map);
GA_Print_distribution(g_b);
GA_Sync();
if(me==0){
printf("\nCompare distributions of A and B\n");
if(GA_Compare_distr(g_a,g_b))
printf("Failure: distributions NOT identical\n");
else
printf("Success: distributions identical\n");
fflush(stdout);
}
if(me==0){
printf("\nAccessing local elements of A: set them to the owner process id\n");
fflush(stdout);
}
GA_Sync();
NGA_Distribution(g_a,me,lo,hi);
if(hi[0]>=0){/* -1 means no elements stored on this processor */
double *ptr;
int locdim[NDIM];
NGA_Access(g_a, lo,hi, &ptr, ld);
for(i=0;i<ndim;i++)locdim[i]=hi[i]-lo[i]+1;
fill_patch(ptr, locdim, ld, ndim,(double)me);
}
for(i=0;i<nproc; i++){
if(me==i && hi[0]>=0){
char msg[100];
sprintf(msg,"%d: leading dimensions",me);
print_subscript(msg,ndim-1,ld,"\n");
fflush(stdout);
}
GA_Sync();
}
GA_Sync();
if(me==0)printf("\nRandomly checking the update using ga_get on array sections\n");
GA_Sync();
/* show ga_get working and verify array updates
* every process does N random gets
* for simplicity get only a single row at a time
*/
srand(me); /* different seed for every process */
hi[ndim-1]=adims[ndim-1] -1 + BASE;
for(i=1;i<ndim-1; i++)ld[i]=1; ld[ndim-2]=adims[ndim-1] -1 + BASE;
/* get buffer memory */
buf = (double*)malloc(adims[ndim-1]*sizeof(double));
if(!buf)GA_Error("malloc failed for buf",0);
/* half of the processes check the result */
if(me<=nproc/2)
for(loop = 0; loop< N; loop++){ /* task parallel loop */
lo[ndim-1]=BASE;
for (i= 0; i < ndim -1; i ++){
lo[i] = hi[i] = rand()%adims[i]+BASE;
}
/* print_subscript("getting",ndim,lo,"\n");*/
NGA_Get(g_a,lo,hi,buf,ld);
/* check values */
for(i=0;i<adims[ndim-1]; i++){
int p = NGA_Locate(g_a, lo);
if((double)p != buf[i]) {
char msg[100];
sprintf(msg,"%d: wrong value: %d != %lf a",me, p, buf[i]);
print_subscript(msg,ndim,lo,"\n");
GA_Error("Error - bye",i);
}
lo[ndim-1]++;
}
}
free(buf);
GA_Sync();
if(me==0)printf("OK\n");
GA_Destroy(g_a);
GA_Destroy(g_b);
}