ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

* Add multi-device support to the Portals 4 btl.

Просмотр исходного кода 
* Remove use of the Portals 4 proc tag for the btl, as it's causing more
problems than its worth.

This commit was SVN r30191.
Этот коммит содержится в:
Brian Barrett 2014-01-09 20:01:42 +00:00
родитель 9fcb46d85a
Коммит 013e0ec771
10 изменённых файлов: 487 добавлений и 405 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

238
ompi/mca/btl/portals4/btl_portals4.c
Просмотреть файл

@ -80,6 +80,7 @@ mca_btl_portals4_add_procs(struct mca_btl_base_module_t* btl_base,
struct mca_btl_base_endpoint_t** btl_peer_data, struct mca_btl_base_endpoint_t** btl_peer_data,
opal_bitmap_t* reachable) opal_bitmap_t* reachable)
{ {
struct mca_btl_portals4_module_t* portals4_btl = (struct mca_btl_portals4_module_t*) btl_base;
int ret; int ret;
struct ompi_proc_t *curr_proc = NULL; struct ompi_proc_t *curr_proc = NULL;
ptl_process_t *id; ptl_process_t *id;
@ -87,11 +88,10 @@ mca_btl_portals4_add_procs(struct mca_btl_base_module_t* btl_base,
bool need_activate = false; bool need_activate = false;
opal_output_verbose(50, ompi_btl_base_framework.framework_output, opal_output_verbose(50, ompi_btl_base_framework.framework_output,
"mca_btl_portals4_add_procs: Adding %d procs (%d)", (int) nprocs, "mca_btl_portals4_add_procs: Adding %d procs (%d) for NI %d", (int) nprocs,
(int) mca_btl_portals4_module.portals_num_procs); (int) portals4_btl->portals_num_procs, portals4_btl->interface_num);
assert(&mca_btl_portals4_module == (mca_btl_portals4_module_t*) btl_base); if (0 == portals4_btl->portals_num_procs) {
if (0 == mca_btl_portals4_module.portals_num_procs) {
need_activate = true; need_activate = true;
} }
@ -107,42 +107,44 @@ mca_btl_portals4_add_procs(struct mca_btl_base_module_t* btl_base,
curr_proc, (void**) &id, &size); curr_proc, (void**) &id, &size);
if (OMPI_SUCCESS != ret) { if (OMPI_SUCCESS != ret) {
opal_output(0, "ompi_modex_recv failed: %d", ret); opal_output_verbose(0, ompi_btl_base_framework.framework_output,
"btl/portals4: ompi_modex_recv failed: %d", ret);
return ret; return ret;
} else if (sizeof(ptl_process_t) != size) { }
opal_output(0, "ompi_modex_recv returned size %d, expected %d", if (size < sizeof(ptl_process_t)) { /* no available connection */
(int) size, (int) sizeof(ptl_process_t));
return OMPI_ERROR; return OMPI_ERROR;
} }
if ((size % sizeof(ptl_process_t)) != 0) {
if (NULL == procs[i]->proc_endpoints[OMPI_PROC_ENDPOINT_TAG_PORTALS4]) { opal_output_verbose(0, ompi_btl_base_framework.framework_output,
btl_peer_data[i] = malloc(sizeof(mca_btl_base_endpoint_t)); "btl/portals4: invalid format in modex");
if (NULL == btl_peer_data[i]) return OMPI_ERROR; return OMPI_ERROR;
btl_peer_data[i]->ptl_proc = *id;
procs[i]->proc_endpoints[OMPI_PROC_ENDPOINT_TAG_PORTALS4] = btl_peer_data[i];
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"add_procs: nid=%x pid=%x\n", id->phys.nid, id->phys.pid));
} else {
ptl_process_t *proc = (ptl_process_t*) procs[i]->proc_endpoints[OMPI_PROC_ENDPOINT_TAG_PORTALS4];
if (proc->phys.nid != id->phys.nid ||
proc->phys.pid != id->phys.pid) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"%s:%d: existing peer and modex peer don't match\n",
__FILE__, __LINE__);
return OMPI_ERROR;
}
btl_peer_data[i] = (mca_btl_base_endpoint_t*) proc;
} }
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"btl/portals4: %d NI(s) declared in the modex", (int) (size/sizeof(ptl_process_t))));
OPAL_THREAD_ADD32(&mca_btl_portals4_module.portals_num_procs, 1); btl_peer_data[i] = malloc(sizeof(mca_btl_base_endpoint_t));
if (NULL == btl_peer_data[i]) return OMPI_ERROR;
/* If the modex received one id per interface (this is the
normal case), store the id of the corresponding
interface */
if (size / sizeof(ptl_process_t) >= portals4_btl->interface_num)
btl_peer_data[i]->ptl_proc = id[portals4_btl->interface_num];
else btl_peer_data[i]->ptl_proc = *id;
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"add_procs: nid=%x pid=%x for NI %d\n",
btl_peer_data[i]->ptl_proc.phys.nid,
btl_peer_data[i]->ptl_proc.phys.pid,
portals4_btl->interface_num));
OPAL_THREAD_ADD32(&portals4_btl->portals_num_procs, 1);
/* and here we can reach */ /* and here we can reach */
opal_bitmap_set_bit(reachable, i); opal_bitmap_set_bit(reachable, i);
} }
if (need_activate && mca_btl_portals4_module.portals_num_procs > 0) { if (need_activate && portals4_btl->portals_num_procs > 0) {
ret = mca_btl_portals4_recv_enable(&mca_btl_portals4_module); ret = mca_btl_portals4_recv_enable(portals4_btl);
} }
return OMPI_SUCCESS; return OMPI_SUCCESS;
} }
@ -153,24 +155,23 @@ mca_btl_portals4_del_procs(struct mca_btl_base_module_t *btl,
struct ompi_proc_t **procs, struct ompi_proc_t **procs,
struct mca_btl_base_endpoint_t **btl_peer_data) struct mca_btl_base_endpoint_t **btl_peer_data)
{ {
struct mca_btl_portals4_module_t* portals4_btl = (struct mca_btl_portals4_module_t*) btl;
size_t i; size_t i;
assert(&mca_btl_portals4_module == (mca_btl_portals4_module_t*) btl);
opal_output_verbose(50, ompi_btl_base_framework.framework_output, opal_output_verbose(50, ompi_btl_base_framework.framework_output,
"mca_btl_portals4_del_procs: Removing %d procs (%d)", (int) nprocs, "mca_btl_portals4_del_procs: Removing %d procs (%d)", (int) nprocs,
(int) mca_btl_portals4_module.portals_num_procs); (int) portals4_btl->portals_num_procs);
/* See comment in btl_portals4_endpoint.h about why we look at the /* See comment in btl_portals4_endpoint.h about why we look at the
portals4 entry in proc_endpoints instead of the peer_data */ portals4 entry in proc_endpoints instead of the peer_data */
for (i = 0 ; i < nprocs ; ++i) { for (i = 0 ; i < nprocs ; ++i) {
if (NULL != procs[i]->proc_endpoints[OMPI_PROC_ENDPOINT_TAG_PORTALS4]) { free(btl_peer_data[i]);
free(procs[i]->proc_endpoints[OMPI_PROC_ENDPOINT_TAG_PORTALS4]); OPAL_THREAD_ADD32(&portals4_btl->portals_num_procs, -1);
procs[i]->proc_endpoints[OMPI_PROC_ENDPOINT_TAG_PORTALS4] = NULL;
}
OPAL_THREAD_ADD32(&mca_btl_portals4_module.portals_num_procs, -1);
} }
if (0 == portals4_btl->portals_num_procs)
mca_btl_portals4_free_module(portals4_btl);
return OMPI_SUCCESS; return OMPI_SUCCESS;
} }
@ -181,20 +182,19 @@ mca_btl_portals4_alloc(struct mca_btl_base_module_t* btl_base,
size_t size, size_t size,
uint32_t flags) uint32_t flags)
{ {
struct mca_btl_portals4_module_t* portals4_btl = (struct mca_btl_portals4_module_t*) btl_base;
mca_btl_portals4_frag_t* frag; mca_btl_portals4_frag_t* frag;
assert(&mca_btl_portals4_module == (mca_btl_portals4_module_t*) btl_base); if (size <= portals4_btl->super.btl_eager_limit) {
OMPI_BTL_PORTALS4_FRAG_ALLOC_EAGER(portals4_btl, frag);
if (size <= mca_btl_portals4_module.super.btl_eager_limit) {
OMPI_BTL_PORTALS4_FRAG_ALLOC_EAGER(&mca_btl_portals4_module, frag);
if (NULL == frag) return NULL; if (NULL == frag) return NULL;
frag->segments[0].base.seg_len = size; frag->segments[0].base.seg_len = size;
} else { } else {
OMPI_BTL_PORTALS4_FRAG_ALLOC_MAX(&mca_btl_portals4_module, frag); OMPI_BTL_PORTALS4_FRAG_ALLOC_MAX(portals4_btl, frag);
if (NULL == frag) return NULL; if (NULL == frag) return NULL;
frag->segments[0].base.seg_len = frag->segments[0].base.seg_len =
size <= mca_btl_portals4_module.super.btl_max_send_size ? size <= portals4_btl->super.btl_max_send_size ?
size : mca_btl_portals4_module.super.btl_max_send_size ; size : portals4_btl->super.btl_max_send_size ;
} }
frag->md_h = PTL_INVALID_HANDLE; frag->md_h = PTL_INVALID_HANDLE;
@ -211,28 +211,27 @@ int
mca_btl_portals4_free(struct mca_btl_base_module_t* btl_base, mca_btl_portals4_free(struct mca_btl_base_module_t* btl_base,
mca_btl_base_descriptor_t* des) mca_btl_base_descriptor_t* des)
{ {
struct mca_btl_portals4_module_t* portals4_btl = (struct mca_btl_portals4_module_t*) btl_base;
mca_btl_portals4_frag_t* frag = (mca_btl_portals4_frag_t*) des; mca_btl_portals4_frag_t* frag = (mca_btl_portals4_frag_t*) des;
assert(&mca_btl_portals4_module == (mca_btl_portals4_module_t*) btl_base);
if (BTL_PORTALS4_FRAG_TYPE_EAGER == frag->type) { if (BTL_PORTALS4_FRAG_TYPE_EAGER == frag->type) {
/* don't ever unlink eager frags */ /* don't ever unlink eager frags */
OMPI_BTL_PORTALS4_FRAG_RETURN_EAGER(&mca_btl_portals4_module.super, frag); OMPI_BTL_PORTALS4_FRAG_RETURN_EAGER(portals4_btl, frag);
} else if (BTL_PORTALS4_FRAG_TYPE_MAX == frag->type) { } else if (BTL_PORTALS4_FRAG_TYPE_MAX == frag->type) {
if (frag->me_h != PTL_INVALID_HANDLE) { if (frag->me_h != PTL_INVALID_HANDLE) {
frag->me_h = PTL_INVALID_HANDLE; frag->me_h = PTL_INVALID_HANDLE;
} }
OMPI_BTL_PORTALS4_FRAG_RETURN_MAX(&mca_btl_portals4_module.super, frag); OMPI_BTL_PORTALS4_FRAG_RETURN_MAX(portals4_btl, frag);
} else if (BTL_PORTALS4_FRAG_TYPE_USER == frag->type) { } else if (BTL_PORTALS4_FRAG_TYPE_USER == frag->type) {
if (frag->me_h != PTL_INVALID_HANDLE) { if (frag->me_h != PTL_INVALID_HANDLE) {
frag->me_h = PTL_INVALID_HANDLE; frag->me_h = PTL_INVALID_HANDLE;
} }
OPAL_THREAD_ADD32(&mca_btl_portals4_module.portals_outstanding_ops, -1); OPAL_THREAD_ADD32(&portals4_btl->portals_outstanding_ops, -1);
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"mca_btl_portals4_free: Decrementing portals_outstanding_ops=%d\n", mca_btl_portals4_module.portals_outstanding_ops)); "mca_btl_portals4_free: Decrementing portals_outstanding_ops=%d\n", portals4_btl->portals_outstanding_ops));
OMPI_BTL_PORTALS4_FRAG_RETURN_USER(&mca_btl_portals4_module.super, frag); OMPI_BTL_PORTALS4_FRAG_RETURN_USER(portals4_btl, frag);
} else { } else {
return OMPI_ERR_BAD_PARAM; return OMPI_ERR_BAD_PARAM;
} }
@ -258,6 +257,7 @@ mca_btl_portals4_prepare_src(struct mca_btl_base_module_t* btl_base,
size_t* size, size_t* size,
uint32_t flags) uint32_t flags)
{ {
struct mca_btl_portals4_module_t* portals4_btl = (struct mca_btl_portals4_module_t*) btl_base;
mca_btl_portals4_frag_t* frag; mca_btl_portals4_frag_t* frag;
size_t max_data = *size; size_t max_data = *size;
struct iovec iov; struct iovec iov;
@ -294,20 +294,20 @@ mca_btl_portals4_prepare_src(struct mca_btl_base_module_t* btl_base,
ptl_me_t me; ptl_me_t me;
/* reserve space in the event queue for rdma operations immediately */ /* reserve space in the event queue for rdma operations immediately */
while (OPAL_THREAD_ADD32(&mca_btl_portals4_module.portals_outstanding_ops, 1) > while (OPAL_THREAD_ADD32(&portals4_btl->portals_outstanding_ops, 1) >
mca_btl_portals4_module.portals_max_outstanding_ops) { portals4_btl->portals_max_outstanding_ops) {
OPAL_THREAD_ADD32(&mca_btl_portals4_module.portals_outstanding_ops, -1); OPAL_THREAD_ADD32(&portals4_btl->portals_outstanding_ops, -1);
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "Call to mca_btl_portals4_component_progress (1)\n")); OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "Call to mca_btl_portals4_component_progress (1)\n"));
mca_btl_portals4_component_progress(); mca_btl_portals4_component_progress();
} }
OMPI_BTL_PORTALS4_FRAG_ALLOC_USER(&mca_btl_portals4_module.super, frag); OMPI_BTL_PORTALS4_FRAG_ALLOC_USER(portals4_btl, frag);
if (NULL == frag){ if (NULL == frag){
OPAL_THREAD_ADD32(&mca_btl_portals4_module.portals_outstanding_ops, -1); OPAL_THREAD_ADD32(&portals4_btl->portals_outstanding_ops, -1);
return NULL; return NULL;
} }
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"mca_btl_portals4_prepare_src: Incrementing portals_outstanding_ops=%d\n", mca_btl_portals4_module.portals_outstanding_ops)); "mca_btl_portals4_prepare_src: Incrementing portals_outstanding_ops=%d\n", portals4_btl->portals_outstanding_ops));
iov.iov_len = max_data; iov.iov_len = max_data;
iov.iov_base = NULL; iov.iov_base = NULL;
@ -316,7 +316,7 @@ mca_btl_portals4_prepare_src(struct mca_btl_base_module_t* btl_base,
frag->segments[0].base.seg_len = max_data; frag->segments[0].base.seg_len = max_data;
frag->segments[0].base.seg_addr.pval = iov.iov_base; frag->segments[0].base.seg_addr.pval = iov.iov_base;
frag->segments[0].key = OPAL_THREAD_ADD64(&(mca_btl_portals4_module.portals_rdma_key), 1); frag->segments[0].key = OPAL_THREAD_ADD64(&(portals4_btl->portals_rdma_key), 1);
frag->base.des_src_cnt = 1; frag->base.des_src_cnt = 1;
/* either a put or get. figure out which later */ /* either a put or get. figure out which later */
@ -344,8 +344,8 @@ mca_btl_portals4_prepare_src(struct mca_btl_base_module_t* btl_base,
BTL_PORTALS4_SOURCE_MASK; BTL_PORTALS4_SOURCE_MASK;
me.ignore_bits = 0; me.ignore_bits = 0;
ret = PtlMEAppend(mca_btl_portals4_module.portals_ni_h, ret = PtlMEAppend(portals4_btl->portals_ni_h,
mca_btl_portals4_module.recv_idx, portals4_btl->recv_idx,
&me, &me,
PTL_PRIORITY_LIST, PTL_PRIORITY_LIST,
frag, frag,
@ -354,8 +354,8 @@ mca_btl_portals4_prepare_src(struct mca_btl_base_module_t* btl_base,
opal_output_verbose(1, ompi_btl_base_framework.framework_output, opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"%s:%d: PtlMEAppend failed: %d\n", "%s:%d: PtlMEAppend failed: %d\n",
__FILE__, __LINE__, ret); __FILE__, __LINE__, ret);
OMPI_BTL_PORTALS4_FRAG_RETURN_USER(&mca_btl_portals4_module.super, frag); OMPI_BTL_PORTALS4_FRAG_RETURN_USER(portals4_btl, frag);
OPAL_THREAD_ADD32(&mca_btl_portals4_module.portals_outstanding_ops, -1); OPAL_THREAD_ADD32(&portals4_btl->portals_outstanding_ops, -1);
return NULL; return NULL;
} }
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
@ -381,27 +381,28 @@ mca_btl_portals4_prepare_dst(struct mca_btl_base_module_t* btl_base,
size_t* size, size_t* size,
uint32_t flags) uint32_t flags)
{ {
struct mca_btl_portals4_module_t* portals4_btl = (struct mca_btl_portals4_module_t*) btl_base;
mca_btl_portals4_frag_t* frag; mca_btl_portals4_frag_t* frag;
/* reserve space in the event queue for rdma operations immediately */ /* reserve space in the event queue for rdma operations immediately */
while (OPAL_THREAD_ADD32(&mca_btl_portals4_module.portals_outstanding_ops, 1) > while (OPAL_THREAD_ADD32(&portals4_btl->portals_outstanding_ops, 1) >
mca_btl_portals4_module.portals_max_outstanding_ops) { portals4_btl->portals_max_outstanding_ops) {
OPAL_THREAD_ADD32(&mca_btl_portals4_module.portals_outstanding_ops, -1); OPAL_THREAD_ADD32(&portals4_btl->portals_outstanding_ops, -1);
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "Call to mca_btl_portals4_component_progress (2)\n")); OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "Call to mca_btl_portals4_component_progress (2)\n"));
mca_btl_portals4_component_progress(); mca_btl_portals4_component_progress();
} }
OMPI_BTL_PORTALS4_FRAG_ALLOC_USER(&mca_btl_portals4_module.super, frag); OMPI_BTL_PORTALS4_FRAG_ALLOC_USER(portals4_btl, frag);
if (NULL == frag) { if (NULL == frag) {
OPAL_THREAD_ADD32(&mca_btl_portals4_module.portals_outstanding_ops, -1); OPAL_THREAD_ADD32(&portals4_btl->portals_outstanding_ops, -1);
return NULL; return NULL;
} }
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"mca_btl_portals4_prepare_dst: Incrementing portals_outstanding_ops=%d\n", mca_btl_portals4_module.portals_outstanding_ops)); "mca_btl_portals4_prepare_dst: Incrementing portals_outstanding_ops=%d\n", portals4_btl->portals_outstanding_ops));
frag->segments[0].base.seg_len = *size; frag->segments[0].base.seg_len = *size;
opal_convertor_get_current_pointer( convertor, (void**)&(frag->segments[0].base.seg_addr.pval) ); opal_convertor_get_current_pointer( convertor, (void**)&(frag->segments[0].base.seg_addr.pval) );
frag->segments[0].key = OPAL_THREAD_ADD64(&(mca_btl_portals4_module.portals_rdma_key), 1); frag->segments[0].key = OPAL_THREAD_ADD64(&(portals4_btl->portals_rdma_key), 1);
frag->base.des_src = NULL; frag->base.des_src = NULL;
frag->base.des_src_cnt = 0; frag->base.des_src_cnt = 0;
frag->base.des_dst = &frag->segments[0].base; frag->base.des_dst = &frag->segments[0].base;
@ -419,64 +420,95 @@ mca_btl_portals4_prepare_dst(struct mca_btl_base_module_t* btl_base,
int int
mca_btl_portals4_finalize(struct mca_btl_base_module_t *btl) mca_btl_portals4_finalize(struct mca_btl_base_module_t *btl)
{ {
int ret; struct mca_btl_portals4_module_t* portals4_btl = (struct mca_btl_portals4_module_t*) btl;
assert(&mca_btl_portals4_module == (mca_btl_portals4_module_t*) btl); mca_btl_portals4_free_module(portals4_btl);
OBJ_DESTRUCT(&portals4_btl->portals_frag_eager);
OBJ_DESTRUCT(&portals4_btl->portals_frag_max);
OBJ_DESTRUCT(&portals4_btl->portals_frag_user);
OBJ_DESTRUCT(&portals4_btl->portals_recv_blocks);
free(portals4_btl);
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"mca_btl_portals4_finalize portals_outstanding_ops=%d\n", mca_btl_portals4_module.portals_outstanding_ops)); "mca_btl_portals4_finalize NI %d: OK\n", portals4_btl->interface_num));
return OMPI_SUCCESS;
}
void mca_btl_portals4_free_module(mca_btl_portals4_module_t *portals4_btl)
{
int ret;
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"mca_btl_portals4_free_module portals_outstanding_ops=%d\n", portals4_btl->portals_outstanding_ops));
/* sanity check */ /* sanity check */
assert(mca_btl_portals4_module.portals_outstanding_ops >= 0); assert(portals4_btl->portals_outstanding_ops >= 0);
/* finalize all communication */ /* finalize all communication */
while (mca_btl_portals4_module.portals_outstanding_ops > 0) { while (portals4_btl->portals_outstanding_ops > 0) {
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"mca_btl_portals4_finalize portals_outstanding_ops: %d", "mca_btl_portals4_free_module portals_outstanding_ops: %d",
mca_btl_portals4_module.portals_outstanding_ops)); portals4_btl->portals_outstanding_ops));
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "Call to mca_btl_portals4_component_progress (3)\n")); OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "Call to mca_btl_portals4_component_progress (3)\n"));
mca_btl_portals4_component_progress(); mca_btl_portals4_component_progress();
} }
PtlMEUnlink(mca_btl_portals4_module.long_overflow_me_h);
PtlMDRelease(mca_btl_portals4_module.zero_md_h);
#if OMPI_PORTALS4_MAX_MD_SIZE < OMPI_PORTALS4_MAX_VA_SIZE #if OMPI_PORTALS4_MAX_MD_SIZE < OMPI_PORTALS4_MAX_VA_SIZE
if (NULL != mca_btl_portals4_module.send_md_hs) { if (NULL != portals4_btl->send_md_hs) {
int i; int i;
int num_mds = mca_btl_portals4_get_num_mds(); int num_mds = mca_btl_portals4_get_num_mds();
for (i = 0 ; i < num_mds ; ++i) { for (i = 0 ; i < num_mds ; ++i) {
if (!PtlHandleIsEqual(mca_btl_portals4_module.send_md_hs[i], PTL_INVALID_HANDLE)) { if (!PtlHandleIsEqual(portals4_btl->send_md_hs[i], PTL_INVALID_HANDLE)) {
PtlMDRelease(mca_btl_portals4_module.send_md_hs[i]); PtlMDRelease(portals4_btl->send_md_hs[i]);
portals4_btl->send_md_hs[i] = PTL_INVALID_HANDLE;
} }
} }
free(mca_btl_portals4_module.send_md_hs); free(portals4_btl->send_md_hs);
portals4_btl->send_md_hs = NULL;
} }
#else #else
if (!PtlHandleIsEqual(mca_btl_portals4_module.send_md_h, PTL_INVALID_HANDLE)) { if (!PtlHandleIsEqual(portals4_btl->send_md_h, PTL_INVALID_HANDLE)) {
PtlMDRelease(mca_btl_portals4_module.send_md_h); PtlMDRelease(portals4_btl->send_md_h);
portals4_btl->send_md_h = PTL_INVALID_HANDLE;
} }
#endif #endif
if (!PtlHandleIsEqual(portals4_btl->zero_md_h, PTL_INVALID_HANDLE)) {
PtlMDRelease(portals4_btl->zero_md_h);
portals4_btl->zero_md_h = PTL_INVALID_HANDLE;
}
PtlPTFree(mca_btl_portals4_module.portals_ni_h, mca_btl_portals4_module.recv_idx); 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;
}
ret = mca_btl_portals4_recv_disable(&mca_btl_portals4_module); 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, ompi_btl_base_framework.framework_output, "Error freeing EQ recv: %d", ret));
OPAL_OUTPUT_VERBOSE((90, ompi_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, ompi_btl_base_framework.framework_output, "Error returned by PtlNIFini: %d\n", ret));
OPAL_OUTPUT_VERBOSE((90, ompi_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, ompi_btl_base_framework.framework_output, "Error freeing recv list: %d", ret)); if (PTL_OK != ret) OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "Error freeing recv list: %d", ret));
/* destroy eqs */
ret = PtlEQFree(mca_btl_portals4_module.recv_eq_h);
if (PTL_OK != ret) OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "Error freeing EQ recv: %d", ret));
ret = PtlNIFini(mca_btl_portals4_module.portals_ni_h);
if (PTL_OK != ret) OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "Error returned by PtlNIFini\n"));
PtlFini();
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "mca_btl_portals4_finalize OK\n"));
/* Maybe other objects have to be freed */
return OMPI_SUCCESS;
} }

