static void destroy_ptl_idx(int dst_pe)
{
ompi_proc_t *proc;
proc = oshmem_proc_group_find(oshmem_group_all, dst_pe);
if (NULL != OSHMEM_PROC_DATA(proc)->transport_ids)
free(OSHMEM_PROC_DATA(proc)->transport_ids);
}
static void destroy_ptl_idx(int dst_pe)
{
oshmem_proc_t *proc;
proc = oshmem_proc_group_find(oshmem_group_all, dst_pe);
if (proc->transport_ids)
free(proc->transport_ids);
}
static int destroy_btl_idx(int dst_pe)
{
oshmem_proc_t *proc;
proc = oshmem_proc_group_find(oshmem_group_all, dst_pe);
if (proc->transport_ids) {
free(proc->transport_ids);
}
return OSHMEM_SUCCESS;
}
static int destroy_btl_idx(int dst_pe)
{
ompi_proc_t *proc;
proc = oshmem_proc_group_find(oshmem_group_all, dst_pe);
if (NULL != OSHMEM_PROC_DATA(proc)->transport_ids) {
free(OSHMEM_PROC_DATA(proc)->transport_ids);
}
return OSHMEM_SUCCESS;
}
static void unpack_remote_mkeys(opal_buffer_t *msg, int remote_pe)
{
int32_t cnt;
int32_t n;
int32_t tr_id;
int i;
oshmem_proc_t *proc;
proc = oshmem_proc_group_find(oshmem_group_all, remote_pe);
cnt = 1;
opal_dss.unpack(msg, &n, &cnt, OPAL_UINT32);
for (i = 0; i < n; i++) {
cnt = 1;
opal_dss.unpack(msg, &tr_id, &cnt, OPAL_UINT32);
cnt = 1;
opal_dss.unpack(msg,
&memheap_oob.mkeys[tr_id].va_base,
&cnt,
OPAL_UINT64);
if (0 == memheap_oob.mkeys[tr_id].va_base) {
cnt = 1;
opal_dss.unpack(msg, &memheap_oob.mkeys[tr_id].u.key, &cnt, OPAL_UINT64);
if (OPAL_PROC_ON_LOCAL_NODE(proc->super.proc_flags)) {
memheap_attach_segment(&memheap_oob.mkeys[tr_id], tr_id);
}
} else {
cnt = 1;
opal_dss.unpack(msg, &memheap_oob.mkeys[tr_id].len, &cnt, OPAL_UINT16);
if (0 < memheap_oob.mkeys[tr_id].len) {
memheap_oob.mkeys[tr_id].u.data = malloc(memheap_oob.mkeys[tr_id].len);
if (NULL == memheap_oob.mkeys[tr_id].u.data) {
MEMHEAP_ERROR("Failed allocate %d bytes", memheap_oob.mkeys[tr_id].len);
oshmem_shmem_abort(-1);
}
cnt = memheap_oob.mkeys[tr_id].len;
opal_dss.unpack(msg, memheap_oob.mkeys[tr_id].u.data, &cnt, OPAL_BYTE);
MCA_SPML_CALL(rmkey_unpack(&memheap_oob.mkeys[tr_id], remote_pe));
} else {
memheap_oob.mkeys[tr_id].u.key = MAP_SEGMENT_SHM_INVALID;
}
}
MEMHEAP_VERBOSE(5,
"tr_id: %d %s",
tr_id, mca_spml_base_mkey2str(&memheap_oob.mkeys[tr_id]));
}
}
static int do_mkey_req(opal_buffer_t *msg, int pe, int seg)
{
uint8_t msg_type;
oshmem_proc_t *proc;
int i, n, tr_id;
mca_spml_mkey_t *mkey;
msg_type = MEMHEAP_RKEY_RESP;
opal_dss.pack(msg, &msg_type, 1, OPAL_UINT8);
/* go over all transports to remote pe and pack mkeys */
n = oshmem_get_transport_count(pe);
proc = oshmem_proc_group_find(oshmem_group_all, pe);
opal_dss.pack(msg, &n, 1, OPAL_UINT32);
MEMHEAP_VERBOSE(5, "found %d transports to %d", n, pe);
for (i = 0; i < n; i++) {
tr_id = proc->transport_ids[i];
mkey = mca_memheap_base_get_mkey(__seg2base_va(seg), tr_id);
if (!mkey) {
MEMHEAP_ERROR("seg#%d tr_id: %d failed to find local mkey",
seg, tr_id);
return OSHMEM_ERROR;
}
opal_dss.pack(msg, &tr_id, 1, OPAL_UINT32);
opal_dss.pack(msg, &mkey->key, 1, OPAL_UINT64);
opal_dss.pack(msg, &mkey->va_base, 1, OPAL_UINT64);
if (NULL != MCA_SPML_CALL(get_remote_context_size)) {
uint32_t context_size =
(mkey->spml_context == NULL ) ?
0 :
(uint32_t) MCA_SPML_CALL(get_remote_context_size(mkey->spml_context));
opal_dss.pack(msg, &context_size, 1, OPAL_UINT32);
if (0 != context_size) {
opal_dss.pack(msg,
MCA_SPML_CALL(get_remote_context(mkey->spml_context)),
context_size,
OPAL_BYTE);
}
}
MEMHEAP_VERBOSE(5,
"seg#%d tr_id: %d key %llx base_va %p",
seg, tr_id, (unsigned long long)mkey->key, mkey->va_base);
}
return OSHMEM_SUCCESS;
}
/**
* @param all_trs
* 0 - pack mkeys for transports to given pe
* 1 - pack mkeys for ALL possible transports. value of pe is ignored
*/
static int pack_local_mkeys(opal_buffer_t *msg, int pe, int seg, int all_trs)
{
oshmem_proc_t *proc;
int i, n, tr_id;
sshmem_mkey_t *mkey;
/* go over all transports to remote pe and pack mkeys */
if (!all_trs) {
n = oshmem_get_transport_count(pe);
proc = oshmem_proc_group_find(oshmem_group_all, pe);
}
else {
proc = NULL;
n = memheap_map->num_transports;
}
opal_dss.pack(msg, &n, 1, OPAL_UINT32);
MEMHEAP_VERBOSE(5, "found %d transports to %d", n, pe);
for (i = 0; i < n; i++) {
if (!all_trs) {
tr_id = proc->transport_ids[i];
}
else {
tr_id = i;
}
mkey = mca_memheap_base_get_mkey(mca_memheap_seg2base_va(seg), tr_id);
if (!mkey) {
MEMHEAP_ERROR("seg#%d tr_id: %d failed to find local mkey",
seg, tr_id);
return OSHMEM_ERROR;
}
opal_dss.pack(msg, &tr_id, 1, OPAL_UINT32);
opal_dss.pack(msg, &mkey->va_base, 1, OPAL_UINT64);
if (0 == mkey->va_base) {
opal_dss.pack(msg, &mkey->u.key, 1, OPAL_UINT64);
} else {
opal_dss.pack(msg, &mkey->len, 1, OPAL_UINT16);
if (0 < mkey->len) {
opal_dss.pack(msg, mkey->u.data, mkey->len, OPAL_BYTE);
}
}
MEMHEAP_VERBOSE(5,
"seg#%d tr_id: %d %s",
seg, tr_id, mca_spml_base_mkey2str(mkey));
}
return OSHMEM_SUCCESS;
}
static int create_ptl_idx(int dst_pe)
{
ompi_proc_t *proc;
proc = oshmem_proc_group_find(oshmem_group_all, dst_pe);
OSHMEM_PROC_DATA(proc)->transport_ids = (char *) malloc(MXM_PTL_LAST * sizeof(char));
if (NULL == OSHMEM_PROC_DATA(proc)->transport_ids)
return OSHMEM_ERROR;
OSHMEM_PROC_DATA(proc)->num_transports = 1;
#if MXM_API < MXM_VERSION(2,0)
if (oshmem_my_proc_id() == dst_pe)
OSHMEM_PROC_DATA(proc)->transport_ids[0] = MXM_PTL_SELF;
else
#endif
OSHMEM_PROC_DATA(proc)->transport_ids[0] = MXM_PTL_RDMA;
return OSHMEM_SUCCESS;
}
/* for each proc create transport ids which are indexes into global
* btl list&map
*/
static int create_btl_idx(int dst_pe)
{
oshmem_proc_t *proc;
int btl_id;
mca_bml_base_endpoint_t* endpoint;
mca_bml_base_btl_t* bml_btl = 0;
int i, size;
mca_bml_base_btl_array_t *btl_array;
int shmem_index = -1;
proc = oshmem_proc_group_find(oshmem_group_all, dst_pe);
endpoint = (mca_bml_base_endpoint_t*) proc->proc_endpoints[OMPI_PROC_ENDPOINT_TAG_BML];
assert(endpoint);
size = mca_bml_base_btl_array_get_size(btl_array = &endpoint->btl_rdma);
if (0 >= size) {
/* Possibly this is SM BTL with KNEM disabled? Then we should use send based get/put */
/*
This hack is necessary for the case when KNEM is not available.
In this case we still want to use send/recv of SM BTL for put and get
but SM BTL is not in the rdma list anymore
*/
size = mca_bml_base_btl_array_get_size(btl_array =
&endpoint->btl_eager);
if (0 < size) {
/*Chose SHMEM capable btl from eager array. Not filter now: take the first
(but could appear on demand).*/
shmem_index = 0;
size = 1;
}
else {
SPML_ERROR("no SHMEM capable transport for dest pe=%d", dst_pe);
return OSHMEM_ERROR;
}
}
proc->transport_ids = (char *) malloc(size * sizeof(char));
if (!proc->transport_ids)
return OSHMEM_ERROR;
proc->num_transports = size;
for (i = 0; i < size; i++) {
bml_btl = mca_bml_base_btl_array_get_index(btl_array,
(shmem_index >= 0) ?
(shmem_index) : (i));
btl_id = _find_btl_id(bml_btl);
SPML_VERBOSE(50,
"dst_pe(%d) use btl (%s) btl_id=%d",
dst_pe, bml_btl->btl->btl_component->btl_version.mca_component_name, btl_id);
if (0 > btl_id) {
SPML_ERROR("unknown btl: dst_pe(%d) use btl (%s) btl_id=%d",
dst_pe, bml_btl->btl->btl_component->btl_version.mca_component_name, btl_id);
return OSHMEM_ERROR;
}
proc->transport_ids[i] = btl_id;
mca_spml_yoda.btl_type_map[btl_id].bml_btl = bml_btl;
mca_spml_yoda.btl_type_map[btl_id].use_cnt++;
}
return OSHMEM_SUCCESS;
}
int mca_spml_ikrit_add_procs(ompi_proc_t** procs, size_t nprocs)
{
spml_ikrit_mxm_ep_conn_info_t *ep_info = NULL;
spml_ikrit_mxm_ep_conn_info_t *ep_hw_rdma_info = NULL;
spml_ikrit_mxm_ep_conn_info_t my_ep_info;
size_t mxm_addr_len = MXM_MAX_ADDR_LEN;
mxm_error_t err;
size_t i, n;
int rc = OSHMEM_ERROR;
ompi_proc_t *proc_self;
int my_rank = oshmem_my_proc_id();
OBJ_CONSTRUCT(&mca_spml_ikrit.active_peers, opal_list_t);
/* Allocate connection requests */
ep_info = calloc(sizeof(spml_ikrit_mxm_ep_conn_info_t), nprocs);
if (NULL == ep_info) {
rc = OSHMEM_ERR_OUT_OF_RESOURCE;
goto bail;
}
if (mca_spml_ikrit.hw_rdma_channel) {
ep_hw_rdma_info = calloc(sizeof(spml_ikrit_mxm_ep_conn_info_t), nprocs);
if (NULL == ep_hw_rdma_info) {
rc = OSHMEM_ERR_OUT_OF_RESOURCE;
goto bail;
}
}
mca_spml_ikrit.mxm_peers = (mxm_peer_t *) calloc(nprocs , sizeof(mxm_peer_t));
if (NULL == mca_spml_ikrit.mxm_peers) {
rc = OSHMEM_ERR_OUT_OF_RESOURCE;
goto bail;
}
memset(&my_ep_info, 0, sizeof(my_ep_info));
if (mca_spml_ikrit.hw_rdma_channel) {
err = mxm_ep_get_address(mca_spml_ikrit.mxm_hw_rdma_ep, &my_ep_info.addr.ep_addr, &mxm_addr_len);
if (MXM_OK != err) {
orte_show_help("help-oshmem-spml-ikrit.txt", "unable to get endpoint address", true,
mxm_error_string(err));
rc = OSHMEM_ERROR;
goto bail;
}
oshmem_shmem_allgather(&my_ep_info, ep_hw_rdma_info,
sizeof(spml_ikrit_mxm_ep_conn_info_t));
}
err = mxm_ep_get_address(mca_spml_ikrit.mxm_ep, &my_ep_info.addr.ep_addr, &mxm_addr_len);
if (MXM_OK != err) {
orte_show_help("help-oshmem-spml-ikrit.txt", "unable to get endpoint address", true,
mxm_error_string(err));
rc = OSHMEM_ERROR;
goto bail;
}
oshmem_shmem_allgather(&my_ep_info, ep_info,
sizeof(spml_ikrit_mxm_ep_conn_info_t));
opal_progress_register(spml_ikrit_progress);
/* Get the EP connection requests for all the processes from modex */
for (n = 0; n < nprocs; ++n) {
/* mxm 2.0 keeps its connections on a list. Make sure
* that list have different order on every rank */
i = (my_rank + n) % nprocs;
mxm_peer_construct(&mca_spml_ikrit.mxm_peers[i]);
err = mxm_ep_connect(mca_spml_ikrit.mxm_ep, ep_info[i].addr.ep_addr, &mca_spml_ikrit.mxm_peers[i].mxm_conn);
if (MXM_OK != err) {
SPML_ERROR("MXM returned connect error: %s\n", mxm_error_string(err));
goto bail;
}
mxm_conn_ctx_set(mca_spml_ikrit.mxm_peers[i].mxm_conn, &mca_spml_ikrit.mxm_peers[i]);
if (mca_spml_ikrit.hw_rdma_channel) {
err = mxm_ep_connect(mca_spml_ikrit.mxm_hw_rdma_ep, ep_hw_rdma_info[i].addr.ep_addr, &mca_spml_ikrit.mxm_peers[i].mxm_hw_rdma_conn);
if (MXM_OK != err) {
SPML_ERROR("MXM returned connect error: %s\n", mxm_error_string(err));
goto bail;
}
} else {
mca_spml_ikrit.mxm_peers[i].mxm_hw_rdma_conn = mca_spml_ikrit.mxm_peers[i].mxm_conn;
}
}
if (ep_info)
free(ep_info);
if (ep_hw_rdma_info)
free(ep_hw_rdma_info);
if (mca_spml_ikrit.bulk_connect) {
/* Need a barrier to ensure remote peers already created connection */
oshmem_shmem_barrier();
mxm_ep_wireup(mca_spml_ikrit.mxm_ep);
}
proc_self = oshmem_proc_group_find(oshmem_group_all, my_rank);
/* identify local processes and change transport to SHM */
for (i = 0; i < nprocs; i++) {
if (procs[i]->super.proc_name.jobid != proc_self->super.proc_name.jobid ||
!OPAL_PROC_ON_LOCAL_NODE(procs[i]->super.proc_flags)) {
continue;
}
if (procs[i] == proc_self)
continue;
/* use zcopy for put/get via sysv shared memory with fallback to RDMA */
mca_spml_ikrit.mxm_peers[i].ptl_id = MXM_PTL_SHM;
}
SPML_VERBOSE(50, "*** ADDED PROCS ***");
return OSHMEM_SUCCESS;
bail:
if (ep_info)
free(ep_info);
if (ep_hw_rdma_info)
free(ep_hw_rdma_info);
SPML_ERROR("add procs FAILED rc=%d", rc);
return rc;
}
int mca_spml_ikrit_add_procs(ompi_proc_t** procs, size_t nprocs)
{
spml_ikrit_mxm_ep_conn_info_t *ep_info = NULL;
spml_ikrit_mxm_ep_conn_info_t *ep_hw_rdma_info = NULL;
spml_ikrit_mxm_ep_conn_info_t my_ep_info = {{0}};
#if MXM_API < MXM_VERSION(2,0)
mxm_conn_req_t *conn_reqs;
int timeout;
#else
size_t mxm_addr_len = MXM_MAX_ADDR_LEN;
#endif
mxm_error_t err;
size_t i, n;
int rc = OSHMEM_ERROR;
ompi_proc_t *proc_self;
int my_rank = oshmem_my_proc_id();
OBJ_CONSTRUCT(&mca_spml_ikrit.active_peers, opal_list_t);
/* Allocate connection requests */
#if MXM_API < MXM_VERSION(2,0)
conn_reqs = malloc(nprocs * sizeof(mxm_conn_req_t));
if (NULL == conn_reqs) {
rc = OSHMEM_ERR_OUT_OF_RESOURCE;
goto bail;
}
memset(conn_reqs, 0x0, sizeof(mxm_conn_req_t));
#endif
ep_info = calloc(sizeof(spml_ikrit_mxm_ep_conn_info_t), nprocs);
if (NULL == ep_info) {
rc = OSHMEM_ERR_OUT_OF_RESOURCE;
goto bail;
}
if (mca_spml_ikrit.hw_rdma_channel) {
ep_hw_rdma_info = calloc(sizeof(spml_ikrit_mxm_ep_conn_info_t), nprocs);
if (NULL == ep_hw_rdma_info) {
rc = OSHMEM_ERR_OUT_OF_RESOURCE;
goto bail;
}
}
mca_spml_ikrit.mxm_peers = (mxm_peer_t **) malloc(nprocs
* sizeof(*(mca_spml_ikrit.mxm_peers)));
if (NULL == mca_spml_ikrit.mxm_peers) {
rc = OSHMEM_ERR_OUT_OF_RESOURCE;
goto bail;
}
#if MXM_API < MXM_VERSION(2,0)
if (OSHMEM_SUCCESS
!= spml_ikrit_get_ep_address(&my_ep_info, MXM_PTL_SELF)) {
rc = OSHMEM_ERROR;
goto bail;
}
if (OSHMEM_SUCCESS
!= spml_ikrit_get_ep_address(&my_ep_info, MXM_PTL_RDMA)) {
rc = OSHMEM_ERROR;
goto bail;
}
#else
if (mca_spml_ikrit.hw_rdma_channel) {
err = mxm_ep_get_address(mca_spml_ikrit.mxm_hw_rdma_ep, &my_ep_info.addr.ep_addr, &mxm_addr_len);
if (MXM_OK != err) {
orte_show_help("help-oshmem-spml-ikrit.txt", "unable to get endpoint address", true,
mxm_error_string(err));
rc = OSHMEM_ERROR;
goto bail;
}
oshmem_shmem_allgather(&my_ep_info, ep_hw_rdma_info,
sizeof(spml_ikrit_mxm_ep_conn_info_t));
}
err = mxm_ep_get_address(mca_spml_ikrit.mxm_ep, &my_ep_info.addr.ep_addr, &mxm_addr_len);
if (MXM_OK != err) {
orte_show_help("help-oshmem-spml-ikrit.txt", "unable to get endpoint address", true,
mxm_error_string(err));
rc = OSHMEM_ERROR;
goto bail;
}
#endif
oshmem_shmem_allgather(&my_ep_info, ep_info,
sizeof(spml_ikrit_mxm_ep_conn_info_t));
opal_progress_register(spml_ikrit_progress);
/* Get the EP connection requests for all the processes from modex */
for (n = 0; n < nprocs; ++n) {
/* mxm 2.0 keeps its connections on a list. Make sure
* that list have different order on every rank */
i = (my_rank + n) % nprocs;
mca_spml_ikrit.mxm_peers[i] = OBJ_NEW(mxm_peer_t);
if (NULL == mca_spml_ikrit.mxm_peers[i]) {
rc = OSHMEM_ERR_OUT_OF_RESOURCE;
goto bail;
}
mca_spml_ikrit.mxm_peers[i]->pe = i;
#if MXM_API < MXM_VERSION(2,0)
conn_reqs[i].ptl_addr[MXM_PTL_SELF] =
(struct sockaddr *) &ep_info[i].addr.ptl_addr[MXM_PTL_SELF];
conn_reqs[i].ptl_addr[MXM_PTL_SHM] = NULL;
conn_reqs[i].ptl_addr[MXM_PTL_RDMA] =
(struct sockaddr *) &ep_info[i].addr.ptl_addr[MXM_PTL_RDMA];
#else
err = mxm_ep_connect(mca_spml_ikrit.mxm_ep, ep_info[i].addr.ep_addr, &mca_spml_ikrit.mxm_peers[i]->mxm_conn);
if (MXM_OK != err) {
SPML_ERROR("MXM returned connect error: %s\n", mxm_error_string(err));
goto bail;
}
if (OSHMEM_SUCCESS != create_ptl_idx(i))
goto bail;
mxm_conn_ctx_set(mca_spml_ikrit.mxm_peers[i]->mxm_conn, mca_spml_ikrit.mxm_peers[i]);
if (mca_spml_ikrit.hw_rdma_channel) {
err = mxm_ep_connect(mca_spml_ikrit.mxm_hw_rdma_ep, ep_hw_rdma_info[i].addr.ep_addr, &mca_spml_ikrit.mxm_peers[i]->mxm_hw_rdma_conn);
if (MXM_OK != err) {
SPML_ERROR("MXM returned connect error: %s\n", mxm_error_string(err));
goto bail;
}
} else {
mca_spml_ikrit.mxm_peers[i]->mxm_hw_rdma_conn = mca_spml_ikrit.mxm_peers[i]->mxm_conn;
}
#endif
}
#if MXM_API < MXM_VERSION(2,0)
/* Connect to remote peers */
if (mxm_get_version() < MXM_VERSION(1,5)) {
timeout = 1000;
} else {
timeout = -1;
}
err = mxm_ep_connect(mca_spml_ikrit.mxm_ep, conn_reqs, nprocs, timeout);
if (MXM_OK != err) {
SPML_ERROR("MXM returned connect error: %s\n", mxm_error_string(err));
for (i = 0; i < nprocs; ++i) {
if (MXM_OK != conn_reqs[i].error) {
SPML_ERROR("MXM EP connect to %s error: %s\n",
procs[i]->proc_hostname, mxm_error_string(conn_reqs[i].error));
}
}
rc = OSHMEM_ERR_CONNECTION_FAILED;
goto bail;
}
/* Save returned connections */
for (i = 0; i < nprocs; ++i) {
mca_spml_ikrit.mxm_peers[i]->mxm_conn = conn_reqs[i].conn;
if (OSHMEM_SUCCESS != create_ptl_idx(i)) {
rc = OSHMEM_ERR_CONNECTION_FAILED;
goto bail;
}
mxm_conn_ctx_set(conn_reqs[i].conn, mca_spml_ikrit.mxm_peers[i]);
}
if (conn_reqs)
free(conn_reqs);
#endif
if (ep_info)
free(ep_info);
if (ep_hw_rdma_info)
free(ep_hw_rdma_info);
#if MXM_API >= MXM_VERSION(2,0)
if (mca_spml_ikrit.bulk_connect) {
/* Need a barrier to ensure remote peers already created connection */
oshmem_shmem_barrier();
mxm_ep_wireup(mca_spml_ikrit.mxm_ep);
}
#endif
proc_self = oshmem_proc_group_find(oshmem_group_all, my_rank);
/* identify local processes and change transport to SHM */
for (i = 0; i < nprocs; i++) {
if (procs[i]->super.proc_name.jobid != proc_self->super.proc_name.jobid ||
!OPAL_PROC_ON_LOCAL_NODE(procs[i]->super.proc_flags)) {
continue;
}
if (procs[i] == proc_self)
continue;
/* use zcopy for put/get via sysv shared memory */
OSHMEM_PROC_DATA(procs[i])->transport_ids[0] = MXM_PTL_SHM;
OSHMEM_PROC_DATA(procs[i])->transport_ids[1] = MXM_PTL_RDMA;
OSHMEM_PROC_DATA(procs[i])->num_transports = 2;
}
SPML_VERBOSE(50, "*** ADDED PROCS ***");
return OSHMEM_SUCCESS;
bail:
#if MXM_API < MXM_VERSION(2,0)
if (conn_reqs)
free(conn_reqs);
#endif
if (ep_info)
free(ep_info);
if (ep_hw_rdma_info)
free(ep_hw_rdma_info);
SPML_ERROR("add procs FAILED rc=%d", rc);
return rc;
}
/**
* shmem_get reads data from a remote address
* in the symmetric heap via RDMA READ.
* Get operation:
* 1. Get the rkey to the remote address.
* 2. Allocate a get request.
* 3. Allocated a temporary pre-registered buffer
* to copy the data to.
* 4. Init the request descriptor with remote side
* data and local side data.
* 5. Read the remote buffer to a pre-registered
* buffer on the local PE using RDMA READ.
* 6. Copy the received data to dst_addr if an
* intermediate pre-register buffer was used.
* 7. Clear the request and return.
*
* src_addr - address on remote pe.
* size - the amount on bytes to be read.
* dst_addr - address on the local pe.
* src - the pe of remote process.
*/
int mca_spml_yoda_get(void* src_addr, size_t size, void* dst_addr, int src)
{
int rc = OSHMEM_SUCCESS;
mca_spml_mkey_t *r_mkey, *l_mkey;
void* rva;
unsigned ncopied = 0;
unsigned int frag_size = 0;
char *p_src, *p_dst;
int i;
int nfrags;
mca_bml_base_btl_t* bml_btl = NULL;
mca_btl_base_segment_t* segment;
mca_btl_base_descriptor_t* des = NULL;
mca_spml_yoda_rdma_frag_t* frag = NULL;
struct mca_spml_yoda_getreq_parent get_holder;
struct yoda_btl *ybtl;
int btl_id = 0;
int get_via_send;
const opal_datatype_t *datatype = &opal_datatype_wchar;
opal_convertor_t convertor;
oshmem_proc_t *proc_self;
size_t prepare_size;
mca_mpool_base_registration_t* registration;
mca_spml_yoda_get_request_t* getreq = NULL;
/*If nothing to get its OK.*/
if (0 >= size) {
return rc;
}
/* Find bml_btl and its global btl_id */
bml_btl = get_next_btl(src, &btl_id);
if (!bml_btl) {
SPML_ERROR("cannot reach %d pe: no appropriate btl found", oshmem_my_proc_id());
oshmem_shmem_abort(-1);
}
/* Check if btl has GET method. If it doesn't - use SEND*/
get_via_send = ! ( (bml_btl->btl->btl_flags & (MCA_BTL_FLAGS_GET)) &&
(bml_btl->btl->btl_flags & (MCA_BTL_FLAGS_PUT)) );
/* Get rkey of remote PE (src proc) which must be on memheap*/
r_mkey = mca_memheap.memheap_get_cached_mkey(src,
src_addr,
btl_id,
&rva);
if (!r_mkey) {
SPML_ERROR("pe=%d: %p is not address of shared variable",
src, src_addr);
oshmem_shmem_abort(-1);
}
#if SPML_YODA_DEBUG == 1
SPML_VERBOSE(100, "get: pe:%d src=%p -> dst: %p sz=%d. src_rva=%p, %s",
src, src_addr, dst_addr, (int)size, (void *)rva, mca_spml_base_mkey2str(r_mkey));
#endif
ybtl = &mca_spml_yoda.btl_type_map[btl_id];
nfrags = 1;
/* check if we doing get into shm attached segment and if so
* just do memcpy
*/
if ((YODA_BTL_SM == ybtl->btl_type)
&& OPAL_LIKELY(mca_memheap.memheap_is_symmetric_addr(src_addr) && src_addr != rva)) {
memcpy(dst_addr, (void *) rva, size);
/* must call progress here to avoid deadlock. Scenarion:
* pe1 pols pe2 via shm get. pe2 tries to get static variable from node one, which goes to sm btl
* In this case pe2 is stuck forever because pe1 never calls opal_progress.
* May be we do not need to call progress on every get() here but rather once in a while.
*/
opal_progress();
return OSHMEM_SUCCESS;
}
l_mkey = mca_memheap.memheap_get_local_mkey(dst_addr,
btl_id);
/*
* Need a copy if local memory has not been registered or
* we make GET via SEND
*/
frag_size = ncopied;
if ((NULL == l_mkey) || get_via_send) {
calc_nfrags(bml_btl, size, &frag_size, &nfrags, get_via_send);
}
p_src = (char*) (unsigned long) rva;
p_dst = (char*) dst_addr;
get_holder.active_count = 0;
for (i = 0; i < nfrags; i++) {
/**
* Allocating a get request from a pre-allocated
* and pre-registered free list.
*/
getreq = mca_spml_yoda_getreq_alloc(src);
assert(getreq);
getreq->p_dst = NULL;
frag = &getreq->get_frag;
getreq->parent = &get_holder;
ncopied = i < nfrags - 1 ? frag_size :(unsigned) ((char *) dst_addr + size - p_dst);
frag->allocated = 0;
/* Prepare destination descriptor*/
assert(0 != r_mkey->len);
memcpy(&frag->rdma_segs[0].base_seg,
r_mkey->u.data,
r_mkey->len);
frag->rdma_segs[0].base_seg.seg_len = (get_via_send ? ncopied + SPML_YODA_SEND_CONTEXT_SIZE : ncopied);
if (get_via_send) {
frag->use_send = 1;
frag->allocated = 1;
/**
* Allocate a temporary buffer on the local PE.
* The local buffer will store the data read
* from the remote address.
*/
mca_spml_yoda_bml_alloc(bml_btl,
&des,
MCA_BTL_NO_ORDER,
(int)frag_size,
MCA_BTL_DES_SEND_ALWAYS_CALLBACK,
get_via_send);
if (OPAL_UNLIKELY(!des || !des->des_src)) {
SPML_ERROR("shmem OOM error need %d bytes", ncopied);
SPML_ERROR("src=%p nfrags = %d frag_size=%d",
src_addr, nfrags, frag_size);
oshmem_shmem_abort(-1);
}
segment = des->des_src;
spml_yoda_prepare_for_get((void*)segment->seg_addr.pval, ncopied, (void*)p_src, oshmem_my_proc_id(), (void*)p_dst, (void*) getreq);
des->des_cbfunc = mca_spml_yoda_get_response_completion;
OPAL_THREAD_ADD32(&mca_spml_yoda.n_active_gets, 1);
}
else {
/*
* Register src memory if do GET via GET
*/
proc_self = oshmem_proc_group_find(oshmem_group_all, oshmem_my_proc_id());
OBJ_CONSTRUCT(&convertor, opal_convertor_t);
prepare_size = ncopied;
opal_convertor_copy_and_prepare_for_recv(proc_self->proc_convertor,
datatype,
prepare_size,
p_dst,
0,
&convertor);
registration = (NULL == l_mkey ? NULL : ((mca_spml_yoda_context_t*)l_mkey->spml_context)->registration);
des = ybtl->btl->btl_prepare_dst(ybtl->btl,
bml_btl->btl_endpoint,
registration,
&convertor,
MCA_BTL_NO_ORDER,
0,
&prepare_size,
0);
if (NULL == des) {
SPML_ERROR("%s: failed to register destination memory %p.",
btl_type2str(ybtl->btl_type), p_dst);
}
OBJ_DESTRUCT(&convertor);
frag->rdma_segs[0].base_seg.seg_addr.lval = (uintptr_t) p_src;
getreq->p_dst = (uint64_t*) p_dst;
frag->size = ncopied;
des->des_cbfunc = mca_spml_yoda_get_completion;
des->des_src = &frag->rdma_segs[0].base_seg;
OPAL_THREAD_ADD32(&mca_spml_yoda.n_active_gets, 1);
}
/**
* Initialize the remote data fragment
* with remote address data required for
* executing RDMA READ from a remote buffer.
*/
frag->rdma_req = getreq;
/**
* Init remote side descriptor.
*/
des->des_src_cnt = 1;
des->des_cbdata = frag;
/**
* Do GET operation
*/
if (get_via_send) {
rc = mca_bml_base_send(bml_btl, des, MCA_SPML_YODA_GET);
if (1 == rc)
rc = OSHMEM_SUCCESS;
} else {
rc = mca_bml_base_get(bml_btl, des);
}
if (OPAL_UNLIKELY(OSHMEM_SUCCESS != rc)) {
if (OSHMEM_ERR_OUT_OF_RESOURCE == rc) {
/* No free resources, Block on completion here */
oshmem_request_wait_completion(&getreq->req_get.req_base.req_oshmem);
return OSHMEM_SUCCESS;
} else {
SPML_ERROR("oshmem_get: error %d", rc);
oshmem_shmem_abort(-1);
return rc;
}
}
p_dst += ncopied;
p_src += ncopied;
OPAL_THREAD_ADD32(&get_holder.active_count, 1);
}
/* revisit if we really need this for self and sm */
/* if (YODA_BTL_SELF == ybtl->btl_type) */
opal_progress();
/* Wait for completion on request */
while (get_holder.active_count > 0)
oshmem_request_wait_completion(&getreq->req_get.req_base.req_oshmem);
return rc;
}
mca_spml_mkey_t *mca_spml_yoda_register(void* addr,
size_t size,
uint64_t shmid,
int *count)
{
int i;
mca_btl_base_descriptor_t* des = NULL;
const opal_datatype_t *datatype = &opal_datatype_wchar;
opal_convertor_t convertor;
mca_spml_mkey_t *mkeys;
struct yoda_btl *ybtl;
oshmem_proc_t *proc_self;
mca_spml_yoda_context_t* yoda_context;
struct iovec iov;
uint32_t iov_count = 1;
SPML_VERBOSE(10, "address %p len %llu", addr, (unsigned long long)size);
*count = 0;
/* make sure everything is initialized to 0 */
mkeys = (mca_spml_mkey_t *) calloc(1,
mca_spml_yoda.n_btls * sizeof(*mkeys));
if (!mkeys) {
return NULL ;
}
proc_self = oshmem_proc_group_find(oshmem_group_all, oshmem_my_proc_id());
/* create convertor */
OBJ_CONSTRUCT(&convertor, opal_convertor_t);
mca_bml.bml_register( MCA_SPML_YODA_PUT,
mca_yoda_put_callback,
NULL );
mca_bml.bml_register( MCA_SPML_YODA_GET,
mca_yoda_get_callback,
NULL );
mca_bml.bml_register( MCA_SPML_YODA_GET_RESPONSE,
mca_yoda_get_response_callback,
NULL );
/* Register proc memory in every rdma BTL. */
for (i = 0; i < mca_spml_yoda.n_btls; i++) {
ybtl = &mca_spml_yoda.btl_type_map[i];
mkeys[i].va_base = addr;
if (!ybtl->use_cnt) {
SPML_VERBOSE(10,
"%s: present but not in use. SKIP registration",
btl_type2str(ybtl->btl_type));
continue;
}
/* If we have shared memory just save its id*/
if (YODA_BTL_SM == ybtl->btl_type
&& MEMHEAP_SHM_INVALID != (int) MEMHEAP_SHM_GET_ID(shmid)) {
mkeys[i].u.key = shmid;
mkeys[i].va_base = 0;
continue;
}
yoda_context = calloc(1, sizeof(*yoda_context));
mkeys[i].spml_context = yoda_context;
yoda_context->registration = NULL;
if (NULL != ybtl->btl->btl_prepare_src) {
/* initialize convertor for source descriptor*/
opal_convertor_copy_and_prepare_for_recv(proc_self->proc_convertor,
datatype,
size,
addr,
0,
&convertor);
if (NULL != ybtl->btl->btl_mpool && NULL != ybtl->btl->btl_mpool->mpool_register) {
iov.iov_len = size;
iov.iov_base = NULL;
opal_convertor_pack(&convertor, &iov, &iov_count, &size);
ybtl->btl->btl_mpool->mpool_register(ybtl->btl->btl_mpool,
iov.iov_base, size, 0, &yoda_context->registration);
}
/* initialize convertor for source descriptor*/
opal_convertor_copy_and_prepare_for_recv(proc_self->proc_convertor,
datatype,
size,
addr,
0,
&convertor);
/* register source memory */
des = ybtl->btl->btl_prepare_src(ybtl->btl,
0,
yoda_context->registration,
&convertor,
MCA_BTL_NO_ORDER,
0,
&size,
0);
if (NULL == des) {
SPML_ERROR("%s: failed to register source memory. ",
btl_type2str(ybtl->btl_type));
}
yoda_context->btl_src_descriptor = des;
mkeys[i].u.data = des->des_src;
mkeys[i].len = ybtl->btl->btl_seg_size;
}
SPML_VERBOSE(5,
"rank %d btl %s address 0x%p len %llu shmid 0x%X|0x%X",
oshmem_proc_local_proc->proc_name.vpid, btl_type2str(ybtl->btl_type),
mkeys[i].va_base, (unsigned long long)size, MEMHEAP_SHM_GET_TYPE(shmid), MEMHEAP_SHM_GET_ID(shmid));
}
OBJ_DESTRUCT(&convertor);
*count = mca_spml_yoda.n_btls;
return mkeys;
}
void mca_memheap_modex_recv_all(void)
{
int i;
int j;
int nprocs, my_pe;
oshmem_proc_t *proc;
mca_spml_mkey_t *mkey;
void* dummy_rva;
if (!mca_memheap_base_key_exchange)
return;
/* init rkey cache */
nprocs = oshmem_num_procs();
my_pe = oshmem_my_proc_id();
/* Note:
* Doing exchange via rml till we figure out problem with grpcomm.modex and barrier
*/
for (i = 0; i < nprocs; i++) {
if (i == my_pe)
continue;
proc = oshmem_proc_group_find(oshmem_group_all, i);
for (j = 0; j < memheap_map->n_segments; j++) {
mkey =
mca_memheap_base_get_cached_mkey(i,
memheap_map->mem_segs[j].start,
proc->transport_ids[0],
&dummy_rva);
if (!mkey) {
MEMHEAP_ERROR("Failed to receive mkeys");
oshmem_shmem_abort(-1);
}
}
}
/*
* There is an issue with orte_grpcomm.barrier usage as
* ess/pmi directs to use grpcomm/pmi in case slurm srun() call grpcomm/pmi calls PMI_Barrier()
* that is a function of external library.
* There is no opal_progress() in such way. As a result slow PEs send a request (MEMHEAP_RKEY_REQ) to
* fast PEs waiting on barrier and do not get a respond (MEMHEAP_RKEY_RESP).
*
* there are following ways to solve one:
* 1. calculate requests from remote PEs and do ORTE_PROGRESSED_WAIT waiting for expected value;
* 2. use shmem_barrier_all();
* 3. rework pmi/barrier to use opal_progress();
* 4. use orte_grpcomm.barrier carefully;
*
* It seems there is no need to use orte_grpcomm.barrier here
*/
if (memheap_map->mem_segs[HEAP_SEG_INDEX].shmid != MEMHEAP_SHM_INVALID) {
/* unfortunately we must do barrier here to assure that everyone are attached to our segment
* good thing that this code path only invoked on older linuxes (-mca shmalloc_use_hugepages 3|4)
* try to minimize damage here by waiting 5 seconds and doing progress
*/
shmem_barrier_all();
/* keys exchanged, segments attached, now we can safely cleanup */
if (memheap_map->mem_segs[HEAP_SEG_INDEX].type
== MAP_SEGMENT_ALLOC_SHM) {
shmctl(memheap_map->mem_segs[HEAP_SEG_INDEX].shmid,
IPC_RMID,
NULL );
}
}
}
