void
test_amlong(threaddata_t *tdata)
{
int peer = RANDOM_PEER(tdata);
int node = tt_thread_map[peer];
void *laddr = tt_addr_map[tdata->tid];
void *raddr = tt_addr_map[peer];
size_t len;
do {
len = RANDOM_SIZE();
} while ((len > gasnet_AMMaxLongRequest()) || (len > gasnet_AMMaxLongReply())
|| (len > TEST_SEGZ_PER_THREAD));
tdata->flag = -1;
gasnett_local_wmb();
ACTION_PRINTF("tid=%3d> AMLongRequest (sz=%7d) to tid=%3d", tdata->tid, (int)len, peer);
GASNET_Safe(gasnet_AMRequestLong2(node,
hidx_ping_longhandler, laddr, len, raddr,
tdata->ltid, peer));
GASNET_BLOCKUNTIL(tdata->flag == 0);
tdata->flag = -1;
ACTION_PRINTF("tid=%3d> AMLongRequest to tid=%3d complete.", tdata->tid, peer);
}
void grt_init(int argc, char **argv) {
pthread_t thread;
/* Set up handler table */
if (!entry_table) {
entry_table = grt_entry_table;
table_size = GRT_TABLE_SIZE;
}
/* call startup */
GASNET_Safe(gasnet_init(&argc, &argv));
/* get SPMD info */
grt_id = gasnet_mynode();
grt_num_procs = gasnet_nodes();
gethostname(grt_proc_name, MAX_PROCESSOR_NAME);
/* Attach to network */
GASNET_Safe(gasnet_attach(entry_table, table_size,
GASNET_HEAP_SIZE, MINHEAPOFFSET));
if (grt_id == 0) {
printf("%s\n", argv[0]);
#ifdef GRT_WORD_32
printf("We are on a 32-bit machine.\n");
#else
printf("We are on a 64-bit machine.\n");
#endif
printf("gasnet_AMMaxMedium()=%lu\n", gasnet_AMMaxMedium());
printf("gasnet_AMMaxLongRequest()=%lu\n", gasnet_AMMaxLongRequest());
printf("gasnet_AMMaxLongReply()=%lu\n", gasnet_AMMaxLongReply());
}
fflush(stdout);
BARRIER();
fflush(stdout);
BARRIER();
/* Get segment info */
grt_seginfo = (gasnet_seginfo_t*) malloc(sizeof(gasnet_seginfo_t) *
grt_num_procs);
GASNET_Safe(gasnet_getSegmentInfo(grt_seginfo, grt_num_procs));
/* Initialize the heap for memory allocation */
grt_heap_base = grt_addr(grt_id, 0);
grt_heap = umalloc_makeheap(grt_heap_base,
grt_heap_size, UMALLOC_HEAP_GROWS_UP);
/* Spawn off a thread to handle remote handler requests */
pthread_create(&thread, NULL, poll, NULL);
/* Set up thread list */
linkedlist_init(&thread_list, 0, 0);
BARRIER();
}
gasnet_handle_t gasnete_amref_put_nb_inner(gasnet_node_t node, void *dest, void *src, size_t nbytes, int isbulk GASNETE_THREAD_FARG) {
if (nbytes <= GASNETE_GETPUT_MEDIUM_LONG_THRESHOLD) {
gasnete_eop_t *op = gasnete_eop_new(GASNETE_MYTHREAD);
GASNETI_SAFE(
MEDIUM_REQ(2,4,(node, gasneti_handleridx(gasnete_amref_put_reqh),
src, nbytes,
PACK(dest), PACK_EOP_DONE(op))));
return (gasnet_handle_t)op;
} else if (nbytes <= gasnet_AMMaxLongRequest()) {
gasnete_eop_t *op = gasnete_eop_new(GASNETE_MYTHREAD);
if (isbulk) {
GASNETI_SAFE(
LONGASYNC_REQ(1,2,(node, gasneti_handleridx(gasnete_amref_putlong_reqh),
src, nbytes, dest,
PACK_EOP_DONE(op))));
} else {
GASNETI_SAFE(
LONG_REQ(1,2,(node, gasneti_handleridx(gasnete_amref_putlong_reqh),
src, nbytes, dest,
PACK_EOP_DONE(op))));
}
return (gasnet_handle_t)op;
} else {
/* TODO: don't need the iop for large xfers in the GASNETE_EOP_COUNTED case */
/* need many messages - use an access region to coalesce them into a single handle */
/* (note this relies on the fact that our implementation of access regions allows recursion) */
gasnete_begin_nbi_accessregion(1 /* enable recursion */ GASNETE_THREAD_PASS);
#if GASNETE_BUILD_AMREF_PUT_BULK && GASNETE_BUILD_AMREF_PUT
if (isbulk) gasnete_amref_put_nbi_bulk(node, dest, src, nbytes GASNETE_THREAD_PASS);
else gasnete_amref_put_nbi (node, dest, src, nbytes GASNETE_THREAD_PASS);
#elif GASNETE_BUILD_AMREF_PUT_BULK
gasnete_amref_put_nbi_bulk(node, dest, src, nbytes GASNETE_THREAD_PASS);
#else
gasnete_amref_put_nbi (node, dest, src, nbytes GASNETE_THREAD_PASS);
#endif
return gasnete_end_nbi_accessregion(GASNETE_THREAD_PASS_ALONE);
}
}
gasnet_handle_t gasnete_extref_put_nb_inner(gasnet_node_t node, void *dest, void *src, size_t nbytes, int isbulk GASNETE_THREAD_FARG) {
if (nbytes <= GASNETE_GETPUT_MEDIUM_LONG_THRESHOLD) {
gasnete_eop_t *op = gasnete_eop_new(GASNETE_MYTHREAD);
GASNETI_SAFE(
MEDIUM_REQ(2,4,(node, gasneti_handleridx(gasnete_extref_put_reqh),
src, nbytes,
PACK(dest), PACK(op))));
return (gasnet_handle_t)op;
} else if (nbytes <= gasnet_AMMaxLongRequest()) {
gasnete_eop_t *op = gasnete_eop_new(GASNETE_MYTHREAD);
if (isbulk) {
GASNETI_SAFE(
LONGASYNC_REQ(1,2,(node, gasneti_handleridx(gasnete_extref_putlong_reqh),
src, nbytes, dest,
PACK(op))));
} else {
GASNETI_SAFE(
LONG_REQ(1,2,(node, gasneti_handleridx(gasnete_extref_putlong_reqh),
src, nbytes, dest,
PACK(op))));
}
return (gasnet_handle_t)op;
} else {
/* need many messages - use an access region to coalesce them into a single handle */
/* (note this relies on the fact that our implementation of access regions allows recursion) */
gasnete_begin_nbi_accessregion(1 /* enable recursion */ GASNETE_THREAD_PASS);
#if 0 /* No AM-based Bulk Puts in gm-conduit */
if (isbulk) gasnete_extref_put_nbi_bulk(node, dest, src, nbytes GASNETE_THREAD_PASS);
else gasnete_extref_put_nbi (node, dest, src, nbytes GASNETE_THREAD_PASS);
#else
gasneti_assert(!isbulk);
gasnete_extref_put_nbi (node, dest, src, nbytes GASNETE_THREAD_PASS);
#endif
return gasnete_end_nbi_accessregion(GASNETE_THREAD_PASS_ALONE);
}
}
void
ping_longhandler(gasnet_token_t token, void *buf, size_t nbytes, harg_t idx, harg_t target_id)
{
int tid;
void *paddr;
gasnet_node_t node;
gasnet_AMGetMsgSource(token, &node);
tid = node * threads_num + idx;
paddr = tt_addr_map[tid];
PRINT_AM(("node=%2d> AMLong Request for (%d,%d)",
(int)gasnet_mynode(), (int)node, (int)idx));
assert(idx >= 0 && idx < threads_num);
assert(node < gasnet_nodes());
assert(nbytes <= gasnet_AMMaxLongRequest());
assert(buf == tt_addr_map[target_id]);
assert((uintptr_t)buf + nbytes <= (uintptr_t)TEST_SEG(gasnet_mynode()) + TEST_SEGSZ);
GASNET_Safe(
gasnet_AMReplyLong1(token, hidx_pong_longhandler,
buf, nbytes, paddr, idx));
}
int main(int argc, char **argv) {
int help=0;
int arg=1;
gasnet_handlerentry_t htable[] = {
{ hidx_ping_shorthandler, ping_shorthandler },
{ hidx_pong_shorthandler, pong_shorthandler },
{ hidx_ping_medhandler, ping_medhandler },
{ hidx_pong_medhandler, pong_medhandler },
{ hidx_ping_longhandler, ping_longhandler },
{ hidx_pong_longhandler, pong_longhandler },
{ hidx_ping_shorthandler_flood, ping_shorthandler_flood },
{ hidx_pong_shorthandler_flood, pong_shorthandler_flood },
{ hidx_ping_medhandler_flood, ping_medhandler_flood },
{ hidx_pong_medhandler_flood, pong_medhandler_flood },
{ hidx_ping_longhandler_flood, ping_longhandler_flood },
{ hidx_pong_longhandler_flood, pong_longhandler_flood },
{ hidx_done_shorthandler, done_shorthandler }
};
GASNET_Safe(gasnet_init(&argc, &argv));
mynode = gasnet_mynode();
numnode = gasnet_nodes();
arg = 1;
while (argc > arg) {
if (!strcmp(argv[arg], "-p")) {
#if GASNET_PAR
pollers = test_thread_limit(atoi(argv[arg+1])+1)-1;
arg += 2;
#else
if (0 == mynode) {
fprintf(stderr, "testam %s\n", GASNET_CONFIG_STRING);
fprintf(stderr, "ERROR: The -p option is only available in the PAR configuration.\n");
fflush(NULL);
}
sleep(1);
gasnet_exit(1);
#endif
} else if (!strcmp(argv[arg], "-in")) {
insegment = 1;
++arg;
} else if (!strcmp(argv[arg], "-out")) {
insegment = 0;
++arg;
} else if (!strcmp(argv[arg], "-c")) {
crossmachinemode = 1;
++arg;
} else if (!strcmp(argv[arg], "-src-noop")) {
src_mode = SRC_NOOP;
++arg;
} else if (!strcmp(argv[arg], "-src-generate")) {
src_mode = SRC_GENERATE;
++arg;
} else if (!strcmp(argv[arg], "-src-memcpy")) {
src_mode = SRC_MEMCPY;
++arg;
} else if (argv[arg][0] == '-') {
help = 1;
++arg;
} else break;
}
if (argc > arg) { iters = atoi(argv[arg]); ++arg; }
if (!iters) iters = 1000;
if (argc > arg) { maxsz = atoi(argv[arg]); ++arg; }
if (!maxsz) maxsz = 2*1024*1024;
if (argc > arg) { TEST_SECTION_PARSE(argv[arg]); ++arg; }
GASNET_Safe(gasnet_attach(htable, sizeof(htable)/sizeof(gasnet_handlerentry_t),
TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET));
#if GASNET_PAR
#define PAR_USAGE \
" The -p option gives the number of polling threads, specified as\n" \
" a non-negative integer argument (default is no polling threads).\n"
#else
#define PAR_USAGE ""
#endif
test_init("testam", 1, "[options] (iters) (maxsz) (test_sections)\n"
" The '-in' or '-out' option selects whether the requestor's\n"
" buffer is in the GASNet segment or not (default is 'in').\n"
PAR_USAGE
" The '-src-*' options select treatment of the payload buffer used for\n"
" Medium and Long AMs, as follows:\n"
" -src-noop: no per-operation initialization (default)\n"
" -src-generate: initialized (w/o memory reads) on each AM injection\n"
" -src-memcpy: initialized using memcpy() on each AM injection\n"
" The -c option enables cross-machine pairing (default is nearest neighbor).\n");
if (help || argc > arg) test_usage();
TEST_PRINT_CONDUITINFO();
if (insegment) {
myseg = TEST_MYSEG();
} else {
char *space = test_malloc(alignup(maxsz,PAGESZ) + PAGESZ);
myseg = alignup_ptr(space, PAGESZ);
}
maxmed = MIN(maxsz, gasnet_AMMaxMedium());
maxlongreq = MIN(maxsz, gasnet_AMMaxLongRequest());
maxlongrep = MIN(maxsz, gasnet_AMMaxLongReply());
if (src_mode == SRC_MEMCPY) {
zero_buffer = test_calloc(maxsz, 1);
}
if (crossmachinemode) {
if ((numnode%2) && (mynode == numnode-1)) {
sender = 1;
peer = mynode;
} else {
gasnet_node_t half = numnode / 2;
sender = (mynode < half);
peer = sender ? (mynode + half) : (mynode - half);
}
} else {
peer = mynode ^ 1;
sender = mynode % 2 == 0;
if (peer == numnode) {
peer = mynode;
}
}
recvr = !sender || (peer == mynode);
// Long Request and Reply (distinct for loopback)
reply_addr = TEST_SEG(peer);
request_addr = (peer == mynode) ? (void*)((uintptr_t)reply_addr + alignup(maxsz,SIZEOF_GASNET_REGISTER_VALUE_T))
: reply_addr;
BARRIER();
#if GASNET_PAR
#define PAR_FMT " %i extra recvr polling threads\n"
#define PAR_ARG ,pollers
#else
#define PAR_FMT /*empty*/
#define PAR_ARG /*empty*/
#endif
if (mynode == 0) {
printf("Running %i iterations of %s AM performance with:\n"
" local addresses %sside the segment%s\n"
" %s\n"
PAR_FMT
" ...\n",
iters,
(crossmachinemode ? "cross-machine ": ""),
(insegment ? "in" : "out"),
(insegment ? " (default)" : ""),
((src_mode == SRC_NOOP) ? "no payload initialization (default)"
:(src_mode == SRC_GENERATE) ? "payload initialized by computation"
: "payload initialized using memcpy()")
PAR_ARG
);
printf(" Msg Sz Description Total time Avg. time Bandwidth\n"
" ------ ----------- ---------- --------- ---------\n");
fflush(stdout);
}
#if GASNET_PAR
TEST_SET_WAITMODE(pollers+1);
if (pollers)
test_createandjoin_pthreads(pollers+1,doAll,NULL,0);
else
#endif
doAll(NULL);
MSG("done.");
gasnet_exit(0);
return 0;
}
int main(int argc, char **argv) {
int arg = 1, help = 0;
gasnet_handlerentry_t htable[] = {
{ hidx_ping_medhandler, ping_medhandler },
{ hidx_pong_medhandler, pong_medhandler },
{ hidx_ping_longhandler, ping_longhandler },
{ hidx_pong_longhandler, pong_longhandler },
{ hidx_ping_alonghandler, ping_alonghandler },
};
/* call startup */
GASNET_Safe(gasnet_init(&argc, &argv));
#define AMOPT() if (!amopt) { amopt = 1; domed = 0; dolong = 0; dolongasync = 0; }
while (argc > arg) {
if (!strcmp(argv[arg], "-p")) {
doprime = 1;
++arg;
} else if (!strcmp(argv[arg], "-u")) {
dosizesync = 0;
++arg;
} else if (!strcmp(argv[arg], "-s")) {
domultith = 0;
++arg;
} else if (!strcmp(argv[arg], "-n")) {
allowretry = 0;
++arg;
} else if (!strcmp(argv[arg], "-in")) {
doinseg = 1; dooutseg = 0;
++arg;
} else if (!strcmp(argv[arg], "-out")) {
doinseg = 0; dooutseg = 1;
++arg;
} else if (!strcmp(argv[arg], "-m")) {
AMOPT();
domed = 1;
++arg;
} else if (!strcmp(argv[arg], "-l")) {
AMOPT();
dolong = 1;
++arg;
} else if (!strcmp(argv[arg], "-a")) {
AMOPT();
dolongasync = 1;
++arg;
} else if (argv[arg][0] == '-') {
help = 1;
++arg;
} else break;
}
if (argc > arg) { iters = atoi(argv[arg]); arg++; }
if (!iters) iters = 10;
if (argc > arg) { max_payload = atoi(argv[arg]); arg++; }
if (!max_payload) max_payload = 1024*1024;
if (argc > arg) { depth = atoi(argv[arg]); arg++; }
if (!depth) depth = 16;
/* round down to largest payload AM allows */
maxlong = MIN(gasnet_AMMaxLongRequest(),gasnet_AMMaxLongReply());
max_payload = MIN(max_payload,MAX(gasnet_AMMaxMedium(),maxlong));
GASNET_Safe(gasnet_attach(htable, sizeof(htable)/sizeof(gasnet_handlerentry_t), TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET));
test_init("testcore2",0,"[options] (iters) (max_payload) (depth)\n"
" -m test AMMedium (defaults to all types)\n"
" -l test AMLong (defaults to all types)\n"
" -a test AMLongAsync (defaults to all types)\n"
" -p prime the AMLong transfer areas with puts, to encourage pinning\n"
" -u loosen sychronization to allow diff payload sizes to be in flight at once\n"
" -s single-threaded PAR mode (default is to start a polling thread in PAR mode)\n"
" -n no retry on failure\n"
" -in/-out use only in- or out-of-segment sources for AMLong(Async) (default is both)\n"
);
if (help || argc > arg) test_usage();
TEST_PRINT_CONDUITINFO();
/* get SPMD info */
myproc = gasnet_mynode();
numprocs = gasnet_nodes();
peerproc = myproc ^ 1;
if (peerproc == gasnet_nodes()) {
/* w/ odd # of nodes, last one talks to self */
peerproc = myproc;
}
myseg = TEST_MYSEG();
peerreqseg = TEST_SEG(peerproc);
peerrepseg = peerreqseg+max_payload*depth*2;
localseg = myseg + max_payload*depth*4;
assert_always(TEST_SEGSZ >= max_payload*depth*5);
privateseg = test_malloc(max_payload*depth*3); /* out-of-seg request src, long reply src, along reply src */
longreplysrc = privateseg+max_payload*depth;
alongreplysrc = privateseg+max_payload*depth*2;
#ifdef GASNET_PAR
if (domultith) test_createandjoin_pthreads(2,doit,NULL,0);
else
#endif
doit(0);
BARRIER();
test_free(privateseg);
MSG("done. (detected %i errs)", test_errs);
gasnet_exit(test_errs > 0 ? 1 : 0);
return 0;
}
void gasnete_amref_put_nbi_inner(gasnet_node_t node, void *dest, void *src, size_t nbytes, int isbulk GASNETE_THREAD_FARG) {
gasnete_threaddata_t * const mythread = GASNETE_MYTHREAD;
gasnete_iop_t * const op = mythread->current_iop;
if (nbytes <= GASNETE_GETPUT_MEDIUM_LONG_THRESHOLD) {
op->initiated_put_cnt++;
GASNETI_SAFE(
MEDIUM_REQ(2,4,(node, gasneti_handleridx(gasnete_amref_put_reqh),
src, nbytes,
PACK(dest), PACK_IOP_DONE(op,put))));
return;
} else if (nbytes <= gasnet_AMMaxLongRequest()) {
op->initiated_put_cnt++;
if (isbulk) {
GASNETI_SAFE(
LONGASYNC_REQ(1,2,(node, gasneti_handleridx(gasnete_amref_putlong_reqh),
src, nbytes, dest,
PACK_IOP_DONE(op,put))));
} else {
GASNETI_SAFE(
LONG_REQ(1,2,(node, gasneti_handleridx(gasnete_amref_putlong_reqh),
src, nbytes, dest,
PACK_IOP_DONE(op,put))));
}
return;
} else {
int chunksz = gasnet_AMMaxLongRequest();
uint8_t *psrc = src;
uint8_t *pdest = dest;
for (;;) {
op->initiated_put_cnt++;
if (nbytes > chunksz) {
if (isbulk) {
GASNETI_SAFE(
LONGASYNC_REQ(1,2,(node, gasneti_handleridx(gasnete_amref_putlong_reqh),
psrc, chunksz, pdest,
PACK_IOP_DONE(op,put))));
} else {
GASNETI_SAFE(
LONG_REQ(1,2,(node, gasneti_handleridx(gasnete_amref_putlong_reqh),
psrc, chunksz, pdest,
PACK_IOP_DONE(op,put))));
}
nbytes -= chunksz;
psrc += chunksz;
pdest += chunksz;
} else {
if (isbulk) {
GASNETI_SAFE(
LONGASYNC_REQ(1,2,(node, gasneti_handleridx(gasnete_amref_putlong_reqh),
psrc, nbytes, pdest,
PACK_IOP_DONE(op,put))));
} else {
GASNETI_SAFE(
LONG_REQ(1,2,(node, gasneti_handleridx(gasnete_amref_putlong_reqh),
psrc, nbytes, pdest,
PACK_IOP_DONE(op,put))));
}
break;
}
}
return;
}
}
int
main(int argc, char **argv)
{
int i;
const char *getopt_str;
int opt_p=0, opt_g=0, opt_a=0, opt_m=0;
#if TEST_MPI
init_test_mpi(&argc, &argv);
getopt_str = "pgamlvtdi:";
#else
getopt_str = "pgalvtdi:";
#endif
GASNET_Safe(gasnet_init(&argc, &argv));
GASNET_Safe(gasnet_attach(htable, HANDLER_TABLE_SIZE,
TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET));
#if TEST_MPI
#define TEST_MPI_USAGE " -m use MPI calls \n"
#else
#define TEST_MPI_USAGE ""
#endif
#if GASNET_PAR
#define TEST_THREAD_USAGE " [<threads_per_node>]\n\n" \
"<threads_per_node> must be between 1 and "_STRINGIFY(TEST_MAXTHREADS)" \n"
#else
#define TEST_THREAD_USAGE "\n\n"
#endif
test_init("testthreads",0, "[ -pgalvtd ] [ -i <iters> ]"
TEST_THREAD_USAGE
"no options means run all tests with "_STRINGIFY(DEFAULT_ITERS)" iterations\n"
"options: \n"
" -p use puts \n"
" -g use gets \n"
" -a use Active Messages \n"
" -l use local Active Messages \n"
TEST_MPI_USAGE
" -v output information about actions taken \n"
" -t include AM handler actions with -v \n"
" -d dynamic thread creation stress test \n"
" -i <iters> use <iters> iterations per thread \n");
while ((i = getopt (argc, argv, getopt_str)) != EOF) {
switch (i) {
case 'p': opt_p = 1; break;
case 'g': opt_g = 1; break;
case 'a': opt_a = 1; break;
case 'm': opt_m = 1; break;
case 'l': AM_loopback = 1; break;
case 'i': iters = atoi(optarg); break;
case 'v': verbose = 1; break;
case 't': amtrace = 1; break;
case 'd': threadstress = 1; break;
default: test_usage();
}
}
if (opt_p) test_functions[functions_num++] = test_put;
if (opt_g) test_functions[functions_num++] = test_get;
if (opt_a) {
test_functions[functions_num++] = test_amshort;
test_functions[functions_num++] = test_ammedium;
test_functions[functions_num++] = test_amlong;
}
#if TEST_MPI
if (opt_m) test_functions[functions_num++] = test_mpi;
#endif
if (amtrace) verbose = 1;
/* Assume all test functions if no option is passed */
if (functions_num == 0) {
MSG("running all functions!");
memcpy(test_functions, test_functions_all,
sizeof(test_functions_all));
functions_num = NUM_FUNCTIONS;
}
argc -= optind;
if (argc > 1) test_usage();
else if (argc == 1) {
argv += optind;
threads_num = atoi(argv[0]);
}
if (threads_num > TEST_MAXTHREADS || threads_num < 1) {
printf("ERROR: Threads must be between 1 and %i\n",TEST_MAXTHREADS);
exit(EXIT_FAILURE);
}
/* limit sizes to a reasonable size */
#define LIMIT(sz) MIN(sz,4194304)
{ int sz = 0;
sizes[sz++] = LIMIT(gasnet_AMMaxMedium()-1);
sizes[sz++] = LIMIT(gasnet_AMMaxMedium());
sizes[sz++] = LIMIT(gasnet_AMMaxMedium()+1);
sizes[sz++] = LIMIT(gasnet_AMMaxLongRequest()-1);
sizes[sz++] = LIMIT(gasnet_AMMaxLongRequest());
sizes[sz++] = LIMIT(gasnet_AMMaxLongRequest()+1);
sizes[sz++] = LIMIT(gasnet_AMMaxLongReply()-1);
sizes[sz++] = LIMIT(gasnet_AMMaxLongReply());
sizes[sz++] = LIMIT(gasnet_AMMaxLongReply()+1);
assert(sizes[sz] == 0);
}
alloc_thread_data(threads_num);
#if TEST_MPI
attach_test_mpi();
#endif
#ifdef GASNET_PAR
if (threadstress) {
int spawniters = MAX(1,iters/threads_num);
int i;
MSG("Dynamic thread creation stress test, %d gasnet threads, (%d at a time)", spawniters*threads_num, threads_num);
iters = 10; /* enough iters to ensure we get thread registration */
for (i = 0; i < spawniters; i++) {
test_createandjoin_pthreads(threads_num, &threadmain, tt_thread_data, sizeof(threaddata_t));
TEST_PROGRESS_BAR(i, spawniters);
}
} else {
MSG("Forking %d gasnet threads and running %d iterations", threads_num, iters);
test_createandjoin_pthreads(threads_num, &threadmain, tt_thread_data, sizeof(threaddata_t));
}
#else /* for testmpi-seq and -parsync */
#ifdef GASNET_SEQ
MSG("Running with 1 thread/node for GASNET_SEQ mode");
#else
MSG("Running with 1 thread/node for GASNET_PARSYNC mode");
#endif
threadmain(tt_thread_data);
#endif
BARRIER();
free_thread_data();
MSG("Tests complete");
BARRIER();
gasnet_exit(0);
return 0;
}
int main(int argc, char **argv) {
int help=0;
int arg=1;
gasnet_handlerentry_t htable[] = {
{ hidx_ping_shorthandler, ping_shorthandler },
{ hidx_pong_shorthandler, pong_shorthandler },
{ hidx_ping_medhandler, ping_medhandler },
{ hidx_pong_medhandler, pong_medhandler },
{ hidx_ping_longhandler, ping_longhandler },
{ hidx_pong_longhandler, pong_longhandler },
{ hidx_ping_shorthandler_flood, ping_shorthandler_flood },
{ hidx_pong_shorthandler_flood, pong_shorthandler_flood },
{ hidx_ping_medhandler_flood, ping_medhandler_flood },
{ hidx_pong_medhandler_flood, pong_medhandler_flood },
{ hidx_ping_longhandler_flood, ping_longhandler_flood },
{ hidx_pong_longhandler_flood, pong_longhandler_flood },
{ hidx_done_shorthandler, done_shorthandler }
};
GASNET_Safe(gasnet_init(&argc, &argv));
mynode = gasnet_mynode();
numnode = gasnet_nodes();
arg = 1;
while (argc > arg) {
if (!strcmp(argv[arg], "-p")) {
#if GASNET_PAR
pollers = atoi(argv[arg+1]);
arg += 2;
#else
if (0 == mynode) {
fprintf(stderr, "testam %s\n", GASNET_CONFIG_STRING);
fprintf(stderr, "ERROR: The -p option is only available in the PAR configuration.\n");
fflush(NULL);
}
sleep(1);
gasnet_exit(1);
#endif
} else if (!strcmp(argv[arg], "-in")) {
insegment = 1;
++arg;
} else if (!strcmp(argv[arg], "-out")) {
insegment = 0;
++arg;
} else if (!strcmp(argv[arg], "-c")) {
crossmachinemode = 1;
++arg;
} else if (argv[arg][0] == '-') {
help = 1;
++arg;
} else break;
}
if (argc > arg) { iters = atoi(argv[arg]); ++arg; }
if (!iters) iters = 1000;
if (argc > arg) { maxsz = atoi(argv[arg]); ++arg; }
if (!maxsz) maxsz = 2*1024*1024;
if (argc > arg) { TEST_SECTION_PARSE(argv[arg]); ++arg; }
GASNET_Safe(gasnet_attach(htable, sizeof(htable)/sizeof(gasnet_handlerentry_t),
TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET));
#if GASNET_PAR
test_init("testam", 1, "[options] (iters) (maxsz) (test_sections)\n"
" The '-in' or '-out' option selects whether the requestor's\n"
" buffer is in the GASNet segment or not (default is 'in').\n"
" The -p option gives the number of polling threads, specified as\n"
" a non-negative integer argument (default is no polling threads).\n"
" The -c option enables cross-machine pairing (default is nearest neighbor).\n");
#else
test_init("testam", 1, "[options] (iters) (maxsz) (test_sections)\n"
" The '-in' or '-out' option selects whether the requestor's\n"
" buffer is in the GASNet segment or not (default is 'in').\n"
" The -c option enables cross-machine pairing (default is nearest neighbor).\n");
#endif
if (help || argc > arg) test_usage();
TEST_PRINT_CONDUITINFO();
if (insegment) {
myseg = TEST_MYSEG();
} else {
char *space = test_malloc(alignup(maxsz,PAGESZ) + PAGESZ);
myseg = alignup_ptr(space, PAGESZ);
}
maxmed = MIN(maxsz, gasnet_AMMaxMedium());
maxlongreq = MIN(maxsz, gasnet_AMMaxLongRequest());
maxlongrep = MIN(maxsz, gasnet_AMMaxLongReply());
if (crossmachinemode) {
if ((numnode%2) && (mynode == numnode-1)) {
sender = 1;
peer = mynode;
} else {
gasnet_node_t half = numnode / 2;
sender = (mynode < half);
peer = sender ? (mynode + half) : (mynode - half);
}
} else {
peer = mynode ^ 1;
sender = mynode % 2 == 0;
if (peer == numnode) {
peer = mynode;
}
}
recvr = !sender || (peer == mynode);
peerseg = TEST_SEG(peer);
BARRIER();
if (mynode == 0) {
printf("Running %sAM performance test with %i iterations"
#if GASNET_PAR
" and %i extra recvr polling threads"
#endif
"...\n",
(crossmachinemode ? "cross-machine ": ""),
iters
#if GASNET_PAR
,pollers
#endif
);
printf(" Msg Sz Description Total time Avg. time Bandwidth\n"
" ------ ----------- ---------- --------- ---------\n");
fflush(stdout);
}
#if GASNET_PAR
if (pollers)
test_createandjoin_pthreads(pollers+1,doAll,NULL,0);
else
#endif
doAll(NULL);
MSG("done.");
gasnet_exit(0);
return 0;
}