40
ompi/mca/btl/portals4/btl_portals4.h
Просмотреть файл

@ -23,9 +23,6 @@
#include <portals4.h> #include <portals4.h>
#include <btl_portals4_frag.h> #include <btl_portals4_frag.h>
#define MEMORY_MAX_SIZE ((long int)1<<48)
#define EXTENDED_ADDR (0xffff000000000000)
#include "opal/class/opal_free_list.h" #include "opal/class/opal_free_list.h"
#include "opal/class/opal_list.h" #include "opal/class/opal_list.h"
#include "opal/datatype/opal_convertor.h" #include "opal/datatype/opal_convertor.h"
@ -41,8 +38,10 @@ struct mca_btl_portals4_component_t {
/* base BTL component */ /* base BTL component */
mca_btl_base_component_2_0_0_t super; mca_btl_base_component_2_0_0_t super;
/* output channel for debugging */ unsigned int num_btls;
int portals_verbosity; unsigned int max_btls; /* Maximum number of accepted Portals4 cards */
struct mca_btl_portals4_module_t** btls; /* array of available BTL modules */
/* initial size of free lists */ /* initial size of free lists */
int portals_free_list_init_num; int portals_free_list_init_num;
@ -56,6 +55,19 @@ struct mca_btl_portals4_component_t {
/* do I need a portals ACK? */ /* do I need a portals ACK? */
int portals_need_ack; int portals_need_ack;
/** Length of the receive event queues */
int recv_queue_size;
/* number outstanding sends and local rdma */
int32_t portals_max_outstanding_ops;
/* incoming send message receive memory descriptors */
int portals_recv_mds_num;
int portals_recv_mds_size;
/** Event queue handles table used in PtlEQPoll */
ptl_handle_eq_t *eqs_h;
}; };
typedef struct mca_btl_portals4_component_t mca_btl_portals4_component_t; typedef struct mca_btl_portals4_component_t mca_btl_portals4_component_t;
@ -68,17 +80,14 @@ struct mca_btl_portals4_module_t {
know when to do activation / shutdown */ know when to do activation / shutdown */
int32_t portals_num_procs; int32_t portals_num_procs;
/* Process_id */ /* number of the interface (btl) */
ptl_process_t ptl_process_id; uint32_t interface_num;
/* fragment free lists */ /* fragment free lists */
ompi_free_list_t portals_frag_eager; ompi_free_list_t portals_frag_eager;
ompi_free_list_t portals_frag_max; ompi_free_list_t portals_frag_max;
ompi_free_list_t portals_frag_user; ompi_free_list_t portals_frag_user;
/* incoming send message receive memory descriptors */
int portals_recv_mds_num;
int portals_recv_mds_size;
opal_list_t portals_recv_blocks; opal_list_t portals_recv_blocks;
/** Length of the receive event queues */ /** Length of the receive event queues */
@ -117,10 +126,6 @@ struct mca_btl_portals4_module_t {
typedef struct mca_btl_portals4_module_t mca_btl_portals4_module_t; typedef struct mca_btl_portals4_module_t mca_btl_portals4_module_t;
extern mca_btl_portals4_module_t mca_btl_portals4_module;
#define REQ_RECV_TABLE_ID 12
/* match/ignore bit manipulation /* match/ignore bit manipulation
* *
* 0123 4567 01234567 01234567 01234567 01234567 01234567 01234567 01234567 * 0123 4567 01234567 01234567 01234567 01234567 01234567 01234567 01234567
@ -168,15 +173,15 @@ extern mca_btl_portals4_module_t mca_btl_portals4_module;
* memory. * memory.
*/ */
static inline void static inline void
ompi_btl_portals4_get_md(const void *ptr, ptl_handle_md_t *md_h, void **base_ptr) ompi_btl_portals4_get_md(const void *ptr, ptl_handle_md_t *md_h, void **base_ptr, mca_btl_portals4_module_t *portals4_btl)
{ {
#if OMPI_PORTALS4_MAX_MD_SIZE < OMPI_PORTALS4_MAX_VA_SIZE #if OMPI_PORTALS4_MAX_MD_SIZE < OMPI_PORTALS4_MAX_VA_SIZE
int mask = (1ULL << (OMPI_PORTALS4_MAX_VA_SIZE - OMPI_PORTALS4_MAX_MD_SIZE + 1)) - 1; int mask = (1ULL << (OMPI_PORTALS4_MAX_VA_SIZE - OMPI_PORTALS4_MAX_MD_SIZE + 1)) - 1;
int which = (((uintptr_t) ptr) >> (OMPI_PORTALS4_MAX_MD_SIZE - 1)) & mask; int which = (((uintptr_t) ptr) >> (OMPI_PORTALS4_MAX_MD_SIZE - 1)) & mask;
*md_h = mca_btl_portals4_module.send_md_hs[which]; *md_h = portals4_btl->send_md_hs[which];
*base_ptr = (void*) (which * (1ULL << (OMPI_PORTALS4_MAX_MD_SIZE - 1))); *base_ptr = (void*) (which * (1ULL << (OMPI_PORTALS4_MAX_MD_SIZE - 1)));
#else #else
*md_h = mca_btl_portals4_module.send_md_h; *md_h = portals4_btl->send_md_h;
*base_ptr = 0; *base_ptr = 0;
#endif #endif
} }
@ -193,6 +198,7 @@ mca_btl_portals4_get_num_mds(void)
} }
int mca_btl_portals4_component_progress(void); int mca_btl_portals4_component_progress(void);
void mca_btl_portals4_free_module(mca_btl_portals4_module_t *portals4_btl);
/* BTL interface functions */ /* BTL interface functions */
int mca_btl_portals4_finalize(struct mca_btl_base_module_t* btl_base); int mca_btl_portals4_finalize(struct mca_btl_base_module_t* btl_base);

