// TODO-EX: this is a candidate for factorization (once we understand the per-conduit variations)
extern int gasnetc_Client_Init(
gex_Client_t *client_p,
gex_EP_t *ep_p,
gex_TM_t *tm_p,
const char *clientName,
int *argc,
char ***argv,
gex_Flags_t flags)
{
gasneti_assert(client_p);
gasneti_assert(ep_p);
gasneti_assert(tm_p);
gasneti_assert(clientName);
#if !GASNET_NULL_ARGV_OK
gasneti_assert(argc);
gasneti_assert(argv);
#endif
// main init
// TODO-EX: must split off per-client and per-endpoint portions
if (!gasneti_init_done) {
int retval = gasnetc_init(argc, argv, flags);
if (retval != GASNET_OK) GASNETI_RETURN(retval);
#if 0
/* called within gasnetc_init to allow init tracing */
gasneti_trace_init(argc, argv);
#endif
}
// allocate the client object
gasneti_Client_t client = gasneti_alloc_client(clientName, flags, 0);
*client_p = gasneti_export_client(client);
// create the initial endpoint with internal handlers
if (gasnetc_EP_Create(ep_p, *client_p, flags))
GASNETI_RETURN_ERRR(RESOURCE,"Error creating initial endpoint");
gasneti_EP_t ep = gasneti_import_ep(*ep_p);
gasnetc_handler = ep->_amtbl; // TODO-EX: this global variable to be removed
// TODO-EX: create team
gasneti_TM_t tm = gasneti_alloc_tm(ep, gasneti_mynode, gasneti_nodes, flags, 0);
*tm_p = gasneti_export_tm(tm);
if (0 == (flags & GASNETI_FLAG_INIT_LEGACY)) {
/* primary attach */
if (GASNET_OK != gasnetc_attach_primary())
GASNETI_RETURN_ERRR(RESOURCE,"Error in primary attach");
/* ensure everything is initialized across all nodes */
gasnet_barrier(0, GASNET_BARRIERFLAG_UNNAMED);
}
return GASNET_OK;
}
static int gasnetc_reghandlers(gasnet_handlerentry_t *table, int numentries,
int lowlimit, int highlimit,
int dontcare, int *numregistered) {
int i;
*numregistered = 0;
for (i = 0; i < numentries; i++) {
int newindex;
if ((table[i].index == 0 && !dontcare) ||
(table[i].index && dontcare)) continue;
else if (table[i].index) newindex = table[i].index;
else { /* deterministic assignment of dontcare indexes */
for (newindex = lowlimit; newindex <= highlimit; newindex++) {
if (!checkuniqhandler[newindex]) break;
}
if (newindex > highlimit) {
char s[255];
snprintf(s, sizeof(s), "Too many handlers. (limit=%i)", highlimit - lowlimit + 1);
GASNETI_RETURN_ERRR(BAD_ARG, s);
}
}
/* ensure handlers fall into the proper range of pre-assigned values */
if (newindex < lowlimit || newindex > highlimit) {
char s[255];
snprintf(s, sizeof(s), "handler index (%i) out of range [%i..%i]", newindex, lowlimit, highlimit);
GASNETI_RETURN_ERRR(BAD_ARG, s);
}
/* discover duplicates */
if (checkuniqhandler[newindex] != 0)
GASNETI_RETURN_ERRR(BAD_ARG, "handler index not unique");
checkuniqhandler[newindex] = 1;
/* register the handler */
if (AM_SetHandler(gasnetc_endpoint, (handler_t)newindex, table[i].fnptr) != AM_OK)
GASNETI_RETURN_ERRR(RESOURCE, "AM_SetHandler() failed while registering handlers");
#ifdef GASNETC_MAX_NUMHANDLERS
/* Maintain a shadow handler table */
gasnetc_handler[(gasnet_handler_t)newindex] = (gasneti_handler_fn_t)table[i].fnptr;
#endif
/* The check below for !table[i].index is redundant and present
* only to defeat the over-aggressive optimizer in pathcc 2.1
*/
if (dontcare && !table[i].index) table[i].index = newindex;
(*numregistered)++;
}
return GASNET_OK;
}
static int gasnetc_init(int *argc, char ***argv) {
int ret;
int rank, size;
/* check system sanity */
gasnetc_check_config();
if (gasneti_init_done)
GASNETI_RETURN_ERRR(NOT_INIT, "GASNet already initialized");
gasneti_freezeForDebugger();
#if GASNET_DEBUG_VERBOSE
/* note - can't call trace macros during gasnet_init because trace system not yet initialized */
fprintf(stderr,"gasnetc_init(): about to spawn...\n"); fflush(stderr);
#endif
#if GASNET_DEBUG_VERBOSE
fprintf(stderr,"gasnetc_init(): spawn successful - node %i/%i starting...\n",
gasneti_mynode, gasneti_nodes); fflush(stderr);
#endif
/* gasnetc_p4_init has barrier semantics such that
gasnetc_bootstrapBarrier and gasnetc_bootstrapExchange will
work upon return of init. */
ret = gasnetc_p4_init(&rank, &size);
if (GASNET_OK != ret) gasneti_fatalerror("gasnetc_p4_init failed: %d\n", ret);
gasneti_mynode = rank;
gasneti_nodes = size;
/* node map set in gasnetc_p4_init */
#if GASNET_PSHM
gasneti_pshm_init(&gasnetc_bootstrapExchange, 0);
#endif
#if GASNET_SEGMENT_FAST || GASNET_SEGMENT_LARGE
{ uintptr_t limit;
limit = gasneti_mmapLimit((uintptr_t)-1, (uint64_t)-1,
&gasnetc_bootstrapExchange,
&gasnetc_bootstrapBarrier);
gasneti_segmentInit(limit, &gasnetc_bootstrapExchange);
}
#elif GASNET_SEGMENT_EVERYTHING
/* segment is everything - nothing to do */
#else
#error Bad segment config
#endif
gasneti_init_done = 1;
gasneti_auxseg_init(); /* adjust max seg values based on auxseg */
return GASNET_OK;
}
extern int gasnetc_EP_Create(gex_EP_t *ep_p,
gex_Client_t client,
gex_Flags_t flags) {
/* (###) add code here to create an endpoint belonging to the given client */
#if 1 // TODO-EX: This is a stub, which assumes 1 implicit call from ClientCreate
static gasneti_mutex_t lock = GASNETI_MUTEX_INITIALIZER;
gasneti_mutex_lock(&lock);
static int once = 0;
int prev = once;
once = 1;
gasneti_mutex_unlock(&lock);
if (prev) gasneti_fatalerror("Multiple endpoints are not yet implemented");
#endif
gasneti_EP_t ep = gasneti_alloc_ep(gasneti_import_client(client), flags, 0);
*ep_p = gasneti_export_ep(ep);
{ /* core API handlers */
gex_AM_Entry_t *ctable = (gex_AM_Entry_t *)gasnetc_get_handlertable();
int len = 0;
int numreg = 0;
gasneti_assert(ctable);
while (ctable[len].gex_fnptr) len++; /* calc len */
if (gasneti_amregister(ep->_amtbl, ctable, len, GASNETC_HANDLER_BASE, GASNETE_HANDLER_BASE, 0, &numreg) != GASNET_OK)
GASNETI_RETURN_ERRR(RESOURCE,"Error registering core API handlers");
gasneti_assert(numreg == len);
}
{ /* extended API handlers */
gex_AM_Entry_t *etable = (gex_AM_Entry_t *)gasnete_get_handlertable();
int len = 0;
int numreg = 0;
gasneti_assert(etable);
while (etable[len].gex_fnptr) len++; /* calc len */
if (gasneti_amregister(ep->_amtbl, etable, len, GASNETE_HANDLER_BASE, GASNETI_CLIENT_HANDLER_BASE, 0, &numreg) != GASNET_OK)
GASNETI_RETURN_ERRR(RESOURCE,"Error registering extended API handlers");
gasneti_assert(numreg == len);
}
return GASNET_OK;
}
static int gasnetc_init(int *argc, char ***argv)
{
int ret = GASNET_OK;
/* check system sanity */
gasnetc_check_config();
if (gasneti_init_done)
GASNETI_RETURN_ERRR(NOT_INIT, "GASNet already initialized");
gasneti_freezeForDebugger();
#if GASNET_DEBUG_VERBOSE
/* note - can't call trace macros during gasnet_init because trace system not yet initialized */
fprintf(stderr,"gasnetc_init(): about to spawn...\n"); fflush(stderr);
#endif
/* bootstrap the nodes for ofi conduit */
ret = gasnetc_ofi_init(argc, argv, &gasneti_nodes, &gasneti_mynode);
if (GASNET_OK != ret)
return ret;
#if GASNET_DEBUG_VERBOSE
fprintf(stderr,"gasnetc_init(): spawn successful - node %i/%i starting...\n",
gasneti_mynode, gasneti_nodes); fflush(stderr);
#endif
#if GASNET_PSHM
gasneti_pshm_init(gasneti_bootstrapSNodeBroadcast, 0);
#endif
#if GASNET_SEGMENT_FAST || GASNET_SEGMENT_LARGE
{ uintptr_t limit;
limit = gasneti_mmapLimit((uintptr_t)-1, (uint64_t)-1,
gasneti_bootstrapExchange,
gasneti_bootstrapBarrier);
gasneti_segmentInit(limit, gasneti_bootstrapExchange);
}
#elif GASNET_SEGMENT_EVERYTHING
/* segment is everything - nothing to do */
#else
#error Bad segment config
#endif
gasneti_init_done = 1;
gasneti_auxseg_init(); /* adjust max seg values based on auxseg */
return GASNET_OK;
}
// TODO-EX: this is a candidate for factorization (once we understand the per-conduit variations)
extern int gasnetc_attach( gex_TM_t _tm,
gasnet_handlerentry_t *table,
int numentries,
uintptr_t segsize)
{
int retval = GASNET_OK;
GASNETI_TRACE_PRINTF(C,("gasnetc_attach(table (%i entries), segsize=%"PRIuPTR")",
numentries, segsize));
gasneti_TM_t tm = gasneti_import_tm(_tm);
gasneti_EP_t ep = tm->_ep;
if (!gasneti_init_done)
GASNETI_RETURN_ERRR(NOT_INIT, "GASNet attach called before init");
if (gasneti_attach_done)
GASNETI_RETURN_ERRR(NOT_INIT, "GASNet already attached");
/* check argument sanity */
#if GASNET_SEGMENT_FAST || GASNET_SEGMENT_LARGE
if ((segsize % GASNET_PAGESIZE) != 0)
GASNETI_RETURN_ERRR(BAD_ARG, "segsize not page-aligned");
if (segsize > gasneti_MaxLocalSegmentSize)
GASNETI_RETURN_ERRR(BAD_ARG, "segsize too large");
#else
segsize = 0;
#endif
/* primary attach */
if (GASNET_OK != gasnetc_attach_primary())
GASNETI_RETURN_ERRR(RESOURCE,"Error in primary attach");
#if GASNET_SEGMENT_FAST || GASNET_SEGMENT_LARGE
/* register client segment */
gex_Segment_t seg; // g2ex segment is automatically saved by a hook
if (GASNET_OK != gasnetc_attach_segment(&seg, _tm, segsize, gasneti_defaultExchange, GASNETI_FLAG_INIT_LEGACY))
GASNETI_RETURN_ERRR(RESOURCE,"Error attaching segment");
#endif
AMLOCK();
/* register client handlers */
if (table && gasneti_amregister_legacy(ep->_amtbl, table, numentries) != GASNET_OK)
INITERR(RESOURCE,"Error registering handlers");
AMUNLOCK();
/* ensure everything is initialized across all nodes */
gasnet_barrier(0, GASNET_BARRIERFLAG_UNNAMED);
return GASNET_OK;
done: /* error return while locked */
AMUNLOCK();
GASNETI_RETURN(retval);
}
extern int gasnetc_Segment_Attach(
gex_Segment_t *segment_p,
gex_TM_t tm,
uintptr_t length)
{
gasneti_assert(segment_p);
// TODO-EX: remove when this limitation is removed
static int once = 1;
if (once) once = 0;
else gasneti_fatalerror("gex_Segment_Attach: current implementation can be called at most once");
/* create a segment collectively */
// TODO-EX: this implementation only works *once*
// TODO-EX: should be using the team's exchange function if possible
// TODO-EX: need to pass proper flags (e.g. pshm and bind) instead of 0
if (GASNET_OK != gasnetc_attach_segment(segment_p, tm, length, gasneti_defaultExchange, 0))
GASNETI_RETURN_ERRR(RESOURCE,"Error attaching segment");
return GASNET_OK;
}
/* ------------------------------------------------------------------------------------ */
extern int gasnetc_attach(gasnet_handlerentry_t *table, int numentries,
uintptr_t segsize, uintptr_t minheapoffset) {
void *segbase = NULL;
int ret;
GASNETI_TRACE_PRINTF(C,("gasnetc_attach(table (%i entries), segsize=%lu, minheapoffset=%lu)",
numentries, (unsigned long)segsize, (unsigned long)minheapoffset));
if (!gasneti_init_done)
GASNETI_RETURN_ERRR(NOT_INIT, "GASNet attach called before init");
if (gasneti_attach_done)
GASNETI_RETURN_ERRR(NOT_INIT, "GASNet already attached");
/* check argument sanity */
#if GASNET_SEGMENT_FAST || GASNET_SEGMENT_LARGE
if ((segsize % GASNET_PAGESIZE) != 0)
GASNETI_RETURN_ERRR(BAD_ARG, "segsize not page-aligned");
if (segsize > gasneti_MaxLocalSegmentSize)
GASNETI_RETURN_ERRR(BAD_ARG, "segsize too large");
if ((minheapoffset % GASNET_PAGESIZE) != 0) /* round up the minheapoffset to page sz */
minheapoffset = ((minheapoffset / GASNET_PAGESIZE) + 1) * GASNET_PAGESIZE;
#else
segsize = 0;
minheapoffset = 0;
#endif
segsize = gasneti_auxseg_preattach(segsize); /* adjust segsize for auxseg reqts */
/* ------------------------------------------------------------------------------------ */
/* register handlers */
{ int i;
for (i = 0; i < GASNETC_MAX_NUMHANDLERS; i++)
gasnetc_handler[i] = (gasneti_handler_fn_t)&gasneti_defaultAMHandler;
}
{ /* core API handlers */
gasnet_handlerentry_t *ctable = (gasnet_handlerentry_t *)gasnetc_get_handlertable();
int len = 0;
int numreg = 0;
gasneti_assert(ctable);
while (ctable[len].fnptr) len++; /* calc len */
if (gasnetc_reghandlers(ctable, len, 1, 63, 0, &numreg) != GASNET_OK)
GASNETI_RETURN_ERRR(RESOURCE,"Error registering core API handlers");
gasneti_assert(numreg == len);
}
{ /* extended API handlers */
gasnet_handlerentry_t *etable = (gasnet_handlerentry_t *)gasnete_get_handlertable();
int len = 0;
int numreg = 0;
gasneti_assert(etable);
while (etable[len].fnptr) len++; /* calc len */
if (gasnetc_reghandlers(etable, len, 64, 127, 0, &numreg) != GASNET_OK)
GASNETI_RETURN_ERRR(RESOURCE,"Error registering extended API handlers");
gasneti_assert(numreg == len);
}
if (table) { /* client handlers */
int numreg1 = 0;
int numreg2 = 0;
/* first pass - assign all fixed-index handlers */
if (gasnetc_reghandlers(table, numentries, 128, 255, 0, &numreg1) != GASNET_OK)
GASNETI_RETURN_ERRR(RESOURCE,"Error registering fixed-index client handlers");
/* second pass - fill in dontcare-index handlers */
if (gasnetc_reghandlers(table, numentries, 128, 255, 1, &numreg2) != GASNET_OK)
GASNETI_RETURN_ERRR(RESOURCE,"Error registering fixed-index client handlers");
gasneti_assert(numreg1 + numreg2 == numentries);
}
/* ------------------------------------------------------------------------------------ */
/* register fatal signal handlers */
/* catch fatal signals and convert to SIGQUIT */
gasneti_registerSignalHandlers(gasneti_defaultSignalHandler);
#if HAVE_ON_EXIT
on_exit(gasnetc_on_exit, NULL);
#else
atexit(gasnetc_atexit);
#endif
/* ------------------------------------------------------------------------------------ */
/* register segment */
gasneti_seginfo = (gasnet_seginfo_t *)gasneti_malloc(gasneti_nodes*sizeof(gasnet_seginfo_t));
gasneti_leak(gasneti_seginfo);
#if GASNET_SEGMENT_FAST || GASNET_SEGMENT_LARGE
if (segsize == 0) segbase = NULL; /* no segment */
else {
gasneti_segmentAttach(segsize, minheapoffset, gasneti_seginfo, &gasnetc_bootstrapExchange);
segbase = gasneti_seginfo[gasneti_mynode].addr;
segsize = gasneti_seginfo[gasneti_mynode].size;
gasneti_assert(((uintptr_t)segbase) % GASNET_PAGESIZE == 0);
gasneti_assert(segsize % GASNET_PAGESIZE == 0);
}
#else
{ /* GASNET_SEGMENT_EVERYTHING */
gasnet_node_t i;
for (i=0; i<gasneti_nodes; i++) {
gasneti_seginfo[i].addr = (void *)0;
gasneti_seginfo[i].size = (uintptr_t)-1;
}
segbase = (void *)0;
segsize = (uintptr_t)-1;
}
#endif
ret = gasnetc_p4_attach(segbase, segsize);
if (GASNET_OK != ret) {
GASNETI_RETURN_ERRR(RESOURCE,"Error attaching Portals4 resources");
}
/* ------------------------------------------------------------------------------------ */
/* gather segment information */
/* This was done by segmentAttach above */
/* ------------------------------------------------------------------------------------ */
/* primary attach complete */
gasneti_attach_done = 1;
gasnetc_bootstrapBarrier();
GASNETI_TRACE_PRINTF(C,("gasnetc_attach(): primary attach complete"));
gasneti_assert(gasneti_seginfo[gasneti_mynode].addr == segbase &&
gasneti_seginfo[gasneti_mynode].size == segsize);
gasneti_auxseg_attach(); /* provide auxseg */
gasnete_init(); /* init the extended API */
gasneti_nodemapFini();
/* ensure extended API is initialized across nodes */
gasnetc_bootstrapBarrier();
return GASNET_OK;
}
/* ------------------------------------------------------------------------------------ */
extern int gasnetc_attach(gasnet_handlerentry_t *table, int numentries,
uintptr_t segsize, uintptr_t minheapoffset) {
void *segbase = NULL;
GASNETI_TRACE_PRINTF(C,("gasnetc_attach(table (%i entries), segsize=%"PRIuPTR", minheapoffset=%"PRIuPTR")",
numentries, segsize, minheapoffset));
if (!gasneti_init_done)
GASNETI_RETURN_ERRR(NOT_INIT, "GASNet attach called before init");
if (gasneti_attach_done)
GASNETI_RETURN_ERRR(NOT_INIT, "GASNet already attached");
/* check argument sanity */
#if GASNET_SEGMENT_FAST || GASNET_SEGMENT_LARGE
if ((segsize % GASNET_PAGESIZE) != 0)
GASNETI_RETURN_ERRR(BAD_ARG, "segsize not page-aligned");
if (segsize > gasneti_MaxLocalSegmentSize)
GASNETI_RETURN_ERRR(BAD_ARG, "segsize too large");
if ((minheapoffset % GASNET_PAGESIZE) != 0) /* round up the minheapoffset to page sz */
minheapoffset = ((minheapoffset / GASNET_PAGESIZE) + 1) * GASNET_PAGESIZE;
#else
segsize = 0;
minheapoffset = 0;
#endif
segsize = gasneti_auxseg_preattach(segsize); /* adjust segsize for auxseg reqts */
/* ------------------------------------------------------------------------------------ */
/* register handlers */
{ int i;
for (i = 0; i < GASNETC_MAX_NUMHANDLERS; i++)
gasnetc_handler[i] = (gasneti_handler_fn_t)&gasneti_defaultAMHandler;
}
{ /* core API handlers */
gasnet_handlerentry_t *ctable = (gasnet_handlerentry_t *)gasnetc_get_handlertable();
int len = 0;
int numreg = 0;
gasneti_assert(ctable);
while (ctable[len].fnptr) len++; /* calc len */
if (gasneti_amregister(ctable, len, 1, 63, 0, &numreg) != GASNET_OK)
GASNETI_RETURN_ERRR(RESOURCE,"Error registering core API handlers");
gasneti_assert(numreg == len);
}
{ /* extended API handlers */
gasnet_handlerentry_t *etable = (gasnet_handlerentry_t *)gasnete_get_handlertable();
int len = 0;
int numreg = 0;
gasneti_assert(etable);
while (etable[len].fnptr) len++; /* calc len */
if (gasneti_amregister(etable, len, 64, 127, 0, &numreg) != GASNET_OK)
GASNETI_RETURN_ERRR(RESOURCE,"Error registering extended API handlers");
gasneti_assert(numreg == len);
}
if (table) { /* client handlers */
int numreg1 = 0;
int numreg2 = 0;
/* first pass - assign all fixed-index handlers */
if (gasneti_amregister(table, numentries, 128, 255, 0, &numreg1) != GASNET_OK)
GASNETI_RETURN_ERRR(RESOURCE,"Error registering fixed-index client handlers");
/* second pass - fill in dontcare-index handlers */
if (gasneti_amregister(table, numentries, 128, 255, 1, &numreg2) != GASNET_OK)
GASNETI_RETURN_ERRR(RESOURCE,"Error registering variable-index client handlers");
gasneti_assert(numreg1 + numreg2 == numentries);
}
/* ------------------------------------------------------------------------------------ */
/* register fatal signal handlers */
/* catch fatal signals and convert to SIGQUIT */
gasneti_registerSignalHandlers(gasneti_defaultSignalHandler);
/* ------------------------------------------------------------------------------------ */
/* setup fo rexit coordination */
gasnetc_exittimeout = gasneti_get_exittimeout(GASNETC_DEFAULT_EXITTIMEOUT_MAX,
GASNETC_DEFAULT_EXITTIMEOUT_MIN,
GASNETC_DEFAULT_EXITTIMEOUT_FACTOR,
GASNETC_DEFAULT_EXITTIMEOUT_MIN);
#if HAVE_ON_EXIT
on_exit(gasnetc_on_exit, NULL);
#else
atexit(gasnetc_atexit);
#endif
/* ------------------------------------------------------------------------------------ */
/* register segment */
gasneti_seginfo = (gasnet_seginfo_t *)gasneti_malloc(gasneti_nodes*sizeof(gasnet_seginfo_t));
gasneti_leak(gasneti_seginfo);
#if GASNET_SEGMENT_FAST || GASNET_SEGMENT_LARGE
if (segsize == 0) segbase = NULL; /* no segment */
else {
gasneti_segmentAttach(segsize, minheapoffset, gasneti_seginfo, gasneti_bootstrapExchange);
segbase = gasneti_seginfo[gasneti_mynode].addr;
segsize = gasneti_seginfo[gasneti_mynode].size;
gasneti_assert(((uintptr_t)segbase) % GASNET_PAGESIZE == 0);
gasneti_assert(segsize % GASNET_PAGESIZE == 0);
}
#else
{ /* GASNET_SEGMENT_EVERYTHING */
gasnet_node_t i;
for (i=0; i<gasneti_nodes; i++) {
gasneti_seginfo[i].addr = (void *)0;
gasneti_seginfo[i].size = (uintptr_t)-1;
}
segbase = (void *)0;
segsize = (uintptr_t)-1;
}
#endif
gasnetc_ofi_attach(segbase, segsize);
/* After local segment is attached, call optional client-provided hook
(###) should call BEFORE any conduit-specific pinning/registration of the segment
*/
if (gasnet_client_attach_hook) {
gasnet_client_attach_hook(segbase, segsize);
}
/* ------------------------------------------------------------------------------------ */
/* primary attach complete */
gasneti_attach_done = 1;
gasneti_bootstrapBarrier();
GASNETI_TRACE_PRINTF(C,("gasnetc_attach(): primary attach complete"));
gasneti_assert(gasneti_seginfo[gasneti_mynode].addr == segbase &&
gasneti_seginfo[gasneti_mynode].size == segsize);
/* (###) exchange_fn is optional (may be NULL) and is only used with GASNET_SEGMENT_EVERYTHING
if your conduit has an optimized bootstrapExchange pass it in place of NULL
*/
gasneti_auxseg_attach(NULL); /* provide auxseg */
gasnete_init(); /* init the extended API */
gasneti_nodemapFini();
/* ensure extended API is initialized across nodes */
gasneti_bootstrapBarrier();
return GASNET_OK;
}
/* ------------------------------------------------------------------------------------ */
extern int gasnetc_amregister(gex_AM_Index_t index, gex_AM_Entry_t *entry) {
if (AM_SetHandler(gasnetc_endpoint, (handler_t)index, entry->gex_fnptr) != AM_OK)
GASNETI_RETURN_ERRR(RESOURCE, "AM_SetHandler() failed while registering handlers");
return GASNET_OK;
}
