static int run_test()
{
int ret, i;
/* Post recvs */
for (i = 0; i < ep_cnt; i++) {
fprintf(stdout, "Posting recv for ctx: %d\n", i);
ret = fi_recv(srx_ctx, rx_buf, rx_size, fi_mr_desc(mr),
FI_ADDR_UNSPEC, NULL);
if (ret) {
FT_PRINTERR("fi_recv", ret);
return ret;
}
}
if (opts.dst_addr) {
/* Post sends addressed to remote EPs */
for (i = 0; i < ep_cnt; i++) {
fprintf(stdout, "Posting send to remote ctx: %d\n", i);
ret = fi_send(ep_array[i], tx_buf, tx_size, fi_mr_desc(mr),
remote_fi_addr[i], NULL);
if (ret) {
FT_PRINTERR("fi_send", ret);
return ret;
}
ft_wait_for_comp(txcq, 1);
}
}
/* Wait for recv completions */
for (i = 0; i < ep_cnt; i++) {
ft_wait_for_comp(rxcq, 1);
}
if (!opts.dst_addr) {
/* Post sends addressed to remote EPs */
for (i = 0; i < ep_cnt; i++) {
fprintf(stdout, "Posting send to remote ctx: %d\n", i);
ret = fi_send(ep_array[i], tx_buf, tx_size, fi_mr_desc(mr),
remote_fi_addr[i], NULL);
if (ret) {
FT_PRINTERR("fi_send", ret);
return ret;
}
ft_wait_for_comp(txcq, 1);
}
}
return 0;
}
static int ft_get_cq_comp(struct fid_cq *cq, uint64_t *cur,
uint64_t total, int timeout)
{
int ret;
switch (opts.comp_method) {
case FT_COMP_SREAD:
ret = ft_wait_for_comp(cq, cur, total, timeout);
break;
case FT_COMP_WAIT_FD:
ret = ft_fdwait_for_comp(cq, cur, total, timeout);
break;
default:
ret = ft_spin_for_comp(cq, cur, total, timeout);
break;
}
if (ret) {
if (ret == -FI_EAVAIL) {
ret = ft_cq_readerr(cq);
(*cur)++;
} else {
FT_PRINTERR("ft_get_cq_comp", ret);
}
}
return ret;
}
static int run_test()
{
int ret;
size_t size = 1000;
uint64_t remote_cq_data;
struct fi_cq_data_entry comp;
if (fi->domain_attr->cq_data_size >= sizeof(uint64_t)) {
remote_cq_data = 0x0123456789abcdefULL;
} else {
remote_cq_data = 0x0123456789abcdef &
((0x1ULL << (fi->domain_attr->cq_data_size * 8)) - 1);
}
if (opts.dst_addr) {
fprintf(stdout,
"Posting send with immediate data: 0x%" PRIx64 "\n",
remote_cq_data);
ret = fi_senddata(ep, buf, size, fi_mr_desc(mr), remote_cq_data,
0, buf);
if (ret) {
FT_PRINTERR("fi_send", ret);
return ret;
}
ft_wait_for_comp(txcq, 1);
fprintf(stdout, "Done\n");
} else {
fprintf(stdout, "Waiting for immediate data from client\n");
ret = fi_cq_sread(rxcq, &comp, 1, NULL, -1);
if (ret < 0) {
if (ret == -FI_EAVAIL) {
cq_readerr(rxcq, "rxcq");
} else {
FT_PRINTERR("fi_cq_sread", ret);
}
return ret;
}
/* Verify completion data */
if (comp.flags & FI_REMOTE_CQ_DATA) {
if (comp.data == remote_cq_data)
fprintf(stdout, "remote_cq_data: success\n");
else
fprintf(stdout, "remote_cq_data: failure\n");
fprintf(stdout, "Expected data:0x%" PRIx64
", Received data:0x%" PRIx64 "\n",
remote_cq_data, comp.data);
}
}
return 0;
}
static int recv_msg(void)
{
int ret;
ret = fi_recv(ep, buf, rx_size, fi_mr_desc(mr), 0, &fi_ctx_recv);
if (ret) {
FT_PRINTERR("fi_recv", ret);
return ret;
}
ret = ft_wait_for_comp(rxcq, 1);
return ret;
}
static int send_msg(int size)
{
int ret;
ret = fi_send(ep, buf, (size_t) size, fi_mr_desc(mr), remote_fi_addr,
&fi_ctx_send);
if (ret) {
FT_PRINTERR("fi_send", ret);
return ret;
}
ret = ft_wait_for_comp(txcq, 1);
return ret;
}
static int run_test(void)
{
int ret, i;
ret = sync_test();
if (ret)
return ret;
clock_gettime(CLOCK_MONOTONIC, &start);
for (i = 0; i < opts.iterations; i++) {
switch (op_type) {
case FT_RMA_WRITE:
ret = write_data(opts.transfer_size);
break;
case FT_RMA_WRITEDATA:
ret = write_data_with_cq_data(opts.transfer_size);
if (ret)
return ret;
ret = wait_remote_writedata_completion();
break;
case FT_RMA_READ:
ret = read_data(opts.transfer_size);
break;
}
if (ret)
return ret;
ret = ft_wait_for_comp(txcq, 1);
if (ret)
return ret;
}
clock_gettime(CLOCK_MONOTONIC, &end);
if (opts.machr)
show_perf_mr(opts.transfer_size, opts.iterations, &start, &end,
1, opts.argc, opts.argv);
else
show_perf(test_name, opts.transfer_size, opts.iterations,
&start, &end, 1);
return 0;
}
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;
}