530
ompi/mca/btl/portals4/btl_portals4_component.c
Просмотреть файл

@ -38,8 +38,6 @@ int mca_btl_portals4_component_progress(void);
OMPI_MODULE_DECLSPEC extern mca_btl_portals4_component_t mca_btl_portals4_component; OMPI_MODULE_DECLSPEC extern mca_btl_portals4_component_t mca_btl_portals4_component;
static unsigned int ompi_btl_portals4_md_size_bit_width;
mca_btl_portals4_component_t mca_btl_portals4_component = { mca_btl_portals4_component_t mca_btl_portals4_component = {
{ {
/* First, the mca_base_module_t struct containing meta /* First, the mca_base_module_t struct containing meta
@ -69,6 +67,18 @@ mca_btl_portals4_component_t mca_btl_portals4_component = {
static int static int
mca_btl_portals4_component_register(void) mca_btl_portals4_component_register(void)
{ {
mca_btl_portals4_component.max_btls = 1;
(void) mca_base_component_var_register(&mca_btl_portals4_component.super.btl_version,
"max_btls",
"Maximum number of accepted Portals4 cards",
MCA_BASE_VAR_TYPE_UNSIGNED_INT,
NULL,
0,
0,
OPAL_INFO_LVL_5,
MCA_BASE_VAR_SCOPE_READONLY,
&mca_btl_portals4_component.max_btls);
mca_btl_portals4_component.portals_free_list_init_num = 16; mca_btl_portals4_component.portals_free_list_init_num = 16;
(void) mca_base_component_var_register(&mca_btl_portals4_component.super.btl_version, (void) mca_base_component_var_register(&mca_btl_portals4_component.super.btl_version,
"free_list_init_num", "free_list_init_num",
@ -129,7 +139,7 @@ mca_btl_portals4_component_register(void)
MCA_BASE_VAR_SCOPE_READONLY, MCA_BASE_VAR_SCOPE_READONLY,
&(mca_btl_portals4_component.portals_need_ack)); &(mca_btl_portals4_component.portals_need_ack));
mca_btl_portals4_module.recv_queue_size = 1024 * 1024; mca_btl_portals4_component.recv_queue_size = 4 * 1024;
(void) mca_base_component_var_register(&mca_btl_portals4_component.super.btl_version, (void) mca_base_component_var_register(&mca_btl_portals4_component.super.btl_version,
"eq_recv_size", "eq_recv_size",
"Size of the receive event queue", "Size of the receive event queue",
@ -139,21 +149,9 @@ mca_btl_portals4_component_register(void)
0, 0,
OPAL_INFO_LVL_5, OPAL_INFO_LVL_5,
MCA_BASE_VAR_SCOPE_READONLY, MCA_BASE_VAR_SCOPE_READONLY,
&(mca_btl_portals4_module.recv_queue_size)); &(mca_btl_portals4_component.recv_queue_size));
ompi_btl_portals4_md_size_bit_width = 48; mca_btl_portals4_component.portals_max_outstanding_ops = 8 * 1024;
(void) mca_base_component_var_register(&mca_btl_portals4_component.super.btl_version,
"md_size_bit_width",
"Number of bits used to specify the length of an MD to the portals4 library",
MCA_BASE_VAR_TYPE_INT,
NULL,
0,
0,
OPAL_INFO_LVL_5,
MCA_BASE_VAR_SCOPE_READONLY,
&ompi_btl_portals4_md_size_bit_width);
mca_btl_portals4_module.portals_max_outstanding_ops = 8 * 1024;
(void) mca_base_component_var_register(&mca_btl_portals4_component.super.btl_version, (void) mca_base_component_var_register(&mca_btl_portals4_component.super.btl_version,
"max_pending_ops", "max_pending_ops",
"Maximum number of pending send/rdma frags", "Maximum number of pending send/rdma frags",
@ -163,9 +161,9 @@ mca_btl_portals4_component_register(void)
0, 0,
OPAL_INFO_LVL_5, OPAL_INFO_LVL_5,
MCA_BASE_VAR_SCOPE_READONLY, MCA_BASE_VAR_SCOPE_READONLY,
&(mca_btl_portals4_module.portals_max_outstanding_ops)); &(mca_btl_portals4_component.portals_max_outstanding_ops));
mca_btl_portals4_module.portals_recv_mds_num = 32; mca_btl_portals4_component.portals_recv_mds_num = 8;
(void) mca_base_component_var_register(&mca_btl_portals4_component.super.btl_version, (void) mca_base_component_var_register(&mca_btl_portals4_component.super.btl_version,
"recv_md_num", "recv_md_num",
"Number of send frag receive descriptors", "Number of send frag receive descriptors",
@ -175,9 +173,9 @@ mca_btl_portals4_component_register(void)
0, 0,
OPAL_INFO_LVL_5, OPAL_INFO_LVL_5,
MCA_BASE_VAR_SCOPE_READONLY, MCA_BASE_VAR_SCOPE_READONLY,
&(mca_btl_portals4_module.portals_recv_mds_num)); &(mca_btl_portals4_component.portals_recv_mds_num));
mca_btl_portals4_module.portals_recv_mds_size = 64 * 1024; mca_btl_portals4_component.portals_recv_mds_size = 256 * 1024;
(void) mca_base_component_var_register(&mca_btl_portals4_component.super.btl_version, (void) mca_base_component_var_register(&mca_btl_portals4_component.super.btl_version,
"recv_md_size", "recv_md_size",
"Size of send frag receive descriptors", "Size of send frag receive descriptors",
@ -187,14 +185,13 @@ mca_btl_portals4_component_register(void)
0, 0,
OPAL_INFO_LVL_5, OPAL_INFO_LVL_5,
MCA_BASE_VAR_SCOPE_READONLY, MCA_BASE_VAR_SCOPE_READONLY,
&(mca_btl_portals4_module.portals_recv_mds_size)); &(mca_btl_portals4_component.portals_recv_mds_size));
return OMPI_SUCCESS; return OMPI_SUCCESS;
} }
static int static int
mca_btl_portals4_component_open(void) mca_btl_portals4_component_open(void)
{ {
mca_btl_portals4_component.portals_verbosity = opal_output_get_verbosity(ompi_btl_base_framework.framework_output);
OPAL_OUTPUT_VERBOSE((1, ompi_btl_base_framework.framework_output, "mca_btl_portals4_component_open\n")); OPAL_OUTPUT_VERBOSE((1, ompi_btl_base_framework.framework_output, "mca_btl_portals4_component_open\n"));
/* /*
@ -226,48 +223,6 @@ mca_btl_portals4_component_open(void)
mca_btl_portals4_module.send_md_h = PTL_INVALID_HANDLE; mca_btl_portals4_module.send_md_h = PTL_INVALID_HANDLE;
#endif #endif
OBJ_CONSTRUCT(&(mca_btl_portals4_module.portals_frag_eager), ompi_free_list_t);
OBJ_CONSTRUCT(&(mca_btl_portals4_module.portals_frag_max), ompi_free_list_t);
OBJ_CONSTRUCT(&(mca_btl_portals4_module.portals_frag_user), ompi_free_list_t);
/* eager frags */
ompi_free_list_init_new(&(mca_btl_portals4_module.portals_frag_eager),
sizeof(mca_btl_portals4_frag_eager_t) +
mca_btl_portals4_module.super.btl_eager_limit,
opal_cache_line_size,
OBJ_CLASS(mca_btl_portals4_frag_eager_t),
0,opal_cache_line_size,
mca_btl_portals4_component.portals_free_list_init_num,
mca_btl_portals4_component.portals_free_list_eager_max_num,
mca_btl_portals4_component.portals_free_list_inc_num,
NULL);
/* send frags */
ompi_free_list_init_new(&(mca_btl_portals4_module.portals_frag_max),
sizeof(mca_btl_portals4_frag_max_t) +
mca_btl_portals4_module.super.btl_max_send_size,
opal_cache_line_size,
OBJ_CLASS(mca_btl_portals4_frag_max_t),
0,opal_cache_line_size,
mca_btl_portals4_component.portals_free_list_init_num,
mca_btl_portals4_component.portals_free_list_max_num,
mca_btl_portals4_component.portals_free_list_inc_num,
NULL);
/* user frags */
ompi_free_list_init_new(&(mca_btl_portals4_module.portals_frag_user),
sizeof(mca_btl_portals4_frag_user_t),
opal_cache_line_size,
OBJ_CLASS(mca_btl_portals4_frag_user_t),
0,opal_cache_line_size,
mca_btl_portals4_component.portals_free_list_init_num,
mca_btl_portals4_component.portals_free_list_max_num,
mca_btl_portals4_component.portals_free_list_inc_num,
NULL);
/* receive block list */
OBJ_CONSTRUCT(&(mca_btl_portals4_module.portals_recv_blocks), opal_list_t);
mca_btl_portals4_module.portals_ni_h = PTL_INVALID_HANDLE; mca_btl_portals4_module.portals_ni_h = PTL_INVALID_HANDLE;
mca_btl_portals4_module.zero_md_h = PTL_INVALID_HANDLE; mca_btl_portals4_module.zero_md_h = PTL_INVALID_HANDLE;
@ -285,15 +240,16 @@ mca_btl_portals4_component_close(void)
opal_output_verbose(50, ompi_btl_base_framework.framework_output, "mca_btl_portals4_component_close\n"); opal_output_verbose(50, ompi_btl_base_framework.framework_output, "mca_btl_portals4_component_close\n");
/* release resources */ /* release resources */
/* close debugging stream */ /* close debugging stream */
opal_output_close(ompi_btl_base_framework.framework_output); opal_output_close(ompi_btl_base_framework.framework_output);
ompi_btl_base_framework.framework_output = -1; ompi_btl_base_framework.framework_output = -1;
OBJ_DESTRUCT(&mca_btl_portals4_module.portals_frag_eager); if (NULL != mca_btl_portals4_component.btls) free(mca_btl_portals4_component.btls);
OBJ_DESTRUCT(&mca_btl_portals4_module.portals_frag_max); if (NULL != mca_btl_portals4_component.eqs_h) free(mca_btl_portals4_component.eqs_h);
OBJ_DESTRUCT(&mca_btl_portals4_module.portals_frag_user); mca_btl_portals4_component.btls = NULL;
OBJ_DESTRUCT(&mca_btl_portals4_module.portals_recv_blocks); mca_btl_portals4_component.eqs_h = NULL;
PtlFini();
return OMPI_SUCCESS; return OMPI_SUCCESS;
} }
@ -302,23 +258,23 @@ static mca_btl_base_module_t** mca_btl_portals4_component_init(int *num_btls,
bool enable_progress_threads, bool enable_progress_threads,
bool enable_mpi_threads) bool enable_mpi_threads)
{ {
int ret; mca_btl_portals4_module_t *portals4_btl = NULL;
ptl_process_t ptl_process_id; mca_btl_base_module_t **btls = NULL;
unsigned int ret, interface;
ptl_handle_ni_t *portals4_nis_h = NULL;
ptl_process_t *ptl_process_ids = NULL;
ptl_md_t md; ptl_md_t md;
ptl_me_t me; ptl_me_t me;
opal_output_verbose(50, ompi_btl_base_framework.framework_output, "mca_btl_portals4_component_init\n"); opal_output_verbose(50, ompi_btl_base_framework.framework_output, "mca_btl_portals4_component_init\n");
mca_btl_base_module_t **btls = malloc(sizeof(mca_btl_base_module_t*));
btls[0] = (mca_btl_base_module_t*) &mca_btl_portals4_module;
if (enable_progress_threads || enable_mpi_threads) { if (enable_progress_threads || enable_mpi_threads) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output, opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"btl portals4 disabled because threads enabled"); "btl portals4 disabled because threads enabled");
return NULL; return NULL;
} }
/* Initialize Portals and create a physical, matching interface */ /* Initialize Portals */
ret = PtlInit(); ret = PtlInit();
if (PTL_OK != ret) { if (PTL_OK != ret) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output, opal_output_verbose(1, ompi_btl_base_framework.framework_output,
@ -329,193 +285,294 @@ static mca_btl_base_module_t** mca_btl_portals4_component_init(int *num_btls,
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "PtlInit OK\n")); OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "PtlInit OK\n"));
/* /*
* Initialize a network device * Initialize the network interfaces (try to open the interfaces 0 to (max_btls-1) )
*/ */
ret = PtlNIInit(PTL_IFACE_DEFAULT, *num_btls = 0;
portals4_nis_h = malloc(mca_btl_portals4_component.max_btls * sizeof(ptl_handle_ni_t));
for (interface=0; interface<mca_btl_portals4_component.max_btls; interface++) {
ret = PtlNIInit((1 == mca_btl_portals4_component.max_btls) ? PTL_IFACE_DEFAULT : interface,
PTL_NI_PHYSICAL | PTL_NI_MATCHING, PTL_NI_PHYSICAL | PTL_NI_MATCHING,
PTL_PID_ANY, /* let library assign our pid */ PTL_PID_ANY, /* let library assign our pid */
NULL, /* no desired limits */ NULL, /* no desired limits */
NULL, /* actual limits */ NULL, /* actual limits */
&mca_btl_portals4_module.portals_ni_h /* our interface handle */ &portals4_nis_h[*num_btls] /* our interface handle */
); );
if (PTL_OK != ret) { if (PTL_OK != ret) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output, opal_output_verbose(90, ompi_btl_base_framework.framework_output,
"%s:%d: PtlNIInit failed: %d\n", "%s:%d: PtlNIInit failed for NI %d: %d\n", __FILE__, __LINE__, interface, ret);
__FILE__, __LINE__, ret); }
goto error; else {
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "PtlNIInit OK for NI %d\n", *num_btls));
(*num_btls)++;
}
} }
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "PtlNIInit OK\n")); if (0 == *num_btls) goto error;
/* Publish our NID/PID in the modex */ /*
ret = PtlGetId(mca_btl_portals4_module.portals_ni_h ,&ptl_process_id); * Configure the different network interfaces and the associated btl modules
if (PTL_OK != ret) { */
opal_output_verbose(1, ompi_btl_base_framework.framework_output, mca_btl_portals4_component.num_btls = *num_btls;
"%s:%d: PtlGetId failed: %d\n", mca_btl_portals4_component.btls = malloc(mca_btl_portals4_component.num_btls * sizeof(mca_btl_portals4_module_t*) );
__FILE__, __LINE__, ret); mca_btl_portals4_component.eqs_h = malloc(mca_btl_portals4_component.num_btls * sizeof(ptl_handle_eq_t));
goto error; ptl_process_ids = malloc(mca_btl_portals4_component.num_btls * sizeof(ptl_process_t) );
for (interface=0; interface<mca_btl_portals4_component.num_btls; interface++) {
mca_btl_portals4_component.btls[interface] = NULL;
mca_btl_portals4_component.eqs_h[interface] = PTL_EQ_NONE;
} }
mca_btl_portals4_module.ptl_process_id = ptl_process_id; for (interface=0; interface<mca_btl_portals4_component.num_btls; interface++) {
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, portals4_btl = malloc(sizeof(mca_btl_portals4_module_t));
"PtlGetId nid=%x pid=%x\n", ptl_process_id.phys.nid, ptl_process_id.phys.pid)); mca_btl_portals4_component.btls[interface] = portals4_btl;
ret = ompi_modex_send(&mca_btl_portals4_component.super.btl_version, /* Copy the default module */
&ptl_process_id, sizeof(ptl_process_t)); memcpy(portals4_btl, &mca_btl_portals4_module, sizeof(mca_btl_portals4_module_t));
if (OMPI_SUCCESS != ret) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"%s:%d: ompi_modex_send failed: %d\n",
__FILE__, __LINE__, ret);
goto error;
}
/* create event queue */ portals4_btl->interface_num = interface;
ret = PtlEQAlloc(mca_btl_portals4_module.portals_ni_h, portals4_btl->portals_ni_h = portals4_nis_h[interface];
mca_btl_portals4_module.recv_queue_size, portals4_btl->portals_max_outstanding_ops = mca_btl_portals4_component.portals_max_outstanding_ops;
&mca_btl_portals4_module.recv_eq_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"%s:%d: PtlEQAlloc failed: %d\n",
__FILE__, __LINE__, ret);
goto error;
}
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "PtlEQAlloc (recv_queue) OK\n"));
/* Create recv_idx portal table entrie */ OBJ_CONSTRUCT(&(portals4_btl->portals_frag_eager), ompi_free_list_t);
ret = PtlPTAlloc(mca_btl_portals4_module.portals_ni_h, OBJ_CONSTRUCT(&(portals4_btl->portals_frag_max), ompi_free_list_t);
PTL_PT_ONLY_USE_ONCE | OBJ_CONSTRUCT(&(portals4_btl->portals_frag_user), ompi_free_list_t);
PTL_PT_ONLY_TRUNCATE,
mca_btl_portals4_module.recv_eq_h,
REQ_RECV_TABLE_ID,
&mca_btl_portals4_module.recv_idx);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"%s:%d: PtlPTAlloc failed: %d\n",
__FILE__, __LINE__, ret);
goto error;
}
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"PtlPTAlloc (recv_idx) OK recv_idx=%d\n", mca_btl_portals4_module.recv_idx));
/* bind zero-length md for sending acks */ /* eager frags */
md.start = NULL; ompi_free_list_init_new(&(portals4_btl->portals_frag_eager),
md.length = 0; sizeof(mca_btl_portals4_frag_eager_t) +
md.options = 0; portals4_btl->super.btl_eager_limit,
md.eq_handle = PTL_EQ_NONE; opal_cache_line_size,
md.ct_handle = PTL_CT_NONE; OBJ_CLASS(mca_btl_portals4_frag_eager_t),
0,opal_cache_line_size,
mca_btl_portals4_component.portals_free_list_init_num,
mca_btl_portals4_component.portals_free_list_eager_max_num,
mca_btl_portals4_component.portals_free_list_inc_num,
NULL);
ret = PtlMDBind(mca_btl_portals4_module.portals_ni_h, /* send frags */
&md, ompi_free_list_init_new(&(portals4_btl->portals_frag_max),
&mca_btl_portals4_module.zero_md_h); sizeof(mca_btl_portals4_frag_max_t) +
if (PTL_OK != ret) { portals4_btl->super.btl_max_send_size,
opal_output_verbose(1, ompi_btl_base_framework.framework_output, opal_cache_line_size,
"%s:%d: PtlMDBind failed: %d\n", OBJ_CLASS(mca_btl_portals4_frag_max_t),
__FILE__, __LINE__, ret); 0,opal_cache_line_size,
goto error; mca_btl_portals4_component.portals_free_list_init_num,
} mca_btl_portals4_component.portals_free_list_max_num,
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "PtlMDBind (zero-length md) OK\n")); mca_btl_portals4_component.portals_free_list_inc_num,
NULL);
/* Bind MD/MDs across all memory. We prefer (for obvious reasons) /* user frags */
to have a single MD across all of memory */ ompi_free_list_init_new(&(portals4_btl->portals_frag_user),
#if OMPI_PORTALS4_MAX_MD_SIZE < OMPI_PORTALS4_MAX_VA_SIZE sizeof(mca_btl_portals4_frag_user_t),
{ opal_cache_line_size,
int i; OBJ_CLASS(mca_btl_portals4_frag_user_t),
int num_mds = mca_btl_portals4_get_num_mds(); 0,opal_cache_line_size,
ptl_size_t size = (1ULL << OMPI_PORTALS4_MAX_MD_SIZE) - 1; mca_btl_portals4_component.portals_free_list_init_num,
ptl_size_t offset_unit = (1ULL << OMPI_PORTALS4_MAX_MD_SIZE) / 2; mca_btl_portals4_component.portals_free_list_max_num,
mca_btl_portals4_component.portals_free_list_inc_num,
NULL);
mca_btl_portals4_module.send_md_hs = malloc(sizeof(ptl_handle_md_t) * num_mds); /* receive block list */
if (NULL == mca_btl_portals4_module.send_md_hs) { OBJ_CONSTRUCT(&(portals4_btl->portals_recv_blocks), opal_list_t);
/* create event queue */
ret = PtlEQAlloc(portals4_btl->portals_ni_h,
mca_btl_portals4_component.recv_queue_size,
&portals4_btl->recv_eq_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output, opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"%s:%d: Error allocating MD array", "%s:%d: PtlEQAlloc failed for NI %d: %d\n",
__FILE__, __LINE__); __FILE__, __LINE__, interface, ret);
ret = OMPI_ERR_TEMP_OUT_OF_RESOURCE;
goto error; goto error;
} }
mca_btl_portals4_component.eqs_h[interface] = portals4_btl->recv_eq_h;
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"PtlEQAlloc (recv_eq=%d) OK for NI %d\n", portals4_btl->recv_eq_h, interface));
for (i = 0 ; i < num_mds ; ++i) { /* Create recv_idx portal table entrie */
mca_btl_portals4_module.send_md_hs[i] = PTL_INVALID_HANDLE; ret = PtlPTAlloc(portals4_btl->portals_ni_h,
PTL_PT_ONLY_USE_ONCE |
PTL_PT_ONLY_TRUNCATE,
portals4_btl->recv_eq_h,
PTL_PT_ANY,
&portals4_btl->recv_idx);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"%s:%d: PtlPTAlloc failed for NI %d: %d\n",
__FILE__, __LINE__, interface, ret);
goto error;
} }
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"PtlPTAlloc (recv_idx) OK for NI %d recv_idx=%d\n", interface, portals4_btl->recv_idx));
for (i = 0 ; i < num_mds ; ++i) { /* bind zero-length md for sending acks */
md.start = (char*) (offset_unit * i); md.start = NULL;
md.length = (i - 1 == num_mds) ? size / 2 : size; md.length = 0;
md.options = 0; md.options = 0;
md.eq_handle = mca_btl_portals4_module.recv_eq_h; md.eq_handle = PTL_EQ_NONE;
md.ct_handle = PTL_CT_NONE; md.ct_handle = PTL_CT_NONE;
opal_output_verbose(50, ompi_btl_base_framework.framework_output, ret = PtlMDBind(portals4_btl->portals_ni_h,
&md,
&portals4_btl->zero_md_h);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"%s:%d: PtlMDBind failed for NI %d: %d\n",
__FILE__, __LINE__, interface, ret);
goto error;
}
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"PtlMDBind (zero-length md=%d) OK for NI %d\n", portals4_btl->zero_md_h, interface));
/* Bind MD/MDs across all memory. We prefer (for obvious reasons)
to have a single MD across all of memory */
#if OMPI_PORTALS4_MAX_MD_SIZE < OMPI_PORTALS4_MAX_VA_SIZE
{
int i;
int num_mds = mca_btl_portals4_get_num_mds();
ptl_size_t size = (1ULL << OMPI_PORTALS4_MAX_MD_SIZE) - 1;
ptl_size_t offset_unit = (1ULL << OMPI_PORTALS4_MAX_MD_SIZE) / 2;
portals4_btl->send_md_hs = malloc(sizeof(ptl_handle_md_t) * num_mds);
if (NULL == portals4_btl->send_md_hs) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"%s:%d: Error allocating MD array",
__FILE__, __LINE__);
ret = OMPI_ERR_TEMP_OUT_OF_RESOURCE;
goto error;
}
for (i = 0 ; i < num_mds ; ++i) {
portals4_btl->send_md_hs[i] = PTL_INVALID_HANDLE;
}
for (i = 0 ; i < num_mds ; ++i) {
md.start = (char*) (offset_unit * i);
md.length = (i - 1 == num_mds) ? size / 2 : size;
md.options = 0;
md.eq_handle = portals4_btl->recv_eq_h;
md.ct_handle = PTL_CT_NONE;
opal_output_verbose(50, ompi_btl_base_framework.framework_output,
"Binding md from %p of length %lx", "Binding md from %p of length %lx",
md.start, md.length); md.start, md.length);
ret = PtlMDBind(mca_btl_portals4_module.portals_ni_h, ret = PtlMDBind(portals4_btl->portals_ni_h,
&md, &md,
&mca_btl_portals4_module.send_md_hs[i]); &portals4_btl->send_md_hs[i]);
if (PTL_OK != ret) { if (PTL_OK != ret) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output, opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"%s:%d: PtlMDBind failed: %d\n", "%s:%d: PtlMDBind failed for NI %d: %d\n",
__FILE__, __LINE__, ret); __FILE__, __LINE__, interface, ret);
goto error; goto error;
}
} }
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "PtlMDBind (all memory) OK for NI %d\n", interface));
} }
}
#else #else
md.start = 0; md.start = 0;
md.length = PTL_SIZE_MAX; md.length = PTL_SIZE_MAX;
md.options = 0; md.options = 0;
md.eq_handle = mca_btl_portals4_module.recv_eq_h; md.eq_handle = portals4_btl->recv_eq_h;
md.ct_handle = PTL_CT_NONE; md.ct_handle = PTL_CT_NONE;
ret = PtlMDBind(mca_btl_portals4_module.portals_ni_h, ret = PtlMDBind(portals4_btl->portals_ni_h,
&md, &md,
&mca_btl_portals4_module.send_md_h); &portals4_btl->send_md_h);
if (PTL_OK != ret) { if (PTL_OK != ret) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output, opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"%s:%d: PtlMDBind failed: %d\n", "%s:%d: PtlMDBind failed for NI %d: %d\n",
__FILE__, __LINE__, ret); __FILE__, __LINE__, interface, ret);
goto error; goto error;
} }
#endif #endif
/* Handle long overflows */ /* Handle long overflows */
me.start = NULL; me.start = NULL;
me.length = 0; me.length = 0;
me.ct_handle = PTL_CT_NONE; me.ct_handle = PTL_CT_NONE;
me.min_free = 0; me.min_free = 0;
me.uid = PTL_UID_ANY; me.uid = PTL_UID_ANY;
me.options = PTL_ME_OP_PUT | me.options = PTL_ME_OP_PUT |
PTL_ME_EVENT_LINK_DISABLE | PTL_ME_EVENT_LINK_DISABLE |
PTL_ME_EVENT_COMM_DISABLE | PTL_ME_EVENT_COMM_DISABLE |
PTL_ME_EVENT_UNLINK_DISABLE; PTL_ME_EVENT_UNLINK_DISABLE;
me.match_id.phys.nid = PTL_NID_ANY; me.match_id.phys.nid = PTL_NID_ANY;
me.match_id.phys.pid = PTL_PID_ANY; me.match_id.phys.pid = PTL_PID_ANY;
me.match_bits = BTL_PORTALS4_LONG_MSG; me.match_bits = BTL_PORTALS4_LONG_MSG;
me.ignore_bits = BTL_PORTALS4_CONTEXT_MASK | me.ignore_bits = BTL_PORTALS4_CONTEXT_MASK |
BTL_PORTALS4_SOURCE_MASK | BTL_PORTALS4_SOURCE_MASK |
BTL_PORTALS4_TAG_MASK; BTL_PORTALS4_TAG_MASK;
ret = PtlMEAppend(mca_btl_portals4_module.portals_ni_h, ret = PtlMEAppend(portals4_btl->portals_ni_h,
mca_btl_portals4_module.recv_idx, portals4_btl->recv_idx,
&me, &me,
PTL_OVERFLOW_LIST, PTL_OVERFLOW_LIST,
NULL, NULL,
&mca_btl_portals4_module.long_overflow_me_h); &portals4_btl->long_overflow_me_h);
if (PTL_OK != ret) { if (PTL_OK != ret) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"%s:%d: PtlMEAppend failed for NI %d: %d\n",
__FILE__, __LINE__, interface, ret);
goto error;
}
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "PtlMEAppend (overflow list) OK for NI %d\n", interface));
}
free(portals4_nis_h);
portals4_nis_h = NULL;
/* Publish our NID(s)/PID(s) in the modex */
for (interface=0; interface<mca_btl_portals4_component.num_btls; interface++) {
portals4_btl = mca_btl_portals4_component.btls[interface];
ret = PtlGetId(portals4_btl->portals_ni_h ,&ptl_process_ids[interface]);
if (PTL_OK != ret) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"%s:%d: PtlGetId for NI %d failed: %d\n",
__FILE__, __LINE__, interface, ret);
goto error;
}
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"PtlGetId NI number %d: ni_h=%d PtlGetId : nid=%x pid=%x\n",
interface, portals4_btl->portals_ni_h,
ptl_process_ids[interface].phys.nid, ptl_process_ids[interface].phys.pid));
}
ret = ompi_modex_send(&mca_btl_portals4_component.super.btl_version,
ptl_process_ids, mca_btl_portals4_component.num_btls * sizeof(ptl_process_t));
if (OMPI_SUCCESS != ret) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output, opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"%s:%d: PtlMEAppend failed: %d\n", "%s:%d: ompi_modex_send failed: %d\n",
__FILE__, __LINE__, ret); __FILE__, __LINE__, ret);
goto error; goto error;
} }
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "PtlMEAppend (overflow list) OK\n")); free(ptl_process_ids);
ptl_process_ids = NULL;
*num_btls = 1; btls = malloc(mca_btl_portals4_component.num_btls * sizeof(mca_btl_portals4_module_t*) );
memcpy(btls , mca_btl_portals4_component.btls,
mca_btl_portals4_component.num_btls*sizeof(mca_btl_portals4_module_t*) );
opal_output_verbose(1, ompi_btl_base_framework.framework_output, "btl portals4 module has been initialized"); opal_output_verbose(1, ompi_btl_base_framework.framework_output, "The btl portals4 component has been initialized and uses %d NI(s)",
mca_btl_portals4_component.num_btls);
return btls; return btls;
error: error:
opal_output_verbose(1, ompi_btl_base_framework.framework_output, "Error in mca_btl_portals4_component_init\n"); opal_output_verbose(1, ompi_btl_base_framework.framework_output, "Error in mca_btl_portals4_component_init\n");
free(btls); if (*num_btls) {
/* Free also other portals4 resources */ if (NULL != portals4_nis_h) free(portals4_nis_h);
if (NULL != ptl_process_ids) free(ptl_process_ids);
for (interface=0; interface<mca_btl_portals4_component.num_btls; interface++) {
portals4_btl = mca_btl_portals4_component.btls[interface];
if (NULL != portals4_btl) mca_btl_portals4_free_module(portals4_btl);
}
mca_btl_portals4_component.num_btls = 0;
*num_btls = 0;
if (NULL != mca_btl_portals4_component.btls) free(mca_btl_portals4_component.btls);
if (NULL != mca_btl_portals4_component.eqs_h) free(mca_btl_portals4_component.eqs_h);
mca_btl_portals4_component.btls = NULL;
mca_btl_portals4_component.eqs_h = NULL;
}
return NULL; return NULL;
} }
@ -581,21 +638,24 @@ mca_btl_portals4_get_error(int ptl_error)
int int
mca_btl_portals4_component_progress(void) mca_btl_portals4_component_progress(void)
{ {
mca_btl_portals4_module_t *portals4_btl;
int num_progressed = 0; int num_progressed = 0;
int ret, btl_ownership; int ret, btl_ownership;
mca_btl_portals4_frag_t *frag = NULL; mca_btl_portals4_frag_t *frag = NULL;
mca_btl_base_tag_t tag; mca_btl_base_tag_t tag;
static ptl_event_t ev; static ptl_event_t ev;
unsigned int which;
mca_btl_active_message_callback_t* reg; mca_btl_active_message_callback_t* reg;
mca_btl_base_segment_t seg[2]; mca_btl_base_segment_t seg[2];
if (0 == mca_btl_portals4_module.portals_num_procs) return 0;
while (true) { while (true) {
ret = PtlEQGet(mca_btl_portals4_module.recv_eq_h, &ev); ret = PtlEQPoll(mca_btl_portals4_component.eqs_h, mca_btl_portals4_component.num_btls, 0, &ev, &which);
if (PTL_OK == ret) { if (PTL_OK == ret) {
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "PtlEQGet Event received: %d (%d)\n", ev.type, ev.ni_fail_type)); OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "PtlEQPoll Event received: %d (%d) on NI %d\n",
ev.type, ev.ni_fail_type, which));
num_progressed++; num_progressed++;
portals4_btl = mca_btl_portals4_component.btls[which];
switch (ev.type) { switch (ev.type) {
@ -609,19 +669,19 @@ mca_btl_portals4_component_progress(void)
if( MCA_BTL_DES_SEND_ALWAYS_CALLBACK & frag->base.des_flags ){ if( MCA_BTL_DES_SEND_ALWAYS_CALLBACK & frag->base.des_flags ){
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"PTL_EVENT_SEND: Direct call to des_cbfunc: %lx\n", (uint64_t)frag->base.des_cbfunc)); "PTL_EVENT_SEND: Direct call to des_cbfunc: %lx\n", (uint64_t)frag->base.des_cbfunc));
frag->base.des_cbfunc(&mca_btl_portals4_module.super, frag->base.des_cbfunc(&portals4_btl->super,
frag->endpoint, frag->endpoint,
&frag->base, &frag->base,
OMPI_SUCCESS); OMPI_SUCCESS);
} }
if (btl_ownership) { if (btl_ownership) {
mca_btl_portals4_free(&mca_btl_portals4_module.super, &frag->base); mca_btl_portals4_free(&portals4_btl->super, &frag->base);
} }
if (0 != frag->size) { if (0 != frag->size) {
OPAL_THREAD_ADD32(&mca_btl_portals4_module.portals_outstanding_ops, -1); OPAL_THREAD_ADD32(&portals4_btl->portals_outstanding_ops, -1);
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"PTL_EVENT_SEND: Decrementing portals_outstanding_ops=%d (1)\n", "PTL_EVENT_SEND: Decrementing portals_outstanding_ops=%d (1)\n",
mca_btl_portals4_module.portals_outstanding_ops)); portals4_btl->portals_outstanding_ops));
} }
} }
@ -641,19 +701,19 @@ mca_btl_portals4_component_progress(void)
if (MCA_BTL_DES_SEND_ALWAYS_CALLBACK & frag->base.des_flags ) { if (MCA_BTL_DES_SEND_ALWAYS_CALLBACK & frag->base.des_flags ) {
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"PTL_EVENT_ACK: Call to des_cbfunc %lx\n", (uint64_t)frag->base.des_cbfunc)); "PTL_EVENT_ACK: Call to des_cbfunc %lx\n", (uint64_t)frag->base.des_cbfunc));
frag->base.des_cbfunc(&mca_btl_portals4_module.super, frag->base.des_cbfunc(&portals4_btl->super,
frag->endpoint, frag->endpoint,
&frag->base, &frag->base,
OMPI_SUCCESS); OMPI_SUCCESS);
} }
if (btl_ownership) { if (btl_ownership) {
mca_btl_portals4_free(&mca_btl_portals4_module.super, &frag->base); mca_btl_portals4_free(&portals4_btl->super, &frag->base);
} }
if (0 != frag->size) { if (0 != frag->size) {
OPAL_THREAD_ADD32(&mca_btl_portals4_module.portals_outstanding_ops, -1); OPAL_THREAD_ADD32(&portals4_btl->portals_outstanding_ops, -1);
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"PTL_EVENT_ACK: Decrementing portals_outstanding_ops=%d (2)\n", mca_btl_portals4_module.portals_outstanding_ops)); "PTL_EVENT_ACK: Decrementing portals_outstanding_ops=%d (2)\n", portals4_btl->portals_outstanding_ops));
} }
goto done; goto done;
@ -673,7 +733,7 @@ mca_btl_portals4_component_progress(void)
reg = mca_btl_base_active_message_trigger + tag; reg = mca_btl_base_active_message_trigger + tag;
OPAL_OUTPUT_VERBOSE((50, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((50, ompi_btl_base_framework.framework_output,
"PTL_EVENT_PUT: tag=%x frag=%p cbfunc: %lx\n", tag, (void*)frag, (uint64_t)reg->cbfunc)); "PTL_EVENT_PUT: tag=%x frag=%p cbfunc: %lx\n", tag, (void*)frag, (uint64_t)reg->cbfunc));
reg->cbfunc(&mca_btl_portals4_module.super, tag, &(frag->base), reg->cbdata); reg->cbfunc(&portals4_btl->super, tag, &(frag->base), reg->cbdata);
goto done; goto done;
break; break;
@ -690,7 +750,7 @@ mca_btl_portals4_component_progress(void)
case PTL_EVENT_AUTO_UNLINK: case PTL_EVENT_AUTO_UNLINK:
/* */ /* */
/* This activation should be done for PTL_EVENT_AUTO_FREE */ /* The Priority List is used, so PTL_EVENT_AUTO_FREE will never be received. So, we have to reactivate the block here */
mca_btl_portals4_activate_block(ev.user_ptr); mca_btl_portals4_activate_block(ev.user_ptr);
goto done; goto done;
break; break;
@ -719,7 +779,7 @@ mca_btl_portals4_component_progress(void)
0, 0,
frag->length, frag->length,
frag->peer_proc, frag->peer_proc,
mca_btl_portals4_module.recv_idx, portals4_btl->recv_idx,
frag->match_bits, /* match bits */ frag->match_bits, /* match bits */
0, 0,
frag); frag);
@ -734,22 +794,22 @@ mca_btl_portals4_component_progress(void)
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"Re-issued PtlGet length=%ld recv_idx=%d pid=%x match_bits=%lx\n", "Re-issued PtlGet length=%ld recv_idx=%d pid=%x match_bits=%lx\n",
frag->length, mca_btl_portals4_module.recv_idx, frag->peer_proc.phys.pid, frag->match_bits)); frag->length, portals4_btl->recv_idx, frag->peer_proc.phys.pid, frag->match_bits));
} }
else { else {
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"PTL_EVENT_REPLY: Call to des_cbfunc: %lx\n", (uint64_t)frag->base.des_cbfunc)); "PTL_EVENT_REPLY: Call to des_cbfunc: %lx\n", (uint64_t)frag->base.des_cbfunc));
frag->base.des_cbfunc(&mca_btl_portals4_module.super, frag->base.des_cbfunc(&portals4_btl->super,
frag->endpoint, frag->endpoint,
&frag->base, &frag->base,
OMPI_SUCCESS); OMPI_SUCCESS);
PtlMDRelease(frag->md_h); PtlMDRelease(frag->md_h);
frag->md_h = PTL_INVALID_HANDLE; frag->md_h = PTL_INVALID_HANDLE;
OMPI_BTL_PORTALS4_FRAG_RETURN_USER(&mca_btl_portals4_module.super, frag); OMPI_BTL_PORTALS4_FRAG_RETURN_USER(&portals4_btl->super, frag);
OPAL_THREAD_ADD32(&mca_btl_portals4_module.portals_outstanding_ops, -1); OPAL_THREAD_ADD32(&portals4_btl->portals_outstanding_ops, -1);
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"PTL_EVENT_REPLY: Decrementing portals_outstanding_ops=%d\n", mca_btl_portals4_module.portals_outstanding_ops)); "PTL_EVENT_REPLY: Decrementing portals_outstanding_ops=%d\n", portals4_btl->portals_outstanding_ops));
goto done; goto done;
} }
break; break;

