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; }
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; }
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; }
char *ft_strtrim(char const *s) { int i; int j; int n; char *tmp; if (s) { i = ft_start(s); j = ft_strlen((char *)s); if (!(tmp = (char *)malloc(sizeof(*tmp) * (j - i + 1)))) return (NULL); j = ft_end(s); n = 0; while (i <= j) { tmp[n] = s[i]; i++; n++; } tmp[n] = '\0'; return (tmp); } return (NULL); }
char *ft_strtrim(char const *s) { char *str_start; char *str_end; int i; int j; int len; len = 0; i = 0; if (!s) return (NULL); str_start = ft_start(s, &j, &len); i = 0; while (s[j + i] != '\0') { str_start[i] = s[j + i]; i++; } str_start[i] = '\0'; while (str_start[len - 1] == ' ' || str_start[len - 1] == '\n' || str_start[len - 1] == '\t') len--; str_end = (char *)malloc(sizeof(char) * (len + 1)); str_end = ft_fill_strim(str_end, str_start, len); return (str_end); }
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; }
//Check if a id is in the interval of this finger as defined in the Chord paper int ft_interval(finger_table * t, int i, id * value) { id low,high; //if the index is valid if(i > 0 && i <= M) { //get the bounds of the interval ft_start(t, &low, i); ft_start(t, &high, (i + 1) % M); //if high < low (interval wraps around circle), checks are diff switch(id_compare(&high, &low)) { case 1: return id_compare(&low, value) <= 0 && id_compare(&high, value) == 1; case -1: return id_compare(&low, value) <= 0 || id_compare(&high, value) == 1; case 0: return 0; } } }
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 main(int ac, char **av) { t_sig *sig; if (ac > 1) { sig = ft_init_sig(); ft_init_signal(); sig->lst = ft_inilst(av, sig->lst); ft_start(sig); } return (0); }
int main(int argc, char *argv[]) { char *str; int ver[2]; int length; int width; int **val; if (ft_start(argc, argv, &str, ver) == 0) return (-1); if ((val = ft_create_tab(&str, &length, &width)) == NULL) { ft_putstr(argv[1]); ft_putstr(": Incorrect value in file\n"); return (0); } ft_init(val, length, width); 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; }
int main(void) { ft_start(); 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); }