int main(int argc, char **argv)
{
int op, ret;
opts = INIT_OPTS;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints);
break;
case '?':
case 'h':
ft_usage(argv[0], "A simple MSG client-sever example that "
"demonstrates one possible usage of the underlying "
"cq wait objects.");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_MSG;
hints->caps = FI_MSG;
hints->mode = FI_LOCAL_MR;
hints->addr_format = FI_SOCKADDR;
/* Fabric and connection setup */
if (!opts.dst_addr) {
ret = server_listen();
if (ret)
return -ret;
}
ret = opts.dst_addr ? client_connect() : server_connect();
if (ret) {
return -ret;
}
/* Exchange data */
ret = send_recv();
fi_shutdown(ep, 0);
free_ep_res();
fi_close(&cmeq->fid);
fi_close(&dom->fid);
fi_close(&fab->fid);
return ret;
}
int main(int argc, char **argv)
{
int op, ret;
opts = INIT_OPTS;
opts.options |= FT_OPT_SIZE | FT_OPT_OOB_CTRL;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
hints->ep_attr->type = FI_EP_RDM;
while ((op = getopt(argc, argv, "h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints, &opts);
break;
case '?':
case 'h':
ft_usage(argv[0], "AV communication unit test.");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->caps = hints->ep_attr->type == FI_EP_RDM ?
FI_TAGGED : FI_MSG;
hints->mode = FI_CONTEXT;
hints->domain_attr->mr_mode = opts.mr_mode;
base_hints = hints;
ret = av_removal_test();
if (ret && ret != -FI_ENODATA)
goto out;
if (opts.dst_addr)
sleep(1);
ret = av_reinsert_test();
if (ret && ret != -FI_ENODATA)
goto out;
out:
return ft_exit_code(ret);
}
int main(int argc, char **argv)
{
int op;
int ret = 0;
opts = INIT_OPTS;
opts.transfer_size = 256;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "c:vh" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints);
break;
case 'c':
num_eps = atoi(optarg);
break;
case 'v':
opts.options |= FT_OPT_VERIFY_DATA;
break;
case '?':
case 'h':
ft_usage(argv[0], "Multi endpoint test");
FT_PRINT_OPTS_USAGE("-c <int>",
"number of endpoints to create and test (def 3)");
FT_PRINT_OPTS_USAGE("-v", "Enable DataCheck testing");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
ft_skip_mr = 1;
hints->caps = FI_MSG;
hints->mode = FI_CONTEXT;
ret = run_test();
free_ep_res();
ft_free_res();
return ft_exit_code(ret);
}
void ft_parsecsopts(int op, char *optarg, struct ft_opts *opts)
{
ft_parse_addr_opts(op, optarg, opts);
switch (op) {
case 'I':
opts->options |= FT_OPT_ITER;
opts->iterations = atoi(optarg);
break;
case 'S':
if (!strncasecmp("all", optarg, 3)) {
opts->sizes_enabled = FT_ENABLE_ALL;
} else {
opts->options |= FT_OPT_SIZE;
opts->transfer_size = atoi(optarg);
}
break;
case 'm':
opts->machr = 1;
break;
case 'c':
if (!strncasecmp("sread", optarg, 5))
opts->comp_method = FT_COMP_SREAD;
else if (!strncasecmp("fd", optarg, 2))
opts->comp_method = FT_COMP_WAIT_FD;
break;
case 't':
if (!strncasecmp("counter", optarg, 7)) {
opts->options |= FT_OPT_RX_CNTR | FT_OPT_TX_CNTR;
opts->options &= ~(FT_OPT_RX_CQ | FT_OPT_TX_CQ);
}
break;
case 'a':
opts->av_name = optarg;
break;
case 'w':
opts->warmup_iterations = atoi(optarg);
break;
case 'l':
opts->options |= FT_OPT_ALIGN;
break;
default:
/* let getopt handle unknown opts*/
break;
}
}
int main(int argc, char **argv)
{
int op, ret = 0;
opts = INIT_OPTS;
opts.options |= FT_OPT_SIZE;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints);
break;
case '?':
case 'h':
ft_usage(argv[0], "A client-server example that uses poll.\n");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_RDM;
hints->caps = FI_MSG;
hints->mode = FI_CONTEXT | FI_LOCAL_MR;
ret = init_fabric();
if (ret)
return -ret;
ret = init_av();
if (ret)
return ret;
/* Exchange data */
ret = send_recv();
ft_free_res();
return ret;
}
int main(int argc, char **argv)
{
int op, ret;
opts = INIT_OPTS;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints);
break;
case '?':
case 'h':
ft_usage(argv[0], "A simple RDM client-sever example.");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_RDM;
hints->caps = FI_MSG;
hints->mode = FI_CONTEXT;
/* Fabric initialization */
ret = init_fabric();
if(ret)
return -ret;
/* Exchange data */
ret = send_recv();
free_ep_res();
fi_close(&dom->fid);
fi_close(&fab->fid);
fi_freeinfo(hints);
fi_freeinfo(fi);
return ret;
}
int main(int argc, char **argv)
{
int op, ret;
opts = INIT_OPTS;
opts.options |= FT_OPT_SIZE;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "q:h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
case 'q':
sock_service = optarg;
break;
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints);
break;
case '?':
case 'h':
ft_usage(argv[0],
"A MSG client-sever example that uses CM data.");
FT_PRINT_OPTS_USAGE("-q <service_port>", "management port");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_MSG;
hints->caps = FI_MSG;
hints->mode = FI_LOCAL_MR;
ft_skip_mr = 1;
ret = run();
ft_free_res();
return -ret;
}
int main(int argc, char **argv)
{
int op, ret;
opts = INIT_OPTS;
opts.options |= FT_OPT_SIZE;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints);
break;
case '?':
case 'h':
ft_usage(argv[0], "An RDM client-server example that uses shared context.\n");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_RDM;
hints->caps = FI_MSG | FI_NAMED_RX_CTX;
hints->mode = FI_CONTEXT | FI_LOCAL_MR;
hints->addr_format = FI_SOCKADDR;
ret = run();
FT_CLOSEV_FID(ep_array, ep_cnt);
FT_CLOSE_FID(srx_ctx);
FT_CLOSE_FID(stx_ctx);
ft_free_res();
free(addr_array);
free(ep_array);
return -ret;
}
int main(int argc, char **argv)
{
int op, ret;
opts = INIT_OPTS;
opts.options |= FT_OPT_SIZE;
opts.comp_method = FT_COMP_SREAD;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints);
break;
case '?':
case 'h':
ft_usage(argv[0], "A client-server example that transfers CQ data.\n");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->domain_attr->cq_data_size = 4; /* required minimum */
hints->ep_attr->type = FI_EP_MSG;
hints->caps = FI_MSG;
hints->mode = FI_LOCAL_MR;
cq_attr.format = FI_CQ_FORMAT_DATA;
ret = run();
ft_free_res();
return -ret;
}
int main(int argc, char **argv)
{
int op, ret;
opts = INIT_OPTS;
opts.options |= FT_OPT_SIZE;
opts.comp_method = FT_COMP_WAIT_FD;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints);
break;
case '?':
case 'h':
ft_usage(argv[0], "A simple MSG client-sever example that "
"demonstrates one possible usage of the underlying "
"cq wait objects.");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_MSG;
hints->caps = FI_MSG;
hints->domain_attr->mr_mode = FI_MR_LOCAL | OFI_MR_BASIC_MAP;
ret = run();
ft_free_res();
close(epfd);
return ft_exit_code(ret);
}
int main(int argc, char **argv)
{
int ret, op;
opts = INIT_OPTS;
opts.options |= FT_OPT_SIZE;
opts.comp_method = FT_COMP_SREAD;
hints = fi_allocinfo();
if (!hints) {
FT_PRINTERR("fi_allocinfo", -FI_ENOMEM);
return EXIT_FAILURE;
}
while ((op = getopt(argc, argv, "h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints);
break;
case '?':
case 'h':
ft_usage(argv[0], "An RDM client-server example that uses tagged search.\n");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->rx_attr->total_buffered_recv = 1024;
hints->ep_attr->type = FI_EP_RDM;
hints->caps = FI_MSG | FI_TAGGED;
hints->mode = FI_CONTEXT | FI_LOCAL_MR;
ret = run();
ft_free_res();
return -ret;
}
int main(int argc, char **argv)
{
int ret, op;
opts = INIT_OPTS;
opts.options = FT_OPT_SIZE;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints);
break;
case '?':
case 'h':
ft_usage(argv[0], "An RDM client-server example with scalable endpoints.\n");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_RDM;
hints->caps = FI_MSG | FI_NAMED_RX_CTX;
hints->mode = FI_LOCAL_MR;
ret = run();
free_res();
/* Closes the scalable ep that was allocated in the test */
FT_CLOSE_FID(sep);
ft_free_res();
return -ret;
}
int main(int argc, char **argv)
{
int op, ret = 0;
opts = INIT_OPTS;
opts.options |= FT_OPT_SIZE;
opts.comp_method = FT_COMP_WAITSET;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints, &opts);
break;
case '?':
case 'h':
ft_usage(argv[0], "A DGRAM client-server example that uses waitset.\n");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_DGRAM;
hints->caps = FI_MSG;
hints->mode = FI_CONTEXT;
hints->domain_attr->mr_mode = opts.mr_mode;
ret = run();
ft_free_res();
return ft_exit_code(ret);
}
int main(int argc, char **argv)
{
int op, ret;
opts = INIT_OPTS;
opts.options |= FT_OPT_SIZE;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints);
break;
case '?':
case 'h':
ft_usage(argv[0], "A simple MSG client-sever example.");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_MSG;
hints->caps = FI_MSG;
hints->mode = FI_LOCAL_MR;
hints->addr_format = FI_SOCKADDR;
ret = run();
ft_free_res();
return -ret;
}
int main(int argc, char **argv)
{
int op, ret;
opts = INIT_OPTS;
opts.options = FT_OPT_SIZE | FT_OPT_RX_CNTR | FT_OPT_TX_CNTR;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints, &opts);
break;
case '?':
case 'h':
ft_usage(argv[0], "A simple RDM client-server RMA example.");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_RDM;
hints->caps = FI_MSG | FI_RMA | FI_RMA_EVENT;
hints->mode = FI_CONTEXT;
hints->domain_attr->mr_mode = opts.mr_mode;
ret = run_test();
ft_free_res();
return ft_exit_code(ret);
}
int main(int argc, char **argv)
{
int op;
int ret;
opts = INIT_OPTS;
opts.options |= FT_OPT_OOB_SYNC | FT_OPT_SKIP_MSG_ALLOC;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "m:i:c:vdSh" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints);
break;
case 'c':
concurrent_msgs = strtoul(optarg, NULL, 0);
break;
case 'i':
num_iters = strtoul(optarg, NULL, 0);
break;
case 'S':
opts.comp_method = FT_COMP_SREAD;
break;
case 'v':
opts.options |= FT_OPT_VERIFY_DATA;
break;
case 'm':
opts.transfer_size = strtoul(optarg, NULL, 0);
break;
case 'd':
send_data = true;
break;
case '?':
case 'h':
ft_usage(argv[0], "Unexpected message functional test");
FT_PRINT_OPTS_USAGE("-c <int>",
"Concurrent messages per iteration ");
FT_PRINT_OPTS_USAGE("-v", "Enable data verification");
FT_PRINT_OPTS_USAGE("-i <int>", "Number of iterations");
FT_PRINT_OPTS_USAGE("-S",
"Use fi_cq_sread instead of polling fi_cq_read");
FT_PRINT_OPTS_USAGE("-m <size>",
"Size of unexpected messages");
FT_PRINT_OPTS_USAGE("-d", "Send remote CQ data");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->mode = FI_CONTEXT;
hints->domain_attr->mr_mode = FI_MR_LOCAL | FI_MR_ALLOCATED;
hints->domain_attr->resource_mgmt = FI_RM_ENABLED;
hints->rx_attr->total_buffered_recv = 0;
hints->caps = FI_TAGGED;
ret = run_test();
ft_free_res();
return ft_exit_code(ret);
}
int main(int argc, char **argv)
{
int op;
int ret = 0;
opts = INIT_OPTS;
opts.tx_cq_size = max_opts;
opts.rx_cq_size = max_opts;
delay = 0;
tagged = 0;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "S:R:m:l:T:X:ActdjwvVh" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints, &opts);
break;
case 'S':
opts.tx_cq_size = strtoul(optarg, NULL, 0);
printf("send cq size: %d\n", (int) opts.tx_cq_size);
break;
case 'R':
opts.rx_cq_size = strtoul(optarg, NULL, 0);
printf("recv cq size: %d\n", (int) opts.rx_cq_size);
break;
case 'T':
hints->tx_attr->size = strtoul(optarg, NULL, 0);
printf("tx context size: %d\n", (int) hints->tx_attr->size);
break;
case 'X':
hints->rx_attr->size = strtoul(optarg, NULL, 0);
printf("rx context size: %d\n", (int) hints->rx_attr->size);
break;
case 'm':
max_opts = strtoul(optarg, NULL, 0);
printf("max_opts set to %d\n", max_opts);
break;
case 'j':
opts.options |= FT_OPT_CQ_SHARED;
printf("using single shared CQ\n");
break;
case 'l':
opts.transfer_size = strtoul(optarg, NULL, 0);
printf("Testing Message Size: %zu\n", opts.transfer_size);
break;
case 't':
tagged = 1;
hints->caps |= FI_TAGGED;
printf("tagged messaging enabled\n");
break;
case 'd':
delay = 1;
break;
case 'A':
hints->domain_attr->av_type = FI_AV_TABLE;
printf("AV TABLE enabled\n");
break;
case 'V':
opts.verbose = 1;
break;
case '?':
case 'h':
ft_usage(argv[0], "Resource Management Functional Test");
FT_PRINT_OPTS_USAGE("-S <int>", "Size of send CQ");
FT_PRINT_OPTS_USAGE("-R <int>", "Size of recv CQ");
FT_PRINT_OPTS_USAGE("-T <int>", "Number of TX Contexts");
FT_PRINT_OPTS_USAGE("-X <int>", "Number of RX Contexts");
FT_PRINT_OPTS_USAGE("-m <int>", "number of operations to post");
FT_PRINT_OPTS_USAGE("-l <int>", "message length to test");
FT_PRINT_OPTS_USAGE("-j", "Enable shared cq");
FT_PRINT_OPTS_USAGE("-t", "Enable tagged message testing");
FT_PRINT_OPTS_USAGE("-d", "Enable setting a delay");
FT_PRINT_OPTS_USAGE("-A", "Enable av table testing (only RDM/DGRAM EP)");
FT_PRINT_OPTS_USAGE("-V", "Enable verbose printing");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->caps = FI_MSG;
hints->mode = FI_CONTEXT;
hints->domain_attr->resource_mgmt = FI_RM_ENABLED;
ret = run_test();
ft_free_res();
return ft_exit_code(ret);
}
int main(int argc, char **argv)
{
char *service = "2710";
char *filename = NULL;
opts = INIT_OPTS;
int ret, op;
while ((op = getopt(argc, argv, "f:q:p:xy:z:h")) != -1) {
switch (op) {
case 'f':
filename = optarg;
break;
case 'q':
service = optarg;
break;
case 'x':
persistent = 0;
break;
case 'y':
test_start_index = atoi(optarg);
break;
case 'z':
test_end_index = atoi(optarg);
break;
default:
ft_parse_addr_opts(op, optarg, &opts);
case '?':
case 'h':
ft_fw_usage(argv[0]);
exit(1);
}
}
if (optind < argc - 1) {
ft_fw_usage(argv[0]);
exit(1);
}
opts.dst_addr = (optind == argc - 1) ? argv[optind] : NULL;
if (opts.dst_addr) {
series = fts_load(filename);
if (!series)
exit(1);
ret = ft_fw_connect(opts.dst_addr, service);
if (ret)
goto out;
ret = ft_fw_client();
ft_fw_shutdown(sock);
} else {
ret = ft_fw_listen(service);
if (ret)
goto out;
do {
sock = accept(listen_sock, NULL, 0);
if (sock < 0) {
ret = sock;
perror("accept");
}
op = 1;
setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
(void *) &op, sizeof(op));
ret = ft_fw_server();
ft_fw_shutdown(sock);
} while (persistent);
}
ft_fw_show_results();
out:
if (opts.dst_addr)
fts_close(series);
return ret;
}
int main(int argc, char **argv)
{
int op, ret;
int option_index = 0;
struct option long_options[] = {
{"no-tx-shared-ctx", no_argument, &tx_shared_ctx, 0},
{"no-rx-shared-ctx", no_argument, &rx_shared_ctx, 0},
{"ep-count", required_argument, 0, FT_EP_CNT},
{0, 0, 0, 0},
};
opts = INIT_OPTS;
opts.options |= FT_OPT_SIZE;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt_long(argc, argv, "h" ADDR_OPTS INFO_OPTS,
long_options, &option_index)) != -1) {
switch (op) {
case FT_EP_CNT:
ep_cnt = atoi(optarg);
if (ep_cnt <= 0) {
FT_ERR("ep_count needs to be greater than 0\n");
return EXIT_FAILURE;
}
hints->domain_attr->ep_cnt = ep_cnt;
break;
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints, &opts);
break;
case '?':
case 'h':
ft_usage(argv[0], "An RDM client-server example that uses"
" shared context.\n");
FT_PRINT_OPTS_USAGE("--no-tx-shared-ctx",
"Disable shared context for TX");
FT_PRINT_OPTS_USAGE("--no-rx-shared-ctx",
"Disable shared context for RX");
FT_PRINT_OPTS_USAGE("--ep-count <count> (default: 4)",
"# of endpoints to be opened");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->caps = FI_MSG;
hints->mode = FI_CONTEXT;
hints->domain_attr->mr_mode = opts.mr_mode;
if (tx_shared_ctx)
hints->ep_attr->tx_ctx_cnt = FI_SHARED_CONTEXT;
if (rx_shared_ctx)
hints->ep_attr->rx_ctx_cnt = FI_SHARED_CONTEXT;
ret = run();
FT_CLOSEV_FID(ep_array, ep_cnt);
if (rx_shared_ctx)
FT_CLOSE_FID(srx_ctx);
if (tx_shared_ctx)
FT_CLOSE_FID(stx_ctx);
ft_free_res();
free(addr_array);
free(ep_array);
fi_freeinfo(fi_dup);
return ft_exit_code(ret);
}
int main(int argc, char **argv)
{
char *node, *service;
uint64_t flags = 0;
struct fi_eq_attr eq_attr;
int op, ret;
opts = INIT_OPTS;
hints = fi_allocinfo();
if (!hints)
exit(1);
hints->caps = FI_MSG;
hints->ep_attr->type = FI_EP_MSG;
hints->mode = FI_LOCAL_MR;
hints->tx_attr->mode = hints->mode;
hints->rx_attr->mode = hints->mode;
hints->ep_attr->max_msg_size = 100;
hints->tx_attr->size = 10;
hints->rx_attr->size = 10;
while ((op = getopt(argc, argv, "c:C:S:h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
case 'c':
connections = atoi(optarg);
break;
case 'C':
hints->tx_attr->size = atoi(optarg);
hints->rx_attr->size = hints->tx_attr->size;
break;
case 'S':
hints->ep_attr->max_msg_size = atoi(optarg);
break;
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints);
break;
case '?':
case 'h':
usage(argv[0]);
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
connects_left = connections;
ret = ft_read_addr_opts(&node, &service, hints, &flags, &opts);
if (ret)
return ret;
ret = fi_getinfo(FT_FIVERSION, node, service, flags, hints, &info);
if (ret) {
FT_PRINTERR("fi_getinfo", ret);
goto exit0;
}
printf("using provider: %s\n", info->fabric_attr->prov_name);
ret = fi_fabric(info->fabric_attr, &fabric, NULL);
if (ret) {
FT_PRINTERR("fi_fabric", ret);
goto exit1;
}
memset(&eq_attr, 0, sizeof eq_attr);
eq_attr.wait_obj = FI_WAIT_UNSPEC;
ret = fi_eq_open(fabric, &eq_attr, &eq, NULL);
if (ret) {
FT_PRINTERR("fi_eq_open", ret);
goto exit2;
}
if (alloc_nodes())
goto exit3;
ret = opts.dst_addr ? run_client() : run_server();
printf("test complete\n");
destroy_nodes();
exit3:
fi_close(&eq->fid);
exit2:
fi_close(&fabric->fid);
exit1:
fi_freeinfo(info);
exit0:
fi_freeinfo(hints);
return -ret;
}
int main(int argc, char **argv)
{
char *node, *service;
uint64_t flags = 0;
int op, ret;
opts = INIT_OPTS;
hints = fi_allocinfo();
if (!hints)
exit(1);
hints->caps = FI_MSG;
hints->ep_attr->type = FI_EP_MSG;
hints->mode = FI_LOCAL_MR;
hints->tx_attr->mode = hints->mode;
hints->rx_attr->mode = hints->mode;
hints->ep_attr->max_msg_size = 100;
hints->tx_attr->size = 10;
hints->rx_attr->size = 10;
while ((op = getopt(argc, argv, "c:C:S:h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
case 'c':
connections = atoi(optarg);
break;
case 'C':
hints->tx_attr->size = atoi(optarg);
hints->rx_attr->size = hints->tx_attr->size;
break;
case 'S':
hints->ep_attr->max_msg_size = atoi(optarg);
break;
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints);
break;
case '?':
case 'h':
usage(argv[0]);
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
connects_left = connections;
ret = ft_read_addr_opts(&node, &service, hints, &flags, &opts);
if (ret)
goto out;
ret = fi_getinfo(FT_FIVERSION, node, service, flags, hints, &fi);
if (ret) {
FT_PRINTERR("fi_getinfo", ret);
goto out;
}
printf("using provider: %s\n", fi->fabric_attr->prov_name);
ret = ft_open_fabric_res();
if (ret)
goto out;
if (alloc_nodes())
goto out;
ret = opts.dst_addr ? run_client() : run_server();
printf("test complete\n");
destroy_nodes();
out:
ft_free_res();
return -ret;
}
int main(int argc, char *argv[])
{
uint64_t flags = 0;
char *service = NULL;
char *node = NULL;
struct pingpong_context *ctx;
struct timeval start, end;
unsigned long size = 4096;
// No provider support yet
//enum ibv_mtu mtu = IBV_MTU_1024;
//size_t mtu = 1024;
int rx_depth_default = 500;
int rx_depth = 0;
int iters = 1000;
int use_event = 0;
int rcnt, scnt;
int ret, rc = 0;
char * ptr;
srand48(getpid() * time(NULL));
opts = INIT_OPTS;
hints = fi_allocinfo();
if (!hints)
return 1;
while (1) {
int c;
c = getopt(argc, argv, "S:m:r:n:eh" ADDR_OPTS INFO_OPTS);
if (c == -1)
break;
switch (c) {
case 'S':
errno = 0;
size = strtol(optarg, &ptr, 10);
if (ptr == optarg || *ptr != '\0' ||
((size == LONG_MIN || size == LONG_MAX) && errno == ERANGE)) {
fprintf(stderr, "Cannot convert from string to long\n");
rc = 1;
goto err1;
}
break;
// No provider support yet
/*case 'm':
mtu = strtol(optarg, NULL, 0);
mtu = pp_mtu_to_enum(strtol(optarg, NULL, 0));
if (mtu < 0) {
usage(argv[0]);
return 1;
}
break;
*/
case 'r':
rx_depth = strtol(optarg, NULL, 0);
break;
case 'n':
iters = strtol(optarg, NULL, 0);
break;
case 'e':
++use_event;
break;
default:
ft_parse_addr_opts(c, optarg, &opts);
ft_parseinfo(c, optarg, hints);
break;
case '?':
case 'h':
usage(argv[0]);
return 1;
}
}
if (optind == argc - 1)
opts.dst_addr = argv[optind];
else if (optind < argc) {
usage(argv[0]);
return 1;
}
page_size = sysconf(_SC_PAGESIZE);
hints->ep_attr->type = FI_EP_MSG;
hints->caps = FI_MSG;
hints->mode = FI_LOCAL_MR;
rc = ft_read_addr_opts(&node, &service, hints, &flags, &opts);
if (rc)
return -rc;
rc = fi_getinfo(FT_FIVERSION, node, service, flags, hints, &fi);
if (rc) {
FT_PRINTERR("fi_getinfo", rc);
return -rc;
}
fi_freeinfo(hints);
if (rx_depth) {
if (rx_depth > fi->rx_attr->size) {
fprintf(stderr, "rx_depth requested: %d, "
"rx_depth supported: %zd\n", rx_depth, fi->rx_attr->size);
rc = 1;
goto err1;
}
} else {
rx_depth = (rx_depth_default > fi->rx_attr->size) ?
fi->rx_attr->size : rx_depth_default;
}
ctx = pp_init_ctx(fi, size, rx_depth, use_event);
if (!ctx) {
rc = 1;
goto err1;
}
if (opts.dst_addr) {
/* client connect */
if (pp_connect_ctx(ctx)) {
rc = 1;
goto err2;
}
} else {
/* server listen and accept */
pp_listen_ctx(ctx);
pp_accept_ctx(ctx);
}
ctx->pending = PINGPONG_RECV_WCID;
if (opts.dst_addr) {
if (pp_post_send(ctx)) {
fprintf(stderr, "Couldn't post send\n");
rc = 1;
goto err3;
}
ctx->pending |= PINGPONG_SEND_WCID;
}
if (gettimeofday(&start, NULL)) {
perror("gettimeofday");
rc = 1;
goto err3;
}
rcnt = scnt = 0;
while (rcnt < iters || scnt < iters) {
struct fi_cq_entry wc;
struct fi_cq_err_entry cq_err;
int rd;
if (use_event) {
/* Blocking read */
rd = fi_cq_sread(ctx->cq, &wc, 1, NULL, -1);
} else {
do {
rd = fi_cq_read(ctx->cq, &wc, 1);
} while (rd == -FI_EAGAIN);
}
if (rd < 0) {
fi_cq_readerr(ctx->cq, &cq_err, 0);
fprintf(stderr, "cq fi_cq_readerr() %s (%d)\n",
fi_cq_strerror(ctx->cq, cq_err.err, cq_err.err_data, NULL, 0),
cq_err.err);
rc = rd;
goto err3;
}
switch ((int) (uintptr_t) wc.op_context) {
case PINGPONG_SEND_WCID:
++scnt;
break;
case PINGPONG_RECV_WCID:
if (--ctx->routs <= 1) {
ctx->routs += pp_post_recv(ctx, ctx->rx_depth - ctx->routs);
if (ctx->routs < ctx->rx_depth) {
fprintf(stderr,
"Couldn't post receive (%d)\n",
ctx->routs);
rc = 1;
goto err3;
}
}
++rcnt;
break;
default:
fprintf(stderr, "Completion for unknown wc_id %d\n",
(int) (uintptr_t) wc.op_context);
rc = 1;
goto err3;
}
ctx->pending &= ~(int) (uintptr_t) wc.op_context;
if (scnt < iters && !ctx->pending) {
if (pp_post_send(ctx)) {
fprintf(stderr, "Couldn't post send\n");
rc = 1;
goto err3;
}
ctx->pending = PINGPONG_RECV_WCID | PINGPONG_SEND_WCID;
}
}
if (gettimeofday(&end, NULL)) {
perror("gettimeofday");
rc = 1;
goto err3;
}
{
float usec = (end.tv_sec - start.tv_sec) * 1000000 +
(end.tv_usec - start.tv_usec);
long long bytes = (long long) size * iters * 2;
printf("%lld bytes in %.2f seconds = %.2f Mbit/sec\n",
bytes, usec / 1000000., bytes * 8. / usec);
printf("%d iters in %.2f seconds = %.2f usec/iter\n",
iters, usec / 1000000., usec / iters);
}
err3:
fi_shutdown(ctx->ep, 0);
err2:
ret = pp_close_ctx(ctx);
if (!rc)
rc = ret;
err1:
fi_freeinfo(fi);
return rc;
}