9
ompi/mca/btl/portals4/btl_portals4_endpoint.h
Просмотреть файл

@ -29,15 +29,6 @@ BEGIN_C_DECLS
* An instance of mca_btl_base_endpoint_t is associated w/ each process * An instance of mca_btl_base_endpoint_t is associated w/ each process
* and BTL pair at startup. However, connections to the endpoint * and BTL pair at startup. However, connections to the endpoint
* are established dynamically on an as-needed basis: * are established dynamically on an as-needed basis:
*
* The MTL, OSC, and COLL components expect the ptl_process_t to be
* hanging off the PORTALS4 tag in the proc_endpoints. That's not
* entirely convenient for the BTL, since we get an endpoint, not an
* ompi_proc_t. So we store the ptl_process_t in both places. Since
* the btl_base_endpoint_t is just a ptl_process_t, we use the same
* storage for both. During tear-down, it's entirely possible that
* the MTL is going to free the PORTALS4 memory, so we need to be
* careful during del_procs.
*/ */
struct mca_btl_base_endpoint_t { struct mca_btl_base_endpoint_t {
ptl_process_t ptl_proc; ptl_process_t ptl_proc;

4
ompi/mca/btl/portals4/btl_portals4_frag.c
Просмотреть файл

@ -49,8 +49,8 @@ mca_btl_portals4_frag_eager_constructor(mca_btl_portals4_frag_t* frag)
static void static void
mca_btl_portals4_frag_eager_destructor(mca_btl_portals4_frag_t* frag) mca_btl_portals4_frag_eager_destructor(mca_btl_portals4_frag_t* frag)
{ {
if (PTL_INVALID_HANDLE == frag->me_h) { if (PTL_INVALID_HANDLE != frag->me_h) {
PtlMDRelease(frag->me_h); PtlMEUnlink(frag->me_h);
frag->me_h = PTL_INVALID_HANDLE; frag->me_h = PTL_INVALID_HANDLE;
} }
} }

11
ompi/mca/btl/portals4/btl_portals4_rdma.c
Просмотреть файл

@ -26,7 +26,7 @@ mca_btl_portals4_put(struct mca_btl_base_module_t* btl_base,
struct mca_btl_base_endpoint_t* btl_peer, struct mca_btl_base_endpoint_t* btl_peer,
struct mca_btl_base_descriptor_t* descriptor) struct mca_btl_base_descriptor_t* descriptor)
{ {
opal_output(0, "mca_btl_portals4_put not implemented\n"); opal_output(ompi_btl_base_framework.framework_output, "mca_btl_portals4_put not implemented\n");
MPI_Abort(MPI_COMM_WORLD, 10); MPI_Abort(MPI_COMM_WORLD, 10);
return OMPI_SUCCESS; return OMPI_SUCCESS;
@ -38,6 +38,7 @@ mca_btl_portals4_get(struct mca_btl_base_module_t* btl_base,
struct mca_btl_base_endpoint_t* btl_peer, struct mca_btl_base_endpoint_t* btl_peer,
struct mca_btl_base_descriptor_t* descriptor) struct mca_btl_base_descriptor_t* descriptor)
{ {
mca_btl_portals4_module_t *portals4_btl = (mca_btl_portals4_module_t *) btl_base;
mca_btl_portals4_segment_t *src_seg = (mca_btl_portals4_segment_t *) descriptor->des_src; mca_btl_portals4_segment_t *src_seg = (mca_btl_portals4_segment_t *) descriptor->des_src;
mca_btl_portals4_frag_t *frag = (mca_btl_portals4_frag_t*) descriptor; mca_btl_portals4_frag_t *frag = (mca_btl_portals4_frag_t*) descriptor;
ptl_md_t md; ptl_md_t md;
@ -46,8 +47,6 @@ mca_btl_portals4_get(struct mca_btl_base_module_t* btl_base,
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"mca_btl_portals4_get frag=%p src_seg=%p frag->md_h=%d\n", (void *)frag, (void *)src_seg, frag->md_h)); "mca_btl_portals4_get frag=%p src_seg=%p frag->md_h=%d\n", (void *)frag, (void *)src_seg, frag->md_h));
assert(&mca_btl_portals4_module == (mca_btl_portals4_module_t*) btl_base);
frag->endpoint = btl_peer; frag->endpoint = btl_peer;
frag->hdr.tag = MCA_BTL_TAG_MAX; frag->hdr.tag = MCA_BTL_TAG_MAX;
@ -55,10 +54,10 @@ mca_btl_portals4_get(struct mca_btl_base_module_t* btl_base,
md.start = (void *)frag->segments[0].base.seg_addr.pval; md.start = (void *)frag->segments[0].base.seg_addr.pval;
md.length = frag->segments[0].base.seg_len; md.length = frag->segments[0].base.seg_len;
md.options = 0; md.options = 0;
md.eq_handle = mca_btl_portals4_module.recv_eq_h; md.eq_handle = portals4_btl->recv_eq_h;
md.ct_handle = PTL_CT_NONE; md.ct_handle = PTL_CT_NONE;
ret = PtlMDBind(mca_btl_portals4_module.portals_ni_h, ret = PtlMDBind(portals4_btl->portals_ni_h,
&md, &md,
&frag->md_h); &frag->md_h);
@ -76,7 +75,7 @@ mca_btl_portals4_get(struct mca_btl_base_module_t* btl_base,
0, 0,
md.length, md.length,
btl_peer->ptl_proc, btl_peer->ptl_proc,
mca_btl_portals4_module.recv_idx, portals4_btl->recv_idx,
frag->match_bits, /* match bits */ frag->match_bits, /* match bits */
0, 0,
frag); frag);

5
ompi/mca/btl/portals4/btl_portals4_recv.c
Просмотреть файл

@ -36,7 +36,7 @@ mca_btl_portals4_recv_enable(mca_btl_portals4_module_t *btl)
int i; int i;
/* create the recv blocks */ /* create the recv blocks */
for (i = 0 ; i < btl->portals_recv_mds_num ; ++i) { for (i = 0 ; i < mca_btl_portals4_component.portals_recv_mds_num ; ++i) {
mca_btl_portals4_recv_block_t *block = mca_btl_portals4_recv_block_t *block =
mca_btl_portals4_recv_block_init(btl); mca_btl_portals4_recv_block_init(btl);
if (NULL == block) { if (NULL == block) {
@ -74,12 +74,11 @@ mca_btl_portals4_recv_block_init(mca_btl_portals4_module_t *btl)
block = OBJ_NEW(mca_btl_portals4_recv_block_t); block = OBJ_NEW(mca_btl_portals4_recv_block_t);
block->btl = btl; block->btl = btl;
block->length = btl->portals_recv_mds_size; block->length = mca_btl_portals4_component.portals_recv_mds_size;
block->start = malloc(block->length); block->start = malloc(block->length);
if (block->start == NULL) return NULL; if (block->start == NULL) return NULL;
block->me_h = PTL_INVALID_HANDLE; block->me_h = PTL_INVALID_HANDLE;
block->md_h = PTL_INVALID_HANDLE;
block->full = false; block->full = false;
block->pending = 0; block->pending = 0;

15
ompi/mca/btl/portals4/btl_portals4_recv.h
Просмотреть файл

@ -29,7 +29,6 @@ struct mca_btl_portals4_recv_block_t {
void *start; void *start;
size_t length; size_t length;
ptl_handle_me_t me_h; ptl_handle_me_t me_h;
ptl_handle_md_t md_h;
volatile bool full; volatile bool full;
volatile int32_t pending; volatile int32_t pending;
@ -70,6 +69,7 @@ mca_btl_portals4_activate_block(mca_btl_portals4_recv_block_t *block)
ptl_me_t me; ptl_me_t me;
ptl_process_t remote_proc; ptl_process_t remote_proc;
ptl_match_bits_t match_bits, ignore_bits; ptl_match_bits_t match_bits, ignore_bits;
mca_btl_portals4_module_t *btl = block->btl;
if (NULL == block->start) return OMPI_ERROR; if (NULL == block->start) return OMPI_ERROR;
@ -79,7 +79,7 @@ mca_btl_portals4_activate_block(mca_btl_portals4_recv_block_t *block)
me.start = block->start; me.start = block->start;
me.length = block->length; me.length = block->length;
me.ct_handle = PTL_CT_NONE; me.ct_handle = PTL_CT_NONE;
me.min_free = mca_btl_portals4_module.super.btl_eager_limit; me.min_free = btl->super.btl_eager_limit;
me.uid = PTL_UID_ANY; me.uid = PTL_UID_ANY;
me.options = me.options =
PTL_ME_OP_PUT | PTL_ME_OP_PUT |
@ -98,19 +98,20 @@ mca_btl_portals4_activate_block(mca_btl_portals4_recv_block_t *block)
block->full = false; block->full = false;
opal_atomic_mb(); opal_atomic_mb();
ret = PtlMEAppend(mca_btl_portals4_module.portals_ni_h, ret = PtlMEAppend(btl->portals_ni_h,
mca_btl_portals4_module.recv_idx, btl->recv_idx,
&me, &me,
PTL_PRIORITY_LIST, PTL_PRIORITY_LIST,
block, block,
&block->me_h); &block->me_h);
if (OPAL_UNLIKELY(PTL_OK != ret)) { if (OPAL_UNLIKELY(PTL_OK != ret)) {
opal_output_verbose(1, ompi_btl_base_framework.framework_output, opal_output_verbose(1, ompi_btl_base_framework.framework_output,
"%s:%d: PtlMEAppend failed: %d", "%s:%d: PtlMEAppend failed on NI %d: %d",
__FILE__, __LINE__, ret); __FILE__, __LINE__, btl->interface_num, ret);
return OMPI_ERROR; return OMPI_ERROR;
} }
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "PtlMEAppend (recv) block=%p me_h=%d start=%p len=%x\n", (void *)block, block->me_h, block->start, (unsigned int) block->length)); OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "PtlMEAppend (recv) block=%p me_h=%d start=%p len=%x NI=%d\n",
(void *)block, block->me_h, block->start, (unsigned int) block->length, btl->interface_num));
return OMPI_SUCCESS; return OMPI_SUCCESS;
} }

