static int run_test(void)
{
int ret, i;
ret = ft_sync();
if (ret)
return ret;
ft_start();
for (i = 0; i < opts.iterations; i++) {
ret = ft_rma(opts.rma_op, ep, opts.transfer_size, &remote, ep);
if (ret)
return ret;
}
ft_stop();
if (opts.machr)
show_perf_mr(opts.transfer_size, opts.iterations, &start, &end,
1, opts.argc, opts.argv);
else
show_perf(NULL, opts.transfer_size, opts.iterations,
&start, &end, 1);
return 0;
}
static int run_test(void)
{
int ret, i;
ret = sync_test();
if (ret) {
fprintf(stderr, "sync_test failed!\n");
goto out;
}
ft_start();
if (opts.dst_addr) {
for (i = 0; i < opts.iterations; i++) {
ret = ft_tx(ep, remote_fi_addr, opts.transfer_size, &tx_ctx);
if (ret)
goto out;
}
} else {
ret = wait_for_recv_completion(opts.iterations);
if (ret)
goto out;
}
ft_stop();
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);
out:
return ret;
}
int pingpong(void)
{
int ret, i;
ret = ft_sync();
if (ret)
return ret;
ft_start();
for (i = 0; i < opts.iterations; i++) {
ret = opts.dst_addr ?
ft_tx(opts.transfer_size) : ft_rx(opts.transfer_size);
if (ret)
return ret;
ret = opts.dst_addr ?
ft_rx(opts.transfer_size) : ft_tx(opts.transfer_size);
if (ret)
return ret;
}
ft_stop();
if (opts.machr)
show_perf_mr(opts.transfer_size, opts.iterations, &start, &end, 2, opts.argc, opts.argv);
else
show_perf(test_name, opts.transfer_size, opts.iterations, &start, &end, 2);
return 0;
}
static int stream(void)
{
int ret, i;
ret = ft_sync();
if (ret)
return ret;
ft_start();
for (i = 0; i < opts.iterations; i++) {
ret = opts.dst_addr ?
ft_tx(ep, remote_fi_addr, opts.transfer_size, &tx_ctx) : ft_rx(ep, opts.transfer_size);
if (ret)
return ret;
}
ft_stop();
if (opts.machr)
show_perf_mr(opts.transfer_size, opts.iterations, &start, &end, 1,
opts.argc, opts.argv);
else
show_perf(NULL, opts.transfer_size, opts.iterations, &start, &end, 1);
return 0;
}
static int sread_event(int timeout, uint64_t flags)
{
struct fi_eq_entry entry;
int64_t elapsed;
uint32_t event;
int ret;
ft_start();
ret = fi_eq_sread(eq, &event, &entry, sizeof(entry), timeout, flags);
if (ret != sizeof(entry)) {
sprintf(err_buf, "fi_eq_sread returned %d, %s", ret,
fi_strerror(-ret));
return ret;
}
/* check timeout accuracy */
ft_stop();
elapsed = get_elapsed(&start, &end, MILLI);
if (elapsed > (int) (timeout * 1.25)) {
sprintf(err_buf, "fi_eq_sread slept %d ms, expected %d",
(int) elapsed, timeout);
return -FI_EOTHER;
}
return FI_SUCCESS;
}
static int
cq_signal()
{
struct fid_cq *cq;
struct fi_cq_tagged_entry entry;
int64_t elapsed;
int testret;
int ret;
testret = FAIL;
ret = create_cq(&cq, 1, 0, FI_CQ_FORMAT_UNSPEC, FI_WAIT_UNSPEC);
if (ret) {
sprintf(err_buf, "fi_cq_open(1, 0, FI_CQ_FORMAT_UNSPEC, "
"FI_WAIT_UNSPEC) = %d, %s",
ret, fi_strerror(-ret));
goto fail1;
}
ret = fi_cq_signal(cq);
if (ret) {
sprintf(err_buf, "fi_cq_signal = %d %s", ret, fi_strerror(-ret));
goto fail2;
}
ft_start();
ret = fi_cq_sread(cq, &entry, 1, NULL, 2000);
ft_stop();
elapsed = get_elapsed(&start, &end, MILLI);
if (ret != -FI_EAGAIN && ret != -FI_ECANCELED) {
sprintf(err_buf, "fi_cq_sread = %d %s", ret, fi_strerror(-ret));
goto fail2;
}
if (elapsed > 1000) {
sprintf(err_buf, "fi_cq_sread - signal ignored");
goto fail2;
}
ret = fi_close(&cq->fid);
if (ret) {
sprintf(err_buf, "close(cq) = %d, %s", ret, fi_strerror(-ret));
goto fail1;
}
cq = NULL;
testret = PASS;
fail2:
FT_CLOSE_FID(cq);
fail1:
cq = NULL;
return TEST_RET_VAL(ret, testret);
}
int pingpong(void)
{
int ret, i;
ret = ft_sync();
if (ret)
return ret;
if (opts.dst_addr) {
for (i = 0; i < opts.iterations + opts.warmup_iterations; i++) {
if (i == opts.warmup_iterations)
ft_start();
if (opts.transfer_size < fi->tx_attr->inject_size)
ret = ft_inject(opts.transfer_size);
else
ret = ft_tx(opts.transfer_size);
if (ret)
return ret;
ret = ft_rx(opts.transfer_size);
if (ret)
return ret;
}
} else {
for (i = 0; i < opts.iterations + opts.warmup_iterations; i++) {
if (i == opts.warmup_iterations)
ft_start();
ret = ft_rx(opts.transfer_size);
if (ret)
return ret;
if (opts.transfer_size < fi->tx_attr->inject_size)
ret = ft_inject(opts.transfer_size);
else
ret = ft_tx(opts.transfer_size);
if (ret)
return ret;
}
}
ft_stop();
if (opts.machr)
show_perf_mr(opts.transfer_size, opts.iterations, &start, &end, 2, opts.argc, opts.argv);
else
show_perf(NULL, opts.transfer_size, opts.iterations, &start, &end, 2);
return 0;
}
int bandwidth(void)
{
int ret, i, j;
ret = ft_sync();
if (ret)
return ret;
/* The loop structured allows for the possibility that the sender
* immediately overruns the receiving side on the first transfer (or
* the entire window). This could result in exercising parts of the
* provider's implementation of FI_RM_ENABLED. For better or worse,
* some MPI-level benchmarks tend to use this type of loop for measuring
* bandwidth. */
if (opts.dst_addr) {
for (i = 0; i < opts.iterations + opts.warmup_iterations; i++) {
if (i == opts.warmup_iterations)
ft_start();
for(j = 0; j < opts.window_size; j++) {
if (opts.transfer_size < fi->tx_attr->inject_size)
ret = ft_inject(opts.transfer_size);
else
ret = ft_post_tx(opts.transfer_size);
if (ret)
return ret;
}
ret = ft_get_tx_comp(tx_seq);
if (ret)
return ret;
ret = ft_rx(4);
if (ret)
return ret;
}
} else {
for (i = 0; i < opts.iterations + opts.warmup_iterations; i++) {
if (i == opts.warmup_iterations)
ft_start();
for(j = 0; j < opts.window_size; j++) {
ret = ft_post_rx(opts.transfer_size);
if (ret)
return ret;
}
ret = ft_get_rx_comp(rx_seq-1); /* rx_seq is always one ahead */
if (ret)
return ret;
ret = ft_tx(4);
if (ret)
return ret;
}
}
ft_stop();
if (opts.machr)
show_perf_mr(opts.transfer_size, opts.iterations, &start, &end,
opts.window_size, opts.argc, opts.argv);
else
show_perf(NULL, opts.transfer_size, opts.iterations, &start, &end,
opts.window_size);
return 0;
}
/*
* Tests:
* - sread with event pending
* - sread with no event pending
*/
static int
eq_wait_fd_sread()
{
struct fi_eq_entry entry;
uint32_t event;
int64_t elapsed;
int testret;
int ret;
testret = FAIL;
ret = create_eq(32, FI_WRITE, FI_WAIT_FD);
if (ret != 0) {
sprintf(err_buf, "fi_eq_open ret=%d, %s", ret, fi_strerror(-ret));
goto fail;
}
/* timed sread on empty EQ, 2s timeout */
ft_start();
ret = fi_eq_sread(eq, &event, &entry, sizeof(entry), 2000, 0);
if (ret != -FI_EAGAIN) {
sprintf(err_buf, "fi_eq_read of empty EQ returned %d", ret);
goto fail;
}
/* check timeout accuracy */
ft_stop();
elapsed = get_elapsed(&start, &end, MILLI);
if (elapsed < 1500 || elapsed > 2500) {
sprintf(err_buf, "fi_eq_sread slept %d ms, expected 2000",
(int)elapsed);
goto fail;
}
/* write an event */
entry.fid = &eq->fid;
entry.context = eq;
ret = fi_eq_write(eq, FI_NOTIFY, &entry, sizeof(entry), 0);
if (ret != sizeof(entry)) {
sprintf(err_buf, "fi_eq_write ret=%d, %s", ret, fi_strerror(-ret));
goto fail;
}
/* timed sread on EQ with event, 2s timeout */
ft_start();
event = ~0;
memset(&entry, 0, sizeof(entry));
ret = fi_eq_sread(eq, &event, &entry, sizeof(entry), 2000, 0);
if (ret != sizeof(entry)) {
sprintf(err_buf, "fi_eq_read ret=%d, %s", ret, fi_strerror(-ret));
goto fail;
}
/* check that no undue waiting occurred */
ft_stop();
elapsed = get_elapsed(&start, &end, MILLI);
if (elapsed > 5) {
sprintf(err_buf, "fi_eq_sread slept %d ms, expected immediate return",
(int)elapsed);
goto fail;
}
if (event != FI_NOTIFY) {
sprintf(err_buf, "fi_eq_sread: event = %d, should be %d\n", event,
FI_NOTIFY);
goto fail;
}
if (entry.fid != &eq->fid) {
sprintf(err_buf, "fi_eq_sread: fid mismatch: %p should be %p\n",
entry.fid, &eq->fid);
goto fail;
}
if (entry.context != eq) {
sprintf(err_buf, "fi_eq_sread: context mismatch: %p should be %p\n",
entry.context, eq);
goto fail;
}
testret = PASS;
fail:
FT_CLOSE_FID(eq);
return TEST_RET_VAL(ret, testret);
}
