void rdm_sr_setup_common(void)
{
int ret = 0, i = 0;
rdm_sr_setup_common_eps();
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);
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);
mr_key[i] = fi_mr_key(rem_mr[i]);
iov_dest_buf_mr_key[i] = fi_mr_key(iov_dest_buf_mr[i]);
}
}
static int exchange_addr_key(void)
{
struct fi_rma_iov *rma_iov;
int ret;
rma_iov = buf;
if (opts.dst_addr) {
rma_iov->addr = fi->domain_attr->mr_mode == FI_MR_SCALABLE ?
0 : (uintptr_t) buf;
rma_iov->key = fi_mr_key(mr);
ret = send_msg(sizeof *rma_iov);
if (ret)
return ret;
ret = post_recv();
if (ret)
return ret;
remote = *rma_iov;
} else {
ret = post_recv();
if (ret)
return ret;
remote = *rma_iov;
rma_iov->addr = fi->domain_attr->mr_mode == FI_MR_SCALABLE ?
0 : (uintptr_t) buf;
rma_iov->key = fi_mr_key(mr);
ret = send_msg(sizeof *rma_iov);
if (ret)
return ret;
}
return 0;
}
static int exchange_addr_key(void)
{
int ret;
int len = sizeof(local);
local.addr = (uint64_t)buf;
local.key = fi_mr_key(mr);
if (dst_addr) {
*(struct addr_key *)buf = local;
ret = send_msg(len);
if(ret)
return ret;
ret = post_recv(len);
if(ret)
return ret;
remote = *(struct addr_key *)buf;
} else {
ret = post_recv(len);
if(ret)
return ret;
remote = *(struct addr_key *)buf;
*(struct addr_key *)buf = local;
ret = send_msg(len);
if(ret)
return ret;
}
return 0;
}
/*
* rpmemd_fip_set_resp -- fill the response structure
*/
static int
rpmemd_fip_set_resp(struct rpmemd_fip *fip, struct rpmem_resp_attr *resp)
{
int ret;
struct sockaddr_in addr_in;
size_t addrlen = sizeof(addr_in);
ret = fi_getname(&fip->pep->fid, &addr_in, &addrlen);
if (ret) {
RPMEMD_FI_ERR(ret, "getting local endpoint address");
goto err_fi_getname;
}
if (!addr_in.sin_port) {
RPMEMD_LOG(ERR, "dynamic allocation of port failed");
goto err_port;
}
resp->port = htons(addr_in.sin_port);
resp->rkey = fi_mr_key(fip->mr);
resp->persist_method = fip->persist_method;
resp->raddr = (uint64_t)fip->addr;
resp->nlanes = fip->nlanes;
return 0;
err_port:
err_fi_getname:
return -1;
}
static int publish_mr_info(void)
{
#ifndef ENABLE_MR_SCALABLE
{
int err;
uint64_t heap_key, data_key;
heap_key = fi_mr_key(shmem_transport_ofi_target_heap_mrfd);
data_key = fi_mr_key(shmem_transport_ofi_target_data_mrfd);
err = shmem_runtime_put("fi_heap_key", &heap_key, sizeof(uint64_t));
if (err) {
OFI_ERRMSG("Error putting heap key to runtime KVS\n");
return 1;
}
err = shmem_runtime_put("fi_data_key", &data_key, sizeof(uint64_t));
if (err) {
OFI_ERRMSG("Error putting data segment key to runtime KVS\n");
return 1;
}
}
#ifndef ENABLE_REMOTE_VIRTUAL_ADDRESSING
{
int err;
err = shmem_runtime_put("fi_heap_addr", &shmem_internal_heap_base, sizeof(uint8_t*));
if (err) {
OFI_ERRMSG("Error putting heap address to runtime KVS\n");
return 1;
}
err = shmem_runtime_put("fi_data_addr", &shmem_internal_data_base, sizeof(uint8_t*));
if (err) {
OFI_ERRMSG("Error putting data segment address to runtime KVS\n");
return 1;
}
}
#endif /* ENABLE_REMOTE_VIRTUAL_ADDRESSING */
#endif /* ENABLE_MR_SCALABLE */
return 0;
}
static int sync_test(void)
{
int ret = 0;
if (client) {
*((uint64_t *)buf) = (uint64_t)buf;
*((uint64_t *)buf + 1) = fi_mr_key(mr);
if ((ret = send_xfer(sizeof(uint64_t)*2))) {
return ret;
}
if ((ret = poll_all_sends())) {
return ret;
}
if ((ret = recv_xfer(sizeof(uint64_t)*2))) {
return ret;
}
if ((ret = poll_all_recvs())) {
return ret;
}
rembuf = *((uint64_t *)buf);
rkey = *((uint64_t *)buf + 1);
} else {
if ((ret = recv_xfer(sizeof(uint64_t)*2))) {
return ret;
}
if ((ret = poll_all_recvs())) {
return ret;
}
rembuf = *((uint64_t *)buf);
rkey = *((uint64_t *)buf + 1);
*((uint64_t *)buf) = (uint64_t)buf;
*((uint64_t *)buf + 1) = fi_mr_key(mr);
if ((ret = send_xfer(sizeof(uint64_t)*2))) {
return ret;
}
if ((ret = poll_all_sends())) {
return ret;
}
}
return ret;
}
int ft_exchange_keys(struct fi_rma_iov *peer_iov)
{
struct fi_rma_iov *rma_iov;
int ret;
if (opts.dst_addr) {
rma_iov = tx_buf + ft_tx_prefix_size();
rma_iov->addr = fi->domain_attr->mr_mode == FI_MR_SCALABLE ?
0 : (uintptr_t) rx_buf + ft_rx_prefix_size();
rma_iov->key = fi_mr_key(mr);
ret = ft_tx(sizeof *rma_iov);
if (ret)
return ret;
ret = ft_get_rx_comp(rx_seq);
if (ret)
return ret;
rma_iov = rx_buf + ft_rx_prefix_size();
*peer_iov = *rma_iov;
ret = ft_post_rx(rx_size);
} else {
ret = ft_get_rx_comp(rx_seq);
if (ret)
return ret;
rma_iov = rx_buf + ft_rx_prefix_size();
*peer_iov = *rma_iov;
ret = ft_post_rx(rx_size);
if (ret)
return ret;
rma_iov = tx_buf + ft_tx_prefix_size();
rma_iov->addr = fi->domain_attr->mr_mode == FI_MR_SCALABLE ?
0 : (uintptr_t) rx_buf + ft_rx_prefix_size();
rma_iov->key = fi_mr_key(mr);
ret = ft_tx(sizeof *rma_iov);
}
return ret;
}
static int exchange_addr_key(void)
{
local.addr = (uintptr_t) buf;
local.key = fi_mr_key(mr);
if (opts.dst_addr) {
*(struct fi_rma_iov *)buf = local;
send_xfer(sizeof local);
recv_xfer(sizeof remote);
remote = *(struct fi_rma_iov *)buf;
} else {
recv_xfer(sizeof remote);
remote = *(struct fi_rma_iov *)buf;
*(struct fi_rma_iov *)buf = local;
send_xfer(sizeof local);
}
return 0;
}
static int rxm_mr_reg(struct fid *domain_fid, const void *buf, size_t len,
uint64_t access, uint64_t offset, uint64_t requested_key,
uint64_t flags, struct fid_mr **mr, void *context)
{
struct rxm_domain *rxm_domain;
struct rxm_mr *rxm_mr;
int ret;
rxm_domain = container_of(domain_fid, struct rxm_domain,
util_domain.domain_fid.fid);
if (!(rxm_mr = calloc(1, sizeof(*rxm_mr))))
return -FI_ENOMEM;
/* Additional flags to use RMA read for large message transfers */
access |= FI_READ | FI_REMOTE_READ;
if (rxm_domain->mr_local)
access |= FI_WRITE;
ret = fi_mr_reg(rxm_domain->msg_domain, buf, len, access, offset, requested_key,
flags, &rxm_mr->msg_mr, context);
if (ret) {
FI_WARN(&rxm_prov, FI_LOG_DOMAIN, "Unable to register MSG MR\n");
goto err;
}
rxm_mr->mr_fid.fid.fclass = FI_CLASS_MR;
rxm_mr->mr_fid.fid.context = context;
rxm_mr->mr_fid.fid.ops = &rxm_mr_ops;
/* Store msg_mr as rxm_mr descriptor so that we can get its key when
* the app passes msg_mr as the descriptor in fi_send and friends.
* The key would be used in large message transfer protocol. */
rxm_mr->mr_fid.mem_desc = rxm_mr->msg_mr;
rxm_mr->mr_fid.key = fi_mr_key(rxm_mr->msg_mr);
*mr = &rxm_mr->mr_fid;
return 0;
err:
free(rxm_mr);
return ret;
}
static inline void cntr_setup_mr(void)
{
int ret;
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_mr(void)
{
int ret;
target = malloc(BUF_SZ);
assert(target);
source = malloc(BUF_SZ);
assert(source);
ret = fi_mr_reg(dom, target, BUF_SZ,
FI_SEND | FI_RECV, 0, 0, 0, &rem_mr, &target);
cr_assert_eq(ret, 0);
ret = fi_mr_reg(dom, source, BUF_SZ,
FI_SEND | FI_RECV, 0, 0, 0, &loc_mr, &source);
cr_assert_eq(ret, 0);
mr_key = fi_mr_key(rem_mr);
}
static void setup_mr(void)
{
int i, ret;
dest_iov = malloc(sizeof(struct iovec) * IOV_CNT);
assert(dest_iov);
target = malloc(BUF_SZ);
assert(target);
source = malloc(BUF_SZ);
assert(source);
src_iov = malloc(sizeof(struct iovec) * IOV_CNT);
assert(src_iov);
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);
assert(dest_iov[i].iov_base != NULL);
}
iov_src_buf = malloc(BUF_SZ * IOV_CNT);
assert(iov_src_buf != NULL);
iov_dest_buf = malloc(BUF_SZ * IOV_CNT);
assert(iov_src_buf != NULL);
ret = fi_mr_reg(dom, target, BUF_SZ,
FI_SEND | FI_RECV, 0, 0, 0, &rem_mr, &target);
cr_assert_eq(ret, 0);
ret = fi_mr_reg(dom, source, BUF_SZ,
FI_SEND | FI_RECV, 0, 0, 0, &loc_mr, &source);
cr_assert_eq(ret, 0);
mr_key = fi_mr_key(rem_mr);
}
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_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_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;
}
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 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]);
}
}
// TODO handle all flags
static ssize_t rxm_ep_send_common(struct fid_ep *ep_fid, const struct iovec *iov,
void **desc, size_t count, fi_addr_t dest_addr, void *context,
uint64_t data, uint64_t tag, uint64_t flags, int op)
{
struct rxm_ep *rxm_ep;
struct rxm_conn *rxm_conn;
struct rxm_tx_entry *tx_entry;
struct rxm_pkt *pkt;
struct fid_mr *mr;
void *desc_tx_buf = NULL;
struct rxm_rma_iov *rma_iov;
int pkt_size = 0;
int i, ret;
rxm_ep = container_of(ep_fid, struct rxm_ep, util_ep.ep_fid.fid);
ret = rxm_get_conn(rxm_ep, dest_addr, &rxm_conn);
if (ret)
return ret;
if (freestack_isempty(rxm_ep->txe_fs)) {
FI_DBG(&rxm_prov, FI_LOG_CQ, "Exhaused tx_entry freestack\n");
return -FI_ENOMEM;
}
tx_entry = freestack_pop(rxm_ep->txe_fs);
tx_entry->ctx_type = RXM_TX_ENTRY;
tx_entry->ep = rxm_ep;
tx_entry->context = context;
tx_entry->flags = flags;
if (rxm_ep->msg_info->mode & FI_LOCAL_MR) {
pkt = util_buf_get_ex(rxm_ep->tx_pool, (void **)&mr);
desc_tx_buf = fi_mr_desc(mr);
} else {
pkt = util_buf_get(rxm_ep->tx_pool);
}
assert(pkt);
tx_entry->pkt = pkt;
rxm_pkt_init(pkt);
pkt->ctrl_hdr.conn_id = rxm_conn->handle.remote_key;
pkt->hdr.op = op;
pkt->hdr.size = ofi_get_iov_len(iov, count);
rxm_op_hdr_process_flags(&pkt->hdr, flags, data);
if (op == ofi_op_tagged)
pkt->hdr.tag = tag;
if (pkt->hdr.size > RXM_TX_DATA_SIZE) {
if (flags & FI_INJECT) {
FI_WARN(&rxm_prov, FI_LOG_EP_DATA,
"inject size supported: %d, msg size: %d\n",
rxm_tx_attr.inject_size,
pkt->hdr.size);
ret = -FI_EMSGSIZE;
goto err;
}
tx_entry->msg_id = ofi_idx2key(&rxm_ep->tx_key_idx,
rxm_txe_fs_index(rxm_ep->txe_fs, tx_entry));
pkt->ctrl_hdr.msg_id = tx_entry->msg_id;
pkt->ctrl_hdr.type = ofi_ctrl_large_data;
rma_iov = (struct rxm_rma_iov *)pkt->data;
rma_iov->count = count;
for (i = 0; i < count; i++) {
rma_iov->iov[i].addr = rxm_ep->msg_info->domain_attr->mr_mode == FI_MR_SCALABLE ?
0 : (uintptr_t)iov->iov_base;
rma_iov->iov[i].len = (uint64_t)iov->iov_len;
rma_iov->iov[i].key = fi_mr_key(desc[i]);
}
pkt_size = sizeof(*pkt) + sizeof(*rma_iov) + sizeof(*rma_iov->iov) * count;
FI_DBG(&rxm_prov, FI_LOG_CQ,
"Sending large msg. msg_id: 0x%" PRIx64 "\n",
tx_entry->msg_id);
FI_DBG(&rxm_prov, FI_LOG_CQ, "tx_entry->state -> RXM_LMT_START\n");
tx_entry->state = RXM_LMT_START;
} else {
pkt->ctrl_hdr.type = ofi_ctrl_data;
ofi_copy_iov_buf(iov, count, pkt->data, pkt->hdr.size, 0,
OFI_COPY_IOV_TO_BUF);
pkt_size = sizeof(*pkt) + pkt->hdr.size;
}
ret = fi_send(rxm_conn->msg_ep, pkt, pkt_size, desc_tx_buf, 0, tx_entry);
if (ret) {
FI_WARN(&rxm_prov, FI_LOG_EP_DATA, "fi_send for MSG provider failed\n");
goto err;
}
return 0;
err:
util_buf_release(rxm_ep->tx_pool, pkt);
freestack_push(rxm_ep->txe_fs, tx_entry);
return ret;
}
void rdm_sr_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");
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);
}
void cancel_setup(void)
{
int ret = 0;
struct fi_av_attr attr;
size_t addrlen = 0;
int rem_requested_key, loc_requested_key;
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_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);
rem_requested_key = USING_SCALABLE(fi) ? 1 : 0;
loc_requested_key = USING_SCALABLE(fi) ? 2 : 0;
ret = fi_mr_reg(dom,
target,
BUF_SZ,
FI_REMOTE_WRITE,
0,
rem_requested_key,
0,
&rem_mr,
&target);
cr_assert_eq(ret, 0);
ret = fi_mr_reg(dom,
source,
BUF_SZ,
FI_REMOTE_WRITE,
0,
loc_requested_key,
0,
&loc_mr,
&source);
cr_assert_eq(ret, 0);
if (USING_SCALABLE(fi)) {
MR_ENABLE(rem_mr, target, BUF_SZ);
MR_ENABLE(loc_mr, source, BUF_SZ);
}
mr_key = fi_mr_key(rem_mr);
}
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]);
}
}
int main(int argc, char *argv[])
{
int i, j, peer;
int size, align_size;
char *s_buf, *r_buf;
uint64_t t_start = 0, t_end = 0, t = 0;
int op, ret;
buf_desc_t lbuf_desc;
ssize_t fi_rc;
FT_Init(&argc, &argv);
FT_Rank(&myid);
FT_Job_size(&numprocs);
hints = fi_allocinfo();
if (!hints)
return -1;
while ((op = getopt(argc, argv, "h" INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parseinfo(op, optarg, hints);
break;
case '?':
case 'h':
print_usage();
return EXIT_FAILURE;
}
}
hints->ep_attr->type = FI_EP_RDM;
hints->caps = FI_MSG | FI_DIRECTED_RECV | FI_RMA;
hints->mode = FI_CONTEXT | FI_LOCAL_MR;
hints->domain_attr->mr_mode = FI_MR_BASIC;
if (numprocs != 2) {
if (myid == 0) {
fprintf(stderr, "This test requires exactly two processes\n");
}
FT_Finalize();
return -1;
}
/* Fabric initialization */
ret = init_fabric();
if (ret) {
fprintf(stderr, "Problem in fabric initialization\n");
return ret;
}
ret = init_av();
if (ret) {
fprintf(stderr, "Problem in AV initialization\n");
return ret;
}
/* Data initialization */
align_size = getpagesize();
assert(align_size <= MAX_ALIGNMENT);
s_buf = (char *) (((unsigned long) s_buf_original + (align_size - 1)) /
align_size * align_size);
r_buf = (char *) (((unsigned long) r_buf_original + (align_size - 1)) /
align_size * align_size);
ret = fi_mr_reg(dom, r_buf, MYBUFSIZE, FI_REMOTE_WRITE, 0, 0, 0, &r_mr, NULL);
if (ret) {
FT_PRINTERR("fi_mr_reg", ret);
return -1;
}
lbuf_desc.addr = (uint64_t)r_buf;
lbuf_desc.key = fi_mr_key(r_mr);
rbuf_descs = (buf_desc_t *)malloc(numprocs * sizeof(buf_desc_t));
/* Distribute memory keys */
FT_Allgather(&lbuf_desc, sizeof(lbuf_desc), rbuf_descs);
ret = fi_mr_reg(dom, s_buf, MYBUFSIZE, FI_WRITE, 0, 0, 0, &l_mr, NULL);
if (ret) {
FT_PRINTERR("fi_mr_reg", ret);
return -1;
}
if (myid == 0) {
fprintf(stdout, HEADER);
fprintf(stdout, "%-*s%*s%*s\n", 10, "# Size", FIELD_WIDTH,
"Bandwidth (MB/s)", FIELD_WIDTH, "latency");
fflush(stdout);
}
/* Bandwidth test */
for (size = 1; size <= MAX_MSG_SIZE; size *= 2) {
/* touch the data */
for (i = 0; i < size; i++) {
s_buf[i] = 'a';
r_buf[i] = 'b';
}
if (size > large_message_size) {
loop = loop_large;
skip = skip_large;
window_size = window_size_large;
}
FT_Barrier();
if (myid == 0) {
peer = 1;
for (i = 0; i < loop + skip; i++) {
if (i == skip) {
t_start = get_time_usec();
}
for (j = 0; j < window_size; j++) {
fi_rc = fi_write(ep, s_buf, size, l_mr,
fi_addrs[peer],
rbuf_descs[peer].addr,
rbuf_descs[peer].key,
(void *)(intptr_t)j);
if (fi_rc) {
FT_PRINTERR("fi_write", fi_rc);
return fi_rc;
}
}
ft_wait_for_comp(scq, window_size);
}
t_end = get_time_usec();
t = t_end - t_start;
} else if (myid == 1) {
peer = 0;
}
if (myid == 0) {
double latency = (t_end - t_start) /
(double)(loop * window_size);
double tmp = size / 1e6 * loop * window_size;
fprintf(stdout, "%-*d%*.*f%*.*f\n", 10, size,
FIELD_WIDTH, FLOAT_PRECISION,
tmp / (t / 1e6), FIELD_WIDTH,
FLOAT_PRECISION, latency);
fflush(stdout);
}
}
FT_Barrier();
fi_close(&l_mr->fid);
fi_close(&r_mr->fid);
free_ep_res();
fi_close(&ep->fid);
fi_close(&dom->fid);
fi_close(&fab->fid);
fi_freeinfo(hints);
fi_freeinfo(fi);
FT_Barrier();
FT_Finalize();
return 0;
}