22
ompi/mca/btl/portals4/btl_portals4_send.c
Просмотреть файл

@ -31,6 +31,7 @@ int mca_btl_portals4_send(struct mca_btl_base_module_t* btl_base,
struct mca_btl_base_descriptor_t* descriptor, struct mca_btl_base_descriptor_t* descriptor,
mca_btl_base_tag_t tag) mca_btl_base_tag_t tag)
{ {
struct mca_btl_portals4_module_t* portals4_btl = (struct mca_btl_portals4_module_t*) btl_base;
mca_btl_portals4_frag_t *frag = (mca_btl_portals4_frag_t*) descriptor; mca_btl_portals4_frag_t *frag = (mca_btl_portals4_frag_t*) descriptor;
ptl_match_bits_t match_bits, msglen_type; ptl_match_bits_t match_bits, msglen_type;
ptl_size_t put_length; ptl_size_t put_length;
@ -43,45 +44,48 @@ int mca_btl_portals4_send(struct mca_btl_base_module_t* btl_base,
frag->hdr.tag = tag; frag->hdr.tag = tag;
put_length = frag->segments[0].base.seg_len; put_length = frag->segments[0].base.seg_len;
if (put_length > mca_btl_portals4_module.super.btl_eager_limit) if (put_length > portals4_btl->super.btl_eager_limit)
msglen_type = BTL_PORTALS4_LONG_MSG; msglen_type = BTL_PORTALS4_LONG_MSG;
else msglen_type = BTL_PORTALS4_SHORT_MSG; else msglen_type = BTL_PORTALS4_SHORT_MSG;
BTL_PORTALS4_SET_SEND_BITS(match_bits, 0, 0, tag, msglen_type); BTL_PORTALS4_SET_SEND_BITS(match_bits, 0, 0, tag, msglen_type);
ompi_btl_portals4_get_md(frag->segments[0].base.seg_addr.pval, &md_h, &base); ompi_btl_portals4_get_md(frag->segments[0].base.seg_addr.pval, &md_h, &base, portals4_btl);
offset = (ptl_size_t) ((char*) frag->segments[0].base.seg_addr.pval - (char*) base); offset = (ptl_size_t) ((char*) frag->segments[0].base.seg_addr.pval - (char*) base);
/* reserve space in the event queue for rdma operations immediately */ /* reserve space in the event queue for rdma operations immediately */
while (OPAL_THREAD_ADD32(&mca_btl_portals4_module.portals_outstanding_ops, 1) > while (OPAL_THREAD_ADD32(&portals4_btl->portals_outstanding_ops, 1) >
mca_btl_portals4_module.portals_max_outstanding_ops) { portals4_btl->portals_max_outstanding_ops) {
OPAL_THREAD_ADD32(&mca_btl_portals4_module.portals_outstanding_ops, -1); OPAL_THREAD_ADD32(&portals4_btl->portals_outstanding_ops, -1);
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"Call to mca_btl_portals4_component_progress (4)\n")); "Call to mca_btl_portals4_component_progress (4)\n"));
mca_btl_portals4_component_progress(); mca_btl_portals4_component_progress();
} }
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output,
"mca_btl_portals4_send: Incrementing portals_outstanding_ops=%d\n", "mca_btl_portals4_send: Incrementing portals_outstanding_ops=%d\n",
mca_btl_portals4_module.portals_outstanding_ops)); portals4_btl->portals_outstanding_ops));
OPAL_OUTPUT_VERBOSE((50, ompi_btl_base_framework.framework_output, OPAL_OUTPUT_VERBOSE((50, ompi_btl_base_framework.framework_output,
"PtlPut frag=%p pid=%x tag=%x len=%ld match_bits=%lx\n", "PtlPut frag=%p pid=%x tag=%x len=%ld match_bits=%lx\n",
(void*)frag, endpoint->ptl_proc.phys.pid, tag, (void*)frag, endpoint->ptl_proc.phys.pid, tag,
put_length, (uint64_t)match_bits)); put_length, (uint64_t)match_bits));
ret = PtlPut(md_h, ret = PtlPut(md_h,
(ptl_size_t) offset, (ptl_size_t) offset,
put_length, /* fragment length */ put_length, /* fragment length */
(mca_btl_portals4_component.portals_need_ack ? PTL_ACK_REQ : PTL_NO_ACK_REQ), (mca_btl_portals4_component.portals_need_ack ? PTL_ACK_REQ : PTL_NO_ACK_REQ),
endpoint->ptl_proc, endpoint->ptl_proc,
mca_btl_portals4_module.recv_idx, portals4_btl->recv_idx,
match_bits, /* match bits */ match_bits, /* match bits */
0, /* remote offset - not used */ 0, /* remote offset - not used */
(void *) frag, /* user ptr */ (void *) frag, /* user ptr */
tag); /* hdr_data: tag */ tag); /* hdr_data: tag */
if (ret != PTL_OK) { if (ret != PTL_OK) {
opal_output(0, "mca_btl_portals4_send: PtlPut failed with error %d", ret); opal_output(ompi_btl_base_framework.framework_output, "mca_btl_portals4_send: PtlPut failed with error %d", ret);
return OMPI_ERROR; return OMPI_ERROR;
} }
OPAL_OUTPUT_VERBOSE((90, ompi_btl_base_framework.framework_output, "PtlPut frag=%p pid=%x tag=%x addr=%p len=%ld match_bits=%lx\n",
(void*)frag, endpoint->ptl_proc.phys.pid, tag, (void *)offset, put_length, (uint64_t)match_bits));
return OMPI_SUCCESS; return OMPI_SUCCESS;
} }
@ -98,7 +102,7 @@ int mca_btl_portals4_sendi(struct mca_btl_base_module_t* btl_base,
mca_btl_base_tag_t tag, mca_btl_base_tag_t tag,
mca_btl_base_descriptor_t** des) mca_btl_base_descriptor_t** des)
{ {
opal_output(0, "mca_btl_portals_sendi is not implemented"); opal_output(ompi_btl_base_framework.framework_output, "mca_btl_portals_sendi is not implemented");
abort(); abort();
return OMPI_SUCCESS; return OMPI_SUCCESS;
} }

10
ompi/mca/btl/portals4/configure.m4
Просмотреть файл

@ -19,16 +19,6 @@
# $HEADER$ # $HEADER$
# #
# MCA_ompi_btl_portals4_POST_CONFIG(will_build)
# ----------------------------------------
# Unlike most of the BTLs, we need to register an endpoint tag so that
# we can get our endpoint information from the same place as all the
# other Portals components (one-sided, mtl, coll, etc.). See comment
# in btl_portals4_endpoint.h for how the pieces fit together.
AC_DEFUN([MCA_ompi_btl_portals4_POST_CONFIG], [
AS_IF([test "$1" = "1"], [OMPI_REQUIRE_ENDPOINT_TAG([PORTALS4])])
])dnl
# MCA_btl_portals4_CONFIG(action-if-can-compile, # MCA_btl_portals4_CONFIG(action-if-can-compile,
# [action-if-cant-compile]) # [action-if-cant-compile])
# ------------------------------------------------ # ------------------------------------------------