in prov/efa/src/rxr/rxr_ep.c [1607:1784]
int rxr_endpoint(struct fid_domain *domain, struct fi_info *info,
struct fid_ep **ep, void *context)
{
struct fi_info *rdm_info;
struct rxr_domain *rxr_domain;
struct efa_domain *efa_domain;
struct rxr_ep *rxr_ep;
struct fi_cq_attr cq_attr;
int ret, retv;
rxr_ep = calloc(1, sizeof(*rxr_ep));
if (!rxr_ep)
return -FI_ENOMEM;
rxr_domain = container_of(domain, struct rxr_domain,
util_domain.domain_fid);
memset(&cq_attr, 0, sizeof(cq_attr));
cq_attr.format = FI_CQ_FORMAT_DATA;
cq_attr.wait_obj = FI_WAIT_NONE;
ret = ofi_endpoint_init(domain, &rxr_util_prov, info, &rxr_ep->util_ep,
context, rxr_ep_progress);
if (ret)
goto err_free_ep;
ret = rxr_get_lower_rdm_info(rxr_domain->util_domain.fabric->
fabric_fid.api_version, NULL, NULL, 0,
&rxr_util_prov, info, &rdm_info);
if (ret)
goto err_close_ofi_ep;
rxr_reset_rx_tx_to_core(info, rdm_info);
ret = fi_endpoint(rxr_domain->rdm_domain, rdm_info,
&rxr_ep->rdm_ep, rxr_ep);
if (ret)
goto err_free_rdm_info;
efa_domain = container_of(rxr_domain->rdm_domain, struct efa_domain,
util_domain.domain_fid);
rxr_ep->use_shm = rxr_ep_use_shm(info);
if (rxr_ep->use_shm) {
/* Open shm provider's endpoint */
assert(!strcmp(shm_info->fabric_attr->name, "shm"));
ret = fi_endpoint(efa_domain->shm_domain, shm_info,
&rxr_ep->shm_ep, rxr_ep);
if (ret)
goto err_close_core_ep;
}
rxr_ep->rx_size = info->rx_attr->size;
rxr_ep->tx_size = info->tx_attr->size;
rxr_ep->rx_iov_limit = info->rx_attr->iov_limit;
rxr_ep->tx_iov_limit = info->tx_attr->iov_limit;
rxr_ep->max_outstanding_tx = rdm_info->tx_attr->size;
rxr_ep->core_rx_size = rdm_info->rx_attr->size;
rxr_ep->core_iov_limit = rdm_info->tx_attr->iov_limit;
rxr_ep->core_caps = rdm_info->caps;
cq_attr.size = MAX(rxr_ep->rx_size + rxr_ep->tx_size,
rxr_env.cq_size);
if (info->tx_attr->op_flags & FI_DELIVERY_COMPLETE)
FI_INFO(&rxr_prov, FI_LOG_CQ, "FI_DELIVERY_COMPLETE unsupported\n");
assert(info->tx_attr->msg_order == info->rx_attr->msg_order);
rxr_ep->msg_order = info->rx_attr->msg_order;
rxr_ep->core_msg_order = rdm_info->rx_attr->msg_order;
rxr_ep->core_inject_size = rdm_info->tx_attr->inject_size;
rxr_ep->mtu_size = rdm_info->ep_attr->max_msg_size;
fi_freeinfo(rdm_info);
if (rxr_env.mtu_size > 0 && rxr_env.mtu_size < rxr_ep->mtu_size)
rxr_ep->mtu_size = rxr_env.mtu_size;
if (rxr_ep->mtu_size > RXR_MTU_MAX_LIMIT)
rxr_ep->mtu_size = RXR_MTU_MAX_LIMIT;
rxr_ep->max_data_payload_size = rxr_ep->mtu_size - sizeof(struct rxr_data_hdr);
/*
* Assume our eager message size is the largest control header size
* without the source address. Use that value to set the default
* receive release threshold.
*/
rxr_ep->min_multi_recv_size = rxr_ep->mtu_size - sizeof(struct rxr_eager_tagrtm_hdr) - sizeof(struct rxr_req_opt_cq_data_hdr);
if (rxr_env.tx_queue_size > 0 &&
rxr_env.tx_queue_size < rxr_ep->max_outstanding_tx)
rxr_ep->max_outstanding_tx = rxr_env.tx_queue_size;
#if ENABLE_DEBUG
rxr_ep->sends = 0;
rxr_ep->send_comps = 0;
rxr_ep->failed_send_comps = 0;
rxr_ep->recv_comps = 0;
#endif
rxr_ep->posted_bufs_shm = 0;
rxr_ep->rx_bufs_shm_to_post = 0;
rxr_ep->posted_bufs_efa = 0;
rxr_ep->rx_bufs_efa_to_post = 0;
rxr_ep->tx_pending = 0;
rxr_ep->available_data_bufs_ts = 0;
ret = fi_cq_open(rxr_domain->rdm_domain, &cq_attr,
&rxr_ep->rdm_cq, rxr_ep);
if (ret)
goto err_close_shm_ep;
ret = fi_ep_bind(rxr_ep->rdm_ep, &rxr_ep->rdm_cq->fid,
FI_TRANSMIT | FI_RECV);
if (ret)
goto err_close_core_cq;
/* Bind ep with shm provider's cq */
if (rxr_ep->use_shm) {
ret = fi_cq_open(efa_domain->shm_domain, &cq_attr,
&rxr_ep->shm_cq, rxr_ep);
if (ret)
goto err_close_core_cq;
ret = fi_ep_bind(rxr_ep->shm_ep, &rxr_ep->shm_cq->fid,
FI_TRANSMIT | FI_RECV);
if (ret)
goto err_close_shm_cq;
}
ret = rxr_ep_init(rxr_ep);
if (ret)
goto err_close_shm_cq;
*ep = &rxr_ep->util_ep.ep_fid;
(*ep)->msg = &rxr_ops_msg;
(*ep)->rma = &rxr_ops_rma;
(*ep)->atomic = &rxr_ops_atomic;
(*ep)->tagged = &rxr_ops_tagged;
(*ep)->fid.ops = &rxr_ep_fi_ops;
(*ep)->ops = &rxr_ops_ep;
(*ep)->cm = &rxr_ep_cm;
return 0;
err_close_shm_cq:
if (rxr_ep->use_shm && rxr_ep->shm_cq) {
retv = fi_close(&rxr_ep->shm_cq->fid);
if (retv)
FI_WARN(&rxr_prov, FI_LOG_CQ, "Unable to close shm cq: %s\n",
fi_strerror(-retv));
}
err_close_core_cq:
retv = fi_close(&rxr_ep->rdm_cq->fid);
if (retv)
FI_WARN(&rxr_prov, FI_LOG_CQ, "Unable to close cq: %s\n",
fi_strerror(-retv));
err_close_shm_ep:
if (rxr_ep->use_shm && rxr_ep->shm_ep) {
retv = fi_close(&rxr_ep->shm_ep->fid);
if (retv)
FI_WARN(&rxr_prov, FI_LOG_EP_CTRL, "Unable to close shm EP: %s\n",
fi_strerror(-retv));
}
err_close_core_ep:
retv = fi_close(&rxr_ep->rdm_ep->fid);
if (retv)
FI_WARN(&rxr_prov, FI_LOG_EP_CTRL, "Unable to close EP: %s\n",
fi_strerror(-retv));
err_free_rdm_info:
fi_freeinfo(rdm_info);
err_close_ofi_ep:
retv = ofi_endpoint_close(&rxr_ep->util_ep);
if (retv)
FI_WARN(&rxr_prov, FI_LOG_EP_CTRL,
"Unable to close util EP: %s\n",
fi_strerror(-retv));
err_free_ep:
free(rxr_ep);
return ret;
}