/* spin-poll until a request is complete */
void mpi_complete(MPI_Request *handle) {
while (1) {
if (mpi_test(handle)) return;
GASNET_Safe(gasnet_AMPoll());
}
}
void
chksum_test(int iters)
{
int i;
int iamsender, iamreceiver;
int received;
#ifdef VERBOSE
int nloop = 0;
#endif
iamsender = (myproc % 2 == 0);
iamreceiver = !iamsender;
BARRIER();
if (iamsender) {
for (i = 0; i < iters; i++)
GASNET_Safe(
gasnet_AMRequestShort2((gasnet_node_t)peerproc,
201, i, _mseed[i].seed));
}
while ( (received = gasnett_atomic_read(&chksum_received,0)) < iters ) {
/*
if (iamreceiver) {
if (received % 5 == 0) {
printf("sleep 1\n");
sleep(1);
}
}
*/
#ifdef VERBOSE
nloop++;
if (nloop % 1000 == 0) {
printf("TEST[%d] nloop = %d chksum_received = %d\n",
myproc,nloop,received);
}
#endif
gasnet_AMPoll();
}
#ifdef VERBOSE
printf("TEST[%d] COMPLETE: nloop = %d chksum_received = %d\n",
myproc,nloop,received);
#endif
BARRIER();
if (iamsender) {
int success = gasnett_atomic_read(&chksum_success,0);
printf("chksum_test(%d) passed %d/%d\n", chksum_iters,
success, received);
}
}
void _XMP_gasnet_atomic_ref(int target_rank ,_XMP_coarray_t *dst_desc, size_t dst_offset, int* value,
size_t elmt_size)
{
gasnet_AMPoll();
char *dst_addr = dst_desc->addr[target_rank] + elmt_size * dst_offset;
if(target_rank == _XMP_world_rank){
gasnet_hsl_lock(&_hsl);
memcpy(value, dst_addr, elmt_size);
gasnet_hsl_unlock(&_hsl);
}
else{
_extend_atomic_queue();
_xmp_gasnet_atomic_queue[_atomic_operations] = _XMP_ATOMIC_REG;
gasnet_AMRequestShort6(target_rank, _XMP_GASNET_ATOMIC_REF_DO, elmt_size,
HIWORD(value), LOWORD(value), HIWORD(dst_addr), LOWORD(dst_addr), _atomic_operations);
_atomic_operations++;
}
}
void *doit(void *id) {
gasnett_threadkey_set(mythread,id);
if ((uintptr_t)id != 0) { /* additional threads polling, to encourage handler concurrency */
while (!done) {
gasnet_AMPoll();
gasnett_sched_yield();
}
return 0;
}
MSG0("Running %sAM%s%s%s%s correctness test %s%swith %i iterations, max_payload=%i, depth=%i...",
#if GASNET_PAR
(domultith?"multi-threaded ":"single-threaded "),
#else
"",
#endif
(amopt?(domed?" Medium":""):""),(amopt?(dolong?" Long":""):""),(amopt?(dolongasync?" LongAsync":""):""),
((doinseg^dooutseg)?(doinseg?" in-segment":" out-of-segment"):""),
(dosizesync?"":"loosely-synced "),
(doprime?"with priming ":""),
iters,max_payload,depth);
BARRIER();
if (doprime) { /* issue some initial puts that cover the Long regions, to try and trigger dynamic pinning */
int chunkidx;
for (chunkidx = 0; chunkidx < depth; chunkidx++) {
/* AMRequestLong primer */
gasnet_put(peerproc, peerreqseg+chunkidx*max_payload, privateseg+chunkidx*max_payload, max_payload);
gasnet_put(peerproc, peerreqseg+chunkidx*max_payload, localseg+chunkidx*max_payload, max_payload);
/* AMRequestLongAsync primer */
gasnet_put(peerproc, peerreqseg+(depth+chunkidx)*max_payload, privateseg+chunkidx*max_payload, max_payload);
gasnet_put(peerproc, peerreqseg+(depth+chunkidx)*max_payload, localseg+chunkidx*max_payload, max_payload);
/* AMReplyLong primer */
gasnet_put(peerproc, peerrepseg+chunkidx*max_payload, myseg+chunkidx*max_payload, max_payload);
gasnet_put(peerproc, peerrepseg+chunkidx*max_payload, longreplysrc+chunkidx*max_payload, max_payload);
/* AMReplyLongAsync primer */
gasnet_put(peerproc, peerrepseg+(depth+chunkidx)*max_payload, myseg+(depth+chunkidx)*max_payload, max_payload);
gasnet_put(peerproc, peerrepseg+(depth+chunkidx)*max_payload, alongreplysrc+chunkidx*max_payload, max_payload);
}
BARRIER();
}
{ int sz,iter,savesz = 1;
int max1 = gasnet_AMMaxMedium(), max2 = maxlong;
if (maxlong < gasnet_AMMaxMedium()) { max1 = maxlong; max2 = gasnet_AMMaxMedium(); }
assert_always(max1 <= max2);
for (sz = 1; sz <= max_payload; ) {
if (dosizesync) BARRIER(); /* optional barrier, to synchronize tests at each payload size across nodes */
MSG0("payload = %i",sz);
for (iter = 0; iter < iters; iter++) {
int chunkidx;
uint8_t *srcseg = ITERSEG(iter);
/* initialize local seg to known values */
for (chunkidx = 0; chunkidx < depth; chunkidx++) {
init_chunk(srcseg,sz,iter,chunkidx);
}
if (domed && sz <= gasnet_AMMaxMedium()) { /* test Medium AMs */
gasnett_atomic_set(&pong_recvd,0,0);
for (chunkidx = 0; chunkidx < depth; chunkidx++) {
GASNET_Safe(gasnet_AMRequestMedium2(peerproc, hidx_ping_medhandler, srcseg+chunkidx*sz, sz,
iter, chunkidx));
}
/* wait for completion */
GASNET_BLOCKUNTIL(gasnett_atomic_read(&pong_recvd,0) == depth);
}
if (sz <= maxlong) {
if (dolong) { /* test Long AMs */
gasnett_atomic_set(&pong_recvd,0,0);
for (chunkidx = 0; chunkidx < depth; chunkidx++) {
GASNET_Safe(gasnet_AMRequestLong2(peerproc, hidx_ping_longhandler, srcseg+chunkidx*sz, sz,
peerreqseg+chunkidx*sz, iter, chunkidx));
}
/* wait for completion */
GASNET_BLOCKUNTIL(gasnett_atomic_read(&pong_recvd,0) == depth);
}
if (dolongasync) { /* test AsyncLong AMs */
gasnett_atomic_set(&pong_recvd,0,0);
for (chunkidx = 0; chunkidx < depth; chunkidx++) {
GASNET_Safe(gasnet_AMRequestLongAsync2(peerproc, hidx_ping_alonghandler, srcseg+chunkidx*sz, sz,
peerreqseg+(depth+chunkidx)*sz, iter, chunkidx));
}
/* wait for completion */
GASNET_BLOCKUNTIL(gasnett_atomic_read(&pong_recvd,0) == depth);
}
}
}
/* double sz each time, but make sure to also exactly hit MaxMedium, MaxLong and max payload */
if (sz < max1 && savesz * 2 > max1) sz = max1;
else if (sz < max2 && savesz * 2 > max2) sz = max2;
else if (sz < max_payload && savesz * 2 > max_payload) sz = max_payload;
else { sz = savesz * 2; savesz = sz; }
}
}
BARRIER();
done = 1;
return(0);
}
void *thread_main(void *arg) {
thread_data_t *td = arg;
int i;
#if GASNET_PAR
if (td->local_id >= threads) {
while (!done) gasnet_AMPoll();
return NULL;
}
gasnet_image_t *imagearray = test_malloc(numprocs * sizeof(gasnet_image_t));
for (i=0; i<numprocs; ++i) { imagearray[i] = threads; }
gasnet_coll_init(imagearray, td->mythread, NULL, 0, 0);
test_free(imagearray);
#else
gasnet_coll_init(NULL, 0, NULL, 0, 0);
#endif
td->hndl = test_malloc(iters*sizeof(gasnet_coll_handle_t));
/* Run w/ root = (first, middle, last) w/o duplication */
for (i = 0; i < 3; ++i) {
int root;
if (i == 0) {
root = 0;
} else if (i == 1) {
if (images < 3) continue;
root = images / 2;
} else {
if (images < 2) continue;
root = images - 1;
}
MSG00("Running tests with root = %d", (int)root);
if (threads > 1) {
MSG00("Skipping SINGLE/single-addr tests (multiple threads)");
} else if (!TEST_ALIGNED_SEGMENTS()) {
MSG00("Skipping SINGLE/single-addr tests (unaligned segments)");
} else {
testSS_NONO(root, td);
testSS_MYMY(root, td);
testSS_ALLALL(root, td);
testSS_NB(root, td);
}
testSM_NONO(root, td);
testSM_MYMY(root, td);
testSM_ALLALL(root, td);
testSM_NB(root, td);
#if 1
testLS_NONO(root, td);
testLS_MYMY(root, td);
testLS_ALLALL(root, td);
testLS_NB(root, td);
testLM_NONO(root, td);
testLM_MYMY(root, td);
testLM_ALLALL(root, td);
testLM_NB(root, td);
#endif
}
test_free(td->hndl);
PTHREAD_LOCALBARRIER(threads);
done = 1;
return NULL;
}
static void *poll(void* arg) {
while(GRT_TRUE) {
GASNET_Safe(gasnet_AMPoll());
sched_yield();
}
}
void test_mpi(threaddata_t *tdata) {
MPI_Request sendhandle = MPI_REQUEST_NULL;
MPI_Request recvhandle = MPI_REQUEST_NULL;
int peer = tdata->tid_peer;
int node = tt_thread_map[peer];
int mpipeer = gasnetnode_to_mpirank[node];
int sz;
char *sendbuf;
char *recvbuf;
int tag = tdata->tid;
int i;
do { sz = RANDOM_SIZE(); } while (sz == 0); /* some MPI's may barf on 0 byte send/recv */
sendbuf = (char*)test_malloc(sz);
recvbuf = (char*)test_malloc(sz);
for (i=0; i < MIN(sz,4096); i++) { /* randomize at least the first 4 KB */
sendbuf[i] = (char)rand();
}
ACTION_PRINTF("tid=%3d> starting MPI ping-pong with tid=%3d.\n", tdata->tid, peer);
MPI_LOCK();
ACTION_PRINTF("tid=%3d> setting MPI_Irecv, %i bytes\n", tdata->tid, sz);
MPI_SAFE(MPI_Irecv(recvbuf, sz, MPI_BYTE, mpipeer, 10000+tag, MPI_COMM_WORLD, &recvhandle));
assert(recvhandle != MPI_REQUEST_NULL);
ACTION_PRINTF("tid=%3d> sending MPI message, %i bytes\n", tdata->tid, sz);
MPI_SAFE(MPI_Isend(sendbuf, sz, MPI_BYTE, mpipeer, tag, MPI_COMM_WORLD, &sendhandle));
assert(sendhandle != MPI_REQUEST_NULL);
MPI_UNLOCK();
tdata->flag = -1;
gasnett_local_wmb();
ACTION_PRINTF("tid=%3d> MPI AMShortRequest to tid=%3d\n", tdata->tid, peer);
GASNET_Safe(gasnet_AMRequestShort2(node, hidx_mpi_handler, tdata->tid, sz));
while (tdata->flag != 0) {
ACTION_PRINTF("tid=%3d> MPI probe AMShortRequest to tid=%3d\n", tdata->tid, peer);
GASNET_Safe(gasnet_AMRequestShort1(node, hidx_mpi_probehandler, tdata->tid));
gasnett_sched_yield();
test_sleep(tdata);
GASNET_Safe(gasnet_AMPoll());
mpi_test(&sendhandle); /* occasional testing may be required for progress */
mpi_test(&recvhandle);
}
tdata->flag = -1;
mpi_complete(&sendhandle);
mpi_complete(&recvhandle);
/* verify */
for (i=0; i < sz; i++) {
if (sendbuf[i] != recvbuf[i])
FATALERR("mismatch at element %i in MPI test.", i);
}
test_free(sendbuf);
test_free(recvbuf);
ACTION_PRINTF("tid=%3d> MPI ping-pong with tid=%3d complete.\n", tdata->tid, peer);
}
