void bulk_test(int iters) {GASNET_BEGIN_FUNCTION();
int i;
int64_t begin, end;
stat_struct_t stput;
int payload;
for (payload = min_payload; payload <= max_payload && payload > 0; payload *= 2) {
init_stat(&stput, payload);
BARRIER();
if (iamsender) {
/* measure the throughput of sending a message */
begin = TIME();
for (i = 0; i < iters; i++) {
gasnet_memset(peerproc, tgtmem, 0xaa, payload);
}
end = TIME();
update_stat(&stput, (end - begin), iters);
}
BARRIER();
if (iamsender) {
print_stat(myproc, &stput, "memset throughput", PRINT_THROUGHPUT);
}
}
}
void bulk_test_nb(int iters) {GASNET_BEGIN_FUNCTION();
int i;
int64_t begin, end;
stat_struct_t stput;
gasnet_handle_t *handles;
int payload;
handles = (gasnet_handle_t *) test_malloc(sizeof(gasnet_handle_t) * iters);
for (payload = min_payload; payload <= max_payload && payload > 0; payload *= 2) {
init_stat(&stput, payload);
BARRIER();
if (iamsender) {
/* measure the throughput of sending a message */
begin = TIME();
for (i = 0; i < iters; i++) {
handles[i] = gasnet_memset_nb(peerproc, tgtmem, 0x5a, payload);
}
gasnet_wait_syncnb_all(handles, iters);
end = TIME();
update_stat(&stput, (end - begin), iters);
}
BARRIER();
if (iamsender) {
print_stat(myproc, &stput, "memset_nb throughput", PRINT_THROUGHPUT);
}
}
test_free(handles);
}
void oneway_nb_test(int iters, int nbytes, int alignment)
{GASNET_BEGIN_FUNCTION();
int i;
int64_t begin, end;
stat_struct_t st;
gasnet_handle_t *handles;
int pad = (alignment % PAGESZ);
/* initialize statistics */
init_stat(&st, nbytes, alignment);
handles = (gasnet_handle_t*) test_malloc(sizeof(gasnet_handle_t) * iters);
memset(locbuf+pad, 1, nbytes);
BARRIER();
if (iamsender) {
/* measure the throughput of sending a message */
begin = TIME();
for (i = 0; i < iters; i++) {
handles[i] = gasnet_put_nb_bulk(peerproc, rembuf, locbuf+pad, nbytes);
}
gasnet_wait_syncnb_all(handles, iters);
end = TIME();
update_stat(&st, (end - begin), iters);
}
BARRIER();
if (iamsender) {
print_stat(myproc, &st, "put_nb_bulk throughput", PRINT_THROUGHPUT);
}
/* initialize statistics */
init_stat(&st, nbytes, alignment);
if (iamsender) {
/* measure the throughput of receiving a message */
begin = TIME();
for (i = 0; i < iters; i++) {
handles[i] = gasnet_get_nb_bulk(locbuf, peerproc, rembuf+pad, nbytes);
}
gasnet_wait_syncnb_all(handles, iters);
end = TIME();
update_stat(&st, (end - begin), iters);
}
BARRIER();
if (iamsender) {
print_stat(myproc, &st, "get_nb_bulk throughput", PRINT_THROUGHPUT);
}
test_free(handles);
}
/* ------------------------------------------------------------------------------------ */
void doit1(void) {
GASNET_BEGIN_FUNCTION();
{
int i;
for (i=0; i<8; i++) handles[i] = GASNET_INVALID_HANDLE;
}
TEST_SECTION_BEGIN();
TIME_OPERATION("Tester overhead", {});
TIME_OPERATION("gasnett_ticks_now()",
{ timertemp = gasnett_ticks_now(); });
void oneway_nbi_test(int iters, int nbytes, int alignment)
{GASNET_BEGIN_FUNCTION();
int i;
int64_t begin, end;
stat_struct_t st;
int pad = (alignment % PAGESZ);
/* initialize statistics */
init_stat(&st, nbytes, alignment);
memset(locbuf+pad, 1, nbytes);
BARRIER();
if (iamsender) {
/* measure the throughput of nonblocking implicit bulk put */
begin = TIME();
for (i = 0; i < iters; i++) {
gasnet_put_nbi_bulk(peerproc, rembuf, locbuf+pad, nbytes);
}
gasnet_wait_syncnbi_puts();
end = TIME();
update_stat(&st, (end - begin), iters);
}
BARRIER();
if (iamsender) {
print_stat(myproc, &st, "put_nbi_bulk throughput", PRINT_THROUGHPUT);
}
/* initialize statistics */
init_stat(&st, nbytes, alignment);
if (iamsender) {
/* measure the throughput of nonblocking implicit bulk get */
begin = TIME();
for (i = 0; i < iters; i++) {
gasnet_get_nbi_bulk(locbuf, peerproc, rembuf+pad, nbytes);
}
gasnet_wait_syncnbi_gets();
end = TIME();
update_stat(&st, (end - begin), iters);
}
BARRIER();
if (iamsender) {
print_stat(myproc, &st, "get_nbi_bulk throughput", PRINT_THROUGHPUT);
}
}
/* ------------------------------------------------------------------------------------ */
void doAMLongAsync(void) {
GASNET_BEGIN_FUNCTION();
TESTAM_PERF("AMLongAsync", RequestLongAsync0, hidx_ping_longhandler, hidx_pong_longhandler, maxlongreq, maxlongrep, 1, LONGDEST);
}
/* ------------------------------------------------------------------------------------ */
void doAMMed(void) {
GASNET_BEGIN_FUNCTION();
TESTAM_PERF("AMMedium ", RequestMedium0, hidx_ping_medhandler, hidx_pong_medhandler, maxmed, maxmed, 0, MEDDEST);
}
/* ------------------------------------------------------------------------------------ */
void doAMShort(void) {
GASNET_BEGIN_FUNCTION();
if (sender) { /* warm-up */
flag = 0;
for (i=0; i < iters; i++) {
GASNET_Safe(gasnet_AMRequestShort0(peer, hidx_ping_shorthandler_flood));
}
GASNET_BLOCKUNTIL(flag == iters);
GASNET_Safe(gasnet_AMRequestShort0(peer, hidx_ping_shorthandler));
GASNET_BLOCKUNTIL(flag == iters+1);
}
BARRIER();
/* ------------------------------------------------------------------------------------ */
if (TEST_SECTION_BEGIN_ENABLED() && sender) {
int64_t start = TIME();
flag = -1;
for (i=0; i < iters; i++) {
GASNET_Safe(gasnet_AMRequestShort0(peer, hidx_ping_shorthandler));
GASNET_BLOCKUNTIL(flag == i);
}
report(" AMShort ping-pong roundtrip ReqRep",TIME() - start, iters, 0, 1);
}
BARRIER();
/* ------------------------------------------------------------------------------------ */
if (TEST_SECTION_ENABLED()) {
int64_t start = TIME();
flag = -1;
BARRIER();
if (sender && recvr) {
assert(peer == mynode);
for (i=0; i < iters; i++) {
int lim = i << 1;
GASNET_Safe(gasnet_AMRequestShort0(peer, hidx_pong_shorthandler));
GASNET_BLOCKUNTIL(flag == lim);
lim++;
GASNET_Safe(gasnet_AMRequestShort0(peer, hidx_pong_shorthandler));
GASNET_BLOCKUNTIL(flag == lim);
}
} else if (sender) {
for (i=0; i < iters; i++) {
GASNET_Safe(gasnet_AMRequestShort0(peer, hidx_pong_shorthandler));
GASNET_BLOCKUNTIL(flag == i);
}
} else if (recvr) {
for (i=0; i < iters; i++) {
GASNET_BLOCKUNTIL(flag == i);
GASNET_Safe(gasnet_AMRequestShort0(peer, hidx_pong_shorthandler));
}
}
report(" AMShort ping-pong roundtrip ReqReq",TIME() - start, iters, 0, 1);
if (mynode == 0) { printf("\n"); fflush(stdout); }
}
BARRIER();
/* ------------------------------------------------------------------------------------ */
if (TEST_SECTION_ENABLED()) {
if (sender) {
int64_t start = TIME();
flag = 0;
BARRIER();
for (i=0; i < iters; i++) {
GASNET_Safe(gasnet_AMRequestShort0(peer, hidx_pong_shorthandler_flood));
}
if (recvr) GASNET_BLOCKUNTIL(flag == iters);
BARRIER();
report(" AMShort flood one-way Req",TIME() - start, iters, 0, 0);
} else {
flag = 0;
BARRIER();
GASNET_BLOCKUNTIL(flag == iters);
BARRIER();
}
if (mynode == 0) { printf("\n"); fflush(stdout); }
}
BARRIER();
/* ------------------------------------------------------------------------------------ */
if (TEST_SECTION_ENABLED() && sender) {
int64_t start = TIME();
flag = 0;
for (i=0; i < iters; i++) {
GASNET_Safe(gasnet_AMRequestShort0(peer, hidx_ping_shorthandler_flood));
}
GASNET_BLOCKUNTIL(flag == iters);
report(" AMShort flood roundtrip ReqRep",TIME() - start, iters, 0, 1);
if (mynode == 0) { printf("\n"); fflush(stdout); }
}
BARRIER();
}
/* ##################################################################### */
void
gasnete_fh_callback_put(struct gm_port *p, void *context,
gm_status_t status) {
#ifndef GASNET_SEGMENT_FAST
GASNET_BEGIN_FUNCTION(); /* thread cache for *_IN_UNKNOWN */
#endif
gasnete_eop_t *pop = (gasnete_eop_t *) context;
#if defined(GASNET_DEBUG) || defined(GASNETI_STATS_OR_TRACE)
gasnet_node_t node = pop->node;
gasneti_tick_t starttime = GASNETI_TICKS_NOW_IFENABLED(C);
#endif
const firehose_request_t *fhreqs[2];
int numreqs = 1;
gasneti_mutex_assertlocked(&gasnetc_lock_gm);
gasneti_assert(pop != NULL);
gasneti_assert(node != gasneti_mynode && node < gasneti_nodes);
if_pf (status != GM_SUCCESS)
gasnetc_callback_error(status, NULL);
gasnetc_token_lo_release();
GASNETI_TRACE_PRINTF(C,
("Firehose decrement remote refcount for (%p,%d) on node %d (op=%p,%p,%d)\n",
(void *) pop->dest, pop->len, (unsigned) node, (void *) pop,
(void *)pop->req_remote.addr, (int)pop->req_remote.len));
fhreqs[0] = &(pop->req_remote);
/* Puts use an ambuffer, while bulk puts send from a pinned location */
if (OPMISC(pop) == OPMISC_AMBUF) {
gasnetc_bufdesc_t *bufd;
bufd = (gasnetc_bufdesc_t *) GASNETC_BUFDESC_PTR(pop->src);
GASNETC_ASSERT_BUFDESC_PTR(bufd, pop->src);
gasnetc_callback_ambuffer(p, (void *) bufd, status);
}
else {
fhreqs[1] = pop->req_local;
numreqs++;
#ifdef GASNET_SEGMENT_FAST
/* Only release locally for "fast" segment */
firehose_release(fhreqs+1, 1);
#endif
}
#ifndef GASNET_SEGMENT_FAST
GASNETE_GM_SET_IN_UNKNOWN();
firehose_release(fhreqs, numreqs);
GASNETE_GM_UNSET_IN_UNKNOWN();
#endif
GASNETE_FIREHOSE_TRACE_PUTGET(pop, PUT);
/* If this was associated to an iop, increment put completed count */
if (pop->iop != NULL) {
gasneti_weakatomic_increment(&(pop->iop->completed_put_cnt),0/*Rel?*/);
gasneti_free(pop); /* free a "dummy" eop */
} else {
gasnete_op_markdone((gasnete_op_t *)pop, 0);
}
GASNETI_TRACE_EVENT_TIME(C, FIREHOSE_MOVE_LOCAL,
GASNETI_TICKS_NOW_IFENABLED(C)-starttime);
return;
}
void * thread_fn1(void *arg) { GASNET_BEGIN_FUNCTION();
int id = (int)(uintptr_t)arg;
TIME_OPERATION_SOME(id, { pthread_mutex_lock(&mutex); pthread_mutex_unlock(&mutex); });
extern void gasneti_vis_progressfn(void) {
#if PLATFORM_COMPILER_SUN_C
/* disable warnings triggered by nesting switch-inside-for */
#pragma error_messages(off, E_LOOP_NOT_ENTERED_AT_TOP)
#endif
GASNET_BEGIN_FUNCTION(); /* TODO: remove this lookup */
gasnete_vis_threaddata_t *td = GASNETE_VIS_MYTHREAD;
gasneti_vis_op_t **lastp = &(td->active_ops);
if (td->progressfn_active) return; /* prevent recursion */
td->progressfn_active = 1;
for (lastp = &(td->active_ops); *lastp; ) {
gasneti_vis_op_t * const visop = *lastp;
#ifdef GASNETE_VIS_PROGRESSFN_EXTRA
GASNETE_VIS_PROGRESSFN_EXTRA(visop, lastp)
#endif
switch (visop->type) {
case GASNETI_VIS_CAT_PUTPC_CHAIN: {
gasneti_vispc_op_t * const vispcop = (gasneti_vispc_op_t *)visop;
#if GASNETE_HAVE_LC
// forward ALC if it exists and the client requested it
if (vispcop->lc) {
if (gasnete_test(vispcop->lc GASNETI_THREAD_PASS) == GASNET_OK) {
vispcop->lc = GEX_EVENT_INVALID;
if (visop->eop) GASNETE_EOP_LC_FINISH((gasnete_eop_t *)(visop->eop));
else GASNETE_IOP_LC_FINISH((gasnete_iop_t *)(visop->iop));
} else break; // no ALC yet, so cannot have operation completion
}
#endif
if (gasnete_test(visop->event GASNETI_THREAD_PASS) == GASNET_OK) {
// could potentially delay visop free until ALC of this medium payload,
// but given the small size it's probably synchronously complete for most conduits anyhow
gasneti_assert(!vispcop->lc);
gex_AM_RequestMedium1(vispcop->tm, vispcop->rank, _hidx_gasnete_vis_pcthunk_reqh,
visop->addr, visop->len, GEX_EVENT_NOW, 0, (uint8_t)visop->count);
GASNETE_VISOP_SIGNAL_AND_FREE(visop, 0);
}
break;
}
#ifdef GASNETE_PUTV_GATHER_SELECTOR
case GASNETI_VIS_CAT_PUTV_GATHER:
if (gasnete_test(visop->event GASNETI_THREAD_PASS) == GASNET_OK) {
GASNETE_VISOP_SIGNAL_AND_FREE(visop, 0);
}
break;
#endif
#ifdef GASNETE_GETV_SCATTER_SELECTOR
case GASNETI_VIS_CAT_GETV_SCATTER:
if (gasnete_test(visop->event GASNETI_THREAD_PASS) == GASNET_OK) {
gex_Memvec_t const * const savedlst = (gex_Memvec_t const *)(visop + 1);
void const * const packedbuf = savedlst + visop->count;
gasnete_memvec_unpack(visop->count, savedlst, packedbuf, 0, (size_t)-1);
GASNETE_VISOP_SIGNAL_AND_FREE(visop, 1);
}
break;
#endif
#ifdef GASNETE_PUTI_GATHER_SELECTOR
case GASNETI_VIS_CAT_PUTI_GATHER:
if (gasnete_test(visop->event GASNETI_THREAD_PASS) == GASNET_OK) {
GASNETE_VISOP_SIGNAL_AND_FREE(visop, 0);
}
break;
#endif
#ifdef GASNETE_GETI_SCATTER_SELECTOR
case GASNETI_VIS_CAT_GETI_SCATTER:
if (gasnete_test(visop->event GASNETI_THREAD_PASS) == GASNET_OK) {
void * const * const savedlst = (void * const *)(visop + 1);
void const * const packedbuf = savedlst + visop->count;
gasnete_addrlist_unpack(visop->count, savedlst, visop->len, packedbuf, 0, (size_t)-1);
GASNETE_VISOP_SIGNAL_AND_FREE(visop, 1);
}
break;
#endif
#ifdef GASNETE_PUTS_GATHER_SELECTOR
case GASNETI_VIS_CAT_PUTS_GATHER:
if (gasnete_test(visop->event GASNETI_THREAD_PASS) == GASNET_OK) {
GASNETE_VISOP_SIGNAL_AND_FREE(visop, 0);
}
break;
#endif
#ifdef GASNETE_GETS_SCATTER_SELECTOR
case GASNETI_VIS_CAT_GETS_SCATTER:
if (gasnete_test(visop->event GASNETI_THREAD_PASS) == GASNET_OK) {
size_t stridelevels = visop->len;
size_t * const savedstrides = (size_t *)(visop + 1);
size_t * const savedcount = savedstrides + stridelevels;
void * const packedbuf = (void *)(savedcount + stridelevels + 1);
gasnete_strided_unpack_all(visop->addr, savedstrides, savedcount, stridelevels, packedbuf);
GASNETE_VISOP_SIGNAL_AND_FREE(visop, 1);
}
break;
#endif
default: gasneti_unreachable_error(("unrecognized visop category: 0x%x", (int)visop->type));
}
lastp = &(visop->next); /* advance */
visop_removed: ;
}
td->progressfn_active = 0;
#if PLATFORM_COMPILER_SUN_C
/* resume default treatment of the message we suppressed */
#pragma error_messages(default, E_LOOP_NOT_ENTERED_AT_TOP)
#endif
}
/* ------------------------------------------------------------------------------------ */
void doAMLong(void) {
GASNET_BEGIN_FUNCTION();
TESTAM_PERF("AMLong ", gasnet_AMRequestLong0, hidx_ping_longhandler, hidx_pong_longhandler, maxlongreq, maxlongrep, 0, LONGDEST);
}