void* roundrobin(void* tparam) {
ptrdiff_t tid = (ptrdiff_t)tparam;
int offset = tid*N_ELEMS;
/* fprintf(stderr,"Starting thread %lu with offset %d\n",tid,offset); */
int nextpe = (shmem_my_pe()+1)%shmem_n_pes();
int prevpe = (shmem_my_pe()-1 + shmem_n_pes())%shmem_n_pes();
shmem_long_put(target+offset, source+offset, N_ELEMS, nextpe);
/* fprintf(stderr,"Thread %lu done first put\n",tid); */
pthread_barrier_wait(&fencebar);
if(tid == 0) shmem_barrier_all();
pthread_barrier_wait(&fencebar);
shmem_long_get(source+offset, target+offset, N_ELEMS, prevpe);
/* fprintf(stderr,"Thread %lu done first get\n",tid); */
pthread_barrier_wait(&fencebar);
if(tid == 0) shmem_barrier_all();
pthread_barrier_wait(&fencebar);
shmem_long_get(target+offset, source+offset, N_ELEMS, nextpe);
/* fprintf(stderr,"Thread %lu done second get\n",tid); */
pthread_barrier_wait(&fencebar);
if(tid == 0) shmem_barrier_all();
pthread_barrier_wait(&fencebar);
/* fprintf(stderr,"Done thread %lu\n",tid); */
return 0;
}
int
main (int argc, char **argv)
{
int npes;
int me;
int *ip;
start_pes (0);
npes = shmem_n_pes ();
me = shmem_my_pe ();
/* fire off allocation */
ip = shmalloc_nb (sizeof (*ip));
printf ("PE %d / %d does some other work in the middle of shmalloc_nb\n", me, npes);
/* now wait for all PEs to be ready */
shmem_barrier_all ();
if (me == 0)
{
/* PE 0 writes number of PEs to top PE */
shmem_int_p (ip, npes, npes - 1);
}
shmem_barrier_all ();
printf ("PE %d / %d says \"ip\" = %d\n", me, npes, *ip);
shfree_nb (ip);
printf ("PE %d / %d does some other work in the middle of shfree_nb\n", me, npes);
return 0;
}
int
main()
{
int me, npes;
setbuf(stdout, NULL);
shmem_init();
me = shmem_my_pe();
npes = shmem_n_pes();
if (me == 0) {
int i;
for (i = 1; i < npes; i += 1) {
printf("From %d: PE %d is ", me, i);
printf("%s", shmem_pe_accessible(i) ? "" : "NOT ");
printf("accessible\n");
}
}
else {
;
}
shmem_finalize();
return 0;
}
int main(int argc, char *argv[])
{
shmem_init();
input_file = argv[1];
mype = shmem_my_pe();
NumProcs = shmem_n_pes();
shmemx_am_attach(hid_BESTPATH, &handler_master_bestpath);
shmemx_am_attach(hid_SUBSCRIBE, &handler_master_subscribe);
shmemx_am_attach(hid_PUTPATH, &handler_master_putpath);
shmemx_am_mutex_init(&lock_shortestlen);
shmemx_am_mutex_init(&lock_queue);
shmemx_am_mutex_init(&lock_workers_stack);
if (NumProcs<2) {
printf("At least 2 processes are required\n");
exit(-1);
}
// Initialize distance matrix. Ususally done by one process
// and bcast, or initialized from a file in a shared file system.
Fill_Dist(); // process 0 read the data and broadcast it to the others
if (mype==0)
Master();
else
Worker();
//TODO
// shmemx_am_detach(hid_BESTPATH);
// shmemx_am_detach(hid_SUBSCRIBE);
// shmemx_am_detach(hid_PUTPATH);
shmem_finalize();
return 0;
}
int main(int argc, char **argv)
{
const long int ITER_CNT = 100;
const long int MAX_MSG_SIZE = 1048576;
int* source_addr;
int peer;
long int i=0,j=0, buff_size;
long long int start_time, stop_time, res;
double time;
shmem_init();
int pe_id = shmem_my_pe();
source_addr = (int*) malloc(MAX_MSG_SIZE);
if(pe_id == 1) {
if(shmem_n_pes()!=4)
fprintf(stderr,"Num PEs should be ==4");
printf("#Message Cnt;Time(s);MR(msgs/sec)\n");
}
if (pe_id==1)
peer = 3;
else if(pe_id==3)
peer = 1;
get_rtc_res_(&res);
for (i = 0; i < SHMEM_BARRIER_SYNC_SIZE; i += 1){
pSync[i] = SHMEM_SYNC_VALUE;
}
/* Collective operation: Implicit barrier on return from attach */
shmemx_am_attach(HANDLER_ID_REQ, &sample_req_handler);
shmem_barrier_all();
if(pe_id == 1 || pe_id == 3) {
for(buff_size=1; buff_size<=MAX_MSG_SIZE; buff_size*=2) {
shmem_barrier(1,1,2,pSync);
get_rtc_(&start_time);
for(j=1;j<=ITER_CNT;j++) {
if(pe_id == 1) {
shmemx_am_request(peer, HANDLER_ID_REQ, source_addr, buff_size);
shmemx_am_quiet();
}
}
shmem_barrier(1,1,2,pSync);
get_rtc_(&stop_time);
time = (stop_time - start_time)*1.0/(double)res/ITER_CNT;
if(pe_id == 1) {
printf("%20ld;%20.12f;%20.12f\n",
buff_size, time, (double)buff_size/time);
}
fflush(stdout);
}
}
shmem_barrier_all();
shmem_finalize();
}
int
main ()
{
int i;
int me;
int npes;
for (i = 0; i < _SHMEM_REDUCE_SYNC_SIZE; i += 1) {
pSync[i] = _SHMEM_SYNC_VALUE;
}
shmem_init ();
me = shmem_my_pe ();
npes = shmem_n_pes ();
src = me + 1;
shmem_barrier_all ();
shmem_int_or_to_all (&dst, &src, 1, 0, 0, npes, pWrk, pSync);
printf ("%d/%d dst = %d\n", me, npes, dst);
shmem_finalize ();
return 0;
}
int main(int argc, char* argv[]) {
int verbose = 0;
if(argc > 1) {
verbose = !strcmp("-v",argv[1]);
}
int errors = 0;
int me, myshmem_n_pes;
shmem_init();
myshmem_n_pes = shmem_n_pes();
me = shmem_my_pe();
srand(1+me);
int nextpe = (me+1)%myshmem_n_pes;
#define RUN_TEST(TYPENAME,TYPE) do { \
errors += (TYPENAME##_rmaTest(nextpe,verbose)); \
} while(0)
SHMEM_DECLARE_FOR_RMA(RUN_TEST);
shmem_finalize();
return errors;
}
void initializeCommunication(LSMSCommunication &comm)
{
//MPI_Init(NULL,NULL);
//comm.comm=MPI_COMM_WORLD;
//MPI_Comm_rank(comm.comm, &comm.rank);
//MPI_Comm_size(comm.comm, &comm.size);
int i;
shmem_init();
allocate_symm_buffers();
comm.comm.rank = shmem_my_pe();
comm.comm.size = shmem_n_pes();
comm.comm.start_pe = 0;
comm.comm.logPE_stride = 0;
sync_send_flag=(int*)shmalloc(comm.comm.size*sizeof(int));
sync_recv_flag=(int*)shmalloc(comm.comm.size*sizeof(int));
memset(sync_send_flag,0,comm.comm.size*sizeof(int));
memset(sync_recv_flag,0,comm.comm.size*sizeof(int));
for (i=0;i<comm.comm.size;i++)
{
sync_send_flag[i]=0;
sync_recv_flag[i]=0;
}
shmem_barrier_all();
for (i = 0; i < _SHMEM_BCAST_SYNC_SIZE; i += 1)
{
pSync1[i] = _SHMEM_SYNC_VALUE;
pSync2[i] = _SHMEM_SYNC_VALUE;
}
}
int
main ()
{
int i;
for (i = 0; i < _SHMEM_REDUCE_SYNC_SIZE; i += 1) {
pSync[i] = _SHMEM_SYNC_VALUE;
}
shmem_init ();
for (i = 0; i < N; i += 1) {
src[i] = shmem_my_pe () + i;
}
shmem_barrier_all ();
shmem_long_max_to_all (dst, src, 3, 0, 0, 4, pWrk, pSync);
printf ("%d/%d dst =", shmem_my_pe (), shmem_n_pes ());
for (i = 0; i < N; i += 1) {
printf (" %ld", dst[i]);
}
printf ("\n");
shmem_finalize ();
return 0;
}
int main(){
int me, npes;
start_pes(0);
me = shmem_my_pe();
npes = shmem_n_pes();
for (i = 0; i < _SHMEM_REDUCE_SYNC_SIZE; i += 1)
{
pSync[i] = _SHMEM_SYNC_VALUE;
}
x = 42;
y = 0;
if(me==0){
shmem_barrier_all();
temp = x+y;
}
else {
shmem_barrier_all();
if(me==1){
old = shmem_int_finc (&y, 0);
shmem_int_sum_to_all(&y,&x,1,1,0,npes-1,pWrk,pSync);
x= x+10;
shmem_int_get(&y,&y,1,0);
}
else{
shmem_int_sum_to_all(&y,&x, 1,1,0,npes-1,pWrk,pSync);
x=y*0.23;
}
}
shmem_barrier_all();
if (me == 0) {
printf("value in temp is %d (should be 42)\n", temp);
}
return 0;
}
int main(void)
{
int i;
int my_pe, num_pes;
for (i = 0; i < SHMEM_BCAST_SYNC_SIZE; i += 1) {
pSync[i] = _SHMEM_SYNC_VALUE;
}
shmem_init();
my_pe = shmem_my_pe();
num_pes = shmem_n_pes();
for (i = 0; i < N; i += 1) {
src[i] = my_pe + i;
}
shmem_barrier_all();
shmem_long_max_to_all(dst, src, N, 0, 0, num_pes, pWrk, pSync);
printf("%d/%d dst =", my_pe, num_pes);
for (i = 0; i < N; i+= 1) {
printf(" %ld", dst[i]);
}
printf("\n");
shmem_finalize();
return 0;
}
int
main(void)
{
int i;
shmem_init();
npes = shmem_n_pes();
me = shmem_my_pe();
for (i = 0; i < DST_SIZE; i++) {
dst[i] = -1;
}
for (i = 0; i < SHMEM_COLLECT_SYNC_SIZE; i += 1) {
pSync[i] = SHMEM_SYNC_VALUE;
}
shmem_barrier_all();
shmem_fcollect64(dst, src, 2, 0, 0, npes, pSync);
shmem_barrier_all();
show_dst("AFTER");
shmem_finalize();
return 0;
}
int
main (void)
{
int i;
start_pes (0);
npes = shmem_n_pes ();
me = shmem_my_pe ();
for (i = 0; i < DST_SIZE; i++)
{
dst[i] = -1;
}
for (i = 0; i < _SHMEM_BCAST_SYNC_SIZE; i += 1)
{
pSync[i] = _SHMEM_SYNC_VALUE;
}
shmem_barrier_all ();
shmem_collect64 (dst, src, me + 1, 0, 0, 4, pSync);
show_dst ("AFTER");
return 0;
}
int main()
{
start_pes(0);
me = shmem_my_pe();
npes = shmem_n_pes();
shmem_barrier_all();
if(me%2==0){
a = 42;
shmem_barrier_all();
}
else{
a = 0;
//shmem_barrier_all();
}
shmem_barrier_all();
if (me == 0) {
printf("value in a is %d (should be 42)\n", a);
}
return 0;
}
int
main (int argc, char **argv)
{
int i;
int nextpe;
int me, npes;
long src[N];
long *dest;
shmemx_request_handle_t handle;
shmem_init ();
me = shmem_my_pe ();
npes = shmem_n_pes ();
for (i = 0; i < N; i += 1) {
src[i] = (long) me;
}
dest = (long *) shmem_malloc (N * sizeof (*dest));
nextpe = (me + 1) % npes;
shmemx_long_put_nb (dest, src, N, nextpe, &handle);
shmemx_wait_req (handle);
shmem_barrier_all ();
shmem_free (dest);
shmem_finalize ();
return 0;
}
int
main (int argc, char **argv)
{
int dest;
int src;
int me, npes;
shmem_init ();
me = shmem_my_pe ();
npes = shmem_n_pes ();
src = 42;
shmem_barrier_all ();
if (me == 0) {
shmem_int_put (&dest, &src, 1, 1);
}
shmem_barrier_all ();
shmem_finalize ();
return 0;
}
int
main(int argc, char* argv[])
{
int i, j, num_pes;
int failed = 0;
shmem_init();
if (shmem_my_pe() == 0) {
num_pes=shmem_n_pes();
for(j = 0; j < num_pes; j++) {
memset(target, 0, sizeof(long) * 10);
shmem_long_get_nbi(target, source, 10, j);
shmem_quiet();
for (i = 0; i < 10; i++) {
if (source[i] != target[i]) {
fprintf(stderr,"[%d] get_nbi from PE %d: target[%d] = %ld, expected %ld\n",
shmem_my_pe(), j, i, target[i], source[i]);
failed = 1;
}
}
if (failed)
shmem_global_exit(1);
}
}
shmem_finalize();
return 0;
}
void Setup(ArgStruct *p)
{
int npes;
start_pes(2);
if((npes=shmem_n_pes())!=2) {
printf("Error Message: Run with npes set to 2\n");
exit(1);
}
p->prot.flag=(int *) shmalloc(sizeof(int));
pTime = (double *) shmalloc(sizeof(double));
pNrepeat = (int *) shmalloc(sizeof(int));
p->tr = p->rcv = 0;
if((p->prot.ipe=_my_pe()) == 0) {
p->tr=1;
p->prot.nbor=1;
*p->prot.flag=1;
} else {
p->rcv=1;
p->prot.nbor=0;
*p->prot.flag=0;
}
}
void init_it(int *argc, char ***argv) {
//mpi_err = MPI_Init(argc,argv);
//mpi_err = MPI_Comm_size( MPI_COMM_WORLD, &numnodes );
//mpi_err = MPI_Comm_rank(MPI_COMM_WORLD, &myid);
start_pes(0);
numnodes = shmem_n_pes();
myid = shmem_my_pe();
}
int main(void)
{
start_pes(0);
printf("I am %d of %d. \n",
shmem_my_pe(), shmem_n_pes() );
return 0;
}
int main(int argc, char **argv)
{
int i,j;
long modj,oldj,oldxmodj;
int my_pe,n_pes;
size_t max_elements,max_elements_bytes;
static long *x;
shmem_init();
my_pe = shmem_my_pe();
n_pes = shmem_n_pes();
#ifdef HAVE_SET_CACHE_INV
shmem_set_cache_inv();
#endif
/* fail if trying to use only one processor */
if ( n_pes <= 1 ){
fprintf(stderr, "FAIL - test requires at least two PEs\n");
exit(1);
}
if(my_pe == 0)
fprintf(stderr, "shmem_long_finc(%s) n_pes=%d\n", argv[0],n_pes);
/* shmalloc x on all pes (only use the one on PE 0) */
max_elements_bytes = (size_t) (sizeof(long) * n_pes);
x = shmem_malloc( max_elements_bytes );
for(i=0; i<n_pes; i++)
x[i] = 0;
count = 0;
shmem_barrier_all();
for(i=0; i<ITER; i++) {
if (my_pe != 0) {
oldj = shmem_long_finc(&count, 0); /* get index oldj from PE 0 */
modj = (oldj % (n_pes-1)); /* PE 0 is just the counter/checker */
/* increment value in x[modj] */
oldxmodj = shmem_long_finc(&x[modj], 0);
/* printf("PE=%d,oldj=%ld,modj=%ld,oldxmodj=%ld\n",my_pe,oldj,modj,oldxmodj); */
}
}
shmem_barrier_all();
if (my_pe == 0) { /* check x[j] array on PE 0 */
for(j=1 ; j<n_pes; j++) {
if (x[j-1] != ITER)
fprintf(stderr, "FAIL PE %d of %d: x[%d] = %ld expected = %ld\n",
my_pe, n_pes, j-1, x[j-1], ITER);
}
}
shmem_barrier_all();
#ifdef NEEDS_FINALIZE
shmem_finalize();
#endif
return 0;
}
int
main(int argc, char* argv[], char *envp[])
{
int me, myshmem_n_pes;
/*
** Starts/Initializes SHMEM/OpenSHMEM
*/
shmem_init();
/*
** Fetch the number or processes
** Some implementations use num_pes();
*/
myshmem_n_pes = shmem_n_pes();
/*
** Assign my process ID to me
*/
me = shmem_my_pe();
srand(1+me);
for(total = 0; total < NUM_POINTS; ++total) {
double x,y;
x = rand()/(double)RAND_MAX;
y = rand()/(double)RAND_MAX;
if(x*x + y*y < 1) {
++inside;
}
}
shmem_barrier_all();
int errors = 0;
if(me == 0) {
for(int i = 1; i < myshmem_n_pes; ++i) {
long long remoteInside,remoteTotal;
shmem_longlong_get(&remoteInside,&inside,1,i);
shmem_longlong_get(&remoteTotal,&total,1,i);
total += remoteTotal;
inside += remoteInside;
}
double approx_pi = 4.0*inside/(double)total;
if(fabs(M_PI-approx_pi) > 0.1) {
++errors;
}
if (NULL == getenv("MAKELEVEL")) {
printf("Pi from %llu points on %d PEs: %lf\n",total,myshmem_n_pes,approx_pi);
}
}
shmem_finalize();
return errors;
}
int main(int argc, char *argv[]){
int i,next_pivot, pivot;
for (i=0; i < SHMEM_BCAST_SYNC_SIZE; i++) {
pSync[i] = _SHMEM_SYNC_VALUE;
}
start_pes(0);
me = shmem_my_pe();
npes = shmem_n_pes();
shmem_barrier_all();
srand (me+time(NULL));
N = atoi(argv[1]);
//int *nelems = (int*) shmalloc(sizeof(int));
//int *nelems_import= (int*) shmalloc(sizeof(int));;
printf("%d: Size = %d with np=%d\n",me,N,npes);
A = (int *)shmalloc((N/npes)*sizeof(int));
temp_arr = (int *)shmalloc((2*N/npes)*sizeof(int));
if(A==NULL){
printf("\nOut of memory");
return 1;
}
n= N/npes;
i=0;
while(i<N/npes){
A[i] = rand()%(10000-0);
i++;
}
printf("\nprocess %d elements:",me);
for(i=0;i<(N/npes);i++){
printf("%d, ", A[i]);
}
pivot = quicksort(A, 0, n-1);
printf("Process %d the pivot:%d",me, pivot);
shmem_barrier_all(); //just for the sake of clear display...can be removed in the end
printf("\nThe sorted list is of process %d: ",me);
for(i=0;i<N/npes;i++){
printf("%d, ",A[i]);
}
printf("\n");
hyperquick(A,N/npes,npes);
printf("\n");
shfree(temp_arr);
shfree(A);
shmem_finalize();
}
void initializeCommunication(LSMSCommunication &comm, SHMEM_activeset comm_shmem)
{
//comm.comm=mpiCommunicator;
//MPI_Comm_rank(comm.comm, &comm.rank);
//MPI_Comm_size(comm.comm, &comm.size);
comm.comm.rank = shmem_my_pe();
comm.comm.size = shmem_n_pes();
comm.comm.start_pe = comm_shmem.start_pe;
comm.comm.logPE_stride = comm_shmem.logPE_stride;
}
int
main(int argc, char* argv[])
{
int i;
for(i = 0; i < N_THREADS*N_ELEMS; ++i) {
source[i] = i+1;
}
int tl_expected = SHMEMX_THREAD_MULTIPLE;
int tl;
shmemx_init_thread(tl_expected,&tl);
if (tl_expected != tl) {
printf("Could not initialize with desired thread level (%d "
"requested, got %d)\n", tl_expected, tl);
return 0;
}
if (shmem_n_pes() == 1) {
printf("%s: Requires number of PEs > 1\n", argv[0]);
shmem_finalize();
return 0;
}
pthread_t threads[N_THREADS];
pthread_barrier_init(&fencebar,NULL,N_THREADS);
fprintf(stderr,"Starting threads\n");
for(i = 0; i < N_THREADS; ++i) {
/* fprintf(stderr,"Starting thread %d\n",i); */
ptrdiff_t tid = i;
pthread_create(&threads[i],NULL,&roundrobin,(void*)tid);
}
for(i = 0; i < N_THREADS; ++i) {
pthread_join(threads[i],NULL);
}
pthread_barrier_destroy(&fencebar);
if (0 != memcmp(source, target, sizeof(long) * N_THREADS*N_ELEMS)) {
fprintf(stderr,"[%d] Src & Target mismatch?\n",shmem_my_pe());
for (i = 0 ; i < 10 ; ++i) {
printf("%ld,%ld ", source[i], target[i]);
}
printf("\n");
shmem_global_exit(1);
}
shmem_finalize();
return 0;
}
int
main (void)
{
int me, npes;
long *dest;
{
time_t now;
time (&now);
srand (now + getpid ());
}
start_pes (0);
me = shmem_my_pe ();
npes = shmem_n_pes ();
dest = (long *) shmalloc (sizeof (*dest));
*dest = 9L;
shmem_barrier_all ();
if (me == 0)
{
int i;
for (i = 0; i < 4; i += 1)
{
long src = 9L;
shmem_long_put (dest, &src, 1, 1);
fprintf (stderr, "PE %d put %d\n", me, src);
}
fprintf (stderr, "----------------------------\n");
for (i = 0; i < 1000; i += 1)
{
long src = rand () % 10;
shmem_long_put (dest, &src, 1, 1);
fprintf (stderr, "PE %d put %d\n", me, src);
if (src != 9L)
break;
}
}
shmem_barrier_all ();
if (me == 1)
{
shmem_long_wait (dest, 9L);
fprintf (stderr, "PE %d finished wait, got %d\n", me, *dest);
}
shmem_barrier_all ();
return 0;
}
int
main (int argc, char **argv)
{
int me, npes;
shmemx_init ();
me = shmem_my_pe ();
npes = shmem_n_pes ();
printf ("Hello from node %4d of %4d\n", me, npes);
return 0;
}
int
main ()
{
int me, npes, src;
int i;
struct timeval start, end;
long time_taken, start_time, end_time;
for (i = 0; i < _SHMEM_BCAST_SYNC_SIZE; i += 1) {
pSync[i] = _SHMEM_SYNC_VALUE;
}
shmem_init ();
me = shmem_my_pe ();
npes = shmem_n_pes ();
src = me - 1;
time_taken = 0;
for (i = 0; i < 10000; i++) {
if (me != 0) {
shmem_int_p (&x, src * (i + 1), me - 1);
}
else {
shmem_int_p (&x, src * (i + 1), npes - 1);
}
shmem_barrier_all ();
gettimeofday (&start, NULL);
start_time = (start.tv_sec * 1000000.0) + start.tv_usec;
shmem_barrier (0, 0, npes, pSync);
gettimeofday (&end, NULL);
end_time = (end.tv_sec * 1000000.0) + end.tv_usec;
time_taken = time_taken + (end_time - start_time);
}
/* printf("%d: x = %d\n", me, x); */
if (me == 0) {
printf
("Time required for a barrier, with %d PEs is %ld microseconds\n",
npes, time_taken / 10000);
}
shmem_finalize ();
return 0;
}
int main(int argc, char **argv) {
shmem_init();
int MyRank = shmem_my_pe ();
int Numprocs = shmem_n_pes ();
printf("rank = %d size = %d\n", MyRank, Numprocs);
int *shared_arr = (int *)shmem_malloc(10 * sizeof(int));
assert(shared_arr);
int i;
for (i = 0; i < 10; i++) {
shared_arr[i] = 3;
}
shmem_finalize();
return 0;
}
/****************************************************************************
* Place for Test Item functions
***************************************************************************/
static int test_item1(void)
{
int rc = TC_PASS;
int myPe = shmem_my_pe();
int myPeer = myPe + ( myPe % 2 ? -1 : 1 ) ;
int nPe = shmem_n_pes();
int remainderPe = nPe - (nPe % 2);
static int statArray[ARRAY_SIZE];
int* dynamicArray = shmalloc( ARRAY_SIZE * sizeof(int) );
int iterate;
for (iterate = 0; iterate < ARRAY_SIZE; iterate++)
{
if (myPe != remainderPe)
{
int tryIterate;
int putNum, getNum;
for (tryIterate = 0; tryIterate < TRY_SIZE; tryIterate++)
{
putNum = iterate + myPe;
shmem_int_put(&statArray[iterate], &putNum, 1, myPeer);
shmem_int_put(&dynamicArray[iterate], &putNum, 1, myPeer);
}
shmem_fence();
shmem_int_get(&getNum, &statArray[iterate], 1, myPeer);
if (getNum != putNum)
{
rc = TC_FAIL;
}
shmem_int_get(&getNum, &dynamicArray[iterate], 1, myPeer);
if (getNum != putNum)
{
rc = TC_FAIL;
}
}
shmem_barrier_all();
}
shfree(dynamicArray);
return rc;
}