static int init_fabric(void)
{
char *node, *service;
uint64_t flags = 0;
int ret;
ret = ft_read_addr_opts(&node, &service, hints, &flags, &opts);
if (ret)
return ret;
ret = fi_getinfo(FT_FIVERSION, node, service, flags, hints, &fi);
if (ret) {
FT_PRINTERR("fi_getinfo", ret);
return ret;
}
if (opts.dst_addr) {
addrlen = fi->dest_addrlen;
remote_addr = malloc(addrlen);
memcpy(remote_addr, fi->dest_addr, addrlen);
}
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
if (ret) {
FT_PRINTERR("fi_fabric", ret);
goto err0;
}
ret = fi_domain(fab, fi, &dom, NULL);
if (ret) {
FT_PRINTERR("fi_domain", ret);
goto err1;
}
ret = alloc_ep_res(fi);
if (ret)
goto err3;
ret = bind_ep_res();
if (ret)
goto err4;
if(opts.dst_addr) {
ret = fi_av_insert(av, remote_addr, 1, &remote_fi_addr, 0,
&fi_ctx_av);
if (ret != 1) {
FT_PRINTERR("fi_av_insert", ret);
return ret;
}
}
return 0;
err4:
free_ep_res();
err3:
fi_close(&dom->fid);
err1:
fi_close(&fab->fid);
err0:
return ret;
}
void rdm_api_setup_ep(void)
{
int ret, i, j;
struct fi_av_attr attr;
size_t addrlen = 0;
/* Get info about fabric services with the provided hints */
for (i = 0; i < NUMEPS; i++) {
ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints[i],
&fi[i]);
cr_assert(!ret, "fi_getinfo");
}
attr.type = FI_AV_MAP;
attr.count = NUMEPS;
cq_attr.format = FI_CQ_FORMAT_TAGGED;
cq_attr.size = 1024;
cq_attr.wait_obj = 0;
target = malloc(BUF_SZ * 3); /* 3x BUF_SZ for multi recv testing */
assert(target);
source = malloc(BUF_SZ);
assert(source);
uc_target = malloc(BUF_SZ);
assert(uc_target);
uc_source = malloc(BUF_SZ);
assert(uc_source);
ret = fi_fabric(fi[0]->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
for (i = 0; i < NUMEPS; i++) {
ret = fi_domain(fab, fi[i], dom + i, NULL);
cr_assert(!ret, "fi_domain");
ret = fi_open_ops(&dom[i]->fid, FI_GNI_DOMAIN_OPS_1,
0, (void **) (gni_domain_ops + i), NULL);
ret = fi_av_open(dom[i], &attr, av + i, NULL);
cr_assert(!ret, "fi_av_open");
ret = fi_endpoint(dom[i], fi[i], ep + i, NULL);
cr_assert(!ret, "fi_endpoint");
ret = fi_cq_open(dom[i], &cq_attr, msg_cq + i, 0);
cr_assert(!ret, "fi_cq_open");
ret = fi_ep_bind(ep[i], &msg_cq[i]->fid, FI_SEND | FI_RECV);
cr_assert(!ret, "fi_ep_bind");
ret = fi_getname(&ep[i]->fid, NULL, &addrlen);
cr_assert(addrlen > 0);
ep_name[i] = malloc(addrlen);
cr_assert(ep_name[i] != NULL);
ret = fi_getname(&ep[i]->fid, ep_name[i], &addrlen);
cr_assert(ret == FI_SUCCESS);
}
for (i = 0; i < NUMEPS; i++) {
/* Insert all gni addresses into each av */
for (j = 0; j < NUMEPS; j++) {
ret = fi_av_insert(av[i], ep_name[j], 1, &gni_addr[j],
0, NULL);
cr_assert(ret == 1);
}
ret = fi_ep_bind(ep[i], &av[i]->fid, 0);
cr_assert(!ret, "fi_ep_bind");
ret = fi_enable(ep[i]);
cr_assert(!ret, "fi_ep_enable");
ret = fi_cntr_open(dom[i], &cntr_attr, send_cntr + i, 0);
cr_assert(!ret, "fi_cntr_open");
ret = fi_ep_bind(ep[i], &send_cntr[i]->fid, FI_SEND);
cr_assert(!ret, "fi_ep_bind");
ret = fi_cntr_open(dom[i], &cntr_attr, recv_cntr + i, 0);
cr_assert(!ret, "fi_cntr_open");
ret = fi_ep_bind(ep[i], &recv_cntr[i]->fid, FI_RECV);
cr_assert(!ret, "fi_ep_bind");
}
for (i = 0; i < NUMEPS; i++) {
ret = fi_mr_reg(dom[i], target, 3 * BUF_SZ,
FI_REMOTE_WRITE, 0, 0, 0, rem_mr + i, &target);
cr_assert_eq(ret, 0);
ret = fi_mr_reg(dom[i], source, BUF_SZ,
FI_REMOTE_WRITE, 0, 0, 0, loc_mr + i, &source);
cr_assert_eq(ret, 0);
mr_key[i] = fi_mr_key(rem_mr[i]);
}
}
void rdm_sr_setup_common_eps(void)
{
int ret = 0, i = 0, j = 0;
struct fi_av_attr attr;
size_t addrlen = 0;
attr.type = FI_AV_MAP;
attr.count = NUMEPS;
cq_attr.format = FI_CQ_FORMAT_TAGGED;
cq_attr.size = 1024;
cq_attr.wait_obj = 0;
target = malloc(BUF_SZ * 3); /* 3x BUF_SZ for multi recv testing */
assert(target);
source = malloc(BUF_SZ);
assert(source);
uc_target = malloc(BUF_SZ);
assert(uc_target);
uc_source = malloc(BUF_SZ);
assert(uc_source);
ret = fi_fabric(fi[0]->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
for (; i < NUMEPS; i++) {
ret = fi_domain(fab, fi[i], dom + i, NULL);
cr_assert(!ret, "fi_domain");
ret = fi_open_ops(&dom[i]->fid, FI_GNI_DOMAIN_OPS_1,
0, (void **) (gni_domain_ops + i), NULL);
ret = fi_av_open(dom[i], &attr, av + i, NULL);
cr_assert(!ret, "fi_av_open");
ret = fi_endpoint(dom[i], fi[i], ep + i, NULL);
cr_assert(!ret, "fi_endpoint");
ret = fi_cq_open(dom[i], &cq_attr, msg_cq + i, 0);
cr_assert(!ret, "fi_cq_open");
ret = fi_ep_bind(ep[i], &msg_cq[i]->fid, FI_SEND | FI_RECV);
cr_assert(!ret, "fi_ep_bind");
ret = fi_getname(&ep[i]->fid, NULL, &addrlen);
cr_assert(addrlen > 0);
ep_name[i] = malloc(addrlen);
cr_assert(ep_name[i] != NULL);
ret = fi_getname(&ep[i]->fid, ep_name[i], &addrlen);
cr_assert(ret == FI_SUCCESS);
}
for (i = 0; i < NUMEPS; i++) {
/* Insert all gni addresses into each av */
for (j = 0; j < NUMEPS; j++) {
ret = fi_av_insert(av[i], ep_name[j], 1, &gni_addr[j],
0, NULL);
cr_assert(ret == 1);
}
ret = fi_ep_bind(ep[i], &av[i]->fid, 0);
cr_assert(!ret, "fi_ep_bind");
ret = fi_enable(ep[i]);
cr_assert(!ret, "fi_ep_enable");
ret = fi_cntr_open(dom[i], &cntr_attr, send_cntr + i, 0);
cr_assert(!ret, "fi_cntr_open");
ret = fi_ep_bind(ep[i], &send_cntr[i]->fid, FI_SEND);
cr_assert(!ret, "fi_ep_bind");
ret = fi_cntr_open(dom[i], &cntr_attr, recv_cntr + i, 0);
cr_assert(!ret, "fi_cntr_open");
ret = fi_ep_bind(ep[i], &recv_cntr[i]->fid, FI_RECV);
cr_assert(!ret, "fi_ep_bind");
}
}
void cancel_setup(void)
{
int ret = 0;
struct fi_av_attr attr;
size_t addrlen = 0;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
hints->domain_attr->mr_mode = GNIX_DEFAULT_MR_MODE;
hints->domain_attr->cq_data_size = 4;
hints->mode = mode_bits;
hints->fabric_attr->prov_name = strdup("gni");
ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
ret = fi_domain(fab, fi, &dom, NULL);
cr_assert(!ret, "fi_domain");
memset(&attr, 0, sizeof(attr));
attr.type = FI_AV_MAP;
attr.count = 16;
ret = fi_av_open(dom, &attr, &av, NULL);
cr_assert(!ret, "fi_av_open");
ret = fi_endpoint(dom, fi, &ep[0], NULL);
cr_assert(!ret, "fi_endpoint");
cq_attr.format = FI_CQ_FORMAT_CONTEXT;
cq_attr.size = 1024;
cq_attr.wait_obj = 0;
ret = fi_cq_open(dom, &cq_attr, &msg_cq[0], 0);
cr_assert(!ret, "fi_cq_open");
ret = fi_cq_open(dom, &cq_attr, &msg_cq[1], 0);
cr_assert(!ret, "fi_cq_open");
ret = fi_ep_bind(ep[0], &msg_cq[0]->fid, FI_SEND | FI_RECV);
cr_assert(!ret, "fi_ep_bind");
ret = fi_getname(&ep[0]->fid, NULL, &addrlen);
cr_assert(addrlen > 0);
ep_name[0] = malloc(addrlen);
cr_assert(ep_name[0] != NULL);
ret = fi_getname(&ep[0]->fid, ep_name[0], &addrlen);
cr_assert(ret == FI_SUCCESS);
ret = fi_endpoint(dom, fi, &ep[1], NULL);
cr_assert(!ret, "fi_endpoint");
ret = fi_ep_bind(ep[1], &msg_cq[1]->fid, FI_SEND | FI_RECV);
cr_assert(!ret, "fi_ep_bind");
ep_name[1] = malloc(addrlen);
cr_assert(ep_name[1] != NULL);
ret = fi_getname(&ep[1]->fid, ep_name[1], &addrlen);
cr_assert(ret == FI_SUCCESS);
ret = fi_av_insert(av, ep_name[0], 1, &gni_addr[0], 0,
NULL);
cr_assert(ret == 1);
ret = fi_av_insert(av, ep_name[1], 1, &gni_addr[1], 0,
NULL);
cr_assert(ret == 1);
ret = fi_ep_bind(ep[0], &av->fid, 0);
cr_assert(!ret, "fi_ep_bind");
ret = fi_ep_bind(ep[1], &av->fid, 0);
cr_assert(!ret, "fi_ep_bind");
ret = fi_enable(ep[0]);
cr_assert(!ret, "fi_ep_enable");
ret = fi_enable(ep[1]);
cr_assert(!ret, "fi_ep_enable");
target = malloc(BUF_SZ);
assert(target);
source = malloc(BUF_SZ);
assert(source);
ret = fi_mr_reg(dom, target, BUF_SZ,
FI_REMOTE_WRITE, 0, 0, 0, &rem_mr, &target);
cr_assert_eq(ret, 0);
ret = fi_mr_reg(dom, source, BUF_SZ,
FI_REMOTE_WRITE, 0, 0, 0, &loc_mr, &source);
cr_assert_eq(ret, 0);
mr_key = fi_mr_key(rem_mr);
}
static void setup_ep(void)
{
int ret;
struct fi_av_attr attr;
size_t addrlen = 0;
attr.type = FI_AV_MAP;
attr.count = 16;
ret = fi_av_open(dom, &attr, &av, NULL);
cr_assert(!ret, "fi_av_open");
ret = fi_endpoint(dom, fi, &ep[0], NULL);
cr_assert(!ret, "fi_endpoint");
cq_attr.format = FI_CQ_FORMAT_TAGGED;
cq_attr.size = 1024;
cq_attr.wait_obj = 0;
ret = fi_cq_open(dom, &cq_attr, &msg_cq[0], 0);
cr_assert(!ret, "fi_cq_open");
ret = fi_cq_open(dom, &cq_attr, &msg_cq[1], 0);
cr_assert(!ret, "fi_cq_open");
ret = fi_ep_bind(ep[0], &msg_cq[0]->fid, FI_SEND | FI_RECV);
cr_assert(!ret, "fi_ep_bind");
ret = fi_getname(&ep[0]->fid, NULL, &addrlen);
cr_assert(addrlen > 0);
ep_name[0] = malloc(addrlen);
cr_assert(ep_name[0] != NULL);
ret = fi_getname(&ep[0]->fid, ep_name[0], &addrlen);
cr_assert(ret == FI_SUCCESS);
ret = fi_endpoint(dom, fi, &ep[1], NULL);
cr_assert(!ret, "fi_endpoint");
ret = fi_ep_bind(ep[1], &msg_cq[1]->fid, FI_SEND | FI_RECV);
cr_assert(!ret, "fi_ep_bind");
ep_name[1] = malloc(addrlen);
cr_assert(ep_name[1] != NULL);
ret = fi_getname(&ep[1]->fid, ep_name[1], &addrlen);
cr_assert(ret == FI_SUCCESS);
ret = fi_av_insert(av, ep_name[0], 1, &gni_addr[0], 0,
NULL);
cr_assert(ret == 1);
ret = fi_av_insert(av, ep_name[1], 1, &gni_addr[1], 0,
NULL);
cr_assert(ret == 1);
ret = fi_ep_bind(ep[0], &av->fid, 0);
cr_assert(!ret, "fi_ep_bind");
ret = fi_ep_bind(ep[1], &av->fid, 0);
cr_assert(!ret, "fi_ep_bind");
ret = fi_enable(ep[0]);
cr_assert(!ret, "fi_ep_enable");
ret = fi_enable(ep[1]);
cr_assert(!ret, "fi_ep_enable");
}
static int init_av(void)
{
int ret;
if (opts.dst_addr) {
// get local address blob. Find the addrlen first. We set
// addrlen as 0 and fi_getname will return the actual addrlen
addrlen = 0;
ret = fi_getname(&ep->fid, local_addr, &addrlen);
if (ret != -FI_ETOOSMALL) {
FT_PRINTERR("fi_getname", ret);
return ret;
}
local_addr = malloc(addrlen);
ret = fi_getname(&ep->fid, local_addr, &addrlen);
if (ret) {
FT_PRINTERR("fi_getname", ret);
return ret;
}
ret = fi_av_insert(av, remote_addr, 1, &remote_fi_addr, 0,
&fi_ctx_av);
if (ret != 1) {
FT_PRINTERR("fi_av_insert", ret);
return ret;
}
// send local addr size and local addr
memcpy(buf, &addrlen, sizeof(size_t));
memcpy(buf + sizeof(size_t), local_addr, addrlen);
ret = send_msg(sizeof(size_t) + addrlen);
if (ret)
return ret;
// receive ACK from server
ret = post_recv();
if (ret)
return ret;
} else {
// post a recv to get the remote address
ret = post_recv();
if (ret)
return ret;
memcpy(&addrlen, buf, sizeof(size_t));
remote_addr = malloc(addrlen);
memcpy(remote_addr, buf + sizeof(size_t), addrlen);
ret = fi_av_insert(av, remote_addr, 1, &remote_fi_addr, 0,
&fi_ctx_av);
if (ret != 1) {
FT_PRINTERR("fi_av_insert", ret);
return ret;
}
// send ACK
ret = send_msg(16);
if (ret)
return ret;
}
return ret;
}
static void vc_setup_common(void)
{
int ret = 0;
struct fi_av_attr attr;
size_t addrlen = 0;
struct gnix_fid_av *gnix_av;
hints->fabric_attr->name = strdup("gni");
ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
ret = fi_domain(fab, fi, &dom, NULL);
cr_assert(!ret, "fi_domain");
attr.type = FI_AV_MAP;
attr.count = 16;
ret = fi_av_open(dom, &attr, &av, NULL);
cr_assert(!ret, "fi_av_open");
gnix_av = container_of(av, struct gnix_fid_av, av_fid);
ret = fi_endpoint(dom, fi, &ep[0], NULL);
cr_assert(!ret, "fi_endpoint");
ret = fi_getname(&ep[0]->fid, NULL, &addrlen);
cr_assert(addrlen > 0);
ep_name[0] = malloc(addrlen);
cr_assert(ep_name[0] != NULL);
ep_name[1] = malloc(addrlen);
cr_assert(ep_name[1] != NULL);
ret = fi_getname(&ep[0]->fid, ep_name[0], &addrlen);
cr_assert(ret == FI_SUCCESS);
ret = fi_endpoint(dom, fi, &ep[1], NULL);
cr_assert(!ret, "fi_endpoint");
ret = fi_getname(&ep[1]->fid, ep_name[1], &addrlen);
cr_assert(ret == FI_SUCCESS);
ret = fi_av_insert(av, ep_name[0], 1, &gni_addr[0], 0,
NULL);
cr_assert(ret == 1);
ret = _gnix_av_lookup(gnix_av, gni_addr[0], &gnix_addr[0]);
cr_assert(ret == FI_SUCCESS);
ret = fi_av_insert(av, ep_name[1], 1, &gni_addr[1], 0,
NULL);
cr_assert(ret == 1);
ret = _gnix_av_lookup(gnix_av, gni_addr[1], &gnix_addr[1]);
cr_assert(ret == FI_SUCCESS);
ret = fi_ep_bind(ep[0], &av->fid, 0);
cr_assert(!ret, "fi_ep_bind");
cq_attr.format = FI_CQ_FORMAT_TAGGED;
cq_attr.size = 1024;
cq_attr.wait_obj = 0;
ret = fi_cq_open(dom, &cq_attr, &cq, 0);
cr_assert(!ret, "fi_cq_open");
ret = fi_ep_bind(ep[0], &cq->fid, FI_SEND | FI_RECV);
cr_assert(!ret, "fi_ep_bind");
ret = fi_enable(ep[0]);
cr_assert(!ret, "fi_enable");
ret = fi_ep_bind(ep[1], &cq->fid, FI_SEND | FI_RECV);
cr_assert(!ret, "fi_ep_bind");
ret = fi_ep_bind(ep[1], &av->fid, 0);
cr_assert(!ret, "fi_ep_bind");
ret = fi_enable(ep[1]);
cr_assert(!ret, "fi_ep_enable");
}
static inline void __api_cntr_setup(uint32_t version, int mr_mode)
{
int ret, i, j;
struct fi_av_attr attr = {0};
size_t addrlen = 0;
for (i = 0; i < NUMEPS; i++) {
hints[i] = fi_allocinfo();
cr_assert(hints[i], "fi_allocinfo");
hints[i]->domain_attr->data_progress = FI_PROGRESS_AUTO;
hints[i]->mode = mode_bits;
hints[i]->fabric_attr->prov_name = strdup("gni");
hints[i]->domain_attr->mr_mode = mr_mode;
}
/* Get info about fabric services with the provided hints */
for (i = 0; i < NUMEPS; i++) {
ret = fi_getinfo(version, NULL, 0, 0, hints[i],
&fi[i]);
cr_assert(!ret, "fi_getinfo");
}
attr.type = FI_AV_MAP;
attr.count = NUMEPS;
/* 3x BUF_SZ for multi recv testing */
target_base = malloc(GNIT_ALIGN_LEN(BUF_SZ * 3));
assert(target_base);
target = GNIT_ALIGN_BUFFER(char *, target_base);
source_base = malloc(GNIT_ALIGN_LEN(BUF_SZ));
assert(source_base);
source = GNIT_ALIGN_BUFFER(char *, source_base);
uc_target = malloc(BUF_SZ);
assert(uc_target);
uc_source = malloc(BUF_SZ);
assert(uc_source);
ret = fi_fabric(fi[0]->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
for (i = 0; i < NUMEPS; i++) {
ret = fi_domain(fab, fi[i], dom + i, NULL);
cr_assert(!ret, "fi_domain");
ret = fi_open_ops(&dom[i]->fid, FI_GNI_DOMAIN_OPS_1,
0, (void **) (gni_domain_ops + i), NULL);
ret = fi_av_open(dom[i], &attr, av + i, NULL);
cr_assert(!ret, "fi_av_open");
ret = fi_endpoint(dom[i], fi[i], ep + i, NULL);
cr_assert(!ret, "fi_endpoint");
ret = fi_cntr_open(dom[i], &cntr_attr, write_cntr + i, 0);
cr_assert(!ret, "fi_cntr_open");
ret = fi_cntr_open(dom[i], &cntr_attr, read_cntr + i, 0);
cr_assert(!ret, "fi_cntr_open");
ret = fi_cntr_open(dom[i], &cntr_attr, send_cntr + i, 0);
cr_assert(!ret, "fi_cntr_open");
ret = fi_cntr_open(dom[i], &cntr_attr, recv_cntr + i, 0);
cr_assert(!ret, "fi_cntr_open");
ret = fi_getname(&ep[i]->fid, NULL, &addrlen);
cr_assert(addrlen > 0);
ep_name[i] = malloc(addrlen);
cr_assert(ep_name[i] != NULL);
ret = fi_getname(&ep[i]->fid, ep_name[i], &addrlen);
cr_assert(ret == FI_SUCCESS);
}
for (i = 0; i < NUMEPS; i++) {
/* Insert all gni addresses into each av */
for (j = 0; j < NUMEPS; j++) {
ret = fi_av_insert(av[i], ep_name[j], 1, &gni_addr[j],
0, NULL);
cr_assert(ret == 1);
}
ret = fi_ep_bind(ep[i], &av[i]->fid, 0);
cr_assert(!ret, "fi_ep_bind");
}
for (i = 0; i < NUMEPS; i++) {
int target_requested_key =
USING_SCALABLE(fi[i]) ? (i * 2) : 0;
int source_requested_key =
USING_SCALABLE(fi[i]) ? (i * 2) + 1 : 0;
ret = fi_mr_reg(dom[i],
target,
3 * BUF_SZ,
FI_REMOTE_WRITE,
0,
target_requested_key,
0,
rem_mr + i,
&target);
cr_assert_eq(ret, 0);
ret = fi_mr_reg(dom[i],
source,
BUF_SZ,
FI_REMOTE_WRITE,
0,
source_requested_key,
0,
loc_mr + i,
&source);
cr_assert_eq(ret, 0);
if (USING_SCALABLE(fi[i])) {
MR_ENABLE(rem_mr[i], target, 3 * BUF_SZ);
MR_ENABLE(loc_mr[i], source, BUF_SZ);
}
mr_key[i] = fi_mr_key(rem_mr[i]);
}
}
void rdm_rma_setup(void)
{
int ret = 0;
struct fi_av_attr attr;
size_t addrlen = 0;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
hints->domain_attr->cq_data_size = 4;
hints->mode = ~0;
hints->fabric_attr->name = strdup("gni");
ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
ret = fi_domain(fab, fi, &dom, NULL);
cr_assert(!ret, "fi_domain");
ret = fi_open_ops(&dom->fid, FI_GNI_DOMAIN_OPS_1,
0, (void **) &gni_domain_ops, NULL);
attr.type = FI_AV_MAP;
attr.count = 16;
ret = fi_av_open(dom, &attr, &av, NULL);
cr_assert(!ret, "fi_av_open");
ret = fi_endpoint(dom, fi, &ep[0], NULL);
cr_assert(!ret, "fi_endpoint");
cq_attr.format = FI_CQ_FORMAT_TAGGED;
cq_attr.size = 1024;
cq_attr.wait_obj = 0;
ret = fi_cq_open(dom, &cq_attr, &send_cq, 0);
cr_assert(!ret, "fi_cq_open");
/*
* imitate shmem, etc. use FI_WRITE for bind
* flag
*/
ret = fi_ep_bind(ep[0], &send_cq->fid, FI_TRANSMIT);
cr_assert(!ret, "fi_ep_bind");
ret = fi_getname(&ep[0]->fid, NULL, &addrlen);
cr_assert(addrlen > 0);
ep_name[0] = malloc(addrlen);
cr_assert(ep_name[0] != NULL);
ep_name[1] = malloc(addrlen);
cr_assert(ep_name[1] != NULL);
ret = fi_getname(&ep[0]->fid, ep_name[0], &addrlen);
cr_assert(ret == FI_SUCCESS);
ret = fi_endpoint(dom, fi, &ep[1], NULL);
cr_assert(!ret, "fi_endpoint");
cq_attr.format = FI_CQ_FORMAT_TAGGED;
ret = fi_cq_open(dom, &cq_attr, &recv_cq, 0);
cr_assert(!ret, "fi_cq_open");
ret = fi_ep_bind(ep[1], &recv_cq->fid, FI_RECV);
cr_assert(!ret, "fi_ep_bind");
ret = fi_getname(&ep[1]->fid, ep_name[1], &addrlen);
cr_assert(ret == FI_SUCCESS);
ret = fi_av_insert(av, ep_name[0], 1, &gni_addr[0], 0,
NULL);
cr_assert(ret == 1);
ret = fi_av_insert(av, ep_name[1], 1, &gni_addr[1], 0,
NULL);
cr_assert(ret == 1);
ret = fi_ep_bind(ep[0], &av->fid, 0);
cr_assert(!ret, "fi_ep_bind");
ret = fi_ep_bind(ep[1], &av->fid, 0);
cr_assert(!ret, "fi_ep_bind");
ret = fi_enable(ep[0]);
cr_assert(!ret, "fi_ep_enable");
ret = fi_enable(ep[1]);
cr_assert(!ret, "fi_ep_enable");
target = malloc(BUF_SZ);
assert(target);
source = malloc(BUF_SZ);
assert(source);
ret = fi_mr_reg(dom, target, BUF_SZ,
FI_REMOTE_WRITE, 0, 0, 0, &rem_mr, &target);
cr_assert_eq(ret, 0);
ret = fi_mr_reg(dom, source, BUF_SZ,
FI_REMOTE_WRITE, 0, 0, 0, &loc_mr, &source);
cr_assert_eq(ret, 0);
uc_source = malloc(BUF_SZ);
assert(uc_source);
mr_key = fi_mr_key(rem_mr);
ret = fi_cntr_open(dom, &cntr_attr, &write_cntr, 0);
cr_assert(!ret, "fi_cntr_open");
ret = fi_ep_bind(ep[0], &write_cntr->fid, FI_WRITE);
cr_assert(!ret, "fi_ep_bind");
ret = fi_cntr_open(dom, &cntr_attr, &read_cntr, 0);
cr_assert(!ret, "fi_cntr_open");
ret = fi_ep_bind(ep[0], &read_cntr->fid, FI_READ);
cr_assert(!ret, "fi_ep_bind");
writes = reads = write_errs = read_errs = 0;
}
static int init_fabric(void)
{
char *node, *service;
uint64_t flags = 0;
int ret;
ret = ft_read_addr_opts(&node, &service, hints, &flags, &opts);
if (ret)
return ret;
/* Get fabric info */
ret = fi_getinfo(FT_FIVERSION, node, service, flags, hints, &fi);
if (ret) {
FT_PRINTERR("fi_getinfo", ret);
return ret;
}
/* Get remote address of the server */
if (opts.dst_addr) {
addrlen = fi->dest_addrlen;
remote_addr = malloc(addrlen);
memcpy(remote_addr, fi->dest_addr, addrlen);
}
/* Open fabric */
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
if (ret) {
FT_PRINTERR("fi_fabric", ret);
goto err1;
}
/* Open domain */
ret = fi_domain(fab, fi, &dom, NULL);
if (ret) {
FT_PRINTERR("fi_domain", ret);
goto err2;
}
ret = alloc_ep_res(fi);
if (ret)
goto err4;
ret = bind_ep_res();
if (ret)
goto err5;
if (opts.dst_addr) {
/* Insert address to the AV and get the fabric address back */
ret = fi_av_insert(av, remote_addr, 1, &remote_fi_addr, 0,
&fi_ctx_av);
if (ret != 1) {
FT_PRINTERR("fi_av_insert", ret);
return ret;
}
}
return 0;
err5:
free_ep_res();
err4:
fi_close(&dom->fid);
err2:
fi_close(&fab->fid);
err1:
return ret;
}
static int init_av(void)
{
int ret;
int i;
/* Get local address blob. Find the addrlen first. We set addrlen
* as 0 and fi_getname will return the actual addrlen. */
addrlen = 0;
ret = fi_getname(&ep_array[0]->fid, local_addr, &addrlen);
if (ret != -FI_ETOOSMALL) {
FT_PRINTERR("fi_getname", ret);
return ret;
}
local_addr = malloc(addrlen * ep_cnt);
/* Get local addresses for all EPs */
for (i = 0; i < ep_cnt; i++) {
ret = fi_getname(&ep_array[i]->fid, local_addr + addrlen * i, &addrlen);
if (ret) {
FT_PRINTERR("fi_getname", ret);
return ret;
}
}
if (opts.dst_addr) {
ret = fi_av_insert(av, remote_addr, 1, &remote_fi_addr[0], 0, &fi_ctx_av);
if (ret != 1) {
FT_PRINTERR("fi_av_insert", ret);
return ret;
}
/* Send local EP addresses to one of the remote endpoints */
memcpy(buf, &addrlen, sizeof(size_t));
memcpy(buf + sizeof(size_t), local_addr, addrlen * ep_cnt);
ret = send_msg(sizeof(size_t) + addrlen * ep_cnt);
if (ret)
return ret;
/* Get remote EP addresses */
ret = recv_msg();
if (ret)
return ret;
memcpy(&addrlen, buf, sizeof(size_t));
memcpy(remote_addr, buf + sizeof(size_t), addrlen * ep_cnt);
/* Insert remote addresses into AV
* Skip the first address since we already have it in AV */
ret = fi_av_insert(av, remote_addr + addrlen, ep_cnt - 1,
remote_fi_addr + 1, 0, &fi_ctx_av);
if (ret != ep_cnt - 1) {
FT_PRINTERR("fi_av_insert", ret);
return ret;
}
/* Send ACK */
ret = send_msg(16);
if (ret)
return ret;
} else {
/* Get remote EP addresses */
ret = recv_msg();
if (ret)
return ret;
memcpy(&addrlen, buf, sizeof(size_t));
remote_addr = malloc(addrlen * ep_cnt);
memcpy(remote_addr, buf + sizeof(size_t), addrlen * ep_cnt);
/* Insert remote addresses into AV */
ret = fi_av_insert(av, remote_addr, ep_cnt, remote_fi_addr, 0, &fi_ctx_av);
if (ret != ep_cnt) {
FT_PRINTERR("fi_av_insert", ret);
return ret;
}
/* Send local EP addresses to one of the remote endpoints */
memcpy(buf, &addrlen, sizeof(size_t));
memcpy(buf + sizeof(size_t), local_addr, addrlen * ep_cnt);
ret = send_msg(sizeof(size_t) + addrlen * ep_cnt);
if (ret)
return ret;
/* Receive ACK from client */
ret = recv_msg();
if (ret)
return ret;
}
free(local_addr);
free(remote_addr);
return 0;
}
void api_cntr_setup(void)
{
int ret, i, j;
struct fi_av_attr attr = {0};
size_t addrlen = 0;
for (i = 0; i < NUMEPS; i++) {
hints[i] = fi_allocinfo();
cr_assert(hints[i], "fi_allocinfo");
hints[i]->domain_attr->data_progress = FI_PROGRESS_AUTO;
hints[i]->mode = ~0;
hints[i]->fabric_attr->name = strdup("gni");
}
/* Get info about fabric services with the provided hints */
for (i = 0; i < NUMEPS; i++) {
ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints[i],
&fi[i]);
cr_assert(!ret, "fi_getinfo");
}
attr.type = FI_AV_MAP;
attr.count = NUMEPS;
target = malloc(BUF_SZ * 3); /* 3x BUF_SZ for multi recv testing */
assert(target);
source = malloc(BUF_SZ);
assert(source);
uc_target = malloc(BUF_SZ);
assert(uc_target);
uc_source = malloc(BUF_SZ);
assert(uc_source);
ret = fi_fabric(fi[0]->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
for (i = 0; i < NUMEPS; i++) {
ret = fi_domain(fab, fi[i], dom + i, NULL);
cr_assert(!ret, "fi_domain");
ret = fi_open_ops(&dom[i]->fid, FI_GNI_DOMAIN_OPS_1,
0, (void **) (gni_domain_ops + i), NULL);
ret = fi_av_open(dom[i], &attr, av + i, NULL);
cr_assert(!ret, "fi_av_open");
ret = fi_endpoint(dom[i], fi[i], ep + i, NULL);
cr_assert(!ret, "fi_endpoint");
ret = fi_cntr_open(dom[i], &cntr_attr, write_cntr + i, 0);
cr_assert(!ret, "fi_cntr_open");
ret = fi_cntr_open(dom[i], &cntr_attr, read_cntr + i, 0);
cr_assert(!ret, "fi_cntr_open");
ret = fi_cntr_open(dom[i], &cntr_attr, send_cntr + i, 0);
cr_assert(!ret, "fi_cntr_open");
ret = fi_cntr_open(dom[i], &cntr_attr, recv_cntr + i, 0);
cr_assert(!ret, "fi_cntr_open");
ret = fi_getname(&ep[i]->fid, NULL, &addrlen);
cr_assert(addrlen > 0);
ep_name[i] = malloc(addrlen);
cr_assert(ep_name[i] != NULL);
ret = fi_getname(&ep[i]->fid, ep_name[i], &addrlen);
cr_assert(ret == FI_SUCCESS);
}
for (i = 0; i < NUMEPS; i++) {
/* Insert all gni addresses into each av */
for (j = 0; j < NUMEPS; j++) {
ret = fi_av_insert(av[i], ep_name[j], 1, &gni_addr[j],
0, NULL);
cr_assert(ret == 1);
}
ret = fi_ep_bind(ep[i], &av[i]->fid, 0);
cr_assert(!ret, "fi_ep_bind");
}
for (i = 0; i < NUMEPS; i++) {
ret = fi_mr_reg(dom[i], target, 3 * BUF_SZ,
FI_REMOTE_WRITE, 0, 0, 0, rem_mr + i, &target);
cr_assert_eq(ret, 0);
ret = fi_mr_reg(dom[i], source, BUF_SZ,
FI_REMOTE_WRITE, 0, 0, 0, loc_mr + i, &source);
cr_assert_eq(ret, 0);
mr_key[i] = fi_mr_key(rem_mr[i]);
}
}
static int rxd_av_insert(struct fid_av *av_fid, const void *addr, size_t count,
fi_addr_t *fi_addr, uint64_t flags, void *context)
{
struct rxd_av *av;
int i = 0, index, ret = 0, success_cnt = 0, lookup = 1;
uint64_t dg_fiaddr;
av = container_of(av_fid, struct rxd_av, util_av.av_fid);
fastlock_acquire(&av->util_av.lock);
if (!av->dg_addrlen) {
ret = rxd_av_set_addrlen(av, addr);
if (ret)
goto out;
/* Skip lookups if this is the first insertion call. */
lookup = 0;
}
for (; i < count; i++, addr = (uint8_t *) addr + av->dg_addrlen) {
ret = lookup ? rxd_av_dg_reverse_lookup(av, i, addr, &dg_fiaddr) :
-FI_ENODATA;
if (ret) {
ret = fi_av_insert(av->dg_av, addr, 1, &dg_fiaddr,
flags, context);
if (ret != 1)
break;
}
ret = ofi_av_insert_addr(&av->util_av, &dg_fiaddr, dg_fiaddr, &index);
if (ret)
break;
success_cnt++;
if (fi_addr)
fi_addr[i] = index;
}
if (ret) {
FI_WARN(&rxd_prov, FI_LOG_AV,
"failed to insert address %d: %d (%s)\n",
i, -ret, fi_strerror(-ret));
if (av->util_av.eq)
ofi_av_write_event(&av->util_av, i, -ret, context);
if (fi_addr)
fi_addr[i] = FI_ADDR_NOTAVAIL;
i++;
}
out:
av->dg_av_used += success_cnt;
fastlock_release(&av->util_av.lock);
for (; i < count; i++) {
if (av->util_av.eq)
ofi_av_write_event(&av->util_av, i, FI_ECANCELED, context);
if (fi_addr)
fi_addr[i] = FI_ADDR_NOTAVAIL;
}
if (av->util_av.eq) {
ofi_av_write_event(&av->util_av, success_cnt, 0, context);
return 0;
}
return success_cnt;
}
void sep_setup_common(int av_type)
{
int ret, i, j;
struct fi_av_attr av_attr = {0};
size_t addrlen = 0;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
hints->ep_attr->type = FI_EP_RDM;
hints->caps = FI_ATOMIC | FI_RMA | FI_MSG | FI_NAMED_RX_CTX;
hints->mode = FI_LOCAL_MR;
hints->domain_attr->cq_data_size = NUMEPS * 2;
hints->domain_attr->data_progress = FI_PROGRESS_AUTO;
hints->domain_attr->mr_mode = FI_MR_BASIC;
hints->fabric_attr->prov_name = strdup("gni");
hints->ep_attr->tx_ctx_cnt = ctx_cnt;
hints->ep_attr->rx_ctx_cnt = ctx_cnt;
for (i = 0; i < NUMEPS; i++) {
ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints, &fi[i]);
cr_assert(!ret, "fi_getinfo");
tx_cq[i] = calloc(ctx_cnt, sizeof(*tx_cq));
rx_cq[i] = calloc(ctx_cnt, sizeof(*rx_cq));
tx_ep[i] = calloc(ctx_cnt, sizeof(*tx_ep));
rx_ep[i] = calloc(ctx_cnt, sizeof(*rx_ep));
if (!tx_cq[i] || !tx_cq[i] ||
!tx_ep[i] || !rx_ep[i]) {
cr_assert(0, "calloc");
}
}
ctx_cnt = MIN(ctx_cnt, fi[0]->domain_attr->rx_ctx_cnt);
ctx_cnt = MIN(ctx_cnt, fi[0]->domain_attr->tx_ctx_cnt);
cr_assert(ctx_cnt, "ctx_cnt is 0");
ret = fi_fabric(fi[0]->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
rx_ctx_bits = 0;
while (ctx_cnt >> ++rx_ctx_bits);
av_attr.rx_ctx_bits = rx_ctx_bits;
av_attr.type = av_type;
av_attr.count = NUMEPS;
cq_attr.format = FI_CQ_FORMAT_TAGGED;
cq_attr.size = 1024;
cq_attr.wait_obj = FI_WAIT_NONE;
rx_addr = calloc(ctx_cnt, sizeof(*rx_addr));
target = calloc(BUF_SZ, 1);
source = calloc(BUF_SZ, 1);
iov_src_buf = malloc(BUF_SZ * IOV_CNT);
iov_dest_buf = malloc(BUF_SZ * IOV_CNT);
src_iov = malloc(sizeof(struct iovec) * IOV_CNT);
dest_iov = malloc(sizeof(struct iovec) * IOV_CNT);
if (!rx_addr || !target || !source || !iov_src_buf || !iov_dest_buf ||
!src_iov || !dest_iov) {
cr_assert(0, "allocation");
}
for (i = 0; i < IOV_CNT; i++) {
src_iov[i].iov_base = malloc(BUF_SZ);
assert(src_iov[i].iov_base != NULL);
dest_iov[i].iov_base = malloc(BUF_SZ * 3);
assert(dest_iov[i].iov_base != NULL);
}
for (i = 0; i < NUMEPS; i++) {
fi[i]->ep_attr->tx_ctx_cnt = ctx_cnt;
fi[i]->ep_attr->rx_ctx_cnt = ctx_cnt;
ret = fi_domain(fab, fi[i], &dom[i], NULL);
cr_assert(!ret, "fi_domain");
ret = fi_scalable_ep(dom[i], fi[i], &sep[i], NULL);
cr_assert(!ret, "fi_scalable_ep");
ret = fi_av_open(dom[i], &av_attr, &av[i], NULL);
cr_assert(!ret, "fi_av_open");
ret = fi_cntr_open(dom[i], &cntr_attr, &send_cntr[i], 0);
cr_assert(!ret, "fi_cntr_open");
ret = fi_cntr_open(dom[i], &cntr_attr, &recv_cntr[i], 0);
cr_assert(!ret, "fi_cntr_open");
for (j = 0; j < ctx_cnt; j++) {
ret = fi_tx_context(sep[i], j, NULL, &tx_ep[i][j],
NULL);
cr_assert(!ret, "fi_tx_context");
ret = fi_cq_open(dom[i], &cq_attr, &tx_cq[i][j],
NULL);
cr_assert(!ret, "fi_cq_open");
ret = fi_rx_context(sep[i], j, NULL, &rx_ep[i][j],
NULL);
cr_assert(!ret, "fi_rx_context");
ret = fi_cq_open(dom[i], &cq_attr, &rx_cq[i][j],
NULL);
cr_assert(!ret, "fi_cq_open");
}
ret = fi_scalable_ep_bind(sep[i], &av[i]->fid, 0);
cr_assert(!ret, "fi_scalable_ep_bind");
for (j = 0; j < ctx_cnt; j++) {
ret = fi_ep_bind(tx_ep[i][j], &tx_cq[i][j]->fid,
FI_TRANSMIT);
cr_assert(!ret, "fi_ep_bind");
ret = fi_ep_bind(tx_ep[i][j], &send_cntr[i]->fid,
FI_SEND | FI_WRITE);
cr_assert(!ret, "fi_ep_bind");
ret = fi_enable(tx_ep[i][j]);
cr_assert(!ret, "fi_enable");
ret = fi_ep_bind(rx_ep[i][j], &rx_cq[i][j]->fid,
FI_RECV);
cr_assert(!ret, "fi_ep_bind");
ret = fi_ep_bind(rx_ep[i][j], &recv_cntr[i]->fid,
FI_RECV | FI_READ);
cr_assert(!ret, "fi_ep_bind");
ret = fi_enable(rx_ep[i][j]);
cr_assert(!ret, "fi_enable");
}
}
for (i = 0; i < NUMEPS; i++) {
ret = fi_enable(sep[i]);
cr_assert(!ret, "fi_enable");
ret = fi_getname(&sep[i]->fid, NULL, &addrlen);
cr_assert(addrlen > 0);
ep_name[i] = malloc(addrlen);
cr_assert(ep_name[i] != NULL);
ret = fi_getname(&sep[i]->fid, ep_name[i], &addrlen);
cr_assert(ret == FI_SUCCESS);
ret = fi_mr_reg(dom[i], target, BUF_SZ, FI_REMOTE_WRITE,
0, 0, 0, &rem_mr[i], &target);
cr_assert_eq(ret, 0);
ret = fi_mr_reg(dom[i], source, BUF_SZ, FI_REMOTE_WRITE,
0, 0, 0, &loc_mr[i], &source);
cr_assert_eq(ret, 0);
mr_key[i] = fi_mr_key(rem_mr[i]);
ret = fi_mr_reg(dom[i], iov_dest_buf, IOV_CNT * BUF_SZ,
FI_REMOTE_WRITE, 0, 0, 0, iov_dest_buf_mr + i,
&iov_dest_buf);
cr_assert_eq(ret, 0);
ret = fi_mr_reg(dom[i], iov_src_buf, IOV_CNT * BUF_SZ,
FI_REMOTE_WRITE, 0, 0, 0, iov_src_buf_mr + i,
&iov_src_buf);
cr_assert_eq(ret, 0);
}
for (i = 0; i < NUMEPS; i++) {
for (j = 0; j < NUMEPS; j++) {
ret = fi_av_insert(av[i], ep_name[j], 1, &gni_addr[j],
0, NULL);
cr_assert(ret == 1);
}
}
for (i = 0; i < ctx_cnt; i++) {
rx_addr[i] = fi_rx_addr(gni_addr[1], i, rx_ctx_bits);
}
}
void rdm_str_addr_sr_setup_common(void)
{
int ret = 0, i = 0, j = 0;
struct fi_av_attr attr;
memset(&attr, 0, sizeof(attr));
attr.type = FI_AV_MAP;
attr.count = NUMEPS;
cq_attr.format = FI_CQ_FORMAT_TAGGED;
cq_attr.size = 1024;
cq_attr.wait_obj = 0;
target_base = malloc(GNIT_ALIGN_LEN(BUF_SZ));
assert(target_base);
target = GNIT_ALIGN_BUFFER(char *, target_base);
source_base = malloc(GNIT_ALIGN_LEN(BUF_SZ));
assert(source_base);
source = GNIT_ALIGN_BUFFER(char *, source_base);
ret = fi_fabric(fi[0]->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
for (i = 0; i < NUMEPS; i++) {
ret = fi_domain(fab, fi[i], dom + i, NULL);
cr_assert(!ret, "fi_domain");
ret = fi_av_open(dom[i], &attr, av + i, NULL);
cr_assert(!ret, "fi_av_open");
ret = fi_endpoint(dom[i], fi[i], ep + i, NULL);
cr_assert(!ret, "fi_endpoint");
ret = fi_cq_open(dom[i], &cq_attr, msg_cq + i, 0);
cr_assert(!ret, "fi_cq_open");
ret = fi_ep_bind(ep[i], &msg_cq[i]->fid, FI_SEND | FI_RECV);
cr_assert(!ret, "fi_ep_bind");
ret = fi_getname(&ep[i]->fid, NULL, &addrlen);
cr_assert(addrlen > 0);
ep_name[i] = malloc(addrlen);
cr_assert(ep_name[i] != NULL);
ret = fi_getname(&ep[i]->fid, ep_name[i], &addrlen);
cr_assert(ret == FI_SUCCESS);
}
for (i = 0; i < NUMEPS; i++) {
/*
* To test API-1.1: Reporting of unknown source addresses --
* only insert addresses into the sender's av
*/
if (i < (NUMEPS / 2)) {
for (j = 0; j < NUMEPS; j++) {
dbg_printf("Only does src EP insertions\n");
ret = fi_av_insert(av[i], ep_name[j], 1,
&gni_addr[j],
0, NULL);
cr_assert(ret == 1);
}
}
ret = fi_ep_bind(ep[i], &av[i]->fid, 0);
cr_assert(!ret, "fi_ep_bind");
ret = fi_enable(ep[i]);
cr_assert(!ret, "fi_ep_enable");
}
}
static void setup(void)
{
int i, j;
int ret = 0;
struct fi_av_attr attr;
size_t addrlen = 0;
struct fi_gni_ops_domain *gni_domain_ops;
uint32_t rx_cq_size;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
hints->domain_attr->cq_data_size = 4;
hints->domain_attr->data_progress = FI_PROGRESS_MANUAL;
hints->mode = ~0;
hints->fabric_attr->name = strdup("gni");
ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
attr.type = FI_AV_TABLE;
attr.count = NUM_EPS;
cq_attr.format = FI_CQ_FORMAT_CONTEXT;
cq_attr.size = 1024;
cq_attr.wait_obj = 0;
for (i = 0; i < NUM_EPS; i++) {
ret = fi_domain(fab, fi, &dom[i], NULL);
cr_assert(!ret, "fi_domain");
ret = fi_open_ops(&dom[i]->fid, FI_GNI_DOMAIN_OPS_1, 0,
(void **) &gni_domain_ops, NULL);
cr_assert(ret == FI_SUCCESS, "fi_open_ops");
rx_cq_size = min_rx_cq_size;
ret = gni_domain_ops->set_val(&dom[i]->fid, GNI_RX_CQ_SIZE,
&rx_cq_size);
cr_assert(ret == FI_SUCCESS, "set_val");
ret = fi_av_open(dom[i], &attr, &av[i], NULL);
cr_assert(!ret, "fi_av_open");
ret = fi_endpoint(dom[i], fi, &ep[i], NULL);
cr_assert(!ret, "fi_endpoint");
cr_assert(ep[i]);
ret = fi_cq_open(dom[i], &cq_attr, &msg_cq[i], 0);
cr_assert(!ret, "fi_cq_open");
ret = fi_ep_bind(ep[i], &msg_cq[i]->fid, FI_SEND | FI_RECV);
cr_assert(!ret, "fi_ep_bind");
}
ret = fi_getname(&ep[0]->fid, NULL, &addrlen);
cr_assert_eq(ret, -FI_ETOOSMALL);
cr_assert(addrlen > 0);
for (i = 0; i < NUM_EPS; i++) {
ep_name[i] = malloc(addrlen);
cr_assert(ep_name[i] != NULL);
ret = fi_getname(&ep[i]->fid, ep_name[i], &addrlen);
cr_assert(ret == FI_SUCCESS);
for (j = 0; j < NUM_EPS; j++) {
ret = fi_av_insert(av[j], ep_name[i],
1, &gni_addr[i], 0, NULL);
cr_assert(ret == 1);
}
}
for (i = 0; i < NUM_EPS; i++) {
ret = fi_ep_bind(ep[i], &av[i]->fid, 0);
cr_assert(!ret, "fi_ep_bind");
ret = fi_enable(ep[i]);
cr_assert(!ret, "fi_ep_enable");
ret = fi_mr_reg(dom[i], target, NUM_EPS*sizeof(int),
FI_RECV, 0, 0, 0, &rem_mr[i], &target);
cr_assert_eq(ret, 0);
ret = fi_mr_reg(dom[i], source, NUM_EPS*sizeof(int),
FI_SEND, 0, 0, 0, &loc_mr[i], &source);
cr_assert_eq(ret, 0);
mr_key[i] = fi_mr_key(rem_mr[i]);
}
}
static ssize_t
usdf_cq_readfrom_context(struct fid_cq *fcq, void *buf, size_t count,
fi_addr_t *src_addr)
{
struct usdf_cq *cq;
struct usd_cq_impl *ucq;
struct fi_cq_entry *entry;
struct fi_cq_entry *last;
ssize_t ret;
struct cq_desc *cq_desc;
struct usdf_ep *ep;
struct sockaddr_in sin;
struct usd_udp_hdr *hdr;
uint16_t index;
cq = cq_ftou(fcq);
if (cq->cq_comp.uc_status != 0) {
return -FI_EAVAIL;
}
ucq = to_cqi(cq->cq_cq);
ret = 0;
entry = buf;
last = entry + count;
while (entry < last) {
cq_desc = (struct cq_desc *)((uint8_t *)ucq->ucq_desc_ring +
(ucq->ucq_next_desc << 4));
ret = usd_poll_cq(cq->cq_cq, &cq->cq_comp);
if (ret == -EAGAIN) {
ret = 0;
break;
}
if (cq->cq_comp.uc_status != 0) {
ret = -FI_EAVAIL;
break;
}
if (cq->cq_comp.uc_type == USD_COMPTYPE_RECV) {
index = le16_to_cpu(cq_desc->completed_index) &
CQ_DESC_COMP_NDX_MASK;
ep = cq->cq_comp.uc_qp->uq_context;
hdr = ep->ep_hdr_ptr[index];
memset(&sin, 0, sizeof(sin));
sin.sin_addr.s_addr = hdr->uh_ip.saddr;
sin.sin_port = hdr->uh_udp.source;
ret = fi_av_insert(av_utof(ep->ep_av), &sin, 1,
src_addr, 0, NULL);
if (ret != 1) {
*src_addr = FI_ADDR_NOTAVAIL;
}
++src_addr;
}
entry->op_context = cq->cq_comp.uc_context;
entry++;
}
if (entry > (struct fi_cq_entry *)buf) {
return entry - (struct fi_cq_entry *)buf;
} else {
return ret;
}
}
static int init_av(void)
{
int ret;
if (opts.dst_addr) {
/* Get local address blob. Find the addrlen first. We set
* addrlen as 0 and fi_getname will return the actual addrlen. */
addrlen = 0;
ret = fi_getname(&ep->fid, local_addr, &addrlen);
if (ret != -FI_ETOOSMALL) {
FT_PRINTERR("fi_getname", ret);
return ret;
}
local_addr = malloc(addrlen);
ret = fi_getname(&ep->fid, local_addr, &addrlen);
if (ret) {
FT_PRINTERR("fi_getname", ret);
return ret;
}
ret = fi_av_insert(av, remote_addr, 1, &remote_fi_addr, 0,
&fi_ctx_av);
if (ret != 1) {
FT_PRINTERR("fi_av_insert", ret);
return ret;
}
/* Send local addr size and local addr */
memcpy(buf, &addrlen, sizeof(size_t));
memcpy(buf + sizeof(size_t), local_addr, addrlen);
ret = send_msg(sizeof(size_t) + addrlen);
if (ret)
return ret;
/* Receive ACK from server */
ret = recv_msg();
if (ret)
return ret;
} else {
/* Post a recv to get the remote address */
ret = recv_msg();
if (ret)
return ret;
memcpy(&addrlen, buf, sizeof(size_t));
remote_addr = malloc(addrlen);
memcpy(remote_addr, buf + sizeof(size_t), addrlen);
ret = fi_av_insert(av, remote_addr, 1, &remote_fi_addr, 0,
&fi_ctx_av);
if (ret != 1) {
FT_PRINTERR("fi_av_insert", ret);
return ret;
}
/* Send ACK */
ret = send_msg(16);
if (ret)
return ret;
}
/* Post first recv */
ret = fi_recv(ep, buf, buffer_size, fi_mr_desc(mr), remote_fi_addr,
&fi_ctx_recv);
if (ret)
FT_PRINTERR("fi_recv", ret);
return ret;
}
/*
* Tests:
* - sync vector with 1 good and 1 bad
*/
static int
av_goodbad_vector_sync()
{
int testret;
int ret;
int i;
struct fid_av *av;
struct fi_av_attr attr;
uint8_t addrbuf[4096];
int buflen;
fi_addr_t fi_addr[MAX_ADDR];
testret = FAIL;
memset(&attr, 0, sizeof(attr));
attr.type = av_type;
attr.count = 32;
av = NULL;
ret = fi_av_open(domain, &attr, &av, NULL);
if (ret != 0) {
sprintf(err_buf, "fi_av_open(%s) = %d, %s",
fi_tostr(&av_type, FI_TYPE_AV_TYPE),
ret, fi_strerror(-ret));
goto fail;
}
for (i = 0; i < MAX_ADDR; ++i) {
fi_addr[i] = FI_ADDR_NOTAVAIL;
}
fi_addr[1] = ~FI_ADDR_NOTAVAIL;
buflen = sizeof(addrbuf);
/* vector is good address + bad address */
ret = av_create_address_list(good_address, 0, 1, addrbuf, 0, buflen);
if (ret < 0) {
goto fail; // av_create_address_list filled err_buf
}
ret = av_create_address_list(bad_address, 0, 1, addrbuf, 1, buflen);
if (ret < 0) {
goto fail; // av_create_address_list filled err_buf
}
ret = fi_av_insert(av, addrbuf, 2, fi_addr, 0, NULL);
if (ret != 1) {
sprintf(err_buf, "fi_av_insert ret=%d, should be 1", ret);
goto fail;
}
/*
* Check returned fi_addrs
*/
if (fi_addr[0] == FI_ADDR_NOTAVAIL) {
sprintf(err_buf, "fi_addr[0] = FI_ADDR_NOTAVAIL");
goto fail;
}
if (fi_addr[1] != FI_ADDR_NOTAVAIL) {
sprintf(err_buf, "fi_addr[1] != FI_ADDR_NOTAVAIL");
goto fail;
}
testret = PASS;
fail:
FT_CLOSE_FID(av);
return testret;
}
static int init_av(void)
{
int ret;
int i;
if (opts.dst_addr) {
/* Get local address blob. Find the addrlen first. We set addrlen
* as 0 and fi_getname will return the actual addrlen. */
addrlen = 0;
ret = fi_getname(&sep->fid, local_addr, &addrlen);
if (ret != -FI_ETOOSMALL) {
FT_PRINTERR("fi_getname", ret);
return ret;
}
local_addr = malloc(addrlen);
ret = fi_getname(&sep->fid, local_addr, &addrlen);
if (ret) {
FT_PRINTERR("fi_getname", ret);
return ret;
}
ret = fi_av_insert(av, remote_addr, 1, &remote_fi_addr, 0, &fi_ctx_av);
if (ret != 1) {
FT_PRINTERR("fi_av_insert", ret);
return ret;
}
for (i = 0; i < ctx_cnt; i++)
remote_rx_addr[i] = fi_rx_addr(remote_fi_addr, i, rx_ctx_bits);
/* Send local addr size and local addr */
memcpy(buf, &addrlen, sizeof(size_t));
memcpy(buf + sizeof(size_t), local_addr, addrlen);
ret = send_msg(sizeof(size_t) + addrlen);
if (ret)
return ret;
/* Receive ACK from server */
ret = recv_msg();
if (ret)
return ret;
} else {
/* Post a recv to get the remote address */
ret = recv_msg();
if (ret)
return ret;
memcpy(&addrlen, buf, sizeof(size_t));
remote_addr = malloc(addrlen);
memcpy(remote_addr, buf + sizeof(size_t), addrlen);
ret = fi_av_insert(av, remote_addr, 1, &remote_fi_addr, 0, &fi_ctx_av);
if (ret != 1) {
FT_PRINTERR("fi_av_insert", ret);
return ret;
}
/* Send ACK */
ret = send_msg(16);
if (ret)
return ret;
}
return 0;
}
