static void do_read_wait(int len)
{
int i, iters = 100;
ssize_t sz;
uint64_t old_w_cnt, new_w_cnt;
uint64_t old_r_cnt;
#define READ_CTX 0x4e3dda1aULL
init_data(source, len, 0);
init_data(target, len, 0xad);
old_w_cnt = fi_cntr_read(write_cntr);
old_r_cnt = fi_cntr_read(read_cntr);
for (i = 0; i < iters; i++) {
sz = fi_read(ep[0], source, len,
loc_mr, gni_addr[1], (uint64_t)target,
mr_key, (void *)READ_CTX);
cr_assert_eq(sz, 0);
}
fi_cntr_wait(read_cntr, old_r_cnt + iters, -1);
cr_assert(check_data(source, target, len), "Data mismatch");
new_w_cnt = fi_cntr_read(write_cntr);
/*
* no fi_read called so old and new read cnts should be equal
*/
cr_assert(new_w_cnt == old_w_cnt);
}
static void *do_thread_read_wait(void *data)
{
int i, tid, ret;
ssize_t sz;
struct tinfo *info = (struct tinfo *) data;
int msg_size = info->msg_size;
int iters = info->iters;
tid = cntr_test_get_tid();
dbg_printf("%d: reading\n", tid);
for (i = 0; i < iters; i++) {
sz = fi_read(ep[tid], &source[tid*msg_size], msg_size, loc_mr,
gni_addr[0], (uint64_t)&target[tid*msg_size],
mr_key, (void *)(READ_CTX+i));
cr_assert_eq(sz, 0);
}
dbg_printf("%d: waiting\n", tid);
ret = fi_cntr_wait(ep_read_cntrs[tid], iters, -1);
cr_assert(ret == FI_SUCCESS);
dbg_printf("%d: done\n", tid);
return NULL;
}
void api_do_read_buf(void)
{
int ret;
int len = 8*1024;
ssize_t sz;
struct fi_cq_tagged_entry cqe;
struct fi_cq_err_entry err_cqe;
rdm_api_init_data(source, BUF_SZ, 0);
rdm_api_init_data(target, BUF_SZ, 0xad);
/* cause a chained transaction */
sz = fi_read(ep[0], source+6, len,
loc_mr[0], gni_addr[1], (uint64_t)target+6, mr_key[1],
(void *)READ_CTX);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(msg_cq[0], &cqe, 1)) == -FI_EAGAIN)
pthread_yield();
if (ret == -FI_EAVAIL) {
fi_cq_readerr(msg_cq[0], &err_cqe, 0);
dbg_printf("fi_cq_readerr err:%d\n", err_cqe.err);
}
if (read_allowed(FI_RMA, fi[0]->caps, fi[1]->caps)) {
cr_assert(ret == 1,
"fi_read failed caps:0x%lx rcaps:0x%lx",
fi[0]->caps, fi[1]->caps);
} else {
cr_assert(err_cqe.err == FI_EOPNOTSUPP,
"fi_read should fail caps:0x%lx rcaps:0x%lx",
fi[0]->caps, fi[1]->caps);
}
}
static void do_read(int len)
{
ssize_t sz;
uint64_t old_w_cnt, new_w_cnt;
uint64_t old_r_cnt, new_r_cnt;
#define READ_CTX 0x4e3dda1aULL
init_data(source, len, 0);
init_data(target, len, 0xad);
old_w_cnt = fi_cntr_read(write_cntr);
old_r_cnt = fi_cntr_read(read_cntr);
sz = fi_read(ep[0], source, len,
loc_mr, gni_addr[1], (uint64_t)target, mr_key,
(void *)READ_CTX);
cr_assert_eq(sz, 0);
do {
new_r_cnt = fi_cntr_read(read_cntr);
if (new_r_cnt == (old_r_cnt + 1))
break;
pthread_yield();
} while (1);
cr_assert(check_data(source, target, len), "Data mismatch");
new_w_cnt = fi_cntr_read(write_cntr);
/*
* no fi_read called so old and new read cnts should be equal
*/
cr_assert(new_w_cnt == old_w_cnt);
}
void do_read(int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe;
#define READ_CTX 0x4e3dda1aULL
init_data(source, len, 0);
init_data(target, len, 0xad);
sz = fi_read(ep[0], source, len,
loc_mr, gni_addr[1], (uint64_t)target, mr_key,
(void *)READ_CTX);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
rdm_rma_check_tcqe(&cqe, (void *)READ_CTX, FI_RMA | FI_READ, 0);
rdm_rma_check_cntrs(0, 1, 0, 0);
dbg_printf("got read context event!\n");
cr_assert(check_data(source, target, len), "Data mismatch");
}
void sep_read(int index, int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe = { (void *) -1, UINT_MAX, UINT_MAX,
(void *) -1, UINT_MAX, UINT_MAX };
uint64_t w[2] = {0}, r[2] = {0}, w_e[2] = {0}, r_e[2] = {0};
#define READ_CTX 0x4e3dda1aULL
sep_init_data(source, len, 0);
sep_init_data(target, len, 0xad);
sz = fi_read(tx_ep[0][index], source, len,
loc_mr[0], rx_addr[index], (uint64_t)target, mr_key[1],
(void *)READ_CTX);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(tx_cq[0][index], &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
sep_check_tcqe(&cqe, (void *)READ_CTX, FI_RMA | FI_READ, 0);
r[0] = 1;
sep_check_cntrs(w, r, w_e, r_e);
cr_assert(sep_check_data(source, target, len), "Data mismatch");
}
void api_write_read(int len)
{
int ret;
struct fi_cq_tagged_entry cqe;
struct fi_cq_err_entry err_cqe = {0};
rdm_api_init_data(source, len, 0xab);
rdm_api_init_data(target, len, 0);
fi_write(ep[0], source, len,
loc_mr[0], gni_addr[1], (uint64_t)target, mr_key[1],
target);
while ((ret = fi_cq_read(msg_cq[0], &cqe, 1)) == -FI_EAGAIN)
pthread_yield();
if (ret == -FI_EAVAIL) {
fi_cq_readerr(msg_cq[0], &err_cqe, 0);
dbg_printf("fi_cq_readerr err:%d\n", err_cqe.err);
}
if (write_allowed(FI_RMA, fi[0]->caps, fi[1]->caps)) {
cr_assert(ret == 1,
"fi_write failed caps:0x%lx ret:%d",
fi[0]->caps, ret);
} else {
cr_assert(err_cqe.err == FI_EOPNOTSUPP,
"fi_write should fail caps:0x%lx err:%d",
fi[0]->caps, err_cqe.err);
}
fi_read(ep[0], source, len,
loc_mr[0], gni_addr[1], (uint64_t)target, mr_key[1],
(void *)READ_CTX);
while ((ret = fi_cq_read(msg_cq[0], &cqe, 1)) == -FI_EAGAIN)
pthread_yield();
if (ret == -FI_EAVAIL) {
fi_cq_readerr(msg_cq[0], &err_cqe, 0);
dbg_printf("fi_cq_readerr err:%d\n", err_cqe.err);
}
if (read_allowed(FI_RMA, fi[0]->caps, fi[1]->caps)) {
cr_assert(ret == 1,
"fi_read failed caps:0x%lx rcaps:0x%lx",
fi[0]->caps, fi[1]->caps);
} else {
cr_assert(err_cqe.err == FI_EOPNOTSUPP,
"fi_read should fail caps:0x%lx rcaps:0x%lx",
fi[0]->caps, fi[1]->caps);
}
}
static int read_data(size_t size)
{
int ret;
ret = fi_read(ep, buf, size, fi_mr_desc(mr),
0, remote.addr, remote.key, ep);
if (ret) {
FT_PRINTERR("fi_read", ret);
return ret;
}
return 0;
}
// --------------------------------------------------------------------
void rma_receiver::read_one_chunk(
fi_addr_t src_addr, region_type *get_region,
const void *remoteAddr, uint64_t rkey)
{
// post the rdma read/get
LOG_DEBUG_MSG("rma_receiver " << hexpointer(this)
<< "RDMA Get fi_read :"
<< "client " << hexpointer(endpoint_)
<< "fi_addr " << hexpointer(src_addr_)
<< "tag " << hexuint64(header_->tag())
<< "local addr " << hexpointer(get_region->get_address())
<< "local desc " << hexpointer(get_region->get_desc())
<< "size " << hexlength(get_region->get_message_length())
<< "rkey " << hexpointer(rkey)
<< "remote cpos " << hexpointer(remoteAddr));
// count reads
++rma_reads_;
ssize_t ret = 0;
for (std::size_t k = 0; true; ++k)
{
LOG_EXCLUSIVE(
// write a pattern and dump out data for debugging purposes
uint32_t *buffer =
reinterpret_cast<uint32_t*>(get_region->get_address());
std::fill(buffer, buffer + get_region->get_size()/4, 0xDEADC0DE);
LOG_TRACE_MSG(
CRC32_MEM(get_region->get_address(), c.size_,
"(RDMA GET region (pre-fi_read))"));
);
ret = fi_read(endpoint_,
get_region->get_address(),
get_region->get_message_length(),
get_region->get_desc(),
src_addr_,
(uint64_t)(remoteAddr), rkey, this);
if (ret == -FI_EAGAIN)
{
LOG_ERROR_MSG("receiver " << hexpointer(this)
<< "reposting fi_read...\n");
hpx::util::detail::yield_k(k, "libfabric::receiver::async_read");
continue;
}
if (ret) throw fabric_error(ret, "fi_read");
break;
}
void do_read_error(int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe;
struct fi_cq_err_entry err_cqe;
init_data(source, len, 0);
init_data(target, len, 0xad);
sz = fi_read(ep[0], source, len,
loc_mr, gni_addr[1], (uint64_t)target, mr_key,
(void *)READ_CTX);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, -FI_EAVAIL);
ret = fi_cq_readerr(send_cq, &err_cqe, 0);
cr_assert_eq(ret, 1);
cr_assert((uint64_t)err_cqe.op_context == (uint64_t)READ_CTX,
"Bad error context");
cr_assert(err_cqe.flags == (FI_RMA | FI_READ));
cr_assert(err_cqe.len == 0, "Bad error len");
cr_assert(err_cqe.buf == 0, "Bad error buf");
cr_assert(err_cqe.data == 0, "Bad error data");
cr_assert(err_cqe.tag == 0, "Bad error tag");
cr_assert(err_cqe.olen == 0, "Bad error olen");
cr_assert(err_cqe.err == FI_ECANCELED, "Bad error errno");
cr_assert(err_cqe.prov_errno == GNI_RC_TRANSACTION_ERROR,
"Bad prov errno");
cr_assert(err_cqe.err_data == NULL, "Bad error provider data");
rdm_rma_check_cntrs(0, 0, 0, 1);
}
void api_cq_send_recv(int len)
{
ssize_t sz;
struct iovec iov;
struct fi_msg_rma rma_msg;
struct fi_rma_iov rma_iov;
iov.iov_base = NULL;
iov.iov_len = 0;
api_cq_init_data(source, len, 0xab);
api_cq_init_data(target, len, 0);
sz = fi_send(ep[0], source, len, loc_mr[0], gni_addr[1], target);
api_cq_send_allowed(sz, cq_bind_flags, "fi_send");
sz = fi_recv(ep[1], target, len, rem_mr[1], gni_addr[0], source);
api_cq_recv_allowed(sz, cq_bind_flags, "fi_recv");
sz = fi_write(ep[0], source, len,
loc_mr[0], gni_addr[1], (uint64_t)target, mr_key[1],
target);
api_cq_send_allowed(sz, cq_bind_flags, "fi_write");
sz = fi_writev(ep[0], &iov, (void **)loc_mr, 1,
gni_addr[1], (uint64_t)target, mr_key[1],
target);
api_cq_send_allowed(sz, cq_bind_flags, "fi_writev");
iov.iov_len = len;
iov.iov_base = source;
rma_iov.addr = (uint64_t)target;
rma_iov.len = len;
rma_iov.key = mr_key[1];
rma_msg.msg_iov = &iov;
rma_msg.desc = (void **)loc_mr;
rma_msg.iov_count = 1;
rma_msg.addr = gni_addr[1];
rma_msg.rma_iov = &rma_iov;
rma_msg.rma_iov_count = 1;
rma_msg.context = target;
rma_msg.data = (uint64_t)target;
sz = fi_writemsg(ep[0], &rma_msg, 0);
api_cq_send_allowed(sz, cq_bind_flags, "fi_writemsg");
#define WRITE_DATA 0x5123da1a145
sz = fi_writedata(ep[0], source, len, loc_mr[0], WRITE_DATA,
gni_addr[1], (uint64_t)target, mr_key[1],
target);
api_cq_send_allowed(sz, cq_bind_flags, "fi_writedata");
#define READ_CTX 0x4e3dda1aULL
sz = fi_read(ep[0], source, len,
loc_mr[0], gni_addr[1], (uint64_t)target, mr_key[1],
(void *)READ_CTX);
api_cq_send_allowed(sz, cq_bind_flags, "fi_read");
sz = fi_readv(ep[0], &iov, (void **)loc_mr, 1,
gni_addr[1], (uint64_t)target, mr_key[1],
target);
api_cq_send_allowed(sz, cq_bind_flags, "fi_readv");
sz = fi_readmsg(ep[0], &rma_msg, 0);
api_cq_send_allowed(sz, cq_bind_flags, "fi_readmsg");
sz = fi_inject_write(ep[0], source, 64,
gni_addr[1], (uint64_t)target, mr_key[1]);
cr_assert_eq(sz, 0);
}
