static int alloc_ep_res(struct fi_info *fi)
{
int ret;
ret = ft_alloc_ep_res(fi);
if (ret)
return ret;
if (tx_shared_ctx) {
ret = fi_stx_context(domain, fi->tx_attr, &stx_ctx, NULL);
if (ret) {
FT_PRINTERR("fi_stx_context", ret);
return ret;
}
}
if (rx_shared_ctx) {
ret = fi_srx_context(domain, fi->rx_attr, &srx_ctx, NULL);
if (ret) {
FT_PRINTERR("fi_srx_context", ret);
return ret;
}
}
return 0;
}
static int rxm_ep_msg_res_open(struct fi_info *rxm_info,
struct util_domain *util_domain, struct rxm_ep *rxm_ep)
{
struct rxm_fabric *rxm_fabric;
struct rxm_domain *rxm_domain;
struct fi_cq_attr cq_attr;
int ret;
ret = ofix_getinfo(rxm_prov.version, NULL, NULL, 0, &rxm_util_prov,
rxm_info, rxm_alter_layer_info, rxm_alter_base_info,
1, &rxm_ep->msg_info);
if (ret)
return ret;
rxm_domain = container_of(util_domain, struct rxm_domain, util_domain);
rxm_fabric = container_of(util_domain->fabric, struct rxm_fabric, util_fabric);
ret = fi_passive_ep(rxm_fabric->msg_fabric, rxm_ep->msg_info, &rxm_ep->msg_pep, rxm_ep);
if (ret) {
FI_WARN(&rxm_prov, FI_LOG_FABRIC, "Unable to open msg PEP\n");
goto err1;
}
memset(&cq_attr, 0, sizeof(cq_attr));
cq_attr.size = rxm_info->tx_attr->size + rxm_info->rx_attr->size;
cq_attr.format = FI_CQ_FORMAT_MSG;
ret = fi_cq_open(rxm_domain->msg_domain, &cq_attr, &rxm_ep->msg_cq, NULL);
if (ret) {
FI_WARN(&rxm_prov, FI_LOG_CQ, "Unable to open MSG CQ\n");
goto err1;
}
ret = fi_srx_context(rxm_domain->msg_domain, rxm_ep->msg_info->rx_attr,
&rxm_ep->srx_ctx, NULL);
if (ret) {
FI_WARN(&rxm_prov, FI_LOG_FABRIC, "Unable to open shared receive context\n");
goto err2;
}
/* We don't care what's in the dest_addr at this point. We go by AV. */
if (rxm_ep->msg_info->dest_addr) {
free(rxm_ep->msg_info->dest_addr);
rxm_ep->msg_info->dest_addr = NULL;
rxm_ep->msg_info->dest_addrlen = 0;
}
/* Zero out the port as we would be creating multiple MSG EPs for a single
* RXM EP and we don't want address conflicts. */
if (rxm_ep->msg_info->src_addr)
((struct sockaddr_in *)(rxm_ep->msg_info->src_addr))->sin_port = 0;
return 0;
err2:
fi_close(&rxm_ep->msg_pep->fid);
err1:
fi_freeinfo(rxm_ep->msg_info);
return ret;
}
static int alloc_ep_res(struct fi_info *fi)
{
struct fi_rx_attr rx_attr;
struct fi_tx_attr tx_attr;
int i, ret = 0;
ret = ft_alloc_bufs();
if (ret)
return ret;
remote_fi_addr = malloc(sizeof(*remote_fi_addr) * ep_cnt);
if (!remote_fi_addr) {
perror("malloc");
return -FI_ENOMEM;
}
av_attr.count = ep_cnt;
ret = ft_alloc_active_res(fi);
if (ret)
return ret;
/* TODO: avoid allocating EP when EP array is used. */
FT_CLOSE_FID(ep);
memset(&tx_attr, 0, sizeof tx_attr);
memset(&rx_attr, 0, sizeof rx_attr);
ret = fi_stx_context(domain, &tx_attr, &stx_ctx, NULL);
if (ret) {
FT_PRINTERR("fi_stx_context", ret);
return ret;
}
ret = fi_srx_context(domain, &rx_attr, &srx_ctx, NULL);
if (ret) {
FT_PRINTERR("fi_srx_context", ret);
return ret;
}
ep_array = calloc(ep_cnt, sizeof(*ep_array));
if (!ep_array) {
perror("malloc");
return ret;
}
for (i = 0; i < ep_cnt; i++) {
ret = fi_endpoint(domain, fi, &ep_array[i], NULL);
if (ret) {
FT_PRINTERR("fi_endpoint", ret);
return ret;
}
}
return 0;
}
static int alloc_ep_res(struct fi_info *fi)
{
struct fi_cq_attr cq_attr;
struct fi_rx_attr rx_attr;
struct fi_tx_attr tx_attr;
struct fi_av_attr av_attr;
int i, ret = 0;
buffer_size = test_size[TEST_CNT - 1].size;
buf = malloc(buffer_size);
remote_fi_addr = (fi_addr_t *)malloc(sizeof(*remote_fi_addr) * ep_cnt);
if (!buf || !remote_fi_addr) {
perror("malloc");
goto err1;
}
memset(&cq_attr, 0, sizeof cq_attr);
cq_attr.format = FI_CQ_FORMAT_CONTEXT;
cq_attr.wait_obj = FI_WAIT_NONE;
cq_attr.size = rx_depth;
memset(&tx_attr, 0, sizeof tx_attr);
memset(&rx_attr, 0, sizeof rx_attr);
ret = fi_stx_context(dom, &tx_attr, &stx_ctx, NULL);
if (ret) {
FT_PRINTERR("fi_stx_context", ret);
goto err1;
}
ret = fi_cq_open(dom, &cq_attr, &scq, NULL);
if (ret) {
FT_PRINTERR("fi_cq_open", ret);
goto err2;
}
ret = fi_srx_context(dom, &rx_attr, &srx_ctx, NULL);
if (ret) {
FT_PRINTERR("fi_srx_context", ret);
goto err3;
}
ret = fi_cq_open(dom, &cq_attr, &rcq, NULL);
if (ret) {
FT_PRINTERR("fi_cq_open", ret);
goto err4;
}
ret = fi_mr_reg(dom, buf, buffer_size, 0, 0, 0, 0, &mr, NULL);
if (ret) {
FT_PRINTERR("fi_mr_reg", ret);
goto err5;
}
memset(&av_attr, 0, sizeof av_attr);
av_attr.type = fi->domain_attr->av_type ?
fi->domain_attr->av_type : FI_AV_MAP;
av_attr.count = ep_cnt;
ret = fi_av_open(dom, &av_attr, &av, NULL);
if (ret) {
FT_PRINTERR("fi_av_open", ret);
goto err6;
}
ep = calloc(ep_cnt, sizeof(*ep));
if (!ep) {
perror("malloc");
goto err7;
}
for (i = 0; i < ep_cnt; i++) {
ret = fi_endpoint(dom, fi, &ep[i], NULL);
if (ret) {
FT_PRINTERR("fi_endpoint", ret);
goto err8;
}
}
return 0;
err8:
FT_CLOSEV(ep, ep_cnt);
err7:
fi_close(&av->fid);
err6:
fi_close(&mr->fid);
err5:
fi_close(&rcq->fid);
err4:
fi_close(&srx_ctx->fid);
err3:
fi_close(&scq->fid);
err2:
fi_close(&stx_ctx->fid);
err1:
free(buf);
free(remote_fi_addr);
return ret;
}
