static int
component_finalize(void)
{
PtlNIFini(mca_osc_portals4_component.matching_ni_h);
return OMPI_SUCCESS;
}
void mca_btl_portals4_free_module(mca_btl_portals4_module_t *portals4_btl)
{
int ret;
OPAL_OUTPUT_VERBOSE((90, opal_btl_base_framework.framework_output,
"mca_btl_portals4_free_module portals_outstanding_ops=%d\n", portals4_btl->portals_outstanding_ops));
/* sanity check */
assert(portals4_btl->portals_outstanding_ops >= 0);
/* finalize all communication */
while (portals4_btl->portals_outstanding_ops > 0) {
OPAL_OUTPUT_VERBOSE((90, opal_btl_base_framework.framework_output,
"mca_btl_portals4_free_module portals_outstanding_ops: %d",
portals4_btl->portals_outstanding_ops));
OPAL_OUTPUT_VERBOSE((90, opal_btl_base_framework.framework_output, "Call to mca_btl_portals4_component_progress (3)\n"));
mca_btl_portals4_component_progress();
}
if (!PtlHandleIsEqual(portals4_btl->send_md_h, PTL_INVALID_HANDLE)) {
PtlMDRelease(portals4_btl->send_md_h);
portals4_btl->send_md_h = PTL_INVALID_HANDLE;
}
if (!PtlHandleIsEqual(portals4_btl->zero_md_h, PTL_INVALID_HANDLE)) {
PtlMDRelease(portals4_btl->zero_md_h);
portals4_btl->zero_md_h = PTL_INVALID_HANDLE;
}
if (!PtlHandleIsEqual(portals4_btl->long_overflow_me_h, PTL_INVALID_HANDLE)) {
PtlMEUnlink(portals4_btl->long_overflow_me_h);
portals4_btl->long_overflow_me_h = PTL_INVALID_HANDLE;
}
if ((ptl_pt_index_t) ~0UL != mca_btl_portals4_module.recv_idx) {
PtlPTFree(portals4_btl->portals_ni_h, portals4_btl->recv_idx);
portals4_btl->recv_idx= (ptl_pt_index_t) ~0UL;
}
if (PTL_EQ_NONE != portals4_btl->recv_eq_h) {
ret = PtlEQFree(portals4_btl->recv_eq_h);
if (PTL_OK != ret) OPAL_OUTPUT_VERBOSE((90, opal_btl_base_framework.framework_output, "Error freeing EQ recv: %d", ret));
OPAL_OUTPUT_VERBOSE((90, opal_btl_base_framework.framework_output, "PtlEQFree: recv_eq_h=%d portals4_btl=%p",
portals4_btl->recv_eq_h, (void*)portals4_btl));
portals4_btl->recv_eq_h = PTL_EQ_NONE;
}
if (!PtlHandleIsEqual(portals4_btl->portals_ni_h, PTL_INVALID_HANDLE)) {
ret = PtlNIFini(portals4_btl->portals_ni_h);
if (PTL_OK != ret) OPAL_OUTPUT_VERBOSE((90, opal_btl_base_framework.framework_output, "Error returned by PtlNIFini: %d\n", ret));
OPAL_OUTPUT_VERBOSE((90, opal_btl_base_framework.framework_output, "PtlNIFini: portals_ni_h=%d portals4_btl=%p",
portals4_btl->portals_ni_h, (void*)portals4_btl));
portals4_btl->portals_ni_h = PTL_INVALID_HANDLE;
}
ret = mca_btl_portals4_recv_disable(portals4_btl);
if (PTL_OK != ret) OPAL_OUTPUT_VERBOSE((90, opal_btl_base_framework.framework_output, "Error freeing recv list: %d", ret));
}
int
ompi_common_portals_ni_finalize(void)
{
if (OPAL_THREAD_ADD32(&ni_usage_count, -1) <= 0) {
if (PTL_INVALID_HANDLE != active_ni_h) {
if (PTL_OK != PtlNIFini(active_ni_h)) {
active_ni_h = PTL_INVALID_HANDLE;
return OMPI_ERROR;
}
active_ni_h = PTL_INVALID_HANDLE;
}
}
return OMPI_SUCCESS;
}
int
ompi_mtl_portals4_finalize(struct mca_mtl_base_module_t *mtl)
{
opal_progress_unregister(ompi_mtl_portals4_progress);
while (0 != ompi_mtl_portals4_progress()) { }
ompi_mtl_portals4_recv_short_fini(&ompi_mtl_portals4);
PtlMEUnlink(ompi_mtl_portals4.long_overflow_me_h);
PtlMDRelease(ompi_mtl_portals4.zero_md_h);
PtlPTFree(ompi_mtl_portals4.ni_h, ompi_mtl_portals4.read_idx);
PtlPTFree(ompi_mtl_portals4.ni_h, ompi_mtl_portals4.send_idx);
PtlEQFree(ompi_mtl_portals4.eq_h);
PtlNIFini(ompi_mtl_portals4.ni_h);
PtlFini();
return OMPI_SUCCESS;
}
int
ompi_mtl_portals4_finalize(struct mca_mtl_base_module_t *mtl)
{
opal_progress_unregister(ompi_mtl_portals4_progress);
while (0 != ompi_mtl_portals4_progress()) { }
#if OMPI_MTL_PORTALS4_FLOW_CONTROL
ompi_mtl_portals4_flowctl_fini();
#endif
ompi_mtl_portals4_recv_short_fini();
PtlMEUnlink(ompi_mtl_portals4.long_overflow_me_h);
PtlMDRelease(ompi_mtl_portals4.zero_md_h);
#if OPAL_PORTALS4_MAX_MD_SIZE < OPAL_PORTALS4_MAX_VA_SIZE
{
int i;
int num_mds = ompi_mtl_portals4_get_num_mds();
for (i = 0 ; i < num_mds ; ++i) {
PtlMDRelease(ompi_mtl_portals4.send_md_hs[i]);
}
free(ompi_mtl_portals4.send_md_hs);
}
#else
PtlMDRelease(ompi_mtl_portals4.send_md_h);
#endif
PtlPTFree(ompi_mtl_portals4.ni_h, ompi_mtl_portals4.read_idx);
PtlPTFree(ompi_mtl_portals4.ni_h, ompi_mtl_portals4.recv_idx);
PtlEQFree(ompi_mtl_portals4.send_eq_h);
PtlEQFree(ompi_mtl_portals4.recv_eq_h);
PtlNIFini(ompi_mtl_portals4.ni_h);
PtlFini();
return OMPI_SUCCESS;
}
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;
}
static int
portals4_close(void)
{
int ret;
OBJ_DESTRUCT(&mca_coll_portals4_component.requests);
if (!PtlHandleIsEqual(mca_coll_portals4_component.zero_md_h, PTL_INVALID_HANDLE)) {
ret = PtlMDRelease(mca_coll_portals4_component.zero_md_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_coll_base_framework.framework_output,
"%s:%d: PtlMDRelease failed: %d\n",
__FILE__, __LINE__, ret);
}
}
mca_coll_portals4_component.zero_md_h = PTL_INVALID_HANDLE;
if (!PtlHandleIsEqual(mca_coll_portals4_component.data_md_h, PTL_INVALID_HANDLE)) {
ret = PtlMDRelease(mca_coll_portals4_component.data_md_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_coll_base_framework.framework_output,
"%s:%d: PtlMDRelease failed: %d\n",
__FILE__, __LINE__, ret);
}
}
mca_coll_portals4_component.data_md_h = PTL_INVALID_HANDLE;
if (!PtlHandleIsEqual(mca_coll_portals4_component.finish_me_h, PTL_INVALID_HANDLE)) {
ret = PtlMEUnlink(mca_coll_portals4_component.finish_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);
}
}
if (!PtlHandleIsEqual(mca_coll_portals4_component.unex_me_h, PTL_INVALID_HANDLE)) {
ret = PtlMEUnlink(mca_coll_portals4_component.unex_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);
}
}
if (mca_coll_portals4_component.finish_pt_idx >= 0) {
ret = PtlPTFree(mca_coll_portals4_component.ni_h, mca_coll_portals4_component.finish_pt_idx);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_coll_base_framework.framework_output,
"%s:%d: PtlPTFree failed: %d\n",
__FILE__, __LINE__, ret);
}
}
if (mca_coll_portals4_component.pt_idx >= 0) {
ret = PtlPTFree(mca_coll_portals4_component.ni_h, mca_coll_portals4_component.pt_idx);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_coll_base_framework.framework_output,
"%s:%d: PtlPTFree failed: %d\n",
__FILE__, __LINE__, ret);
}
}
if (!PtlHandleIsEqual(mca_coll_portals4_component.eq_h, PTL_INVALID_HANDLE)) {
ret = PtlEQFree(mca_coll_portals4_component.eq_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_coll_base_framework.framework_output,
"%s:%d: PtlEQFree failed: %d\n",
__FILE__, __LINE__, ret);
}
}
if (!PtlHandleIsEqual(mca_coll_portals4_component.ni_h, PTL_INVALID_HANDLE)) {
ret = PtlNIFini(mca_coll_portals4_component.ni_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_coll_base_framework.framework_output,
"%s:%d: PtlNIFini failed: %d\n",
__FILE__, __LINE__, ret);
}
PtlFini();
}
opal_progress_unregister(portals4_progress);
return OMPI_SUCCESS;
}
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, char **envp)
{
int i,ret,npes;
int num_interfaces;
ptl_handle_ni_t nih;
ptl_handle_eq_t eqh;
ptl_ni_limits_t ptl_limits;
pid_t child;
ptl_process_id_t rnk;
child = fork();
if ((ret=PtlInit(&num_interfaces)) != PTL_OK) {
printf("%s: PtlInit failed: %d\n", FUNCTION_NAME, ret);
exit(1);
}
printf("%s: PtlInit succeeds (%d)\n", FUNCTION_NAME, ret);
if ((ret=PtlNIInit(
IFACE_FROM_BRIDGE_AND_NALID(PTL_BRIDGE_UK, PTL_IFACE_SS),
PTL_PID_ANY, NULL, &ptl_limits, &nih)) != PTL_OK) {
printf("%s: PtlNIInit 1 failed: %d\n", FUNCTION_NAME, ret);
}
if((ret = PtlNIFini(nih)) !=PTL_OK){
printf("%s: PtlNIFini failed: %d\n", FUNCTION_NAME, ret);
}
PtlFini();
if ((ret=PtlInit(&num_interfaces)) != PTL_OK) {
printf("%s: PtlInit failed: %d\n", FUNCTION_NAME, ret);
exit(1);
}
if ((ret=PtlNIInit(
IFACE_FROM_BRIDGE_AND_NALID(PTL_BRIDGE_UK, PTL_IFACE_SS),
PTL_PID_ANY, NULL, &ptl_limits, &nih)) != PTL_OK) {
printf("%s: PtlNIInit 2 failed: %d\n", FUNCTION_NAME, ret);
exit(1);
}
#if 0
if ((ret=PtlNIInit(
IFACE_FROM_BRIDGE_AND_NALID(PTL_BRIDGE_UK, PTL_IFACE_SS),
PTL_PID_ANY, NULL, &ptl_limits, &nih)) != PTL_OK) {
printf("%s: PtlNIInit failed: %d\n", FUNCTION_NAME, ret);
exit(1);
}
#endif
printf("%s: PtlNIInit succeeds (%d)\n", FUNCTION_NAME, ret);
if ((ret=PtlEQAlloc(nih, 4096, NULL, &eqh)) != PTL_OK) {
printf("%s: PtlEQAlloc failed: %d(%d)\n",
FUNCTION_NAME, ret, child);
exit(1);
}
printf("%s: PtlEQAlloc succeeds (%d:%d)\n", FUNCTION_NAME, child, ret);
if ((ret=PtlGetId(nih,&rnk)) !=PTL_OK) {
printf("%s: PtlGetId failed: %d(%d)\n",
FUNCTION_NAME, ret, child);
exit(1);
}
printf("%s: nid=%d pid=%d(%d)\n",FUNCTION_NAME,rnk.nid,rnk.pid,child);
if(child){
MPI_Init(&argc,&argv);
MPI_Finalize();
printf("%s: mpi_init and finalize succeed(%d)\n",FUNCTION_NAME,child);
}
}
static int ptl_finalize(void)
{
int mpi_errno = MPI_SUCCESS;
int ret;
ptl_handle_eq_t eqs[5];
MPIR_FUNC_VERBOSE_STATE_DECL(MPID_STATE_PTL_FINALIZE);
MPIR_FUNC_VERBOSE_ENTER(MPID_STATE_PTL_FINALIZE);
/* shut down other modules */
mpi_errno = MPID_nem_ptl_nm_finalize();
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
mpi_errno = MPID_nem_ptl_poll_finalize();
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
/* shut down portals */
eqs[0] = MPIDI_nem_ptl_eq;
eqs[1] = MPIDI_nem_ptl_get_eq;
eqs[2] = MPIDI_nem_ptl_control_eq;
eqs[3] = MPIDI_nem_ptl_origin_eq;
eqs[4] = MPIDI_nem_ptl_rpt_eq;
ret = MPID_nem_ptl_rptl_drain_eq(5, eqs);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptfree", "**ptlptfree %s", MPID_nem_ptl_strerror(ret));
ret = MPID_nem_ptl_rptl_ptfini(MPIDI_nem_ptl_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptfree", "**ptlptfree %s", MPID_nem_ptl_strerror(ret));
ret = PtlPTFree(MPIDI_nem_ptl_ni, MPIDI_nem_ptl_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptfree", "**ptlptfree %s", MPID_nem_ptl_strerror(ret));
ret = MPID_nem_ptl_rptl_ptfini(MPIDI_nem_ptl_get_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptfree", "**ptlptfree %s", MPID_nem_ptl_strerror(ret));
ret = PtlPTFree(MPIDI_nem_ptl_ni, MPIDI_nem_ptl_get_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptfree", "**ptlptfree %s", MPID_nem_ptl_strerror(ret));
ret = MPID_nem_ptl_rptl_ptfini(MPIDI_nem_ptl_control_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptfree", "**ptlptfree %s", MPID_nem_ptl_strerror(ret));
ret = PtlPTFree(MPIDI_nem_ptl_ni, MPIDI_nem_ptl_control_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptfree", "**ptlptfree %s", MPID_nem_ptl_strerror(ret));
ret = PtlPTFree(MPIDI_nem_ptl_ni, MPIDI_nem_ptl_rpt_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptfree", "**ptlptfree %s", MPID_nem_ptl_strerror(ret));
ret = PtlPTFree(MPIDI_nem_ptl_ni, MPIDI_nem_ptl_get_rpt_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptfree", "**ptlptfree %s", MPID_nem_ptl_strerror(ret));
ret = PtlPTFree(MPIDI_nem_ptl_ni, MPIDI_nem_ptl_control_rpt_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptfree", "**ptlptfree %s", MPID_nem_ptl_strerror(ret));
ret = PtlNIFini(MPIDI_nem_ptl_ni);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlnifini", "**ptlnifini %s", MPID_nem_ptl_strerror(ret));
PtlFini();
fn_exit:
MPIR_FUNC_VERBOSE_EXIT(MPID_STATE_PTL_FINALIZE);
return mpi_errno;
fn_fail:
goto fn_exit;
}
static int ptl_init(MPIDI_PG_t *pg_p, int pg_rank, char **bc_val_p, int *val_max_sz_p)
{
int mpi_errno = MPI_SUCCESS;
int ret;
ptl_md_t md;
ptl_ni_limits_t desired;
MPIR_FUNC_VERBOSE_STATE_DECL(MPID_STATE_PTL_INIT);
MPIR_FUNC_VERBOSE_ENTER(MPID_STATE_PTL_INIT);
/* first make sure that our private fields in the vc and req fit into the area provided */
MPIR_Assert(sizeof(MPID_nem_ptl_vc_area) <= MPIDI_NEM_VC_NETMOD_AREA_LEN);
MPIR_Assert(sizeof(MPID_nem_ptl_req_area) <= MPIDI_NEM_REQ_NETMOD_AREA_LEN);
/* Make sure our IOV is the same as portals4's IOV */
MPIR_Assert(sizeof(ptl_iovec_t) == sizeof(MPL_IOV));
MPIR_Assert(((void*)&(((ptl_iovec_t*)0)->iov_base)) == ((void*)&(((MPL_IOV*)0)->MPL_IOV_BUF)));
MPIR_Assert(((void*)&(((ptl_iovec_t*)0)->iov_len)) == ((void*)&(((MPL_IOV*)0)->MPL_IOV_LEN)));
MPIR_Assert(sizeof(((ptl_iovec_t*)0)->iov_len) == sizeof(((MPL_IOV*)0)->MPL_IOV_LEN));
mpi_errno = MPIDI_CH3I_Register_anysource_notification(MPID_nem_ptl_anysource_posted, MPID_nem_ptl_anysource_matched);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
MPIDI_Anysource_improbe_fn = MPID_nem_ptl_anysource_improbe;
/* init portals */
ret = PtlInit();
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlinit", "**ptlinit %s", MPID_nem_ptl_strerror(ret));
/* do an interface pre-init to get the default limits struct */
ret = PtlNIInit(PTL_IFACE_DEFAULT, PTL_NI_MATCHING | PTL_NI_PHYSICAL,
PTL_PID_ANY, NULL, &desired, &MPIDI_nem_ptl_ni);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlniinit", "**ptlniinit %s", MPID_nem_ptl_strerror(ret));
/* finalize the interface so we can re-init with our desired maximums */
ret = PtlNIFini(MPIDI_nem_ptl_ni);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlnifini", "**ptlnifini %s", MPID_nem_ptl_strerror(ret));
/* set higher limits if they are determined to be too low */
if (desired.max_unexpected_headers < UNEXPECTED_HDR_COUNT && getenv("PTL_LIM_MAX_UNEXPECTED_HEADERS") == NULL)
desired.max_unexpected_headers = UNEXPECTED_HDR_COUNT;
if (desired.max_list_size < LIST_SIZE && getenv("PTL_LIM_MAX_LIST_SIZE") == NULL)
desired.max_list_size = LIST_SIZE;
if (desired.max_entries < ENTRY_COUNT && getenv("PTL_LIM_MAX_ENTRIES") == NULL)
desired.max_entries = ENTRY_COUNT;
/* do the real init */
ret = PtlNIInit(PTL_IFACE_DEFAULT, PTL_NI_MATCHING | PTL_NI_PHYSICAL,
PTL_PID_ANY, &desired, &MPIDI_nem_ptl_ni_limits, &MPIDI_nem_ptl_ni);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlniinit", "**ptlniinit %s", MPID_nem_ptl_strerror(ret));
/* allocate EQs for each portal */
ret = PtlEQAlloc(MPIDI_nem_ptl_ni, EVENT_COUNT, &MPIDI_nem_ptl_eq);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptleqalloc", "**ptleqalloc %s", MPID_nem_ptl_strerror(ret));
ret = PtlEQAlloc(MPIDI_nem_ptl_ni, EVENT_COUNT, &MPIDI_nem_ptl_get_eq);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptleqalloc", "**ptleqalloc %s", MPID_nem_ptl_strerror(ret));
ret = PtlEQAlloc(MPIDI_nem_ptl_ni, EVENT_COUNT, &MPIDI_nem_ptl_control_eq);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptleqalloc", "**ptleqalloc %s", MPID_nem_ptl_strerror(ret));
ret = PtlEQAlloc(MPIDI_nem_ptl_ni, EVENT_COUNT, &MPIDI_nem_ptl_rpt_eq);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptleqalloc", "**ptleqalloc %s", MPID_nem_ptl_strerror(ret));
/* allocate a separate EQ for origin events. with this, we can implement rate-limit operations
to prevent a locally triggered flow control even */
ret = PtlEQAlloc(MPIDI_nem_ptl_ni, EVENT_COUNT, &MPIDI_nem_ptl_origin_eq);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptleqalloc", "**ptleqalloc %s", MPID_nem_ptl_strerror(ret));
/* allocate portal for matching messages */
ret = PtlPTAlloc(MPIDI_nem_ptl_ni, PTL_PT_ONLY_USE_ONCE | PTL_PT_ONLY_TRUNCATE | PTL_PT_FLOWCTRL, MPIDI_nem_ptl_eq,
PTL_PT_ANY, &MPIDI_nem_ptl_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptalloc", "**ptlptalloc %s", MPID_nem_ptl_strerror(ret));
/* allocate portal for large messages where receiver does a get */
ret = PtlPTAlloc(MPIDI_nem_ptl_ni, PTL_PT_ONLY_USE_ONCE | PTL_PT_ONLY_TRUNCATE | PTL_PT_FLOWCTRL, MPIDI_nem_ptl_get_eq,
PTL_PT_ANY, &MPIDI_nem_ptl_get_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptalloc", "**ptlptalloc %s", MPID_nem_ptl_strerror(ret));
/* allocate portal for MPICH control messages */
ret = PtlPTAlloc(MPIDI_nem_ptl_ni, PTL_PT_ONLY_USE_ONCE | PTL_PT_ONLY_TRUNCATE | PTL_PT_FLOWCTRL, MPIDI_nem_ptl_control_eq,
PTL_PT_ANY, &MPIDI_nem_ptl_control_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptalloc", "**ptlptalloc %s", MPID_nem_ptl_strerror(ret));
/* allocate portal for MPICH control messages */
ret = PtlPTAlloc(MPIDI_nem_ptl_ni, PTL_PT_ONLY_USE_ONCE | PTL_PT_ONLY_TRUNCATE | PTL_PT_FLOWCTRL, MPIDI_nem_ptl_rpt_eq,
PTL_PT_ANY, &MPIDI_nem_ptl_rpt_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptalloc", "**ptlptalloc %s", MPID_nem_ptl_strerror(ret));
/* allocate portal for MPICH control messages */
ret = PtlPTAlloc(MPIDI_nem_ptl_ni, PTL_PT_ONLY_USE_ONCE | PTL_PT_ONLY_TRUNCATE | PTL_PT_FLOWCTRL, MPIDI_nem_ptl_rpt_eq,
PTL_PT_ANY, &MPIDI_nem_ptl_get_rpt_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptalloc", "**ptlptalloc %s", MPID_nem_ptl_strerror(ret));
/* allocate portal for MPICH control messages */
ret = PtlPTAlloc(MPIDI_nem_ptl_ni, PTL_PT_ONLY_USE_ONCE | PTL_PT_ONLY_TRUNCATE | PTL_PT_FLOWCTRL, MPIDI_nem_ptl_rpt_eq,
PTL_PT_ANY, &MPIDI_nem_ptl_control_rpt_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptalloc", "**ptlptalloc %s", MPID_nem_ptl_strerror(ret));
/* create an MD that covers all of memory */
md.start = 0;
md.length = (ptl_size_t)-1;
md.options = 0x0;
md.eq_handle = MPIDI_nem_ptl_origin_eq;
md.ct_handle = PTL_CT_NONE;
ret = PtlMDBind(MPIDI_nem_ptl_ni, &md, &MPIDI_nem_ptl_global_md);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlmdbind", "**ptlmdbind %s", MPID_nem_ptl_strerror(ret));
/* currently, rportlas only works with a single NI and EQ */
ret = MPID_nem_ptl_rptl_init(MPIDI_Process.my_pg->size, ORIGIN_EVENTS, get_target_info);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlniinit", "**ptlniinit %s", MPID_nem_ptl_strerror(ret));
/* allow rportal to manage the primary portal and retransmit if needed */
ret = MPID_nem_ptl_rptl_ptinit(MPIDI_nem_ptl_ni, MPIDI_nem_ptl_origin_eq, MPIDI_nem_ptl_pt, MPIDI_nem_ptl_rpt_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptalloc", "**ptlptalloc %s", MPID_nem_ptl_strerror(ret));
/* allow rportal to manage the get and control portals, but we
* don't expect retransmission to be needed on the get portal, so
* we pass PTL_PT_ANY as the dummy portal. unfortunately, portals
* does not have an "invalid" PT constant, which would have been
* more appropriate to pass over here. */
ret = MPID_nem_ptl_rptl_ptinit(MPIDI_nem_ptl_ni, MPIDI_nem_ptl_origin_eq, MPIDI_nem_ptl_get_pt, MPIDI_nem_ptl_get_rpt_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptalloc", "**ptlptalloc %s", MPID_nem_ptl_strerror(ret));
ret = MPID_nem_ptl_rptl_ptinit(MPIDI_nem_ptl_ni, MPIDI_nem_ptl_origin_eq, MPIDI_nem_ptl_control_pt, MPIDI_nem_ptl_control_rpt_pt);
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptlptalloc", "**ptlptalloc %s", MPID_nem_ptl_strerror(ret));
/* create business card */
mpi_errno = get_business_card(pg_rank, bc_val_p, val_max_sz_p);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
/* init other modules */
mpi_errno = MPID_nem_ptl_poll_init();
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
mpi_errno = MPID_nem_ptl_nm_init();
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
fn_exit:
MPIR_FUNC_VERBOSE_EXIT(MPID_STATE_PTL_INIT);
return mpi_errno;
fn_fail:
goto fn_exit;
}
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;
}
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);
}
}
int main(int argc,
char *argv[])
{
ptl_handle_ni_t ni_h;
ptl_pt_index_t pt_index;
uint64_t *buf;
ENTRY_T entry;
HANDLE_T entry_h;
ptl_md_t md;
ptl_handle_md_t md_h;
int rank;
int num_procs;
int ret;
ptl_process_t *procs;
ptl_handle_eq_t eq_h;
ptl_event_t ev;
ptl_hdr_data_t rcvd = 0;
ptl_hdr_data_t goal = 0;
ptl_hdr_data_t hdr_data = 1;
ptl_size_t offset = sizeof(uint64_t);
uint32_t distance;
int sends = 0;
CHECK_RETURNVAL(PtlInit());
CHECK_RETURNVAL(libtest_init());
rank = libtest_get_rank();
num_procs = libtest_get_size();
/* This test only succeeds if we have more than one rank */
if (num_procs < 2) return 77;
CHECK_RETURNVAL(PtlNIInit(PTL_IFACE_DEFAULT, NI_TYPE | PTL_NI_LOGICAL,
PTL_PID_ANY, NULL, NULL, &ni_h));
procs = libtest_get_mapping(ni_h);
CHECK_RETURNVAL(PtlSetMap(ni_h, num_procs, procs));
CHECK_RETURNVAL(PtlEQAlloc(ni_h, 1024, &eq_h));
CHECK_RETURNVAL(PtlPTAlloc(ni_h, 0, eq_h, 0, &pt_index));
assert(pt_index == 0);
buf = malloc(sizeof(uint64_t) * num_procs);
assert(NULL != buf);
md.start = buf;
md.length = sizeof(uint64_t) * num_procs;
md.options = PTL_MD_UNORDERED;
md.eq_handle = eq_h;
md.ct_handle = PTL_CT_NONE;
CHECK_RETURNVAL(PtlMDBind(ni_h, &md, &md_h));
entry.start = buf;
entry.length = sizeof(uint64_t) * num_procs;
entry.ct_handle = PTL_CT_NONE;
entry.uid = PTL_UID_ANY;
entry.options = OPTIONS;
#if MATCHING == 1
entry.match_id.rank = PTL_RANK_ANY;
entry.match_bits = 0;
entry.ignore_bits = 0;
entry.min_free = 0;
#endif
CHECK_RETURNVAL(APPEND(ni_h, pt_index, &entry,
PTL_PRIORITY_LIST, NULL, &entry_h));
/* ensure ME is linked before the barrier */
CHECK_RETURNVAL(PtlEQWait(eq_h, &ev));
assert( ev.type == PTL_EVENT_LINK );
libtest_barrier();
/* Bruck's Concatenation Algorithm */
memcpy(buf, &rank, sizeof(uint64_t));
for (distance = 1; distance < num_procs; distance *= 2) {
ptl_size_t to_xfer;
int peer;
ptl_process_t proc;
if (rank >= distance) {
peer = rank - distance;
} else {
peer = rank + (num_procs - distance);
}
to_xfer = sizeof(uint64_t) * MIN(distance, num_procs - distance);
proc.rank = peer;
CHECK_RETURNVAL(PtlPut(md_h,
0,
to_xfer,
PTL_NO_ACK_REQ,
proc,
0,
0,
offset,
NULL,
hdr_data));
sends += 1;
/* wait for completion of the proper receive, and keep count
of uncompleted sends. "rcvd" is an accumulator to deal
with out-of-order receives, which are IDed by the
hdr_data */
goal |= hdr_data;
while ((rcvd & goal) != goal) {
ret = PtlEQWait(eq_h, &ev);
switch (ret) {
case PTL_OK:
if (ev.type == PTL_EVENT_SEND) {
sends -= 1;
} else {
rcvd |= ev.hdr_data;
assert(ev.type == PTL_EVENT_PUT);
assert(ev.rlength == ev.mlength);
assert((ev.rlength == to_xfer) || (ev.hdr_data != hdr_data));
}
break;
default:
fprintf(stderr, "PtlEQWait failure: %d\n", ret);
abort();
}
}
hdr_data <<= 1;
offset += to_xfer;
}
/* wait for any SEND_END events not yet seen */
while (sends) {
ret = PtlEQWait(eq_h, &ev);
switch (ret) {
case PTL_OK:
assert( ev.type == PTL_EVENT_SEND );
sends -= 1;
break;
default:
fprintf(stderr, "PtlEQWait failure: %d\n", ret);
abort();
}
}
CHECK_RETURNVAL(UNLINK(entry_h));
CHECK_RETURNVAL(PtlMDRelease(md_h));
free(buf);
libtest_barrier();
/* cleanup */
CHECK_RETURNVAL(PtlPTFree(ni_h, pt_index));
CHECK_RETURNVAL(PtlEQFree(eq_h));
CHECK_RETURNVAL(PtlNIFini(ni_h));
CHECK_RETURNVAL(libtest_fini());
PtlFini();
return 0;
}
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() */