int
ompi_mtl_portals4_flowctl_fini(void)
{
PtlPTFree(ompi_mtl_portals4.ni_h, ompi_mtl_portals4.flowctl_idx);
PtlCTFree(ompi_mtl_portals4.flowctl.trigger_ct_h);
PtlMEUnlink(ompi_mtl_portals4.flowctl.trigger_me_h);
PtlCTFree(ompi_mtl_portals4.flowctl.alert_ct_h);
PtlMEUnlink(ompi_mtl_portals4.flowctl.alert_me_h);
PtlCTFree(ompi_mtl_portals4.flowctl.fanin_ct_h);
PtlMEUnlink(ompi_mtl_portals4.flowctl.fanin_me_h);
PtlCTFree(ompi_mtl_portals4.flowctl.fanout_ct_h);
PtlMEUnlink(ompi_mtl_portals4.flowctl.fanout_me_h);
return OMPI_SUCCESS;
}
int
ompi_osc_portals4_free(struct ompi_win_t *win)
{
ompi_osc_portals4_module_t *module =
(ompi_osc_portals4_module_t*) win->w_osc_module;
int ret = OMPI_SUCCESS;
/* synchronize */
module->comm->c_coll.coll_barrier(module->comm,
module->comm->c_coll.coll_barrier_module);
/* cleanup */
PtlMEUnlink(module->data_me_h);
PtlMDRelease(module->md_h);
PtlMDRelease(module->req_md_h);
PtlCTFree(module->ct_h);
if (NULL != module->disp_units) free(module->disp_units);
ompi_comm_free(&module->comm);
if (NULL != module->free_after) free(module->free_after);
if (!opal_list_is_empty(&module->outstanding_locks)) {
ret = OMPI_ERR_RMA_SYNC;
}
OBJ_DESTRUCT(&module->outstanding_locks);
free(module);
return ret;
}
int
ompi_coll_portals4_ibarrier_intra_fini(ompi_coll_portals4_request_t *request)
{
int ret;
/* cleanup */
ret = PtlMEUnlink(request->me_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_coll_base_framework.framework_output,
"%s:%d: PtlMEUnlink failed: %d\n",
__FILE__, __LINE__, ret);
return OMPI_ERROR;
}
ret = PtlCTFree(request->ct_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_coll_base_framework.framework_output,
"%s:%d: PtlCTFree failed: %d\n",
__FILE__, __LINE__, ret);
return OMPI_ERROR;
}
OPAL_THREAD_LOCK(&ompi_request_lock);
ompi_request_complete(&request->super, true);
OPAL_THREAD_UNLOCK(&ompi_request_lock);
return OMPI_SUCCESS;
}
static int
triggered_read_msg(void *start, ptl_size_t length, ptl_process_t target,
ptl_match_bits_t match_bits, ptl_size_t remote_offset,
ompi_mtl_portals4_recv_request_t *request)
{
int ret;
ret = PtlCTAlloc(ompi_mtl_portals4.ni_h, &request->ct_h);
if (OPAL_UNLIKELY(PTL_OK != ret)) {
opal_output_verbose(1, ompi_mtl_base_framework.framework_output,
"%s:%d: PtlCTAlloc failed: %d",
__FILE__, __LINE__, ret);
return OMPI_ERR_OUT_OF_RESOURCE;
}
ret = PtlTriggeredGet(ompi_mtl_portals4.send_md_h,
(ptl_size_t) start,
length,
target,
ompi_mtl_portals4.read_idx,
match_bits,
remote_offset,
request,
request->ct_h, 1);
if (OPAL_UNLIKELY(PTL_OK != ret)) {
PtlCTFree(request->ct_h);
request->ct_h = PTL_INVALID_HANDLE;
opal_output_verbose(1, ompi_mtl_base_framework.framework_output,
"%s:%d: PtlTriggeredGet failed: %d",
__FILE__, __LINE__, ret);
return OMPI_ERR_OUT_OF_RESOURCE;
}
return OMPI_SUCCESS;
}
static int
cleanup_sync_handles(ompi_coll_portals4_request_t *request)
{
int ret, line;
int ptl_ret;
OPAL_OUTPUT((ompi_coll_base_framework.framework_output,
"coll:portals4:cleanup_sync_handles enter rank %d", request->u.scatter.my_rank));
/**********************************/
/* Cleanup Sync Handles */
/**********************************/
do {
ret = PtlMEUnlink(request->u.scatter.sync_meh);
if (PTL_IN_USE == ret) {
opal_output(ompi_coll_base_framework.framework_output,
"%s:%4d: sync_meh still in use (ret=%d, rank %2d)",
__FILE__, __LINE__, ret, request->u.scatter.my_rank);
continue;
}
if (PTL_OK != ret) {
ret = OMPI_ERROR;
line = __LINE__;
goto err_hdlr;
}
} while (ret == PTL_IN_USE);
ret = PtlCTFree(request->u.scatter.sync_cth);
if (PTL_OK != ret) {
ptl_ret = ret;
ret = OMPI_ERROR;
line = __LINE__;
goto err_hdlr;
}
OPAL_OUTPUT((ompi_coll_base_framework.framework_output,
"coll:portals4:cleanup_sync_handles exit rank %d", request->u.scatter.my_rank));
return OMPI_SUCCESS;
err_hdlr:
opal_output(ompi_coll_base_framework.framework_output,
"%s:%4d:%4d\tError occurred (ptl_ret=%d) ret=%d, rank %2d",
__FILE__, __LINE__, line, ptl_ret, ret, request->u.scatter.my_rank);
return ret;
}
static int
component_select(struct ompi_win_t *win, void **base, size_t size, int disp_unit,
struct ompi_communicator_t *comm, struct ompi_info_t *info,
int flavor, int *model)
{
ompi_osc_portals4_module_t *module = NULL;
int ret = OMPI_ERROR;
int tmp;
ptl_md_t md;
ptl_me_t me;
char *name;
if (MPI_WIN_FLAVOR_SHARED == flavor) return OMPI_ERR_NOT_SUPPORTED;
/* create module structure */
module = (ompi_osc_portals4_module_t*)
calloc(1, sizeof(ompi_osc_portals4_module_t));
if (NULL == module) return OMPI_ERR_TEMP_OUT_OF_RESOURCE;
/* fill in the function pointer part */
memcpy(module, &ompi_osc_portals4_module_template,
sizeof(ompi_osc_base_module_t));
/* fill in our part */
if (MPI_WIN_FLAVOR_ALLOCATE == flavor) {
module->free_after = *base = malloc(size);
if (NULL == *base) goto error;
} else {
module->free_after = NULL;
}
ret = ompi_comm_dup(comm, &module->comm);
if (OMPI_SUCCESS != ret) goto error;
opal_output_verbose(1, ompi_osc_base_framework.framework_output,
"portals4 component creating window with id %d",
ompi_comm_get_cid(module->comm));
asprintf(&name, "portals4 window %d", ompi_comm_get_cid(module->comm));
ompi_win_set_name(win, name);
free(name);
/* share everyone's displacement units. Only do an allgather if
strictly necessary, since it requires O(p) state. */
tmp = disp_unit;
ret = module->comm->c_coll.coll_bcast(&tmp, 1, MPI_INT, 0,
module->comm,
module->comm->c_coll.coll_bcast_module);
if (OMPI_SUCCESS != ret) {
opal_output_verbose(1, ompi_osc_base_framework.framework_output,
"%s:%d: MPI_Bcast failed: %d\n",
__FILE__, __LINE__, ret);
goto error;
}
tmp = (tmp == disp_unit) ? 1 : 0;
ret = module->comm->c_coll.coll_allreduce(MPI_IN_PLACE, &tmp, 1, MPI_INT, MPI_LAND,
module->comm, module->comm->c_coll.coll_allreduce_module);
if (OMPI_SUCCESS != ret) goto error;
if (tmp == 1) {
module->disp_unit = disp_unit;
module->disp_units = NULL;
} else {
module->disp_unit = -1;
module->disp_units = malloc(sizeof(int) * ompi_comm_size(module->comm));
ret = module->comm->c_coll.coll_allgather(&disp_unit, 1, MPI_INT,
module->disp_units, 1, MPI_INT,
module->comm,
module->comm->c_coll.coll_allgather_module);
if (OMPI_SUCCESS != ret) goto error;
}
module->ni_h = mca_osc_portals4_component.matching_ni_h;
module->pt_idx = mca_osc_portals4_component.matching_pt_idx;
ret = PtlCTAlloc(module->ni_h, &(module->ct_h));
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_osc_base_framework.framework_output,
"%s:%d: PtlCTAlloc failed: %d\n",
__FILE__, __LINE__, ret);
goto error;
}
md.start = 0;
md.length = PTL_SIZE_MAX;
md.options = PTL_MD_EVENT_SUCCESS_DISABLE | PTL_MD_EVENT_CT_REPLY | PTL_MD_EVENT_CT_ACK;
md.eq_handle = mca_osc_portals4_component.matching_eq_h;
md.ct_handle = module->ct_h;
ret = PtlMDBind(module->ni_h, &md, &module->md_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_osc_base_framework.framework_output,
"%s:%d: PtlMDBind failed: %d\n",
__FILE__, __LINE__, ret);
goto error;
}
md.start = 0;
md.length = PTL_SIZE_MAX;
md.options = PTL_MD_EVENT_CT_REPLY | PTL_MD_EVENT_CT_ACK;
md.eq_handle = mca_osc_portals4_component.matching_eq_h;
md.ct_handle = module->ct_h;
ret = PtlMDBind(module->ni_h, &md, &module->req_md_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_osc_base_framework.framework_output,
"%s:%d: PtlMDBind failed: %d\n",
__FILE__, __LINE__, ret);
goto error;
}
if (MPI_WIN_FLAVOR_DYNAMIC == flavor) {
me.start = 0;
me.length = PTL_SIZE_MAX;
} else {
me.start = *base;
me.length = size;
}
me.ct_handle = PTL_CT_NONE;
me.uid = PTL_UID_ANY;
me.options = PTL_ME_OP_PUT | PTL_ME_OP_GET | PTL_ME_NO_TRUNCATE | PTL_ME_EVENT_SUCCESS_DISABLE;
me.match_id.phys.nid = PTL_NID_ANY;
me.match_id.phys.pid = PTL_PID_ANY;
me.match_bits = module->comm->c_contextid;
me.ignore_bits = 0;
ret = PtlMEAppend(module->ni_h,
module->pt_idx,
&me,
PTL_PRIORITY_LIST,
NULL,
&module->data_me_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_osc_base_framework.framework_output,
"%s:%d: PtlMEAppend failed: %d\n",
__FILE__, __LINE__, ret);
goto error;
}
me.start = &module->state;
me.length = sizeof(module->state);
me.ct_handle = PTL_CT_NONE;
me.uid = PTL_UID_ANY;
me.options = PTL_ME_OP_PUT | PTL_ME_OP_GET | PTL_ME_NO_TRUNCATE | PTL_ME_EVENT_SUCCESS_DISABLE;
me.match_id.phys.nid = PTL_NID_ANY;
me.match_id.phys.pid = PTL_PID_ANY;
me.match_bits = module->comm->c_contextid | OSC_PORTALS4_MB_CONTROL;
me.ignore_bits = 0;
ret = PtlMEAppend(module->ni_h,
module->pt_idx,
&me,
PTL_PRIORITY_LIST,
NULL,
&module->control_me_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_osc_base_framework.framework_output,
"%s:%d: PtlMEAppend failed: %d\n",
__FILE__, __LINE__, ret);
goto error;
}
module->opcount = 0;
module->match_bits = module->comm->c_contextid;
module->atomic_max = (check_config_value_equal("accumulate_ordering", info, "none")) ?
mca_osc_portals4_component.matching_atomic_max :
MIN(mca_osc_portals4_component.matching_atomic_max,
mca_osc_portals4_component.matching_atomic_ordered_size);
module->fetch_atomic_max = (check_config_value_equal("accumulate_ordering", info, "none")) ?
mca_osc_portals4_component.matching_fetch_atomic_max :
MIN(mca_osc_portals4_component.matching_fetch_atomic_max,
mca_osc_portals4_component.matching_atomic_ordered_size);
module->zero = 0;
module->one = 1;
module->start_group = NULL;
module->post_group = NULL;
module->state.post_count = 0;
module->state.complete_count = 0;
if (check_config_value_bool("no_locks", info)) {
module->state.lock = LOCK_ILLEGAL;
} else {
module->state.lock = LOCK_UNLOCKED;
}
OBJ_CONSTRUCT(&module->outstanding_locks, opal_list_t);
module->passive_target_access_epoch = false;
#if OPAL_ASSEMBLY_ARCH == OPAL_AMD64 || OPAL_ASSEMBLY_ARCH == OPAL_IA32
*model = MPI_WIN_UNIFIED;
#else
*model = MPI_WIN_SEPARATE;
#endif
win->w_osc_module = &module->super;
PtlAtomicSync();
/* Make sure that everyone's ready to receive. */
module->comm->c_coll.coll_barrier(module->comm,
module->comm->c_coll.coll_barrier_module);
return OMPI_SUCCESS;
error:
/* BWB: FIX ME: This is all wrong... */
if (0 != module->ct_h) PtlCTFree(module->ct_h);
if (0 != module->data_me_h) PtlMEUnlink(module->data_me_h);
if (0 != module->req_md_h) PtlMDRelease(module->req_md_h);
if (0 != module->md_h) PtlMDRelease(module->md_h);
if (NULL != module->comm) ompi_comm_free(&module->comm);
if (NULL != module) free(module);
return ret;
}
int main(int argc,
char *argv[])
{
ptl_handle_ni_t ni_logical;
ptl_pt_index_t logical_pt_index;
ptl_process_t myself;
struct timeval start, stop;
int potato = 0;
ENTRY_T potato_catcher;
HANDLE_T potato_catcher_handle;
ptl_md_t potato_launcher;
ptl_handle_md_t potato_launcher_handle;
int num_procs;
CHECK_RETURNVAL(PtlInit());
CHECK_RETURNVAL(libtest_init());
num_procs = libtest_get_size();
if (NULL != getenv("MAKELEVEL") && num_procs > 2) {
return 77;
}
CHECK_RETURNVAL(PtlNIInit
(PTL_IFACE_DEFAULT, NI_TYPE | PTL_NI_LOGICAL, PTL_PID_ANY,
NULL, NULL, &ni_logical));
CHECK_RETURNVAL(PtlSetMap(ni_logical, num_procs,
libtest_get_mapping(ni_logical)));
CHECK_RETURNVAL(PtlGetId(ni_logical, &myself));
CHECK_RETURNVAL(PtlPTAlloc
(ni_logical, 0, PTL_EQ_NONE, PTL_PT_ANY,
&logical_pt_index));
assert(logical_pt_index == 0);
/* Now do the initial setup on ni_logical */
potato_catcher.start = &potato;
potato_catcher.length = sizeof(potato);
potato_catcher.uid = PTL_UID_ANY;
potato_catcher.options = OPTIONS;
#if INTERFACE == 1
potato_catcher.match_id.rank = PTL_RANK_ANY;
potato_catcher.match_bits = 1;
potato_catcher.ignore_bits = ~potato_catcher.match_bits;
#endif
CHECK_RETURNVAL(PtlCTAlloc(ni_logical, &potato_catcher.ct_handle));
CHECK_RETURNVAL(APPEND
(ni_logical, logical_pt_index, &potato_catcher,
PTL_PRIORITY_LIST, NULL, &potato_catcher_handle));
/* Now do a barrier (on ni_physical) to make sure that everyone has their
* logical interface set up */
libtest_barrier();
/* now I can communicate between ranks with ni_logical */
/* set up the potato launcher */
potato_launcher.start = &potato;
potato_launcher.length = sizeof(potato);
potato_launcher.options =
PTL_MD_EVENT_CT_ACK | PTL_MD_EVENT_CT_SEND;
potato_launcher.eq_handle = PTL_EQ_NONE; // i.e. don't queue send events
CHECK_RETURNVAL(PtlCTAlloc(ni_logical, &potato_launcher.ct_handle));
CHECK_RETURNVAL(PtlMDBind
(ni_logical, &potato_launcher, &potato_launcher_handle));
/* rank 0 starts the potato going */
if (myself.rank == 0) {
ptl_process_t nextrank;
nextrank.rank = myself.rank + 1;
nextrank.rank *= (nextrank.rank <= num_procs - 1);
gettimeofday(&start, NULL);
CHECK_RETURNVAL(PtlPut(potato_launcher_handle, 0, potato_launcher.length,
(LOOPS == 1) ? PTL_OC_ACK_REQ : PTL_NO_ACK_REQ,
nextrank, logical_pt_index, 1, 0,
NULL, 1));
}
{ /* the potato-passing loop */
size_t waitfor;
ptl_ct_event_t ctc;
ptl_process_t nextrank;
nextrank.rank = myself.rank + 1;
nextrank.rank *= (nextrank.rank <= num_procs - 1);
for (waitfor = 1; waitfor <= LOOPS; ++waitfor) {
CHECK_RETURNVAL(PtlCTWait(potato_catcher.ct_handle, waitfor, &ctc)); // wait for potato
assert(ctc.failure == 0);
assert(ctc.success == waitfor);
/* I have the potato! */
++potato;
if (potato < LOOPS * (num_procs)) { // otherwise, the recipient may have exited
/* Bomb's away! */
if (myself.rank == 0) {
CHECK_RETURNVAL(PtlPut(potato_launcher_handle, 0,
potato_launcher.length,
(waitfor == (LOOPS - 1)) ? PTL_OC_ACK_REQ : PTL_NO_ACK_REQ,
nextrank, logical_pt_index, 3, 0, NULL, 2));
} else {
CHECK_RETURNVAL(PtlPut(potato_launcher_handle, 0,
potato_launcher.length,
(waitfor == LOOPS) ? PTL_OC_ACK_REQ : PTL_NO_ACK_REQ,
nextrank, logical_pt_index, 3, 0, NULL, 2));
}
}
}
// make sure that last send completed before exiting
CHECK_RETURNVAL(PtlCTWait(potato_launcher.ct_handle, LOOPS+1, &ctc));
assert(ctc.failure == 0);
}
if (myself.rank == 0) {
double accumulate = 0.0;
gettimeofday(&stop, NULL);
accumulate =
(stop.tv_sec + stop.tv_usec * 1e-6) - (start.tv_sec +
start.tv_usec * 1e-6);
/* calculate the average time waiting */
printf("Total time: %g secs\n", accumulate);
accumulate /= LOOPS;
printf("Average time around the loop: %g microseconds\n",
accumulate * 1e6);
accumulate /= num_procs;
printf("Average catch-to-toss latency: %g microseconds\n",
accumulate * 1e6);
}
/* cleanup */
CHECK_RETURNVAL(PtlMDRelease(potato_launcher_handle));
CHECK_RETURNVAL(PtlCTFree(potato_launcher.ct_handle));
CHECK_RETURNVAL(UNLINK(potato_catcher_handle));
CHECK_RETURNVAL(PtlCTFree(potato_catcher.ct_handle));
/* major cleanup */
CHECK_RETURNVAL(PtlPTFree(ni_logical, logical_pt_index));
CHECK_RETURNVAL(PtlNIFini(ni_logical));
CHECK_RETURNVAL(libtest_fini());
PtlFini();
return 0;
}
int main(int argc,
char *argv[])
{
ptl_handle_ni_t ni_handle;
ptl_process_t *procs;
int rank;
ptl_pt_index_t pt_index, signal_pt_index;
HANDLE_T signal_e_handle;
HANDLE_T signal_e2_handle;
int num_procs;
ptl_handle_eq_t eq_handle;
ptl_handle_ct_t ct_handle;
ptl_handle_md_t md_handle;
ptl_ni_limits_t limits_reqd, limits_actual;
ENTRY_T value_e;
limits_reqd.max_entries = 1024;
limits_reqd.max_unexpected_headers = ITERS*2;
limits_reqd.max_mds = 1024;
limits_reqd.max_eqs = 1024;
limits_reqd.max_cts = 1024;
limits_reqd.max_pt_index = 64;
limits_reqd.max_iovecs = 1024;
limits_reqd.max_list_size = 1024;
limits_reqd.max_triggered_ops = 1024;
limits_reqd.max_msg_size = 1048576;
limits_reqd.max_atomic_size = 1048576;
limits_reqd.max_fetch_atomic_size = 1048576;
limits_reqd.max_waw_ordered_size = 1048576;
limits_reqd.max_war_ordered_size = 1048576;
limits_reqd.max_volatile_size = 1048576;
limits_reqd.features = 0;
CHECK_RETURNVAL(PtlInit());
CHECK_RETURNVAL(libtest_init());
rank = libtest_get_rank();
num_procs = libtest_get_size();
if (num_procs < 2) {
fprintf(stderr, "test_flowctl_noeq requires at least two processes\n");
return 77;
}
int iters;
if (num_procs < ITERS)
iters = ITERS*2+1;
else
iters = ITERS;
CHECK_RETURNVAL(PtlNIInit(PTL_IFACE_DEFAULT, NI_TYPE | PTL_NI_LOGICAL,
PTL_PID_ANY, &limits_reqd, &limits_actual, &ni_handle));
procs = libtest_get_mapping(ni_handle);
CHECK_RETURNVAL(PtlSetMap(ni_handle, num_procs, procs));
if (0 == rank) {
/* create data PT space */
CHECK_RETURNVAL(PtlEQAlloc(ni_handle, (num_procs - 1) * iters + 64, &eq_handle));
CHECK_RETURNVAL(PtlPTAlloc(ni_handle, PTL_PT_FLOWCTRL, eq_handle, 5,
&pt_index));
/* create signal ME */
CHECK_RETURNVAL(PtlCTAlloc(ni_handle, &ct_handle));
CHECK_RETURNVAL(PtlPTAlloc(ni_handle, 1, eq_handle, 6,
&signal_pt_index));
value_e.start = NULL;
value_e.length = 0;
value_e.ct_handle = ct_handle;
value_e.uid = PTL_UID_ANY;
value_e.options = OPTIONS | PTL_LE_EVENT_CT_COMM;
#if INTERFACE == 1
value_e.match_id.rank = PTL_RANK_ANY;
value_e.match_bits = 0;
value_e.ignore_bits = 0;
#endif
CHECK_RETURNVAL(APPEND(ni_handle, 5, &value_e, PTL_OVERFLOW_LIST, NULL, &signal_e_handle));
} else {
ptl_md_t md;
/* 16 extra just in case... */
CHECK_RETURNVAL(PtlEQAlloc(ni_handle, iters*2 + 16, &eq_handle));
md.start = NULL;
md.length = 0;
md.options = 0;
md.eq_handle = eq_handle;
md.ct_handle = PTL_CT_NONE;
CHECK_RETURNVAL(PtlMDBind(ni_handle, &md, &md_handle));
}
fprintf(stderr,"at barrier \n");
libtest_barrier();
if (0 == rank) {
ptl_ct_event_t ct;
ptl_event_t ev;
int ret, count = 0, saw_flowctl = 0;
fprintf(stderr,"begin ctwait \n");
/* wait for signal counts */
CHECK_RETURNVAL(PtlCTWait(ct_handle, iters / 2 , &ct));
if (ct.success != iters / 2 || ct.failure != 0) {
return 1;
}
fprintf(stderr,"done CT wait \n");
/* wait for event entries */
while (1) {
ret = PtlEQGet(eq_handle, &ev);
if (PTL_OK == ret) {
count++;
fprintf(stderr, "found EQ value \n");
} else if (ret == PTL_EQ_EMPTY) {
continue;
} else {
fprintf(stderr, "0: Unexpected return code from EQGet: %d\n", ret);
return 1;
}
if (ev.type == PTL_EVENT_PT_DISABLED) {
saw_flowctl++;
break;
}
}
fprintf(stderr, "0: Saw %d flowctl\n", saw_flowctl);
if (saw_flowctl == 0) {
return 1;
}
/* Now clear out all of the unexpected messages so we can clean up everything */
CHECK_RETURNVAL(APPEND(ni_handle, 5, &value_e, PTL_PRIORITY_LIST, NULL, &signal_e2_handle));
ret = PTL_OK;
while (ret != PTL_EQ_EMPTY)
ret = PtlEQGet(eq_handle, &ev);
} else {
ptl_process_t target;
ptl_event_t ev;
int ret, count = 0, fails = 0;
int i;
target.rank = 0;
printf("beginning puts \n");
for (i = 0 ; i < iters ; ++i) {
CHECK_RETURNVAL(PtlPut(md_handle,
0,
0,
PTL_ACK_REQ,
target,
5,
0,
0,
NULL,
0));
usleep(100);
}
while (count < iters) {
ret = PtlEQGet(eq_handle, &ev);
if (PTL_EQ_EMPTY == ret) {
continue;
} else if (PTL_OK != ret) {
fprintf(stderr, "%d: PtlEQGet returned %d\n", rank, ret);
return 1;
}
if (ev.ni_fail_type == PTL_NI_OK) {
if (ev.type == PTL_EVENT_SEND) {
continue;
} else if (ev.type == PTL_EVENT_ACK) {
count++;
} else {
fprintf(stderr, "%d: Unexpected event type %d\n", rank, ev.type);
}
} else if (ev.ni_fail_type == PTL_NI_PT_DISABLED) {
count++;
fails++;
} else if (ev.ni_fail_type == PTL_EQ_EMPTY) {
continue;
} else if (ev.ni_fail_type == PTL_EQ_DROPPED) {
continue;
} else {
fprintf(stderr, "%d: Unexpected fail type: %d\n", rank, ev.ni_fail_type);
return 1;
}
}
fprintf(stderr, "%d: Saw %d of %d ACKs as fails\n", rank, fails, count);
}
fprintf(stderr,"at final barrier \n");
libtest_barrier();
if (0 == rank) {
CHECK_RETURNVAL(UNLINK(signal_e_handle));
CHECK_RETURNVAL(UNLINK(signal_e2_handle));
CHECK_RETURNVAL(PtlPTFree(ni_handle, signal_pt_index));
CHECK_RETURNVAL(PtlCTFree(ct_handle));
CHECK_RETURNVAL(PtlPTFree(ni_handle, pt_index));
CHECK_RETURNVAL(PtlEQFree(eq_handle));
} else {
CHECK_RETURNVAL(PtlMDRelease(md_handle));
CHECK_RETURNVAL(PtlEQFree(eq_handle));
}
fprintf(stderr,"final cleanup \n");
CHECK_RETURNVAL(PtlNIFini(ni_handle));
CHECK_RETURNVAL(libtest_fini());
PtlFini();
return 0;
}
int main(int argc,
char *argv[])
{
ptl_handle_ni_t ni_handle;
ptl_process_t *procs;
int rank;
ptl_pt_index_t pt_index, signal_pt_index;
HANDLE_T value_e_handle, signal_e_handle;
int num_procs;
ptl_handle_eq_t eq_handle;
ptl_handle_ct_t ct_handle;
ptl_handle_md_t md_handle;
CHECK_RETURNVAL(PtlInit());
CHECK_RETURNVAL(libtest_init());
rank = libtest_get_rank();
num_procs = libtest_get_size();
if (num_procs < 2) {
fprintf(stderr, "test_flowctl_noeq requires at least two processes\n");
return 77;
}
CHECK_RETURNVAL(PtlNIInit(PTL_IFACE_DEFAULT, NI_TYPE | PTL_NI_LOGICAL,
PTL_PID_ANY, NULL, NULL, &ni_handle));
procs = libtest_get_mapping(ni_handle);
CHECK_RETURNVAL(PtlSetMap(ni_handle, num_procs, procs));
if (0 == rank) {
ENTRY_T value_e;
/* create data ME */
CHECK_RETURNVAL(PtlEQAlloc(ni_handle, (num_procs - 1) * ITERS / 2, &eq_handle));
CHECK_RETURNVAL(PtlPTAlloc(ni_handle, PTL_PT_FLOWCTRL, eq_handle, 5,
&pt_index));
value_e.start = NULL;
value_e.length = 0;
value_e.ct_handle = PTL_CT_NONE;
value_e.uid = PTL_UID_ANY;
value_e.options = OPTIONS;
#if INTERFACE == 1
value_e.match_id.rank = PTL_RANK_ANY;
value_e.match_bits = 0;
value_e.ignore_bits = 0;
#endif
CHECK_RETURNVAL(APPEND(ni_handle, 5, &value_e, PTL_PRIORITY_LIST, NULL, &value_e_handle));
/* create signal ME */
CHECK_RETURNVAL(PtlCTAlloc(ni_handle, &ct_handle));
CHECK_RETURNVAL(PtlPTAlloc(ni_handle, 0, PTL_EQ_NONE, 6,
&signal_pt_index));
value_e.start = NULL;
value_e.length = 0;
value_e.ct_handle = ct_handle;
value_e.uid = PTL_UID_ANY;
value_e.options = OPTIONS | PTL_LE_EVENT_SUCCESS_DISABLE | PTL_LE_EVENT_CT_COMM;
#if INTERFACE == 1
value_e.match_id.rank = PTL_RANK_ANY;
value_e.match_bits = 0;
value_e.ignore_bits = 0;
#endif
CHECK_RETURNVAL(APPEND(ni_handle, 6, &value_e, PTL_PRIORITY_LIST, NULL, &signal_e_handle));
} else {
ptl_md_t md;
/* 16 extra just in case... */
CHECK_RETURNVAL(PtlEQAlloc(ni_handle, ITERS * 2 + 16, &eq_handle));
md.start = NULL;
md.length = 0;
md.options = 0;
md.eq_handle = eq_handle;
md.ct_handle = PTL_CT_NONE;
CHECK_RETURNVAL(PtlMDBind(ni_handle, &md, &md_handle));
}
libtest_barrier();
if (0 == rank) {
ptl_ct_event_t ct;
ptl_event_t ev;
int ret, count = 0, saw_dropped = 0, saw_flowctl = 0;
/* wait for signal counts */
CHECK_RETURNVAL(PtlCTWait(ct_handle, num_procs - 1, &ct));
if (ct.success != num_procs - 1 || ct.failure != 0) {
return 1;
}
/* wait for event entries */
while (count < ITERS * (num_procs - 1)) {
ret = PtlEQWait(eq_handle, &ev);
if (PTL_OK == ret) {
;
} else if (PTL_EQ_DROPPED == ret) {
saw_dropped++;
if (ev.type == PTL_EVENT_PT_DISABLED){
saw_flowctl++;
CHECK_RETURNVAL(PtlPTEnable(ni_handle, pt_index));
}
break;
} else {
fprintf(stderr, "0: Unexpected return code from EQWait: %d\n", ret);
return 1;
}
if (ev.type == PTL_EVENT_PT_DISABLED) {
CHECK_RETURNVAL(PtlPTEnable(ni_handle, pt_index));
saw_flowctl++;
} else {
count++;
}
}
fprintf(stderr, "0: Saw %d dropped, %d flowctl\n", saw_dropped, saw_flowctl);
if (saw_flowctl == 0) {
return 1;
}
} else {
ptl_process_t target;
ptl_event_t ev;
int ret, count = 0, fails = 0;
int i;
int *fail_seen;
fail_seen = malloc(sizeof(int) * ITERS);
if (NULL == fail_seen) {
fprintf(stderr, "%d: malloc failed\n", rank);
return 1;
}
memset(fail_seen, 0, sizeof(int) * ITERS);
target.rank = 0;
for (i = 0 ; i < ITERS ; ++i) {
CHECK_RETURNVAL(PtlPut(md_handle,
0,
0,
PTL_ACK_REQ,
target,
5,
0,
0,
(void*)(size_t)i,
0));
usleep(100);
}
while (count < ITERS) {
ret = PtlEQGet(eq_handle, &ev);
if (PTL_EQ_EMPTY == ret) {
continue;
} else if (PTL_OK != ret) {
fprintf(stderr, "%d: PtlEQGet returned %d\n", rank, ret);
return 1;
}
if (ev.ni_fail_type == PTL_NI_OK) {
if (ev.type == PTL_EVENT_SEND) {
continue;
} else if (ev.type == PTL_EVENT_ACK) {
count++;
} else {
fprintf(stderr, "%d: Unexpected event type %d\n", rank, ev.type);
}
} else if (ev.ni_fail_type == PTL_NI_PT_DISABLED) {
int iter = (size_t) ev.user_ptr;
if (fail_seen[iter]++ > 0) {
fprintf(stderr, "%d: Double report of PT_DISABLED for "
"iteration %d\n", rank, iter);
return 1;
}
count++;
fails++;
} else {
fprintf(stderr, "%d: Unexpected fail type: %d\n", rank, ev.ni_fail_type);
return 1;
}
}
fprintf(stderr, "%d: Saw %d of %d events as fails\n", rank, fails, count);
CHECK_RETURNVAL(PtlPut(md_handle,
0,
0,
PTL_NO_ACK_REQ,
target,
6,
0,
0,
NULL,
0));
/* wait for the send event on the last put */
CHECK_RETURNVAL(PtlEQWait(eq_handle, &ev));
while (fails > 0) {
CHECK_RETURNVAL(PtlPut(md_handle,
0,
0,
PTL_ACK_REQ,
target,
5,
0,
0,
NULL,
0));
while (1) {
ret = PtlEQWait(eq_handle, &ev);
if (PTL_OK != ret) {
fprintf(stderr, "%d: PtlEQWait returned %d\n", rank, ret);
return 1;
}
if (ev.ni_fail_type == PTL_NI_OK) {
if (ev.type == PTL_EVENT_SEND) {
continue;
} else if (ev.type == PTL_EVENT_ACK) {
fails--;
break;
} else {
fprintf(stderr, "%d: Unexpected event type %d\n", rank, ev.type);
}
} else if (ev.ni_fail_type == PTL_NI_PT_DISABLED) {
break;
} else {
fprintf(stderr, "%d: Unexpected fail type: %d\n", rank, ev.ni_fail_type);
return 1;
}
}
}
}
libtest_barrier();
if (0 == rank) {
CHECK_RETURNVAL(UNLINK(signal_e_handle));
CHECK_RETURNVAL(PtlPTFree(ni_handle, signal_pt_index));
CHECK_RETURNVAL(PtlCTFree(ct_handle));
CHECK_RETURNVAL(UNLINK(value_e_handle));
CHECK_RETURNVAL(PtlPTFree(ni_handle, pt_index));
CHECK_RETURNVAL(PtlEQFree(eq_handle));
} else {
CHECK_RETURNVAL(PtlMDRelease(md_handle));
CHECK_RETURNVAL(PtlEQFree(eq_handle));
}
CHECK_RETURNVAL(PtlNIFini(ni_handle));
CHECK_RETURNVAL(libtest_fini());
PtlFini();
return 0;
}
int
ompi_coll_portals4_barrier_intra(struct ompi_communicator_t *comm,
mca_coll_base_module_t *module)
{
mca_coll_portals4_module_t *portals4_module = (mca_coll_portals4_module_t*) module;
int ret, i, dim, hibit, mask, num_msgs;
int size = ompi_comm_size(comm);
int rank = ompi_comm_rank(comm);
ptl_ct_event_t ct;
ptl_handle_ct_t ct_h;
ptl_handle_me_t me_h;
ptl_me_t me;
size_t count;
ptl_match_bits_t match_bits;
ptl_handle_md_t md_h;
void *base;
ompi_coll_portals4_get_md(0, &md_h, &base);
count = opal_atomic_add_size_t(&portals4_module->barrier_count, 1);
ret = PtlCTAlloc(mca_coll_portals4_component.ni_h,
&ct_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_coll_base_framework.framework_output,
"%s:%d: PtlCTAlloc failed: %d\n",
__FILE__, __LINE__, ret);
return OMPI_ERR_TEMP_OUT_OF_RESOURCE;
}
COLL_PORTALS4_SET_BITS(match_bits, ompi_comm_get_cid(comm),
0, COLL_PORTALS4_BARRIER, count);
/* Build "tree" out of hypercube */
dim = comm->c_cube_dim;
hibit = opal_hibit(rank, dim);
--dim;
/* receive space */
me.start = NULL;
me.length = 0;
me.ct_handle = ct_h;
me.min_free = 0;
me.uid = mca_coll_portals4_component.uid;
me.options = PTL_ME_OP_PUT | PTL_ME_EVENT_SUCCESS_DISABLE |
PTL_ME_EVENT_LINK_DISABLE | PTL_ME_EVENT_UNLINK_DISABLE |
PTL_ME_EVENT_CT_COMM | PTL_ME_EVENT_CT_OVERFLOW;
me.match_id.phys.nid = PTL_NID_ANY;
me.match_id.phys.pid = PTL_PID_ANY;
me.match_bits = match_bits;
me.ignore_bits = 0;
ret = PtlMEAppend(mca_coll_portals4_component.ni_h,
mca_coll_portals4_component.pt_idx,
&me,
PTL_PRIORITY_LIST,
NULL,
&me_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_coll_base_framework.framework_output,
"%s:%d: PtlMEAppend failed: %d\n",
__FILE__, __LINE__, ret);
return OMPI_ERROR;
}
/* calculate number of children to receive from */
num_msgs = ompi_coll_portals4_get_nchildren(dim + 1, hibit, rank, size);
/* send to parent when children have sent to us */
if (rank > 0) {
int parent = rank & ~(1 << hibit);
ret = PtlTriggeredPut(md_h,
0,
0,
PTL_NO_ACK_REQ,
ompi_coll_portals4_get_peer(comm, parent),
mca_coll_portals4_component.pt_idx,
match_bits,
0,
NULL,
0,
ct_h,
num_msgs);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_coll_base_framework.framework_output,
"%s:%d: PtlTriggeredPut failed: %d\n",
__FILE__, __LINE__, ret);
return OMPI_ERROR;
}
/* we'll need to wait for the parent response before the next set of comms */
num_msgs++;
}
/* send to children when parent (or all children if root) has sent to us */
for (i = hibit + 1, mask = 1 << i; i <= dim; ++i, mask <<= 1) {
int peer = rank | mask;
if (peer < size) {
ret = PtlTriggeredPut(md_h,
0,
0,
PTL_NO_ACK_REQ,
ompi_coll_portals4_get_peer(comm, peer),
mca_coll_portals4_component.pt_idx,
match_bits,
0,
NULL,
0,
ct_h,
num_msgs);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_coll_base_framework.framework_output,
"%s:%d: PtlTriggeredPut failed: %d\n",
__FILE__, __LINE__, ret);
return OMPI_ERROR;
}
}
}
/* Wait for all incoming messages */
ret = PtlCTWait(ct_h, num_msgs, &ct);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_coll_base_framework.framework_output,
"%s:%d: PtlCTWait failed: %d\n",
__FILE__, __LINE__, ret);
return OMPI_ERROR;
}
/* cleanup */
ret = PtlMEUnlink(me_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_coll_base_framework.framework_output,
"%s:%d: PtlMEUnlink failed: %d\n",
__FILE__, __LINE__, ret);
return OMPI_ERROR;
}
ret = PtlCTFree(ct_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_coll_base_framework.framework_output,
"%s:%d: PtlCTFree failed: %d\n",
__FILE__, __LINE__, ret);
return OMPI_ERROR;
}
return OMPI_SUCCESS;
}
static void
cleanup_handles(void)
{
if (!PtlHandleIsEqual(shmem_transport_portals4_get_md_h, PTL_INVALID_HANDLE)) {
PtlMDRelease(shmem_transport_portals4_get_md_h);
}
if (!PtlHandleIsEqual(shmem_transport_portals4_put_event_md_h, PTL_INVALID_HANDLE)) {
PtlMDRelease(shmem_transport_portals4_put_event_md_h);
}
if (!PtlHandleIsEqual(shmem_transport_portals4_put_volatile_md_h, PTL_INVALID_HANDLE)) {
PtlMDRelease(shmem_transport_portals4_put_volatile_md_h);
}
if (!PtlHandleIsEqual(shmem_transport_portals4_put_cntr_md_h, PTL_INVALID_HANDLE)) {
PtlMDRelease(shmem_transport_portals4_put_cntr_md_h);
}
if (!PtlHandleIsEqual(shmem_transport_portals4_get_ct_h, PTL_INVALID_HANDLE)) {
PtlCTFree(shmem_transport_portals4_get_ct_h);
}
if (!PtlHandleIsEqual(shmem_transport_portals4_put_ct_h, PTL_INVALID_HANDLE)) {
PtlCTFree(shmem_transport_portals4_put_ct_h);
}
#ifdef ENABLE_REMOTE_VIRTUAL_ADDRESSING
if (!PtlHandleIsEqual(shmem_transport_portals4_le_h, PTL_INVALID_HANDLE)) {
PtlLEUnlink(shmem_transport_portals4_le_h);
}
#else
if (!PtlHandleIsEqual(shmem_transport_portals4_heap_le_h, PTL_INVALID_HANDLE)) {
PtlLEUnlink(shmem_transport_portals4_heap_le_h);
}
if (!PtlHandleIsEqual(shmem_transport_portals4_data_le_h, PTL_INVALID_HANDLE)) {
PtlLEUnlink(shmem_transport_portals4_data_le_h);
}
#endif
#ifndef ENABLE_HARD_POLLING
if (!PtlHandleIsEqual(shmem_transport_portals4_target_ct_h, PTL_INVALID_HANDLE)) {
PtlCTFree(shmem_transport_portals4_target_ct_h);
}
#endif
#ifdef ENABLE_REMOTE_VIRTUAL_ADDRESSING
if (PTL_PT_ANY != all_pt) {
PtlPTFree(shmem_transport_portals4_ni_h, all_pt);
}
#else
if (PTL_PT_ANY != heap_pt) {
PtlPTFree(shmem_transport_portals4_ni_h, heap_pt);
}
if (PTL_PT_ANY != data_pt) {
PtlPTFree(shmem_transport_portals4_ni_h, data_pt);
}
#endif
if (!PtlHandleIsEqual(shmem_transport_portals4_eq_h, PTL_INVALID_HANDLE)) {
PtlEQFree(shmem_transport_portals4_eq_h);
}
if (!PtlHandleIsEqual(shmem_transport_portals4_ni_h, PTL_INVALID_HANDLE)) {
PtlNIFini(shmem_transport_portals4_ni_h);
}
if (NULL != shmem_transport_portals4_bounce_buffers) {
shmem_free_list_destroy(shmem_transport_portals4_bounce_buffers);
}
if (NULL != shmem_transport_portals4_long_frags) {
shmem_free_list_destroy(shmem_transport_portals4_long_frags);
}
}
/* called when a receive should be progressed */
static int
ompi_mtl_portals4_recv_progress(ptl_event_t *ev,
ompi_mtl_portals4_base_request_t* ptl_base_request)
{
int ret;
ompi_mtl_portals4_recv_request_t* ptl_request =
(ompi_mtl_portals4_recv_request_t*) ptl_base_request;
size_t msg_length = 0;
ptl_match_bits_t read_match_bits;
/* as soon as we've seen any event associated with a request, it's
started */
ptl_request->req_started = true;
switch (ev->type) {
case PTL_EVENT_PUT:
OPAL_OUTPUT_VERBOSE((50, ompi_mtl_base_framework.framework_output,
"Recv %lu (0x%lx) got put event",
ptl_request->opcount, ev->hdr_data));
if (ev->ni_fail_type != PTL_NI_OK) {
opal_output_verbose(1, ompi_mtl_base_framework.framework_output,
"%s:%d: PTL_EVENT_PUT with ni_fail_type: %d",
__FILE__, __LINE__, ev->ni_fail_type);
goto callback_error;
}
ptl_request->me_h = PTL_INVALID_HANDLE;
msg_length = MTL_PORTALS4_GET_LENGTH(ev->hdr_data);
ptl_request->super.super.ompi_req->req_status.MPI_SOURCE =
MTL_PORTALS4_GET_SOURCE(ev->match_bits);
ptl_request->super.super.ompi_req->req_status.MPI_TAG =
MTL_PORTALS4_GET_TAG(ev->match_bits);
if (OPAL_UNLIKELY(msg_length > ptl_request->delivery_len)) {
opal_output_verbose(1, ompi_mtl_base_framework.framework_output,
"truncate expected: %ld %ld",
msg_length, ptl_request->delivery_len);
ptl_request->super.super.ompi_req->req_status.MPI_ERROR = MPI_ERR_TRUNCATE;
}
#if OPAL_ENABLE_DEBUG
ptl_request->hdr_data = ev->hdr_data;
#endif
if (!MTL_PORTALS4_IS_SHORT_MSG(ev->match_bits) && ompi_mtl_portals4.protocol == rndv) {
/* If it's not a short message and we're doing rndv, we
only have the first part of the message. Issue the get
to pull the second part of the message. */
if (ptl_request->is_triggered) {
ptl_request->super.super.ompi_req->req_status._ucount = 0;
}
else {
ptl_request->super.super.ompi_req->req_status._ucount = ompi_mtl_portals4.eager_limit;
MTL_PORTALS4_SET_READ_BITS(read_match_bits,
MTL_PORTALS4_GET_CONTEXT(ev->match_bits),
MTL_PORTALS4_GET_TAG(ev->match_bits));
ret = read_msg((char*) ptl_request->delivery_ptr + ompi_mtl_portals4.eager_limit,
((msg_length > ptl_request->delivery_len) ?
ptl_request->delivery_len : msg_length) - ompi_mtl_portals4.eager_limit,
ev->initiator,
read_match_bits,
ompi_mtl_portals4.eager_limit,
ptl_request);
if (OPAL_UNLIKELY(OMPI_SUCCESS != ret)) {
if (NULL != ptl_request->buffer_ptr) free(ptl_request->buffer_ptr);
goto callback_error;
}
}
} else {
/* If we're either using the eager protocol or were a
short message, all data has been received, so complete
the message. */
ret = ompi_mtl_datatype_unpack(ptl_request->convertor,
ev->start,
ev->mlength);
if (OPAL_UNLIKELY(OMPI_SUCCESS != ret)) {
opal_output_verbose(1, ompi_mtl_base_framework.framework_output,
"%s:%d: ompi_mtl_datatype_unpack failed: %d",
__FILE__, __LINE__, ret);
ptl_request->super.super.ompi_req->req_status.MPI_ERROR = ret;
}
ptl_request->super.super.ompi_req->req_status._ucount = ev->mlength;
OPAL_OUTPUT_VERBOSE((50, ompi_mtl_base_framework.framework_output,
"Recv %lu (0x%lx) completed, expected",
ptl_request->opcount, ptl_request->hdr_data));
ptl_request->super.super.completion_callback(&ptl_request->super.super);
}
break;
case PTL_EVENT_REPLY:
OPAL_OUTPUT_VERBOSE((50, ompi_mtl_base_framework.framework_output,
"Recv %lu (0x%lx) got reply event",
ptl_request->opcount, ptl_request->hdr_data));
if (OPAL_UNLIKELY(ev->ni_fail_type != PTL_NI_OK)) {
opal_output_verbose(1, ompi_mtl_base_framework.framework_output,
"%s:%d: PTL_EVENT_REPLY with ni_fail_type: %d",
__FILE__, __LINE__, ev->ni_fail_type);
goto callback_error;
}
if (ptl_request->is_triggered) {
PtlCTFree(ptl_request->ct_h);
ptl_request->ct_h = PTL_INVALID_HANDLE;
}
/* set the received length in the status, now that we know
exactly how much data was sent. */
ptl_request->super.super.ompi_req->req_status._ucount += ev->mlength;
#if OMPI_MTL_PORTALS4_FLOW_CONTROL
OPAL_THREAD_ADD32(&ompi_mtl_portals4.flowctl.send_slots, 1);
#endif
/* make sure the data is in the right place. Use _ucount for
the total length because it will be set correctly for all
three protocols. mlength is only correct for eager, and
delivery_len is the length of the buffer, not the length of
the send. */
ret = ompi_mtl_datatype_unpack(ptl_request->convertor,
ptl_request->delivery_ptr,
ptl_request->super.super.ompi_req->req_status._ucount);
if (OPAL_UNLIKELY(OMPI_SUCCESS != ret)) {
opal_output_verbose(1, ompi_mtl_base_framework.framework_output,
"%s:%d: ompi_mtl_datatype_unpack failed: %d",
__FILE__, __LINE__, ret);
ptl_request->super.super.ompi_req->req_status.MPI_ERROR = ret;
}
OPAL_OUTPUT_VERBOSE((50, ompi_mtl_base_framework.framework_output,
"Recv %lu (0x%lx) completed, reply",
ptl_request->opcount, ptl_request->hdr_data));
ptl_request->super.super.completion_callback(&ptl_request->super.super);
break;
case PTL_EVENT_PUT_OVERFLOW:
OPAL_OUTPUT_VERBOSE((50, ompi_mtl_base_framework.framework_output,
"Recv %lu (0x%lx) got put_overflow event",
ptl_request->opcount, ev->hdr_data));
if (OPAL_UNLIKELY(ev->ni_fail_type != PTL_NI_OK)) {
opal_output_verbose(1, ompi_mtl_base_framework.framework_output,
"%s:%d: PTL_EVENT_PUT_OVERFLOW with ni_fail_type: %d",
__FILE__, __LINE__, ev->ni_fail_type);
goto callback_error;
}
ptl_request->me_h = PTL_INVALID_HANDLE;
msg_length = MTL_PORTALS4_GET_LENGTH(ev->hdr_data);
ptl_request->super.super.ompi_req->req_status.MPI_SOURCE =
MTL_PORTALS4_GET_SOURCE(ev->match_bits);
ptl_request->super.super.ompi_req->req_status.MPI_TAG =
MTL_PORTALS4_GET_TAG(ev->match_bits);
if (OPAL_UNLIKELY(msg_length > ptl_request->delivery_len)) {
opal_output_verbose(1, ompi_mtl_base_framework.framework_output,
"truncate unexpected: %ld %ld %d",
msg_length, ptl_request->delivery_len,
MTL_PORTALS4_IS_SHORT_MSG(ev->match_bits));
ptl_request->super.super.ompi_req->req_status.MPI_ERROR = MPI_ERR_TRUNCATE;
}
#if OPAL_ENABLE_DEBUG
ptl_request->hdr_data = ev->hdr_data;
#endif
ptl_request->super.super.ompi_req->req_status._ucount = ev->mlength;
/* overflow case. Short messages have the buffer stashed
somewhere. Long messages left in buffer at the source */
if (MTL_PORTALS4_IS_SHORT_MSG(ev->match_bits)) {
if (ev->mlength > 0) {
struct iovec iov;
uint32_t iov_count = 1;
size_t max_data;
iov.iov_base = (char*) ev->start;
iov.iov_len = ev->mlength;
max_data = iov.iov_len;
ret = opal_convertor_unpack(ptl_request->convertor,
&iov, &iov_count,
&max_data );
if (NULL != ptl_request->buffer_ptr) free(ptl_request->buffer_ptr);
if (OPAL_UNLIKELY(ret < 0)) {
opal_output_verbose(1, ompi_mtl_base_framework.framework_output,
"%s:%d: opal_convertor_unpack failed: %d",
__FILE__, __LINE__, ret);
goto callback_error;
}
}
/* if it's a sync, send the ack */
if (MTL_PORTALS4_IS_SYNC_MSG(ev->hdr_data)) {
OPAL_OUTPUT_VERBOSE((50, ompi_mtl_base_framework.framework_output,
"Recv %lu (0x%lx) sending sync ack",
ptl_request->opcount, ptl_request->hdr_data));
ret = PtlPut(ompi_mtl_portals4.zero_md_h,
0,
0,
PTL_NO_ACK_REQ,
ev->initiator,
ompi_mtl_portals4.read_idx,
ev->hdr_data,
0,
NULL,
0);
if (OPAL_UNLIKELY(PTL_OK != ret)) {
opal_output_verbose(1, ompi_mtl_base_framework.framework_output,
"%s:%d: PtlPut failed: %d",
__FILE__, __LINE__, ret);
goto callback_error;
}
}
OPAL_OUTPUT_VERBOSE((50, ompi_mtl_base_framework.framework_output,
"Recv %lu (0x%lx) completed, unexpected short (0x%lx)",
ptl_request->opcount, ptl_request->hdr_data, (long) ev->start));
ptl_request->super.super.completion_callback(&ptl_request->super.super);
} else {
if (!ptl_request->is_triggered) {
if (ev->mlength > 0) {
/* if rndv or triggered, copy the eager part to the right place */
memcpy(ptl_request->delivery_ptr, ev->start, ev->mlength);
}
MTL_PORTALS4_SET_READ_BITS(read_match_bits,
MTL_PORTALS4_GET_CONTEXT(ev->match_bits),
MTL_PORTALS4_GET_TAG(ev->match_bits));
ret = read_msg((char*) ptl_request->delivery_ptr + ev->mlength,
((msg_length > ptl_request->delivery_len) ?
ptl_request->delivery_len : msg_length) - ev->mlength,
ev->initiator,
read_match_bits,
ev->mlength,
ptl_request);
if (OPAL_UNLIKELY(OMPI_SUCCESS != ret)) {
if (NULL != ptl_request->buffer_ptr) free(ptl_request->buffer_ptr);
goto callback_error;
}
}
}
break;
case PTL_EVENT_LINK:
break;
default:
opal_output_verbose(1, ompi_mtl_base_framework.framework_output,
"Unhandled receive callback with event type %d",
ev->type);
return OMPI_ERROR;
}
return OMPI_SUCCESS;
callback_error:
ptl_request->super.super.ompi_req->req_status.MPI_ERROR =
ompi_mtl_portals4_get_error(ret);
ptl_request->super.super.completion_callback(&ptl_request->super.super);
return OMPI_SUCCESS;
}
void
CleanUp(ArgStruct *p)
{
int rc;
/* Free all CTs */
rc= PtlCTFree(send_ct_handle);
LIBTEST_CHECK(rc, "PtlCTFree(send_ct_handle) in CleanUp");
rc= PtlCTFree(send_int_ct_handle);
LIBTEST_CHECK(rc, "PtlCTFree(send_int_ct_handle) in CleanUp");
rc= PtlCTFree(send_double_ct_handle);
LIBTEST_CHECK(rc, "PtlCTFree(send_double_ct_handle) in CleanUp");
rc= PtlCTFree(recv_ct_handle);
LIBTEST_CHECK(rc, "PtlCTFree(recv_ct_handle) in CleanUp");
rc= PtlCTFree(recv_int_ct_handle);
LIBTEST_CHECK(rc, "PtlCTFree(recv_int_ct_handle) in CleanUp");
rc= PtlCTFree(recv_double_ct_handle);
LIBTEST_CHECK(rc, "PtlCTFree(recv_double_ct_handle) in CleanUp");
/* Free all MDs */
rc= PtlMDRelease(md_handle);
LIBTEST_CHECK(rc, "PtlMDRelease(md_handle) in CleanUp");
rc= PtlMDRelease(send_int_md_handle);
LIBTEST_CHECK(rc, "PtlMDRelease (send_int_md_handle) in CleanUp");
rc= PtlMDRelease(send_double_md_handle);
LIBTEST_CHECK(rc, "PtlMDRelease (send_double_md_handle) in CleanUp");
/* Free all LEs */
rc= PtlLEUnlink(le_handle);
LIBTEST_CHECK(rc, "PtlLEUnlink(le_handle) in CleanUp");
rc= PtlLEUnlink(recv_int_le_handle);
LIBTEST_CHECK(rc, "PtlLEUnlink(recv_int_le_handle) in CleanUp");
rc= PtlLEUnlink(recv_double_le_handle);
LIBTEST_CHECK(rc, "PtlLEUnlink(recv_double_le_handle) in CleanUp");
/* Free the Portal table entries we used */
rc= PtlPTFree(ni_logical, PTL_XMIT_INDEX);
LIBTEST_CHECK(rc, "PtlPTFree(PTL_XMIT_INDEX) in CleanUp");
rc= PtlPTFree(ni_logical, PTL_SEND_INT_INDEX);
LIBTEST_CHECK(rc, "PtlPTFree(PTL_SEND_INT_INDEX) in CleanUp");
rc= PtlPTFree(ni_logical, PTL_SEND_DOUBLE_INDEX);
LIBTEST_CHECK(rc, "PtlPTFree(PTL_SEND_DOUBLE_INDEX) in CleanUp");
/* Almost done */
PtlNIFini(ni_logical);
PtlFini();
} /* end of CleanUp() */
