static int bind_ep_res(void)
{
int ret;
ret = fi_bind(&ep->fid, &scq->fid, FI_SEND);
if (ret) {
printf("fi_bind scq %d (%s)\n", ret, fi_strerror(-ret));
return ret;
}
ret = fi_bind(&ep->fid, &rcq->fid, FI_RECV);
if (ret) {
printf("fi_bind rcq %d (%s)\n", ret, fi_strerror(-ret));
return ret;
}
ret = fi_bind(&ep->fid, &av->fid, 0);
if (ret) {
printf("fi_bind av %d (%s)\n", ret, fi_strerror(-ret));
return ret;
}
ret = fi_enable(ep);
if (ret) {
printf("fi_enable %d (%s)\n", ret, fi_strerror(-ret));
return ret;
}
ret = fi_recv(ep, buf, buffer_size, fi_mr_desc(mr), buf);
if (ret) {
printf("fi_recv %d (%s)\n", ret, fi_strerror(-ret));
}
return ret;
}
int bind_fid( fid_t ep, fid_t res, uint64_t flags)
{
int ret;
ret = fi_bind(ep, res, flags);
if (ret)
FI_PRINTERR("fi_bind", ret);
return ret;
}
static int bind_fid( fid_t ep, fid_t res, uint64_t flags)
{
int ret;
ret = fi_bind(ep, res, flags);
if (ret)
fprintf(stderr, "fi_bind %s\n", fi_strerror(-ret));
return ret;
}
static int server_listen(void)
{
struct fi_info *fi;
int ret;
ret = fi_getinfo(FI_VERSION(1, 0), src_addr, port, FI_SOURCE, &hints, &fi);
if (ret) {
printf("fi_getinfo %s\n", strerror(-ret));
return ret;
}
cq_data_size = fi->domain_attr->cq_data_size;
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
if (ret) {
printf("fi_fabric %s\n", fi_strerror(-ret));
goto err0;
}
ret = fi_passive_ep(fab, fi, &pep, NULL);
if (ret) {
printf("fi_passive_ep %s\n", fi_strerror(-ret));
goto err1;
}
ret = alloc_cm_res();
if (ret)
goto err2;
ret = fi_bind(&pep->fid, &cmeq->fid, 0);
if (ret) {
printf("fi_bind %s\n", fi_strerror(-ret));
goto err3;
}
ret = fi_listen(pep);
if (ret) {
printf("fi_listen %s\n", fi_strerror(-ret));
goto err3;
}
fi_freeinfo(fi);
return 0;
err3:
free_lres();
err2:
fi_close(&pep->fid);
err1:
fi_close(&fab->fid);
err0:
fi_freeinfo(fi);
return ret;
}
/*
* Tests:
* - async good vector
*/
static int
av_zero_async()
{
int testret;
int ret;
struct fid_av *av;
struct fi_av_attr attr;
uint8_t addrbuf[4096];
uint32_t ctx;
fi_addr_t fi_addr[MAX_ADDR];
testret = FAIL;
memset(&attr, 0, sizeof(attr));
attr.type = av_type;
attr.count = 32;
attr.flags = FI_EVENT;
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;
}
ret = fi_bind(&av->fid, &eq->fid, 0);
if (ret != 0) {
sprintf(err_buf, "fi_bind() = %d, %s", ret, fi_strerror(-ret));
goto fail;
}
ret = fi_av_insert(av, addrbuf, 0, fi_addr, 0, &ctx);
if (ret != 0) {
sprintf(err_buf, "fi_av_insert ret=%d, should be 0", ret);
goto fail;
}
if (check_eq_sread(eq, &av->fid, &ctx, 0, 20000, 0) != 0) {
goto fail;
}
testret = PASS;
fail:
if (av != NULL) {
fi_close(&av->fid);
}
return testret;
}
/*
* Tests:
* - async 2 vector, 1 good, 1 mix bad+good
*/
static int
av_goodbad_2vector_async()
{
int testret;
int ret;
int i;
struct fid_av *av;
struct fi_av_attr attr;
uint8_t addrbuf[4096];
uint32_t event;
uint32_t ctx[2];
uint8_t good[2];
uint8_t err;
struct fi_eq_entry entry;
int buflen;
fi_addr_t fi_addr[MAX_ADDR];
testret = FAIL;
memset(&attr, 0, sizeof(attr));
attr.type = av_type;
attr.count = 32;
attr.flags = FI_EVENT;
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;
}
ret = fi_bind(&av->fid, &eq->fid, 0);
if (ret != 0) {
sprintf(err_buf, "fi_bind() = %d, %s", 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);
/* 1st vector is one good 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 = fi_av_insert(av, addrbuf, 1, fi_addr, FI_MORE, &ctx[0]);
if (ret != 1) {
sprintf(err_buf, "fi_av_insert ret=%d, %s", ret, fi_strerror(-ret));
goto fail;
}
ctx[0] = 1;
/* second vector is one bad address followed by N-1 good ones */
ret = av_create_address_list(bad_address, 0, 1, addrbuf, 0, buflen);
if (ret < 0) {
goto fail; // av_create_address_list filled err_buf
}
if (num_good_addr > 1) {
ret = av_create_address_list(good_address, 1, num_good_addr - 1,
addrbuf, 1, buflen);
if (ret < 0) {
goto fail; // av_create_address_list filled err_buf
}
}
ret = fi_av_insert(av, addrbuf, num_good_addr, &fi_addr[1], 0, &ctx[1]);
if (ret != num_good_addr) {
sprintf(err_buf, "fi_av_insert ret=%d, %s", ret, fi_strerror(-ret));
goto fail;
}
ctx[1] = num_good_addr - 1;
/*
* A little tricky here because the good completions may come in any order,
* all we can far for sure is that error must come before good completion 2.
*/
memset(good, 0, sizeof(good));
err = 0;
for (i = 0; i < 3; ++i) {
ret = fi_eq_sread(eq, &event, &entry, sizeof(entry), 20000, 0);
if (ret == -FI_EAVAIL) {
if (good[1] > 0 || err > 0) {
sprintf(err_buf, "Unexpected error completion");
goto fail;
}
ret = check_eq_readerr(eq, &av->fid, &ctx[1], 0);
if (ret != 0) {
goto fail;
}
err = 1;
} else {
ret = check_eq_result(ret, event, &entry, &av->fid, NULL, ~0);
if (ret != 0) {
goto fail;
}
if (entry.context != &ctx[0] &&
entry.context != &ctx[1]) {
sprintf(err_buf, "bad context: %p", entry.context);
goto fail;
}
if (*(uint32_t *)(entry.context) == ~0) {
sprintf(err_buf, "duplicate context: %p", entry.context);
goto fail;
}
if (entry.context == &ctx[1] && err == 0) {
sprintf(err_buf, "2nd good comp before error");
goto fail;
}
if (*(uint32_t *)(entry.context) != entry.data) {
sprintf(err_buf, "count = %lu, should be %d", entry.data,
*(uint32_t *)(entry.context));
goto fail;
}
*(uint32_t *)(entry.context) = ~0;
}
}
ret = fi_eq_sread(eq, &event, &entry, sizeof(entry), 1000, 0);
if (ret != -FI_ETIMEDOUT) {
sprintf(err_buf, "too many events");
goto fail;
}
for (i = 0; i < num_good_addr + 1; ++i) {
if (i == 1) {
if (fi_addr[1] != FI_ADDR_NOTAVAIL) {
sprintf(err_buf, "fi_addr[1] != FI_ADDR_NOTAVAIL");
goto fail;
}
} else {
if (fi_addr[i] == FI_ADDR_NOTAVAIL) {
sprintf(err_buf, "fi_addr[%d] = FI_ADDR_NOTAVAIL", i);
goto fail;
}
}
}
testret = PASS;
fail:
if (av != NULL) {
fi_close(&av->fid);
}
return testret;
}
/*
* Tests:
* - async vector with 1 good and 1 bad
*/
static int
av_goodbad_vector_async()
{
int testret;
int ret;
int i;
struct fid_av *av;
struct fi_av_attr attr;
uint8_t addrbuf[4096];
uint32_t event;
uint32_t ctx;
struct fi_eq_entry entry;
int buflen;
fi_addr_t fi_addr[MAX_ADDR];
testret = FAIL;
memset(&attr, 0, sizeof(attr));
attr.type = av_type;
attr.count = 32;
attr.flags = FI_EVENT;
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;
}
ret = fi_bind(&av->fid, &eq->fid, 0);
if (ret != 0) {
sprintf(err_buf, "fi_bind() = %d, %s", 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, &ctx);
if (ret != 2) {
sprintf(err_buf, "fi_av_insert ret=%d, %s", ret, fi_strerror(-ret));
goto fail;
}
/*
* Read event after sync, verify we get FI_EAVAIL, then read and
* verify the error completion
*/
ret = fi_eq_sread(eq, &event, &entry, sizeof(entry), 20000, 0);
if (ret != -FI_EAVAIL) {
sprintf(err_buf, "fi_eq_sread ret = %d, should be -FI_EAVAIL", ret);
goto fail;
}
ret = check_eq_readerr(eq, &av->fid, &ctx, 1);
if (ret != 0) {
goto fail;
}
/*
* Now we should get a good completion, and all fi_addr except fd_addr[1]
* should have good values.
*/
if (check_eq_sread(eq, &av->fid, &ctx, 1, 20000, 0) != 0) {
goto fail;
}
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:
if (av != NULL) {
fi_close(&av->fid);
}
return testret;
}
/*
* Tests:
* - async 2 good vectors
*/
static int
av_good_2vector_async()
{
int testret;
int ret;
int i;
struct fid_av *av;
struct fi_av_attr attr;
uint8_t addrbuf[4096];
uint32_t event;
struct fi_eq_entry entry;
uint32_t ctx[2];
int buflen;
fi_addr_t fi_addr[MAX_ADDR];
testret = FAIL;
memset(&attr, 0, sizeof(attr));
attr.type = av_type;
attr.count = 32;
attr.flags = FI_EVENT;
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;
}
ret = fi_bind(&av->fid, &eq->fid, 0);
if (ret != 0) {
sprintf(err_buf, "fi_bind() = %d, %s", ret, fi_strerror(-ret));
goto fail;
}
for (i = 0; i < MAX_ADDR; ++i) {
fi_addr[i] = FI_ADDR_NOTAVAIL;
}
buflen = sizeof(addrbuf);
/* 1st vector is just first 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 = fi_av_insert(av, addrbuf, 1, fi_addr, FI_MORE, &ctx[0]);
if (ret != 1) {
sprintf(err_buf, "fi_av_insert ret=%d, %s", ret, fi_strerror(-ret));
goto fail;
}
ctx[0] = 1;
/* 2nd vector is remaining addresses */
ret = av_create_address_list(good_address, 1, num_good_addr-1,
addrbuf, 0, buflen);
if (ret < 0) {
goto fail; // av_create_address_list filled err_buf
}
ret = fi_av_insert(av, addrbuf, num_good_addr-1, &fi_addr[1], 0, &ctx[1]);
if (ret != num_good_addr-1) {
sprintf(err_buf, "fi_av_insert ret=%d, %s", ret, fi_strerror(-ret));
goto fail;
}
ctx[1] = num_good_addr-1;
/*
* Handle completions in either order
*/
for (i = 0; i < 2; ++i) {
ret = fi_eq_sread(eq, &event, &entry, sizeof(entry), 20000, 0);
ret = check_eq_result(ret, event, &entry, &av->fid, NULL, ~0);
if (ret != 0) {
goto fail;
}
if (entry.context != &ctx[0] && entry.context != &ctx[1]) {
sprintf(err_buf, "bad context: %p", entry.context);
goto fail;
}
if (*(uint32_t *)(entry.context) == ~0) {
sprintf(err_buf, "duplicate context: %p", entry.context);
goto fail;
}
if (*(uint32_t *)(entry.context) != entry.data) {
sprintf(err_buf, "count = %lu, should be %d", entry.data,
*(uint32_t *)(entry.context));
goto fail;
}
*(uint32_t *)(entry.context) = ~0;
}
for (i = 0; i < num_good_addr; ++i) {
if (fi_addr[i] == FI_ADDR_NOTAVAIL) {
sprintf(err_buf, "fi_addr[%d] = FI_ADDR_NOTAVAIL", i);
goto fail;
}
}
testret = PASS;
fail:
if (av != NULL) {
fi_close(&av->fid);
}
return testret;
}
/*
* Tests:
* - async good vector
*/
static int
av_good_vector_async()
{
int testret;
int ret;
int i;
struct fid_av *av;
struct fi_av_attr attr;
uint8_t addrbuf[4096];
uint32_t ctx;
int buflen;
fi_addr_t fi_addr[MAX_ADDR];
testret = FAIL;
memset(&attr, 0, sizeof(attr));
attr.type = av_type;
attr.count = 32;
attr.flags = FI_EVENT;
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;
}
ret = fi_bind(&av->fid, &eq->fid, 0);
if (ret != 0) {
sprintf(err_buf, "fi_bind() = %d, %s", ret, fi_strerror(-ret));
goto fail;
}
for (i = 0; i < MAX_ADDR; ++i) {
fi_addr[i] = FI_ADDR_NOTAVAIL;
}
buflen = sizeof(addrbuf);
ret = av_create_address_list(good_address, 0, num_good_addr,
addrbuf, 0, buflen);
if (ret < 0) {
goto fail; // av_create_address_list filled err_buf
}
for (i = 0; i < num_good_addr; ++i) {
fi_addr[i] = FI_ADDR_NOTAVAIL;
}
ret = fi_av_insert(av, addrbuf, num_good_addr, fi_addr, 0, &ctx);
if (ret != num_good_addr) {
sprintf(err_buf, "fi_av_insert ret=%d, %s", ret, fi_strerror(-ret));
goto fail;
}
if (check_eq_sread(eq, &av->fid, &ctx, num_good_addr, 20000, 0) != 0) {
goto fail;
}
for (i = 0; i < num_good_addr; ++i) {
if (fi_addr[i] == FI_ADDR_NOTAVAIL) {
sprintf(err_buf, "fi_addr[%d] = FI_ADDR_NOTAVAIL", i);
goto fail;
}
}
testret = PASS;
fail:
if (av != NULL) {
fi_close(&av->fid);
}
return testret;
}
