int main(int argc,char *argv[]){ gaspi_rank_t rank,num; gaspi_return_t ret; float vers; signal(SIGINT,signal_handler); gaspi_print_affinity_mask(); ret = gaspi_proc_init(GPI2_TOUT); if(ret!=GASPI_SUCCESS){ printf("gaspi_init failed ! [%s]\n",ret==-1 ? "GASPI_ERROR":"GASPI_TIMEOUT"); gaspi_proc_term(GPI2_TOUT); exit(-1); } gaspi_version(&vers); gaspi_proc_rank(&rank); gaspi_proc_num(&num); gaspi_printf("rank: %d num: %d (vers: %.2f)\n",rank,num,vers); srand(time(NULL)*(rank+1)); const int dst = rand(); if( gaspi_sn_ping(dst%num,1000) != GASPI_SUCCESS) printf("gaspi_sn_ping failed ! [%s]\n",ret==-1 ? "GASPI_ERROR":"GASPI_TIMEOUT"); //tmp workaround, we have no barrier yet gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK); gaspi_proc_term(GPI2_TOUT); return 0; }
int main(int argc, char *argv[]) { static const int VLEN = 1 << 2; SUCCESS_OR_DIE( gaspi_proc_init(GASPI_BLOCK) ); gaspi_rank_t iProc, nProc; SUCCESS_OR_DIE( gaspi_proc_rank(&iProc) ); SUCCESS_OR_DIE( gaspi_proc_num(&nProc) ); gaspi_segment_id_t const segment_id = 0; gaspi_size_t const segment_size = VLEN * sizeof (double); SUCCESS_OR_DIE ( gaspi_segment_create ( segment_id, segment_size , GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_MEM_UNINITIALIZED ) ); gaspi_pointer_t array; SUCCESS_OR_DIE( gaspi_segment_ptr (segment_id, &array) ); for (int j = 0; j < VLEN; ++j) { ( (double *)array )[j]= (double)( iProc * VLEN + j ); printf("rank %d elem %d: %f \n", iProc,j,( (double *)array )[j] ); } SUCCESS_OR_DIE( gaspi_proc_term(GASPI_BLOCK) ); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { // gaspi_group_t g; gaspi_rank_t nprocs, myrank; TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); ASSERT(gaspi_proc_num(&nprocs)); ASSERT(gaspi_proc_rank(&myrank)); int n; for(n = 1; n <= 255; n++) { gaspi_datatype_t type; for(type = GASPI_TYPE_INT; type <= GASPI_TYPE_ULONG; type++) { gaspi_operation_t op; for(op = GASPI_OP_MIN; op <= GASPI_OP_SUM; op++) ASSERT(testOP(op, type, n, GASPI_GROUP_ALL)); } } gaspi_printf("done\n"); //sync ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { gaspi_rank_t nprocs, i; TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); ASSERT(gaspi_proc_num(&nprocs)); ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); gaspi_state_vector_t vec = (gaspi_state_vector_t) malloc(nprocs); gaspi_printf("vec out %p\n", vec); ASSERT(gaspi_state_vec_get(vec)); gaspi_printf("vec out %p\n", vec); for(i = 0; i < nprocs; i++) { assert(vec[i] == 0); } ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { int ntimes = 10; gaspi_rank_t rank, nprocs; gaspi_notification_id_t id; gaspi_notification_t val; TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); ASSERT(gaspi_proc_num(&nprocs)); ASSERT (gaspi_proc_rank(&rank)); const gaspi_rank_t right = (rank + nprocs + 1) % nprocs; do { ASSERT (gaspi_segment_create(0, 1024, GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_MEM_UNINITIALIZED)); ASSERT( gaspi_write_notify(0, 0, right, 0, 0, 8, 0, 1, 0, GASPI_BLOCK) ); ASSERT( gaspi_wait( 0, GASPI_BLOCK) ); ASSERT(gaspi_notify_waitsome(0, 0, 1, &id, GASPI_BLOCK)); ASSERT( gaspi_notify_reset(0, id, &val)); ASSERT (gaspi_segment_delete(0)); ASSERT (gaspi_segment_create(0, 2048, GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_MEM_UNINITIALIZED)); ASSERT( gaspi_write_notify(0, 0, right, 0, 0, 8, 0, 1, 0, GASPI_BLOCK) ); ASSERT( gaspi_wait( 0, GASPI_BLOCK) ); ASSERT(gaspi_notify_waitsome(0, 0, 1, &id, GASPI_BLOCK)); ASSERT( gaspi_notify_reset(0, id, &val)); ASSERT (gaspi_segment_delete(0)); ntimes--; } while(ntimes > 0); ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); gaspi_rank_t P, myrank; ASSERT (gaspi_proc_num(&P)); ASSERT (gaspi_proc_rank(&myrank)); ASSERT (gaspi_segment_create(0, _4GB, GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_MEM_INITIALIZED)); ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); const gaspi_size_t msgSize = 1; if(myrank == 0) { gaspi_rank_t n; for(n = 1; n < P; n++) EXPECT_TIMEOUT(gaspi_passive_send(0, 0, n, msgSize, 2000)); } ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); gaspi_rank_t nprocs; ASSERT(gaspi_proc_num(&nprocs)); ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); gaspi_state_vector_t vec = NULL; EXPECT_FAIL(gaspi_state_vec_get(vec)); vec = (gaspi_state_vector_t) malloc(nprocs); ASSERT(gaspi_state_vec_get(vec)); int i; for(i = 0; i < nprocs; i++) { assert(vec[i] == GASPI_STATE_HEALTHY); } ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { gaspi_gpu_id_t gpus[8]; gaspi_number_t nGPUs; TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); gaspi_rank_t rank, num; ASSERT (gaspi_proc_rank(&rank)); ASSERT (gaspi_proc_num(&num)); ASSERT (gaspi_gpu_init()); ASSERT (gaspi_gpu_number(&nGPUs)); ASSERT (gaspi_gpu_ids(gpus)); printf("Hello from rank %d of %d with %d GPUs:\n", rank, num, nGPUs ); int i; for (i = 0; i < gpus; i++) { gaspi_printf("device with Id %d \n", gpus[i]); } ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { int i; int num_threads = 0; gaspi_size_t segSize; TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); ASSERT(gaspi_threads_init(&num_threads)); ASSERT (gaspi_proc_num(&numranks)); ASSERT (gaspi_proc_rank(&myrank)); ASSERT (gaspi_segment_create(0, _128MB, GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_MEM_INITIALIZED)); ASSERT( gaspi_segment_size(0, myrank, &segSize)); for(i = 1; i < num_threads; i++) ASSERT(gaspi_threads_run(thread_fun, NULL)); thread_fun(NULL); ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { gaspi_rank_t nprocs, n; gaspi_number_t max_groups, gsize; gaspi_rank_t *partners; TSUITE_INIT(argc, argv); gaspi_group_max(&max_groups); ASSERT (gaspi_proc_init(GASPI_BLOCK)); ASSERT(gaspi_proc_num(&nprocs)); ASSERT(gaspi_group_size(GASPI_GROUP_ALL, &gsize)); partners = malloc(gsize * sizeof(gaspi_rank_t)); ASSERT(gaspi_group_ranks(GASPI_GROUP_ALL, partners)); for(n = 0; n < gsize; n++) { assert(partners[n] == n); } ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { gaspi_rank_t rank, nc, i; TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_rank(&rank)); ASSERT (gaspi_proc_num(&nc)); if(rank == 0) { for(i = 1; i < nc; i++) { ASSERT(gaspi_proc_kill( i, GASPI_BLOCK)); } EXPECT_FAIL(gaspi_proc_kill( rank, GASPI_BLOCK)); } else { //hang ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); } ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); gaspi_rank_t numranks, myrank, n; ASSERT (gaspi_proc_num(&numranks)); ASSERT (gaspi_proc_rank(&myrank)); ASSERT (gaspi_segment_create(0, _2GB, GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_MEM_INITIALIZED)); gaspi_atomic_value_t val; gaspi_atomic_value_t compare = 0; if(myrank == 0) for(n = 0; n < numranks; n++) ASSERT(gaspi_atomic_compare_swap(0, 0, n, compare, (gaspi_atomic_value_t) 42, &val, GASPI_BLOCK)); gaspi_pointer_t _vptr; ASSERT (gaspi_segment_ptr(0, &_vptr)); //sync ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); gaspi_atomic_value_t *end_val; end_val = (gaspi_atomic_value_t *)_vptr; assert(*end_val == 42); ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { gaspi_size_t mem; TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); mem = get_system_mem(); if(mem > 0) { mem *= 1024; //to bytes mem *= 45; //45% mem /= 100; } else { gaspi_printf("Failed to get mem (%lu)\n", mem); exit(-1); } gaspi_printf("Segment size %lu MB\n", mem / 1024 / 1024); ASSERT( gaspi_segment_create(0, mem, GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_MEM_UNINITIALIZED)); ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
void end_bench () { gaspi_barrier (GASPI_GROUP_ALL, GASPI_BLOCK); gaspi_proc_term (GASPI_BLOCK); }
int main(int argc, char *argv[]) { gaspi_rank_t r; gaspi_notification_id_t id; TSUITE_INIT(argc, argv); ASSERT( gaspi_proc_init(GASPI_BLOCK)); ASSERT( gaspi_proc_rank(&r)); ASSERT( gaspi_segment_create(0, 1, GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_ALLOC_DEFAULT)); ASSERT(gaspi_notify(0, r, r, 1, 0, GASPI_BLOCK)); ASSERT( gaspi_notify_waitsome(0, r, 1, &id, GASPI_BLOCK)); // wait for zero notifications ASSERT( gaspi_notify_waitsome(0, 0, 0, &id, GASPI_BLOCK)); ASSERT( gaspi_segment_delete(0 )); ASSERT( gaspi_proc_term(GASPI_BLOCK) ); return 0; }
int main(int argc, char *argv[]) { gaspi_group_t g; gaspi_rank_t nprocs, myrank; gaspi_number_t gsize; TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); ASSERT(gaspi_proc_num(&nprocs)); ASSERT(gaspi_proc_rank(&myrank)); ASSERT (gaspi_group_create(&g)); gaspi_rank_t i; for(i = 0; i < nprocs; i++) { ASSERT(gaspi_group_add(g, i)); } ASSERT(gaspi_group_size(g, &gsize)); assert((gsize == nprocs)); if(myrank > 0 ) sleep(10); //simulate delay //should fail since other ranks are still sleeping /* if(myrank == 0 ) */ /* EXPECT_TIMEOUT(gaspi_group_commit(g, 1000)); */ gaspi_return_t ret; do { ret = gaspi_group_commit(g, 1000); gaspi_printf("commit returned %d\n", ret); } while (ret == GASPI_TIMEOUT || ret == GASPI_ERROR); assert((ret != GASPI_ERROR)); gaspi_printf("group barrier %d \n", ret); //group barrier -> should fail due to timeout of commit ASSERT(gaspi_barrier(g, 5000)); gaspi_printf("all barrier\n"); //all barrier ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); //sync ASSERT (gaspi_proc_term(GASPI_BLOCK)); gaspi_printf("finish\n"); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { gaspi_group_t g; gaspi_rank_t nprocs, myrank; gaspi_number_t gsize; TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); ASSERT(gaspi_proc_num(&nprocs)); ASSERT(gaspi_proc_rank(&myrank)); ASSERT (gaspi_group_create(&g)); ASSERT(gaspi_group_size(g, &gsize)); assert((gsize == 0)); gaspi_rank_t i; for(i = 0; i < nprocs; i++) { ASSERT(gaspi_group_add(g, i)); } ASSERT(gaspi_group_size(g, &gsize)); assert((gsize == nprocs)); ASSERT(gaspi_group_commit(g, GASPI_BLOCK)); //loop barrier int j; for (j = 0; j < ITERATIONS; j++) { ASSERT (gaspi_barrier(g, GASPI_BLOCK)); /* with timeout */ ASSERT (gaspi_barrier(g, nprocs * 1000)); } for (j = 0; j < ITERATIONS; j++) { ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); } //with timeout if(myrank % 2 == 0) { sleep(2); } else { EXPECT_TIMEOUT (gaspi_barrier(GASPI_GROUP_ALL, 20)); } ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { unsigned long i; gaspi_pointer_t _vptr; gaspi_rank_t num_ranks, myrank; gaspi_number_t qmax ; gaspi_number_t queueSize; gaspi_rank_t left_rank, right_rank; const unsigned long N = (1 << 13); TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); ASSERT (gaspi_proc_num(&num_ranks)); ASSERT (gaspi_proc_rank(&myrank)); ASSERT(gaspi_segment_create(0, _2MB, GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_MEM_INITIALIZED)); ASSERT(gaspi_segment_ptr(0, &_vptr)); ASSERT (gaspi_queue_size_max(&qmax)); ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); left_rank = (myrank + num_ranks - 1 ) % num_ranks; right_rank = (myrank + num_ranks + 1) % num_ranks; ASSERT( gaspi_write(0, //seg 0, //local off left_rank, //rank 0, //seg rem 0, //remote off 1, //size 32KB 0, //queue GASPI_BLOCK)); ASSERT( gaspi_write(0, //seg 0, //local off right_rank, //rank 0, //seg rem 0, //remote off 1, //size 32KB 0, //queue GASPI_BLOCK)); ASSERT (gaspi_wait(0, GASPI_BLOCK)); ASSERT (gaspi_barrier(GASPI_GROUP_ALL, 5000)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); printf("Rank %d: Finish\n", myrank); fflush(stdout); return EXIT_SUCCESS; }
int main(int argc,char *argv[]) { gaspi_rank_t rank,tnc; gaspi_float vers; gaspi_config_t gconf; char mtype[16]; int i; mcycles_t t0, t1; mcycles_t delta[1024]; gaspi_float cpu_freq; gaspi_config_get(&gconf); gconf.mtu = 4096; gconf.queue_num = 1; gaspi_config_set(gconf); GPI2_ASSERT(gaspi_proc_init(GASPI_BLOCK)); GPI2_ASSERT( gaspi_version(&vers) ); GPI2_ASSERT( gaspi_proc_rank(&rank) ); GPI2_ASSERT( gaspi_proc_num(&tnc) ); GPI2_ASSERT( gaspi_machine_type(mtype) ); GPI2_ASSERT( gaspi_cpu_frequency(&cpu_freq)); if ( 0 == rank) printf("my rank: %d tnc: %d (vers: %.2f) machine:%s\n",rank,tnc,vers,mtype); GPI2_ASSERT(gaspi_barrier(GASPI_GROUP_ALL,GASPI_BLOCK)); if(0 == rank) printf("cpu freq: %.2f\n",cpu_freq); //benchmark for(i = 0; i < 1000; i++) { t0 = get_mcycles(); GPI2_ASSERT(gaspi_barrier(GASPI_GROUP_ALL,GASPI_BLOCK)); t1 = get_mcycles(); delta[i] = (t1 - t0); } if(0 == rank) { qsort(delta,1000,sizeof *delta,mcycles_compare); const double div = 1.0 / cpu_freq; const double ts = (double)delta[500] * div; printf("time: %f usec\n",ts); } fflush(stdout); GPI2_ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); GPI2_ASSERT(gaspi_proc_term(GASPI_BLOCK)); return 0; }
int main(int argc, char *argv[]) { TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); gaspi_notification_id_t n=0; gaspi_number_t notif_num; gaspi_rank_t rank, nprocs, i; const gaspi_segment_id_t seg_id = 0; ASSERT(gaspi_proc_num(&nprocs)); ASSERT (gaspi_proc_rank(&rank)); ASSERT (gaspi_segment_create(seg_id, 1024, GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_MEM_UNINITIALIZED)); ASSERT( gaspi_notification_num(¬if_num)); gaspi_printf("max num notifications %u\n", notif_num); if(rank == 0) { gaspi_number_t queue_size; gaspi_number_t queue_max; ASSERT (gaspi_queue_size_max(&queue_max)); for(n = 0; n < notif_num; n++) { ASSERT (gaspi_queue_size(0, &queue_size)); if(queue_size > queue_max - 1) ASSERT (gaspi_wait(0, GASPI_BLOCK)); for(i = 1; i < nprocs; i++) { ASSERT (gaspi_notify( seg_id, i, n, 1, 0, GASPI_BLOCK)); } } } else { do { gaspi_notification_id_t id; ASSERT (gaspi_notify_waitsome(seg_id, 0, notif_num, &id, GASPI_BLOCK)); gaspi_notification_t notification_val; ASSERT( gaspi_notify_reset(seg_id, id, ¬ification_val)); assert(notification_val == 1); n++; } while(n < notif_num); } ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { assert ((argc > 1)); ASSERT (gaspi_proc_init(5000)); ASSERT (gaspi_proc_term(5000)); return EXIT_SUCCESS; }
/* Test that sends passive messages without blocking (GASPI_TEST) */ int main(int argc, char *argv[]) { TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); gaspi_rank_t P, myrank; ASSERT (gaspi_proc_num(&P)); ASSERT (gaspi_proc_rank(&myrank)); if( P < 2 ) { return EXIT_SUCCESS; } ASSERT (gaspi_segment_create(0, _2MB, GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_MEM_INITIALIZED)); ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); const gaspi_size_t msgSize = 4; if( P > 1 ) { if(myrank == 1) { gaspi_rank_t n; for(n = 0; n < P; n++) { if(n == myrank) continue; gaspi_return_t ret = GASPI_ERROR; do { ret = gaspi_passive_send(0, 0, n, msgSize, GASPI_TEST); } while(ret != GASPI_SUCCESS); } } else { gaspi_rank_t sender; ASSERT(gaspi_passive_receive(0, 0, &sender, msgSize, GASPI_BLOCK)); assert(sender == 1); } } ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { gaspi_rank_t numranks, myrank; gaspi_rank_t rankSend; gaspi_size_t segSize; const gaspi_offset_t localOff= 0; const gaspi_offset_t remOff = 0; gaspi_number_t queueSize, qmax; gaspi_size_t commSize ; TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); ASSERT (gaspi_proc_num(&numranks)); ASSERT (gaspi_proc_rank(&myrank)); ASSERT (gaspi_segment_create(0, _128MB, GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_MEM_INITIALIZED)); ASSERT( gaspi_segment_size(0, myrank, &segSize)); ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_queue_size_max(&qmax)); for(commSize= 4; commSize < _8MB; commSize*=2 ) { for(rankSend = 0; rankSend < numranks; rankSend++) { if(rankSend == myrank) continue; printf("partner rank: %d - %lu bytes\n", rankSend, commSize); //FAILS with or without outstanding requests gaspi_queue_size(1, &queueSize); if (queueSize > qmax - 24) ASSERT (gaspi_wait(1, GASPI_BLOCK)); ASSERT (gaspi_read(0, localOff, rankSend, 0, remOff, commSize, 1, GASPI_BLOCK)); } } ASSERT (gaspi_wait(1, GASPI_BLOCK)); ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { int i; int mpi_rank, mpi_sz, mpi_ret; gaspi_rank_t rank, nnodes; if(MPI_Init(&argc, &argv) != MPI_SUCCESS) return EXIT_FAILURE; ASSERT(gaspi_proc_init(GASPI_BLOCK)); ASSERT(gaspi_proc_rank(&rank)); ASSERT(gaspi_proc_num(&nnodes)); mpi_ret = MPI_Comm_size(MPI_COMM_WORLD, &mpi_sz); assert(mpi_ret == 0); mpi_ret = MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank); assert(mpi_ret == 0); /* the test starts here */ int vec_elems = 1; int max_vec_elems = 255; if (argc > 1) max_vec_elems = atoi(argv[1]); double * vector = (double *) malloc (max_vec_elems * sizeof(double)); for(i = 0; i < max_vec_elems; i++) vector[i] = 1.0f; for(i = vec_elems; i <= max_vec_elems; i++) { gaspi_printf("Norm for %d elems: %.2f\n", i, normP_GPI(vector, i)); } /* sync and finish */ ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); assert(MPI_Barrier(MPI_COMM_WORLD) == MPI_SUCCESS); ASSERT(gaspi_proc_term(GASPI_BLOCK)); if(MPI_Finalize() != MPI_SUCCESS) return EXIT_FAILURE; free(vector); return 0; }
void exit_safely(void) { gaspi_rank_t rank, nprocs, i; ASSERT (gaspi_proc_num(&nprocs)); ASSERT (gaspi_proc_rank(&rank)); if(rank == 0) { for( i = 1; i < nprocs; i++) ASSERT(gaspi_proc_kill(i, GASPI_BLOCK)); } ASSERT (gaspi_proc_term(GASPI_BLOCK)); }
int main(int argc, char *argv[]) { // gaspi_group_t g; gaspi_rank_t nprocs, myrank; TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); ASSERT(gaspi_proc_num(&nprocs)); ASSERT(gaspi_proc_rank(&myrank)); int n; double * a = (double *) malloc(255 * sizeof(double)); double * b = (double *) malloc(255 * sizeof(double)); if(a == NULL || b == NULL) return EXIT_FAILURE; for(n = 0; n < 255; n++) { a[n] = b[n] = myrank * 1.0; } ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); for(n = 1; n <= 255; n++) { int i; ASSERT(gaspi_allreduce_user(a, b, n, sizeof(double), (gaspi_reduce_operation_t) my_fun, NULL, GASPI_GROUP_ALL, GASPI_BLOCK)); for(i = 0; i < n; i++) assert(b[i] == nprocs - 1); } free(a); free(b); gaspi_printf("done\n"); //sync ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { SUCCESS_OR_DIE( gaspi_proc_init(GASPI_BLOCK) ); gaspi_rank_t rank; gaspi_rank_t num; SUCCESS_OR_DIE( gaspi_proc_rank(&rank) ); SUCCESS_OR_DIE( gaspi_proc_num(&num) ); gaspi_printf("Hello world from rank %d of %d\n",rank, num); SUCCESS_OR_DIE( gaspi_proc_term(GASPI_BLOCK) ); return EXIT_SUCCESS; }
/* Test creating the same segment (0) */ int main(int argc, char *argv[]) { TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); ASSERT (gaspi_segment_create(0, _2MB, GASPI_GROUP_ALL, GASPI_BLOCK,GASPI_MEM_UNINITIALIZED)); ASSERT (gaspi_segment_create(0, _8MB, GASPI_GROUP_ALL, GASPI_BLOCK,GASPI_MEM_UNINITIALIZED)); ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { gaspi_rank_t numranks, myrank; gaspi_rank_t rankSend; gaspi_size_t segSize; TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); ASSERT (gaspi_proc_num(&numranks)); ASSERT (gaspi_proc_rank(&myrank)); ASSERT (gaspi_segment_create(0, _2GB, GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_MEM_INITIALIZED)); ASSERT( gaspi_segment_size(0, myrank, &segSize)); gaspi_printf("seg size %lu MB \n", segSize/1024/1024); // ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); gaspi_offset_t localOff= 814780664; gaspi_offset_t remOff = 81478246; gaspi_offset_t size = 1800; gaspi_number_t queueSize, qmax; ASSERT (gaspi_queue_size_max(&qmax)); for(rankSend = 0; rankSend < numranks; rankSend++) { gaspi_printf("rank to send: %d\n", rankSend); gaspi_queue_size(1, &queueSize); if (queueSize > qmax - 24) ASSERT (gaspi_wait(1, GASPI_BLOCK)); ASSERT (gaspi_write(0, localOff, rankSend, 0, remOff, size, 1, GASPI_BLOCK)); } ASSERT (gaspi_wait(1, GASPI_BLOCK)); ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { TSUITE_INIT(argc, argv); ASSERT (gaspi_proc_init(GASPI_BLOCK)); gaspi_rank_t P, myrank; ASSERT (gaspi_proc_num(&P)); ASSERT (gaspi_proc_rank(&myrank)); ASSERT (gaspi_segment_create(0, _2MB, GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_MEM_INITIALIZED)); ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); int * int_GlbMem; gaspi_pointer_t _vptr; ASSERT(gaspi_segment_ptr(0, &_vptr)); int_GlbMem = ( int *) _vptr; gaspi_size_t msgSize; gaspi_size_t i; for(msgSize = 4; msgSize < 8192; msgSize *=2) if(myrank == 0) { for(i = 0; i < msgSize / sizeof(int); i++) int_GlbMem[i] = (int) msgSize; gaspi_rank_t n; for(n = 1; n < P; n++) ASSERT(gaspi_passive_send(0, 0, n, msgSize, GASPI_BLOCK)); } else { gaspi_rank_t sender; ASSERT(gaspi_passive_receive(0, 0, &sender, msgSize, GASPI_BLOCK)); for(i = 0; i < msgSize / sizeof(int); i++) assert( int_GlbMem[i] == (int) msgSize ); } ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); ASSERT (gaspi_proc_term(GASPI_BLOCK)); return EXIT_SUCCESS; }