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_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;
}
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[])
{
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[])
{
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_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));
gaspi_printf("%d partners\n", gsize);
for(n=0; n < gsize; n++)
gaspi_printf("%d ", partners[n]);
gaspi_printf("\n");
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 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, _2GB, 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_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[])
{
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;
}
/* 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[])
{
// 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;
}
/* 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;
}
//alloc GPU segemnt
//and then register it with all nodes
//then delete it
int main(int argc, char *argv[])
{
TSUITE_INIT(argc, argv);
ASSERT (gaspi_proc_init(GASPI_BLOCK));
ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
gaspi_rank_t rank, nprocs, i;
gaspi_number_t seg_max;
gaspi_gpu_id_t gpus[8];
gaspi_number_t nGPUs;
ASSERT(gaspi_proc_num(&nprocs));
ASSERT (gaspi_proc_rank(&rank));
ASSERT(gaspi_gpu_init());
seg_max = 1;
ASSERT (gaspi_gpu_number(&nGPUs));
ASSERT (gaspi_gpu_ids(gpus));
cudaSetDevice(gpus[0]);
ASSERT (gaspi_segment_alloc(0, 1024, GASPI_MEM_INITIALIZED|GASPI_MEM_GPU));
ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
for (i = 0; i < nprocs; i++)
{
if(i == rank)
continue;
ASSERT( gaspi_segment_register(0, i, GASPI_BLOCK));
}
ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
ASSERT (gaspi_segment_delete(0));
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, _8MB, GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_MEM_INITIALIZED));
ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
ASSERT (gaspi_queue_size_max(&qmax));
for(commSize= 1; commSize <= _8MB; commSize*=2 )
{
for(rankSend = 0; rankSend < numranks; rankSend++)
{
gaspi_printf("rank to send: %d - %lu bytes\n", rankSend, commSize);
gaspi_queue_size(1, &queueSize);
if (queueSize > qmax - 24)
ASSERT (gaspi_wait(1, GASPI_BLOCK));
ASSERT (gaspi_write(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[])
{
const int ntimes = 1000;
TSUITE_INIT(argc, argv);
ASSERT (gaspi_proc_init(GASPI_BLOCK));
gaspi_rank_t numranks, myrank, n,m;
ASSERT (gaspi_proc_num(&numranks));
ASSERT (gaspi_proc_rank(&myrank));
ASSERT (gaspi_segment_create(0, _2MB, GASPI_GROUP_ALL, GASPI_BLOCK, GASPI_MEM_INITIALIZED));
gaspi_atomic_value_t val;
for(m = 0; m < ntimes; m++)
for(n = 0; n < numranks; n++)
{
gaspi_return_t ret;
do
{
ret = gaspi_atomic_fetch_add(0, 0, n, 1, &val, GASPI_BLOCK);
}
while(ret == GASPI_TIMEOUT);
}
gaspi_pointer_t _vptr;
ASSERT (gaspi_segment_ptr(0, &_vptr));
//sync to make sure everyone did it
ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
gaspi_atomic_value_t *end_val;
end_val = (gaspi_atomic_value_t *)_vptr;
assert(*end_val == (numranks * ntimes));
ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
ASSERT (gaspi_proc_term(GASPI_BLOCK));
return EXIT_SUCCESS;
}
//alloc a segment of different size
int main(int argc, char *argv[])
{
TSUITE_INIT(argc, argv);
ASSERT (gaspi_proc_init(GASPI_BLOCK));
ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
gaspi_rank_t rank, nprocs, i;
gaspi_size_t seg_size;
ASSERT (gaspi_proc_num(&nprocs));
ASSERT (gaspi_proc_rank(&rank));
if (rank == 0)
{ ASSERT (gaspi_segment_alloc(0, 1024, GASPI_MEM_INITIALIZED)); }
else
ASSERT (gaspi_segment_alloc(0, 2048, GASPI_MEM_INITIALIZED));
ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
ASSERT(gaspi_segment_size(0, rank, &seg_size));
for (i = 0; i < nprocs; i++)
{
gaspi_printf("register seg of size %lu with %u\n", seg_size, i);
if(i == rank)
continue;
ASSERT( gaspi_segment_register(0, i, GASPI_BLOCK));
// sleep(1);
}
ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
ASSERT (gaspi_segment_delete(0));
ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
ASSERT (gaspi_proc_term(GASPI_BLOCK));
return EXIT_SUCCESS;
}
//alloc max number of segs, fail after that
//and them register them all with all nodes
//then delete them
int main(int argc, char *argv[])
{
TSUITE_INIT(argc, argv);
ASSERT (gaspi_proc_init(GASPI_BLOCK));
//need the barrier to make sn is up
ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
gaspi_rank_t rank, nprocs, i;
gaspi_number_t seg_max;
ASSERT(gaspi_proc_num(&nprocs));
ASSERT (gaspi_proc_rank(&rank));
seg_max = 1;
ASSERT (gaspi_segment_alloc(0, 1024, GASPI_MEM_INITIALIZED));
ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
for (i = 0; i < nprocs; i++)
{
gaspi_printf("register with %u\n", i);
if(i == rank)
continue;
ASSERT( gaspi_segment_register(0, i, GASPI_BLOCK));
// sleep(1);
}
ASSERT(gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
ASSERT (gaspi_segment_delete(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));
int * int_GlbMem;
gaspi_pointer_t _vptr;
ASSERT(gaspi_segment_ptr(0, &_vptr));
int_GlbMem = ( int *) _vptr;
const gaspi_size_t msgSize = sizeof(int);
if(myrank == 0)
{
int_GlbMem[0] = 11223344;
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));
gaspi_printf("Received msg from %d\n", sender);
assert( int_GlbMem[0] == 11223344 );
}
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));
mctpInitUser(2);
int tid = mctpRegisterThread();
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));
int * int_GlbMem;
gaspi_pointer_t _vptr;
ASSERT(gaspi_segment_ptr(0, &_vptr));
int_GlbMem = ( int *) _vptr;
mctpStartSingleThread(recvThread, int_GlbMem);
int_GlbMem[0] = 11223344;
//send to myself (need trick to avoid blocking)
gaspi_return_t ret = GASPI_ERROR;
do
{
ret = gaspi_passive_send(0, 0, myrank, sizeof(int), GASPI_TEST);
assert (ret != GASPI_ERROR);
sleep(1);
}
while (ret != GASPI_SUCCESS);
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));
for(i = 0; i < nc; i++)
{
ASSERT(gaspi_proc_ping( i, 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));
const gaspi_size_t msgSize = 4;
const int times = 1000;
int i;
for(i = 1; i < times; i++)
{
if(myrank == 0)
{
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));
gaspi_printf("Received msg (%lu bytes) from %d\n", msgSize, sender);
}
}
ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
ASSERT (gaspi_proc_term(GASPI_BLOCK));
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
gaspi_number_t elem_max;
gaspi_size_t buf_size;
TSUITE_INIT(argc, argv);
ASSERT (gaspi_proc_init(GASPI_BLOCK));
ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
ASSERT(gaspi_allreduce_buf_size ( &buf_size));
ASSERT(gaspi_allreduce_elem_max (&elem_max));
gaspi_printf("buf size %lu max elem %d\n", buf_size, elem_max);
ASSERT (gaspi_barrier(GASPI_GROUP_ALL, GASPI_BLOCK));
ASSERT (gaspi_proc_term(GASPI_BLOCK));
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, nprocs * 1000));
//loop barrier
int j;
for (j = 0; j < ITERATIONS; j++)
ASSERT (gaspi_barrier(g, nprocs * 1000));
//sync
ASSERT (gaspi_barrier(GASPI_GROUP_ALL, nprocs * 1000));
ASSERT (gaspi_proc_term(GASPI_BLOCK));
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
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));
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;
}
