void NC_set_numrecs(NC *ncp, size_t nrecs) {
shmem_t numrec = (shmem_t) nrecs;
/* update local value too */
ncp->lock[LOCKNUMREC_VALUE] = (ushmem_t) numrec;
shmem_short_put((shmem_t *) ncp->lock + LOCKNUMREC_VALUE, &numrec, 1,
ncp->lock[LOCKNUMREC_BASEPE]);
}
int main(int argc, char* argv[])
{
short source[SIZE];
static short target[SIZE];
int i;
int num_pe, my_pe;
shmem_init();
num_pe = shmem_n_pes();
my_pe = shmem_my_pe();
if (my_pe == 0) {
/* initialize array */
for(i = 0; i < SIZE; i++) {
source[i] = i;
}
/* local, not symmetric */
/* static makes it symmetric */
/* put "size" words into target on each PE */
for(i = 1; i < num_pe; i++) {
shmem_short_put(target, source, SIZE, i);
}
}
shmem_barrier_all(); /* sync sender and receiver */
if (my_pe != 0) {
printf("Target on PE %d is \t", my_pe);
for(i = 0; i < SIZE; i++) {
printf("%hd \t", target[i]);
}
printf("\n");
}
shmem_barrier_all(); /* sync before exiting */
shmem_finalize();
return 0;
}
int
main (int argc, char **argv)
{
int i;
int nextpe;
int me, npes;
int success1, success2, success3, success4, success5, success6, success7,
success8;
short src1[N];
int src2[N];
long src3[N];
long double src4[N];
long long src5[N];
double src6[N];
float src7[N];
char *src8;
short src9;
int src10;
long src11;
double src12;
float src13;
short *dest1;
int *dest2;
long *dest3;
long double *dest4;
long long *dest5;
double *dest6;
float *dest7;
char *dest8;
short *dest9;
int *dest10;
long *dest11;
double *dest12;
float *dest13;
shmem_init ();
me = shmem_my_pe ();
npes = shmem_n_pes ();
if (npes > 1) {
success1 = 0;
success2 = 0;
success3 = 0;
success4 = 0;
success5 = 0;
success6 = 0;
success7 = 0;
success8 = 0;
src8 = (char *) malloc (N * sizeof (char));
for (i = 0; i < N; i += 1) {
src1[i] = (short) me;
src2[i] = me;
src3[i] = (long) me;
src4[i] = (long double) me;
src5[i] = (long long) me;
src6[i] = (double) me;
src7[i] = (float) me;
src8[i] = (char) me;
}
src9 = (short) me;
src10 = me;
src11 = (long) me;
src12 = (double) me;
src13 = (float) me;
dest1 = (short *) shmem_malloc (N * sizeof (*dest1));
dest2 = (int *) shmem_malloc (N * sizeof (*dest2));
dest3 = (long *) shmem_malloc (N * sizeof (*dest3));
dest4 = (long double *) shmem_malloc (N * sizeof (*dest4));
dest5 = (long long *) shmem_malloc (N * sizeof (*dest5));
dest6 = (double *) shmem_malloc (N * sizeof (*dest6));
dest7 = (float *) shmem_malloc (N * sizeof (*dest7));
dest8 = (char *) shmem_malloc (4 * sizeof (*dest8));
dest9 = (short *) shmem_malloc (sizeof (*dest9));
dest10 = (int *) shmem_malloc (sizeof (*dest10));
dest11 = (long *) shmem_malloc (sizeof (*dest11));
dest12 = (double *) shmem_malloc (sizeof (*dest12));
dest13 = (float *) shmem_malloc (sizeof (*dest13));
for (i = 0; i < N; i += 1) {
dest1[i] = -9;
dest2[i] = -9;
dest3[i] = -9;
dest4[i] = -9;
dest5[i] = -9;
dest6[i] = -9;
dest7[i] = -9.0;
dest8[i] = -9;
}
*dest9 = -9;
*dest10 = -9;
*dest11 = -9;
*dest12 = -9;
*dest13 = -9.0;
nextpe = (me + 1) % npes;
/* Testing shmem_short_put, shmem_int_put, shmem_long_put,
shmem_longdouble_put, shmem_longlong_put, shmem_double_put,
shmem_float_put, shmem_putmem */
shmem_barrier_all ();
shmem_short_put (dest1, src1, N, nextpe);
shmem_int_put (dest2, src2, N, nextpe);
shmem_long_put (dest3, src3, N, nextpe);
shmem_longdouble_put (dest4, src4, N, nextpe);
shmem_longlong_put (dest5, src5, N, nextpe);
shmem_double_put (dest6, src6, N, nextpe);
shmem_float_put (dest7, src7, N, nextpe);
shmem_putmem (dest8, src8, N * sizeof (char), nextpe);
shmem_barrier_all ();
if (me == 0) {
for (i = 0; i < N; i += 1) {
if (dest1[i] != (npes - 1)) {
success1 = 1;
}
if (dest2[i] != (npes - 1)) {
success2 = 1;
}
if (dest3[i] != (npes - 1)) {
success3 = 1;
}
if (dest4[i] != (npes - 1)) {
success4 = 1;
}
if (dest5[i] != (npes - 1)) {
success5 = 1;
}
if (dest6[i] != (npes - 1)) {
success6 = 1;
}
if (dest7[i] != (npes - 1)) {
success7 = 1;
}
if (dest8[i] != (npes - 1)) {
success8 = 1;
}
}
if (success1 == 0)
printf ("Test shmem_short_put: Passed\n");
else
printf ("Test shmem_short_put: Failed\n");
if (success2 == 0)
printf ("Test shmem_int_put: Passed\n");
else
printf ("Test shmem_int_put: Failed\n");
if (success3 == 0)
printf ("Test shmem_long_put: Passed\n");
else
printf ("Test shmem_long_put: Failed\n");
if (success4 == 0)
printf ("Test shmem_longdouble_put: Passed\n");
else
printf ("Test shmem_longdouble_put: Failed\n");
if (success5 == 0)
printf ("Test shmem_longlong_put: Passed\n");
else
printf ("Test shmem_longlong_put: Failed\n");
if (success6 == 0)
printf ("Test shmem_double_put: Passed\n");
else
printf ("Test shmem_double_put: Failed\n");
if (success7 == 0)
printf ("Test shmem_float_put: Passed\n");
else
printf ("Test shmem_float_put: Failed\n");
if (success8 == 0)
printf ("Test shmem_putmem: Passed\n");
else
printf ("Test shmem_putmem: Failed\n");
}
shmem_barrier_all ();
/* Testing shmem_put32, shmem_put64, shmem_put128 */
if (sizeof (int) == 4) {
for (i = 0; i < N; i += 1) {
dest2[i] = -9;
dest3[i] = -9;
dest4[i] = -9;
}
success2 = 0;
success3 = 0;
success4 = 0;
shmem_barrier_all ();
shmem_put32 (dest2, src2, N, nextpe);
shmem_put64 (dest3, src3, N, nextpe);
shmem_put128 (dest4, src4, N, nextpe);
shmem_barrier_all ();
if (me == 0) {
for (i = 0; i < N; i += 1) {
if (dest2[i] != (npes - 1)) {
success2 = 1;
}
if (dest3[i] != (npes - 1)) {
success3 = 1;
}
if (dest4[i] != (npes - 1)) {
success4 = 1;
}
}
if (success2 == 0)
printf ("Test shmem_put32: Passed\n");
else
printf ("Test shmem_put32: Failed\n");
if (success3 == 0)
printf ("Test shmem_put64: Passed\n");
else
printf ("Test shmem_put64: Failed\n");
if (success4 == 0)
printf ("Test shmem_put128: Passed\n");
else
printf ("Test shmem_put128: Failed\n");
}
}
else if (sizeof (int) == 8) {
for (i = 0; i < N; i += 1) {
dest1[i] = -9;
dest2[i] = -9;
dest3[i] = -9;
}
success1 = 0;
success2 = 0;
success3 = 0;
shmem_barrier_all ();
shmem_put32 (dest1, src1, N, nextpe);
shmem_put64 (dest2, src2, N, nextpe);
shmem_put128 (dest3, src3, N, nextpe);
shmem_barrier_all ();
if (me == 0) {
for (i = 0; i < N; i += 1) {
if (dest1[i] != (npes - 1)) {
success1 = 1;
}
if (dest2[i] != (npes - 1)) {
success2 = 1;
}
if (dest3[i] != (npes - 1)) {
success3 = 1;
}
}
if (success1 == 0)
printf ("Test shmem_put32: Passed\n");
else
printf ("Test shmem_put32: Failed\n");
if (success2 == 0)
printf ("Test shmem_put64: Passed\n");
else
printf ("Test shmem_put64: Failed\n");
if (success3 == 0)
printf ("Test shmem_put128: Passed\n");
else
printf ("Test shmem_put128: Failed\n");
}
}
/* Testing shmem_iput32, shmem_iput64, shmem_iput128 */
shmem_barrier_all ();
if (sizeof (int) == 4) {
for (i = 0; i < N; i += 1) {
dest2[i] = -9;
dest3[i] = -9;
dest4[i] = -9;
}
success2 = 0;
success3 = 0;
success4 = 0;
shmem_barrier_all ();
shmem_iput32 (dest2, src2, 1, 2, N, nextpe);
shmem_iput64 (dest3, src3, 1, 2, N, nextpe);
shmem_iput128 (dest4, src4, 1, 2, N, nextpe);
shmem_barrier_all ();
if (me == 0) {
for (i = 0; i < N / 2; i += 1) {
if (dest2[i] != (npes - 1)) {
success2 = 1;
}
if (dest3[i] != (npes - 1)) {
success3 = 1;
}
if (dest4[i] != (npes - 1)) {
success4 = 1;
}
}
if (success2 == 0)
printf ("Test shmem_iput32: Passed\n");
else
printf ("Test shmem_iput32: Failed\n");
if (success3 == 0)
printf ("Test shmem_iput64: Passed\n");
else
printf ("Test shmem_iput64: Failed\n");
if (success4 == 0)
printf ("Test shmem_iput128: Passed\n");
else
printf ("Test shmem_iput128: Failed\n");
}
}
else if (sizeof (int) == 8) {
for (i = 0; i < N; i += 1) {
dest1[i] = -9;
dest2[i] = -9;
dest3[i] = -9;
}
success1 = 0;
success2 = 0;
success3 = 0;
shmem_barrier_all ();
shmem_iput32 (dest1, src1, 1, 2, N, nextpe);
shmem_iput64 (dest2, src2, 1, 2, N, nextpe);
shmem_iput128 (dest3, src3, 1, 2, N, nextpe);
shmem_barrier_all ();
if (me == 0) {
for (i = 0; i < N / 2; i += 1) {
if (dest1[i] != (npes - 1)) {
success1 = 1;
}
if (dest2[i] != (npes - 1)) {
success2 = 1;
}
if (dest3[i] != (npes - 1)) {
success3 = 1;
}
}
if (success1 == 0)
printf ("Test shmem_iput32: Passed\n");
else
printf ("Test shmem_iput32: Failed\n");
if (success2 == 0)
printf ("Test shmem_iput64: Passed\n");
else
printf ("Test shmem_iput64: Failed\n");
if (success3 == 0)
printf ("Test shmem_iput128: Passed\n");
else
printf ("Test shmem_iput128: Failed\n");
}
}
/* Testing shmem_short_iput, shmem_int_iput, shmem_long_iput,
shmem_double_iput, shmem_float_iput */
for (i = 0; i < N; i += 1) {
dest1[i] = -9;
dest2[i] = -9;
dest3[i] = -9;
dest6[i] = -9;
dest7[i] = -9;
}
success1 = 0;
success2 = 0;
success3 = 0;
success6 = 0;
success7 = 0;
shmem_barrier_all ();
shmem_short_iput (dest1, src1, 1, 2, N, nextpe);
shmem_int_iput (dest2, src2, 1, 2, N, nextpe);
shmem_long_iput (dest3, src3, 1, 2, N, nextpe);
shmem_double_iput (dest6, src6, 1, 2, N, nextpe);
shmem_float_iput (dest7, src7, 1, 2, N, nextpe);
shmem_barrier_all ();
if (me == 0) {
for (i = 0; i < N / 2; i += 1) {
if (dest1[i] != (npes - 1)) {
success1 = 1;
}
if (dest2[i] != (npes - 1)) {
success2 = 1;
}
if (dest3[i] != (npes - 1)) {
success3 = 1;
}
if (dest6[i] != (npes - 1)) {
success6 = 1;
}
if (dest7[i] != (npes - 1)) {
success7 = 1;
}
}
if (success1 == 0)
printf ("Test shmem_short_iput: Passed\n");
else
printf ("Test shmem_short_iput: Failed\n");
if (success2 == 0)
printf ("Test shmem_int_iput: Passed\n");
else
printf ("Test shmem_int_iput: Failed\n");
if (success3 == 0)
printf ("Test shmem_long_iput: Passed\n");
else
printf ("Test shmem_long_iput: Failed\n");
if (success6 == 0)
printf ("Test shmem_double_iput: Passed\n");
else
printf ("Test shmem_double_iput: Failed\n");
if (success7 == 0)
printf ("Test shmem_float_iput: Passed\n");
else
printf ("Test shmem_float_iput: Failed\n");
}
/* Testing shmem_double_p, shmem_float_p, shmem_int_p, shmem_long_p,
shmem_short_p */
shmem_barrier_all ();
shmem_short_p (dest9, src9, nextpe);
shmem_int_p (dest10, src10, nextpe);
shmem_long_p (dest11, src11, nextpe);
shmem_double_p (dest12, src12, nextpe);
shmem_float_p (dest13, src13, nextpe);
shmem_barrier_all ();
if (me == 0) {
if (*dest9 == (npes - 1))
printf ("Test shmem_short_p: Passed\n");
else
printf ("Test shmem_short_p: Failed\n");
if (*dest10 == (npes - 1))
printf ("Test shmem_int_p: Passed\n");
else
printf ("Test shmem_int_p: Failed\n");
if (*dest11 == (npes - 1))
printf ("Test shmem_long_p: Passed\n");
else
printf ("Test shmem_long_p: Failed\n");
if (*dest12 == (npes - 1))
printf ("Test shmem_double_p: Passed\n");
else
printf ("Test shmem_double_p: Failed\n");
if (*dest13 == (npes - 1))
printf ("Test shmem_float_p: Passed\n");
else
printf ("Test shmem_float_p: Failed\n");
}
shmem_barrier_all ();
shmem_free (dest1);
shmem_free (dest2);
shmem_free (dest3);
shmem_free (dest4);
shmem_free (dest5);
shmem_free (dest6);
shmem_free (dest7);
shmem_free (dest8);
shmem_free (dest9);
shmem_free (dest10);
shmem_free (dest11);
shmem_free (dest12);
shmem_free (dest13);
}
else {
printf ("Number of PEs must be > 1 to test shmem put, test skipped\n");
}
shmem_finalize ();
return 0;
}
int main(int argc, char **argv)
{
int i,j,iter;
int my_pe,n_pes;
int *flag,*one;
size_t max_elements,max_elements_bytes;
size_t elements[16] = {1,2,4,8,12,16,24,32,64,128,256,512,1024,2048,4096,8192};
int num_elements = 16;
short *srce_short,*targ_short;
int *srce_int,*targ_int;
long *srce_long,*targ_long;
float *srce_float,*targ_float;
double *srce_double,*targ_double;
shmem_init();
my_pe = shmem_my_pe();
n_pes = shmem_n_pes();
flag = shmem_malloc((size_t) sizeof(int));
one = shmem_malloc((size_t) sizeof(int));
*one = 1;
/* fail if trying to use odd number of processors */
if ( (n_pes % 2) != 0 ){
fprintf(stderr, "FAIL - test requires even number of PEs\n");
exit(1);
}
if(my_pe == 0)
fprintf(stderr, "shmem_both_put_nb_size(%s)\n", argv[0]);
/* alloc arrays */
max_elements = (size_t) (MAX_SIZE / sizeof(int));
max_elements_bytes = (size_t) (sizeof(int)*max_elements);
if(my_pe == 0)
fprintf(stderr,"shmem_int_put_nb max_elements = %d\n",max_elements);
srce_int = shmem_malloc(max_elements_bytes);
targ_int = shmem_malloc(max_elements_bytes);
if((srce_int == NULL) || (targ_int == NULL))
shmalloc_error();
max_elements = (size_t) (MAX_SIZE / sizeof(short));
max_elements_bytes = (size_t) (sizeof(short)*max_elements);
if(my_pe == 0)
fprintf(stderr,"shmem_short_put max_elements = %d\n",max_elements);
srce_short = shmem_malloc(max_elements_bytes);
targ_short = shmem_malloc(max_elements_bytes);
if((srce_short == NULL) || (targ_short == NULL))
shmalloc_error();
max_elements = (size_t) (MAX_SIZE / sizeof(long));
max_elements_bytes = (size_t) (sizeof(long)*max_elements);
if(my_pe == 0)
fprintf(stderr,"shmem_long_put_nb max_elements = %d\n",max_elements);
srce_long = shmem_malloc(max_elements_bytes);
targ_long = shmem_malloc(max_elements_bytes);
if((srce_long == NULL) || (targ_long == NULL))
shmalloc_error();
max_elements = (size_t) (MAX_SIZE / sizeof(float));
max_elements_bytes = (size_t) (sizeof(float)*max_elements);
if(my_pe == 0)
fprintf(stderr,"shmem_float_put_nb max_elements = %d\n",max_elements);
srce_float = shmem_malloc(max_elements_bytes);
targ_float = shmem_malloc(max_elements_bytes);
if((srce_float == NULL) || (targ_float == NULL))
shmalloc_error();
max_elements = (size_t) (MAX_SIZE / sizeof(double));
max_elements_bytes = (size_t) (sizeof(double)*max_elements);
if(my_pe == 0)
fprintf(stderr,"shmem_double_put_nb max_elements = %d\n",max_elements);
srce_double = shmem_malloc(max_elements_bytes);
targ_double = shmem_malloc(max_elements_bytes);
if((srce_double == NULL) || (targ_double == NULL))
shmalloc_error();
if(my_pe == 0)
fprintf(stderr,"Actual value used for max_elements = %d\n",max_elements);
/* try the different sizes MAX_ITER times */
for (iter = 0; iter < MAX_ITER; iter++) {
for (i = 0; i < num_elements; i++) {
*flag = 0;
if (elements[i] <= max_elements) {
if ( (my_pe % 2) == 0 )
for(j = 0; j < elements[i]; j++) {
srce_short[j] = (short)(my_pe+j);
srce_int[j] = (int)(iter*10000+elements[i]*100+my_pe+j);
srce_long[j] = (long)(iter*10000+elements[i]*100+my_pe+j);
srce_float[j] = (float)(iter*10000+elements[i]*100+my_pe+j);
srce_double[j] = (double)(iter*10000+elements[i]*100+my_pe+j);
}
else
for(j = 0; j < elements[i]; j++) {
targ_short[j] = (short)(my_pe+j);
targ_int[j] = (int)(iter*10000+elements[i]*100+my_pe+j);
targ_long[j] = (long)(iter*10000+elements[i]*100+my_pe+j);
targ_float[j] = (float)(iter*10000+elements[i]*100+my_pe+j);
targ_double[j] = (double)(iter*10000+elements[i]*100+my_pe+j);
}
shmem_barrier_all();
if ( (my_pe % 2) == 0 ) {
#ifndef OPENSHMEM
shmemx_int_put_nb(targ_int,srce_int,elements[i],my_pe+1,NULL);
shmemx_long_put_nb(targ_long,srce_long,elements[i],my_pe+1,NULL);
shmemx_float_put_nb(targ_float,srce_float,elements[i],my_pe+1,NULL);
shmemx_double_put_nb(targ_double,srce_double,elements[i],my_pe+1,NULL);
#else
shmem_int_put_nbi(targ_int,srce_int,elements[i],my_pe+1);
shmem_long_put_nbi(targ_long,srce_long,elements[i],my_pe+1);
shmem_float_put_nbi(targ_float,srce_float,elements[i],my_pe+1);
shmem_double_put_nbi(targ_double,srce_double,elements[i],my_pe+1);
#endif
/* this one is blocking */
shmem_short_put(targ_short,srce_short,elements[i],my_pe+1);
shmem_quiet();
shmem_int_put(flag,one,(size_t)1,my_pe+1);
} else {
shmem_int_wait(flag,0);
for(j = 0; j < elements[i]; j++) {
if ( targ_short[j] != (short)(my_pe+j-1) )
fprintf(stderr,
"FAIL: PE [%d] iter=%d i=%d targ_short[%d]=%d not equal %d\n",
my_pe,iter,i,j,targ_short[j],my_pe+j-1);
if ( targ_int[j] != (int)(iter*10000+elements[i]*100+my_pe+j-1) )
fprintf(stderr,
"FAIL: PE [%d] iter=%d i=%d targ_int[%d]=%d not equal %d\n",
my_pe,iter,i,j,targ_int[j],iter*10000+elements[i]*100+my_pe+j-1);
if ( targ_long[j] != (long)(iter*10000+elements[i]*100+my_pe+j-1) )
fprintf(stderr,
"FAIL: PE [%d] iter=%d i=%d targ_long[%d]=%d not equal %d\n",
my_pe,iter,i,j,targ_long[j],iter*10000+elements[i]*100+my_pe+j-1);
if ( targ_float[j] != (float)(iter*10000+elements[i]*100+my_pe+j-1) )
fprintf(stderr,
"FAIL: PE [%d] iter=%d i=%d targ_long[%d]=%f not equal %d\n",
my_pe,iter,i,j,targ_float[j],iter*10000+elements[i]*100+my_pe+j-1);
if ( targ_double[j] != (double)(iter*10000+elements[i]*100+my_pe+j-1) )
fprintf(stderr,
"FAIL: PE [%d] iter=%d i=%d targ_double[%d]=%f not equal %d\n",
my_pe,iter,i,j,targ_double[j],iter*10000+elements[i]*100+my_pe+j-1);
}
}
}
}
}
shmem_free(srce_short); shmem_free(targ_short);
shmem_free(srce_int); shmem_free(targ_int);
shmem_free(srce_long); shmem_free(targ_long);
shmem_free(srce_float); shmem_free(targ_float);
shmem_free(srce_double); shmem_free(targ_double);
#ifdef NEEDS_FINALIZE
shmem_finalize();
#endif
return 0;
}
