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); }