static int receive_loop(size_t size) { int ret; int q_opts = 0; struct fi_context recv_ctx[max_opts]; while (q_opts < max_opts) { do { ft_tag = q_opts + 1; if (tagged) ret = fi_trecv(ep, rx_buf, size, NULL, remote_fi_addr, ft_tag, 0x0, (void *) &recv_ctx[q_opts]); else ret = fi_recv(ep, rx_buf, size, NULL, remote_fi_addr, (void *) &recv_ctx[q_opts]); if (ret == FI_SUCCESS) { rx_seq++; q_opts++; } } while (!ret && (q_opts != max_opts)); if (ret < 0) { if (ret == -FI_EAGAIN) { if (delay > 0) sleep(delay); ret = ft_get_rx_comp(rx_seq); if (ret) return ret; } else { FT_PRINTERR("Recv OP", ret); return ret; } } } if (delay > 0) sleep(delay); ret = ft_get_rx_comp(rx_seq); if (ret) return ret; if (opts.verbose) printf("Success: Completed %d queued ops\n", q_opts); return 0; }
int send_recv_greeting(struct fid_ep *ep) { int ret; const char *message = "Hello from Client!"; size_t message_len = strlen(message) + 1; if (opts.dst_addr) { fprintf(stdout, "Sending message...\n"); if (snprintf(tx_buf, tx_size, "%s", message) >= tx_size) { fprintf(stderr, "Transmit buffer too small.\n"); return -FI_ETOOSMALL; } ret = ft_tx(ep, remote_fi_addr, message_len, &tx_ctx); if (ret) return ret; fprintf(stdout, "Send completion received\n"); } else { fprintf(stdout, "Waiting for message from client...\n"); ret = ft_get_rx_comp(rx_seq); if (ret) return ret; ret = check_recv_msg(message); if (ret) return ret; fprintf(stdout, "Received data from client: %s\n", (char *) rx_buf); } return 0; }
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; } rx_seq++; } 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), addr_array[i], NULL); if (ret) { FT_PRINTERR("fi_send", ret); return ret; } ret = ft_get_tx_comp(++tx_seq); if (ret) return ret; } } /* Wait for recv completions */ ret = ft_get_rx_comp(rx_seq); if (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), addr_array[i], NULL); if (ret) { FT_PRINTERR("fi_send", ret); return ret; } ret = ft_get_tx_comp(++tx_seq); if (ret) return ret; } } return 0; }
static int run_test() { int ret, i; if (!(tx_ctx_arr = calloc(ep_cnt, sizeof *tx_ctx_arr))) return -FI_ENOMEM; if (!(rx_ctx_arr = calloc(ep_cnt, sizeof *rx_ctx_arr))) return -FI_ENOMEM; /* Post recvs */ for (i = 0; i < ep_cnt; i++) { if (rx_shared_ctx) { fprintf(stdout, "Posting recv #%d for shared rx ctx\n", i); ret = ft_post_rx(srx_ctx, rx_size, &rx_ctx_arr[i]); } else { fprintf(stdout, "Posting recv for endpoint #%d\n", i); ret = ft_post_rx(ep_array[i], rx_size, &rx_ctx_arr[i]); } if (ret) return ret; } if (opts.dst_addr) { /* Post sends addressed to remote EPs */ for (i = 0; i < ep_cnt; i++) { if (tx_shared_ctx) fprintf(stdout, "Posting send #%d to shared tx ctx\n", i); else fprintf(stdout, "Posting send to endpoint #%d\n", i); ret = ft_tx(ep_array[i], addr_array[i], tx_size, &tx_ctx_arr[i]); if (ret) return ret; } } /* Wait for recv completions */ ret = ft_get_rx_comp(rx_seq - 1); if (ret) return ret; if (!opts.dst_addr) { /* Post sends addressed to remote EPs */ for (i = 0; i < ep_cnt; i++) { if (tx_shared_ctx) fprintf(stdout, "Posting send #%d to shared tx ctx\n", i); else fprintf(stdout, "Posting send to endpoint #%d\n", i); ret = ft_tx(ep_array[i], addr_array[i], tx_size, &tx_ctx_arr[i]); if (ret) return ret; } } return 0; }
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; }
int ft_finalize(void) { struct iovec iov; int ret; struct fi_context ctx; void *desc = fi_mr_desc(mr); strcpy(tx_buf + ft_tx_prefix_size(), "fin"); iov.iov_base = tx_buf; iov.iov_len = 4 + ft_tx_prefix_size(); if (hints->caps & FI_TAGGED) { struct fi_msg_tagged tmsg; memset(&tmsg, 0, sizeof tmsg); tmsg.msg_iov = &iov; tmsg.desc = &desc; tmsg.iov_count = 1; tmsg.addr = remote_fi_addr; tmsg.tag = tx_seq; tmsg.ignore = 0; tmsg.context = &ctx; ret = fi_tsendmsg(ep, &tmsg, FI_INJECT | FI_TRANSMIT_COMPLETE); } else { struct fi_msg msg; memset(&msg, 0, sizeof msg); msg.msg_iov = &iov; msg.desc = &desc; msg.iov_count = 1; msg.addr = remote_fi_addr; msg.context = &ctx; ret = fi_sendmsg(ep, &msg, FI_INJECT | FI_TRANSMIT_COMPLETE); } if (ret) { FT_PRINTERR("transmit", ret); return ret; } ret = ft_get_tx_comp(++tx_seq); if (ret) return ret; ret = ft_get_rx_comp(rx_seq); if (ret) return ret; return 0; }
static int recv_msg(void) { int ret; ret = fi_recv(srx_ctx, buf, rx_size, fi_mr_desc(mr), 0, &rx_ctx); if (ret) { FT_PRINTERR("fi_recv", ret); return ret; } ret = ft_get_rx_comp(++rx_seq); return ret; }
int send_recv_greeting(void) { int ret; const char *message = "Hello from Client!"; /* strlen doesn't include null terminated byte. snprintf size includes * null terminated byte. */ size_t message_len = strlen(message) + 1; size_t recv_len; if (opts.dst_addr) { fprintf(stdout, "Sending message...\n"); if (snprintf(tx_buf, tx_size, "%s", message) >= tx_size) { fprintf(stderr, "Transmit buffer too small.\n"); return -FI_ETOOSMALL; } ret = ft_tx(message_len); if (ret) return ret; fprintf(stdout, "Send completion received\n"); } else { fprintf(stdout, "Waiting for message from client...\n"); ret = ft_get_rx_comp(rx_seq); if (ret) return ret; /* Account for null terminated byte. */ recv_len = strlen(rx_buf) + 1; if (recv_len != message_len) { fprintf(stderr, "Received length does not match expected length.\n"); return -1; } if (strncmp(rx_buf, message, MIN(recv_len, message_len))) { fprintf(stderr, "Received message does not match expected message.\n"); return -1; } fprintf(stdout, "Received data from client: %s\n", (char *) rx_buf); } return 0; }
static int run_test(void) { int ret = 0; const char *message = "Hello from Client!"; size_t message_len = strlen(message) + 1; ret = ft_init_fabric(); if (ret) return ret; ret = ft_exchange_keys(&remote); if (ret) return ret; if (opts.dst_addr) { fprintf(stdout, "RMA write to server\n"); if (snprintf(tx_buf, tx_size, "%s", message) >= tx_size) { fprintf(stderr, "Transmit buffer too small.\n"); return -FI_ETOOSMALL; } ret = fi_write(ep, tx_buf, message_len, mr_desc, remote_fi_addr, remote.addr, remote.key, &fi_ctx_write); if (ret) return ret; ret = ft_get_tx_comp(++tx_seq); if (ret) return ret; fprintf(stdout, "Received a completion event for RMA write\n"); } else { ret = ft_get_rx_comp(rx_seq); if (ret) return ret; ret = check_recv_msg(message); if (ret) return ret; fprintf(stdout, "Received data from Client: %s\n", (char *) rx_buf); } /* TODO: need support for finalize operation to sync test */ return 0; }
ssize_t ft_rx(size_t size) { ssize_t ret; ret = ft_get_rx_comp(rx_seq); if (ret) return ret; if (ft_check_opts(FT_OPT_VERIFY_DATA | FT_OPT_ACTIVE)) { ret = ft_check_buf((char *) rx_buf + ft_rx_prefix_size(), size); if (ret) return ret; } /* TODO: verify CQ data, if available */ ret = ft_post_rx(rx_size); return ret; }
static int do_transfers(void) { int i, ret; for (i = 0; i < num_eps; i++) { rx_buf = recv_bufs[i]; ret = ft_post_rx(eps[i], opts.transfer_size, &recv_ctx[i]); if (ret) return ret; } for (i = 0; i < num_eps; i++) { if (ft_check_opts(FT_OPT_VERIFY_DATA)) ft_fill_buf(send_bufs[i], opts.transfer_size); tx_buf = send_bufs[i]; ret = ft_post_tx(eps[i], remote_addr[i], opts.transfer_size, &send_ctx[i]); if (ret) return ret; } ret = ft_get_tx_comp(num_eps); if (ret < 0) return ret; ret = ft_get_rx_comp(num_eps); if (ret < 0) return ret; if (ft_check_opts(FT_OPT_VERIFY_DATA)) { for (i = 0; i < num_eps; i++) { ret = ft_check_buf(recv_bufs[i], opts.transfer_size); if (ret) return ret; } } for (i = 0; i < num_eps; i++) ft_finalize_ep(eps[i]); printf("PASSED multi ep\n"); return 0; }
ssize_t ft_rx(struct fid_ep *ep, size_t size) { ssize_t ret; ret = ft_get_rx_comp(rx_seq); if (ret) return ret; if (ft_check_opts(FT_OPT_VERIFY_DATA | FT_OPT_ACTIVE)) { ret = ft_check_buf((char *) rx_buf + ft_rx_prefix_size(), size); if (ret) return ret; } /* TODO: verify CQ data, if available */ /* Ignore the size arg. Post a buffer large enough to handle all message * sizes. ft_sync() makes use of ft_rx() and gets called in tests just before * message size is updated. The recvs posted are always for the next incoming * message */ ret = ft_post_rx(ep, rx_size, &rx_ctx); return ret; }
static int send_recv() { int ret; if (opts.dst_addr) { /* Client */ fprintf(stdout, "Sending message to server...\n"); sprintf(tx_buf, "Hello World!"); ret = ft_tx(sizeof("Hello World!")); if (ret) return ret; fprintf(stdout, "Send completed\n"); } else { fprintf(stdout, "Waiting for client...\n"); ret = ft_get_rx_comp(rx_seq); if (ret) return ret; fprintf(stdout, "Received data from client: %s\n", (char *) rx_buf); } 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; }
static int run(void) { int ret; ret = init_fabric(); if (ret) return ret; ret = ft_init_av(); if (ret) return ret; if (opts.dst_addr) { printf("Searching for a bad msg\n"); ret = tagged_peek(0xbad); if (ret != -FI_ENOMSG) { FT_PRINTERR("FI_PEEK", ret); return ret; } printf("Synchronizing with sender..\n"); ret = ft_sync(); if (ret) return ret; printf("Searching for a good msg\n"); ret = tagged_peek(0x900d); if (ret != 1) { FT_PRINTERR("FI_PEEK", ret); return ret; } printf("Receiving msg\n"); ret = fi_trecv(ep, buf, rx_size, fi_mr_desc(mr), remote_fi_addr, 0x900d, 0, &rx_ctx); if (ret) { FT_PRINTERR("fi_trecv", ret); return ret; } printf("Completing recv\n"); ret = ft_get_rx_comp(++rx_seq); if (ret) return ret; } else { printf("Sending tagged message\n"); ret = fi_tsend(ep, tx_buf, tx_size, fi_mr_desc(mr), remote_fi_addr, 0x900d, &tx_ctx); if (ret) return ret; printf("Synchronizing with receiver..\n"); ret = ft_sync(); if (ret) return ret; printf("Getting send completion\n"); ret = ft_get_tx_comp(tx_seq + 1); if (ret) return ret; } ft_finalize(); return 0; }