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;
}