int main( int argc, char *argv[] )
{
int minsize = -1, maxsize = -1, repeats = -1;
int c;
MPI_Init( &argc, &argv );
while( ( c = getopt( argc, argv, "i:a:r:" ) ) != -1 ) {
switch( c ) {
case 'i':
if( sscanf( optarg, "%d", &minsize ) != 1 )
exit( EXIT_FAILURE );
break;
case 'a':
if( sscanf( optarg, "%d", &maxsize ) != 1 )
exit( EXIT_FAILURE );
break;
case 'r':
if( sscanf( optarg, "%d", &repeats ) != 1 )
exit( EXIT_FAILURE );
break;
}
}
allgather( minsize, maxsize, repeats );
MPI_Finalize();
exit( EXIT_SUCCESS );
}
void blocking_spike(data& d, MPI_Datatype spike){
//gather how many spikes each process is sending
allgather(d);
//set the displacements
set_displ(d);
//next distribute items to every other process using allgatherv
allgatherv(d, spike);
}
void allgather_and_gate::compute(int num_loops)
{
for (int i = 0; i < num_loops; ++i)
{
// do some stuff
double value = rank_ * 3.14159 * (i+1);
// now hit the barrier
allgather(value);
}
}
int main(int argc, char* argv[])
{
pami_result_t result = PAMI_ERROR;
/* initialize the second client */
char * clientname = "";
pami_client_t client;
result = PAMI_Client_create(clientname, &client, NULL, 0);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Client_create");
/* query properties of the client */
pami_configuration_t config[4];
config[0].name = PAMI_CLIENT_NUM_TASKS;
config[1].name = PAMI_CLIENT_TASK_ID;
config[2].name = PAMI_CLIENT_NUM_CONTEXTS;
config[3].name = PAMI_CLIENT_NUM_LOCAL_TASKS;
result = PAMI_Client_query(client, config, 4);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Client_query");
const size_t world_size = config[0].value.intval;
const size_t world_rank = config[1].value.intval;
const size_t num_contexts = config[2].value.intval;
const size_t num_local_tasks = config[3].value.intval;
TEST_ASSERT(num_contexts>1,"num_contexts>1");
int ppn = (int)num_local_tasks;
int nnodes = world_size/ppn;
int mycore = world_size%nnodes;
int mynode = (world_rank-mycore)/ppn;
if (world_rank==0)
{
printf("hello world from rank %ld of %ld, node %d of %d, core %d of %d \n",
world_rank, world_size, mynode, nnodes, mycore, ppn );
fflush(stdout);
}
/* initialize the contexts */
contexts = (pami_context_t *) safemalloc( num_contexts * sizeof(pami_context_t) );
result = PAMI_Context_createv( client, NULL, 0, contexts, num_contexts );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Context_createv");
/* setup the world geometry */
pami_geometry_t world_geometry;
result = PAMI_Geometry_world(client, &world_geometry );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Geometry_world");
#ifdef PROGRESS_THREAD
int status = pthread_create(&Progress_thread, NULL, &Progress_function, NULL);
TEST_ASSERT(status==0, "pthread_create");
#endif
/************************************************************************/
for (int n=1; n<=(256*1024); n*=2)
{
if (world_rank==0)
{
printf("starting n = %d \n", n);
fflush(stdout);
}
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
double * sbuf = safemalloc(world_size*n*sizeof(double));
double * rbuf = safemalloc(world_size*n*sizeof(double));
for (int s=0; s<world_size; s++ )
for (int k=0; k<n; k++)
sbuf[s*n+k] = world_rank*n+k;
for (int s=0; s<world_size; s++ )
for (int k=0; k<n; k++)
rbuf[s*n+k] = -1.0;
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
size_t bytes = world_size * n * sizeof(double), bytes_out;
pami_memregion_t shared_mr;
result = PAMI_Memregion_create(contexts[1], rbuf, bytes, &bytes_out, &shared_mr);
TEST_ASSERT(result == PAMI_SUCCESS && bytes==bytes_out,"PAMI_Memregion_create");
pami_memregion_t local_mr;
result = PAMI_Memregion_create(contexts[0], sbuf, bytes, &bytes_out, &local_mr);
TEST_ASSERT(result == PAMI_SUCCESS && bytes==bytes_out,"PAMI_Memregion_create");
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
pami_endpoint_t * target_eps = (pami_endpoint_t *) safemalloc( world_size * sizeof(pami_endpoint_t) );
for (int target=0; target<world_size; target++)
{
result = PAMI_Endpoint_create(client, (pami_task_t) target, 1 /* async context*/, &(target_eps[target]) );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Endpoint_create");
}
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
pami_memregion_t * shmrs = (pami_memregion_t *) safemalloc( world_size * sizeof(pami_memregion_t) );
result = allgather(world_geometry, contexts[0], sizeof(pami_memregion_t), &shared_mr, shmrs);
TEST_ASSERT(result == PAMI_SUCCESS,"allgather");
if (world_rank==0)
{
printf("starting A2A \n");
fflush(stdout);
}
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
#ifdef SEPARATE_COMPLETION
done_t active = { .local = world_size,
.remote = world_size };
#else
int active = world_size;
#endif
uint64_t t0 = GetTimeBase();
for (int count=0; count<world_size; count++)
{
int t = world_rank+count;
int target = t%world_size;
//printf("%ld: attempting Rput to %ld (bytes=%ld,loff=%ld, roff=%ld) \n",
// (long)world_rank, (long)target, bytes, n*sizeof(double),
// target*n*sizeof(double), world_rank*n*sizeof(double));
//printf("%ld: attempting Rput to %ld \n", (long)world_rank, (long)target),
//fflush(stdout);
pami_rput_simple_t parameters;
parameters.rma.dest = target_eps[target];
//parameters.rma.hints = ;
parameters.rma.bytes = n*sizeof(double);
parameters.rma.cookie = &active;
#ifdef SEPARATE_COMPLETION
parameters.rma.done_fn = cb_done_local;
parameters.put.rdone_fn = cb_done_remote;
#else
parameters.rma.done_fn = NULL;
parameters.put.rdone_fn = cb_done;
#endif
parameters.rdma.local.mr = &local_mr;
parameters.rdma.local.offset = target*n*sizeof(double);
parameters.rdma.remote.mr = &shmrs[target];
parameters.rdma.remote.offset = world_rank*n*sizeof(double);
result = PAMI_Rput(contexts[0], ¶meters);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Rput");
}
#ifdef SEPARATE_COMPLETION
while (active.local>0)
{
result = PAMI_Context_trylock_advancev(&(contexts[0]), 1, 1000);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Context_trylock_advancev");
}
#endif
uint64_t t1 = GetTimeBase();
double dt1 = (t1-t0)*tic;
#ifdef SEPARATE_COMPLETION
while (active.remote>0)
#else
while (active>0)
#endif
{
result = PAMI_Context_trylock_advancev(&(contexts[0]), 1, 1000);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Context_trylock_advancev");
}
uint64_t t2 = GetTimeBase();
double dt2 = (t2-t0)*tic;
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
double megabytes = 1.e-6*bytes;
printf("%ld: PAMI_Rput A2A: %ld bytes per rank, local %lf seconds (%lf MB/s), remote %lf seconds (%lf MB/s) \n",
(long)world_rank, n*sizeof(double),
dt1, megabytes/dt1,
dt2, megabytes/dt2 );
fflush(stdout);
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
for (int s=0; s<world_size; s++ )
for (int k=0; k<n; k++)
{
if (rbuf[s*n+k]!=(1.0*s*n+1.0*k))
printf("%4d: rbuf[%d] = %lf (%lf) \n", (int)world_rank, s*n+k, rbuf[s*n+k], (1.0*s*n+1.0*k) );
}
fflush(stdout);
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
result = PAMI_Memregion_destroy(contexts[0], &shared_mr);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Memregion_destroy");
result = PAMI_Memregion_destroy(contexts[0], &local_mr);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Memregion_destroy");
free(target_eps);
free(shmrs);
free(rbuf);
free(sbuf);
}
/************************************************************************/
#ifdef PROGRESS_THREAD
void * rv;
status = pthread_cancel(Progress_thread);
TEST_ASSERT(status==0, "pthread_cancel");
status = pthread_join(Progress_thread, &rv);
TEST_ASSERT(status==0, "pthread_join");
#endif
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
/* finalize the contexts */
result = PAMI_Context_destroyv( contexts, num_contexts );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Context_destroyv");
free(contexts);
/* finalize the client */
result = PAMI_Client_destroy( &client );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Client_destroy");
if (world_rank==0)
printf("%ld: end of test \n", world_rank );
fflush(stdout);
return 0;
}
/* Wrapper for avoiding duplicate code - performs Allgathers for all particle
* data */
void synchronize() {
allgather(ParticleXs);
allgather(ParticleYs);
allgather(ParticleStates);
}
int main(int argc, char* argv[])
{
pami_result_t result = PAMI_ERROR;
/* initialize the second client */
char * clientname = "";
pami_client_t client;
result = PAMI_Client_create(clientname, &client, NULL, 0);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Client_create");
/* query properties of the client */
pami_configuration_t config[3];
size_t num_contexts;
config[0].name = PAMI_CLIENT_NUM_TASKS;
config[1].name = PAMI_CLIENT_TASK_ID;
config[2].name = PAMI_CLIENT_NUM_CONTEXTS;
result = PAMI_Client_query(client, config, 3);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Client_query");
world_size = config[0].value.intval;
world_rank = config[1].value.intval;
num_contexts = config[2].value.intval;
TEST_ASSERT(num_contexts>1,"num_contexts>1");
if (world_rank==0)
{
printf("hello world from rank %ld of %ld \n", world_rank, world_size );
fflush(stdout);
}
/* initialize the contexts */
contexts = (pami_context_t *) safemalloc( num_contexts * sizeof(pami_context_t) );
result = PAMI_Context_createv( client, NULL, 0, contexts, num_contexts );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Context_createv");
/* setup the world geometry */
pami_geometry_t world_geometry;
result = PAMI_Geometry_world(client, &world_geometry );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Geometry_world");
int status = pthread_create(&Progress_thread, NULL, &Progress_function, NULL);
TEST_ASSERT(status==0, "pthread_create");
/************************************************************************/
int n = (argc>1 ? atoi(argv[1]) : 1000000);
size_t bytes = n * sizeof(int);
int * shared = (int *) safemalloc(bytes);
for (int i=0; i<n; i++)
shared[i] = world_rank;
int * local = (int *) safemalloc(bytes);
for (int i=0; i<n; i++)
local[i] = -1;
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
int ** shptrs = (int **) safemalloc( world_size * sizeof(int *) );
result = allgather(world_geometry, contexts[0], sizeof(int*), &shared, shptrs);
TEST_ASSERT(result == PAMI_SUCCESS,"allgather");
int target = (world_rank>0 ? world_rank-1 : world_size-1);
pami_endpoint_t target_ep;
result = PAMI_Endpoint_create(client, (pami_task_t) target, 1, &target_ep);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Endpoint_create");
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
int active = 1;
pami_get_simple_t parameters;
parameters.rma.dest = target_ep;
//parameters.rma.hints = ;
parameters.rma.bytes = bytes;
parameters.rma.cookie = &active;
parameters.rma.done_fn = cb_done;
parameters.addr.local = local;
parameters.addr.remote = shptrs[target];
uint64_t t0 = GetTimeBase();
result = PAMI_Get(contexts[0], ¶meters);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Rget");
while (active)
{
//result = PAMI_Context_advance( contexts[0], 100);
//TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Context_advance");
result = PAMI_Context_trylock_advancev(&(contexts[0]), 1, 1000);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Context_trylock_advancev");
}
uint64_t t1 = GetTimeBase();
uint64_t dt = t1-t0;
/* barrier on non-progressing context to make sure CHT does its job */
barrier(world_geometry, contexts[0]);
printf("%ld: PAMI_Get of %ld bytes achieves %lf MB/s \n", (long)world_rank, bytes, 1.6e9*1e-6*(double)bytes/(double)dt );
fflush(stdout);
int errors = 0;
//target = (world_rank<(world_size-1) ? world_rank+1 : 0);
target = (world_rank>0 ? world_rank-1 : world_size-1);
for (int i=0; i<n; i++)
if (local[i] != target)
errors++;
if (errors>0)
for (int i=0; i<n; i++)
if (local[i] != target)
printf("%ld: local[%d] = %d (%d) \n", (long)world_rank, i, local[i], target);
else
printf("%ld: no errors :-) \n", (long)world_rank);
fflush(stdout);
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
free(shptrs);
free(local);
free(shared);
/************************************************************************/
void * rv;
status = pthread_cancel(Progress_thread);
TEST_ASSERT(status==0, "pthread_cancel");
status = pthread_join(Progress_thread, &rv);
TEST_ASSERT(status==0, "pthread_join");
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
/* finalize the contexts */
result = PAMI_Context_destroyv( contexts, num_contexts );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Context_destroyv");
free(contexts);
/* finalize the client */
result = PAMI_Client_destroy( &client );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Client_destroy");
if (world_rank==0)
printf("%ld: end of test \n", world_rank );
fflush(stdout);
return 0;
}
int main(int argc, char* argv[])
{
pami_result_t result = PAMI_ERROR;
/* initialize the second client */
char * clientname = "";
pami_client_t client;
result = PAMI_Client_create(clientname, &client, NULL, 0);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Client_create");
/* query properties of the client */
pami_configuration_t config[4];
config[0].name = PAMI_CLIENT_NUM_TASKS;
config[1].name = PAMI_CLIENT_TASK_ID;
config[2].name = PAMI_CLIENT_NUM_CONTEXTS;
config[3].name = PAMI_CLIENT_NUM_LOCAL_TASKS;
result = PAMI_Client_query(client, config, 4);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Client_query");
const size_t world_size = config[0].value.intval;
const size_t world_rank = config[1].value.intval;
const size_t num_contexts = (config[2].value.intval > 32) ? 32 : config[2].value.intval; /* because I only need 16+16 contexts in c1 mode */
const size_t num_local_tasks = config[3].value.intval;
TEST_ASSERT(num_contexts>1,"num_contexts>1");
const int ppn = (int)num_local_tasks;
const int nnodes = world_size/ppn;
const int mycore = world_size%nnodes;
const int mynode = (world_rank-mycore)/ppn;
const int num_sync = num_contexts/2;
const int num_async = num_contexts/2;
const int async_context_begin = num_sync+1;
const int async_context_end = num_contexts;
if (world_rank==0)
{
printf("hello world from rank %ld of %ld, node %d of %d, core %d of %d \n",
world_rank, world_size, mynode, nnodes, mycore, ppn );
printf("num_contexts = %ld, async_context_begin = %d, async_context_end = %d \n",
num_contexts, async_context_begin, async_context_end);
fflush(stdout);
}
/* initialize the contexts */
contexts = (pami_context_t *) safemalloc( num_contexts * sizeof(pami_context_t) );
result = PAMI_Context_createv( client, NULL, 0, contexts, num_contexts );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Context_createv");
/* setup the world geometry */
pami_geometry_t world_geometry;
result = PAMI_Geometry_world(client, &world_geometry );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Geometry_world");
/************************************************************************/
for (int n=1; n<=(256*1024); n*=2)
{
if (world_rank==0)
{
printf("starting n = %d \n", n);
fflush(stdout);
}
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
double * sbuf = safemalloc(world_size*n*sizeof(double));
double * rbuf = safemalloc(world_size*n*sizeof(double));
for (int s=0; s<world_size; s++ )
for (int k=0; k<n; k++)
sbuf[s*n+k] = world_rank*n+k;
for (int s=0; s<world_size; s++ )
for (int k=0; k<n; k++)
rbuf[s*n+k] = -1.0;
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
size_t bytes = world_size * n * sizeof(double), bytes_out;
pami_memregion_t * local_mr = safemalloc(num_sync * sizeof(pami_memregion_t) );
pami_memregion_t * shared_mr = safemalloc(num_sync * sizeof(pami_memregion_t) );
for (int i=0; i<num_sync; i++)
{
result = PAMI_Memregion_create(contexts[i], rbuf, bytes, &bytes_out, &(local_mr[i]));
TEST_ASSERT(result == PAMI_SUCCESS && bytes==bytes_out,"PAMI_Memregion_create");
result = PAMI_Memregion_create(contexts[async_context_begin+i], sbuf, bytes, &bytes_out, &(shared_mr[i]));
TEST_ASSERT(result == PAMI_SUCCESS && bytes==bytes_out,"PAMI_Memregion_create");
}
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
pami_endpoint_t * target_eps = (pami_endpoint_t *) safemalloc( num_async * world_size * sizeof(pami_endpoint_t) );
for (int target=0; target<world_size; target++)
for (int i=0; i<num_async; i++)
{
result = PAMI_Endpoint_create(client, (pami_task_t) target, i, &(target_eps[target*num_async+i]) );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Endpoint_create");
}
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
pami_memregion_t * shmrs = (pami_memregion_t *) safemalloc( num_async * world_size * sizeof(pami_memregion_t) );
result = allgather(world_geometry, contexts[0], num_async * sizeof(pami_memregion_t), shared_mr, shmrs);
TEST_ASSERT(result == PAMI_SUCCESS,"allgather");
/* check now that count will not iterate over an incomplete iteration space */
int remote_targets_per_thread = world_size/num_sync;
assert((world_size%num_sync)==0);
if (world_rank==0)
{
printf("starting A2A \n");
fflush(stdout);
}
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
int active = world_size;
uint64_t t0 = GetTimeBase();
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
/* GCC prior to 4.7 will not permit const variables to be private i.e. firstprivate */
#ifdef _OPENMP
#pragma omp parallel default(shared) firstprivate(n, num_async, num_sync)
#endif
{
#ifdef _OPENMP
int tid = omp_get_thread_num();
#else
int tid = 0;
#endif
for (int count=0; count<remote_targets_per_thread; count++)
{
int target = remote_targets_per_thread*tid + count;
target += world_rank;
target = target % world_size;
//printf("%ld: attempting Rget to %ld \n", (long)world_rank, (long)target);
//fflush(stdout);
int local_context = tid; /* each thread uses its own context so this is thread-safe */
int remote_context = target % num_async;
pami_rget_simple_t parameters;
parameters.rma.dest = target_eps[target*num_async+remote_context];
//parameters.rma.hints = ;
parameters.rma.bytes = n*sizeof(double);
parameters.rma.cookie = &active;
parameters.rma.done_fn = cb_done;
parameters.rdma.local.mr = &local_mr[local_context];
parameters.rdma.local.offset = target*n*sizeof(double);
parameters.rdma.remote.mr = &shmrs[target*num_async+remote_context];
parameters.rdma.remote.offset = world_rank*n*sizeof(double);
result = PAMI_Rget(contexts[local_context], ¶meters);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Rget");
}
}
uint64_t t1 = GetTimeBase();
double dt1 = (t1-t0)*tic;
while (active>0)
{
result = PAMI_Context_trylock_advancev(&(contexts[0]), num_sync+num_async, 1000);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Context_trylock_advancev");
}
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
uint64_t t2 = GetTimeBase();
double dt2 = (t2-t0)*tic;
//result = barrier(world_geometry, contexts[0]);
//TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
double megabytes = 1.e-6*bytes;
printf("%ld: PAMI_Rget A2A: %ld bytes per rank, local %lf seconds (%lf MB/s), remote %lf seconds (%lf MB/s) \n",
(long)world_rank, n*sizeof(double),
dt1, megabytes/dt1,
dt2, megabytes/dt2 );
fflush(stdout);
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
for (int s=0; s<world_size; s++ )
for (int k=0; k<n; k++)
{
if (rbuf[s*n+k]!=(1.0*s*n+1.0*k))
printf("%4d: rbuf[%d] = %lf (%lf) \n", (int)world_rank, s*n+k, rbuf[s*n+k], (1.0*s*n+1.0*k) );
}
fflush(stdout);
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
for (int i=0; i<num_async; i++)
{
result = PAMI_Memregion_destroy(contexts[i], &(local_mr[i]) );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Memregion_destroy");
result = PAMI_Memregion_destroy(contexts[async_context_begin+i], &(shared_mr[i]) );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Memregion_destroy");
}
free(shared_mr);
free(local_mr);
free(target_eps);
free(shmrs);
free(rbuf);
free(sbuf);
}
/************************************************************************/
result = barrier(world_geometry, contexts[0]);
TEST_ASSERT(result == PAMI_SUCCESS,"barrier");
/* finalize the contexts */
result = PAMI_Context_destroyv( contexts, num_contexts );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Context_destroyv");
free(contexts);
/* finalize the client */
result = PAMI_Client_destroy( &client );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Client_destroy");
if (world_rank==0)
printf("%ld: end of test \n", world_rank );
fflush(stdout);
return 0;
}
int main(int argc, char* argv[])
{
pami_result_t result = PAMI_ERROR;
/* initialize the client */
pami_client_t client;
char * clientname = "";
result = PAMI_Client_create(clientname, &client, NULL, 0);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Client_create");
/* query properties of the client */
pami_configuration_t config;
size_t num_contexts;
config.name = PAMI_CLIENT_NUM_TASKS;
result = PAMI_Client_query( client, &config,1);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Client_query");
world_size = config.value.intval;
config.name = PAMI_CLIENT_TASK_ID;
result = PAMI_Client_query( client, &config,1);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Client_query");
world_rank = config.value.intval;
printf("hello world from rank %ld of %ld \n", world_rank, world_size );
fflush(stdout);
config.name = PAMI_CLIENT_NUM_CONTEXTS;
result = PAMI_Client_query( client, &config, 1);
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Client_query");
num_contexts = config.value.intval;
/* initialize the contexts */
pami_context_t * contexts;
contexts = (pami_context_t *) malloc( num_contexts * sizeof(pami_context_t) );
TEST_ASSERT(contexts!=NULL,"malloc");
result = PAMI_Context_createv( client, &config, 0, contexts, num_contexts );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Context_createv");
printf("%ld contexts were created by rank %ld \n", num_contexts, world_rank );
fflush(stdout);
/* setup the world geometry */
pami_geometry_t world_geometry;
result = PAMI_Geometry_world( client, &world_geometry );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Geometry_world");
barrier();
/****************************************************************/
int n = 1000;
char * in = (char *) malloc(n);
char * out = (char *) malloc(n);
memset(in, '\0', n);
memset(out, '\a', n);
allgather(n, in, out);
free(out);
free(in);
/****************************************************************/
barrier();
/* finalize the contexts */
result = PAMI_Context_destroyv( contexts, num_contexts );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Context_destroyv");
free(contexts);
/* finalize the client */
result = PAMI_Client_destroy( &client );
TEST_ASSERT(result == PAMI_SUCCESS,"PAMI_Client_destroy");
printf("%ld: end of test \n", world_rank );
fflush(stdout);
return 0;
}