int main(int argc, char **argv)
{
int op, ret;
int failed = 0;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, FAB_OPTS "h")) != -1) {
switch (op) {
default:
ft_parseinfo(op, optarg, hints, &opts);
break;
case '?':
case 'h':
usage();
return EXIT_FAILURE;
}
}
hints->mode = ~0;
hints->domain_attr->mode = ~0;
hints->domain_attr->mr_mode = ~(FI_MR_BASIC | FI_MR_SCALABLE);
ret = fi_getinfo(FT_FIVERSION, NULL, 0, 0, hints, &fi);
if (ret) {
FT_PRINTERR("fi_getinfo", ret);
goto out;
}
if (!fi->domain_attr->cntr_cnt)
goto out;
ret = ft_open_fabric_res();
if (ret)
goto out;
printf("Testing CNTRS on fabric %s\n", fi->fabric_attr->name);
failed = run_tests(test_array, err_buf);
if (failed > 0)
printf("Summary: %d tests failed\n", failed);
else
printf("Summary: all tests passed\n");
out:
ft_free_res();
return ret ? ft_exit_code(ret) : (failed > 0) ? EXIT_FAILURE : EXIT_SUCCESS;
}
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);
}
int main(int argc, char **argv)
{
int ret, op;
opts = INIT_OPTS;
timeout = 5;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "hT:" CS_OPTS INFO_OPTS BENCHMARK_OPTS)) !=
-1) {
switch (op) {
case 'T':
timeout = atoi(optarg);
break;
default:
ft_parse_benchmark_opts(op, optarg);
ft_parseinfo(op, optarg, hints);
ft_parsecsopts(op, optarg, &opts);
break;
case '?':
case 'h':
ft_csusage(argv[0], "Ping pong client and server using UD.");
ft_benchmark_usage();
FT_PRINT_OPTS_USAGE("-T <timeout>",
"seconds before timeout on receive");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_DGRAM;
if (opts.options & FT_OPT_SIZE)
hints->ep_attr->max_msg_size = opts.transfer_size;
hints->caps = FI_MSG;
hints->domain_attr->mr_mode = FI_MR_LOCAL | OFI_MR_BASIC_MAP;
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 | FT_OPT_SKIP_REG_MR;
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->domain_attr->mr_mode = FI_MR_LOCAL | OFI_MR_BASIC_MAP;
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" CS_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parseinfo(op, optarg, hints);
ft_parsecsopts(op, optarg, &opts);
break;
case '?':
case 'h':
ft_csusage(argv[0], "Streaming RDM client-server using multi recv buffer.");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_RDM;
hints->caps = FI_MSG | FI_MULTI_RECV;
hints->mode = FI_CONTEXT;
hints->domain_attr->mr_mode = FI_MR_LOCAL | OFI_MR_BASIC_MAP;
cq_attr.format = FI_CQ_FORMAT_DATA;
ret = run();
free_res();
ft_free_res();
return ft_exit_code(ret);
}
int main(int argc, char **argv)
{
int op, ret;
opts = INIT_OPTS;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
hints->mode = FI_CONTEXT;
hints->caps = FI_MSG | FI_RMA;
hints->ep_attr->type = FI_EP_RDM;
hints->domain_attr->mr_mode = FI_MR_LOCAL | OFI_MR_BASIC_MAP;
while ((op = getopt(argc, argv, "ho:" CS_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parseinfo(op, optarg, hints);
ft_parsecsopts(op, optarg, &opts);
ret = ft_parse_rma_opts(op, optarg, hints, &opts);
if (ret)
return ret;
break;
case '?':
case 'h':
ft_csusage(argv[0], "Ping pong client and server using rma.");
fprintf(stderr, " -o <op>\trma op type: read|write|writedata (default: write)]\n");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
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;
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 op, ret;
opts = INIT_OPTS;
opts.options = FT_OPT_RX_CNTR | FT_OPT_TX_CNTR;
opts.comp_method = FT_COMP_SREAD;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "h" CS_OPTS INFO_OPTS BENCHMARK_OPTS)) != -1) {
switch (op) {
default:
ft_parse_benchmark_opts(op, optarg);
ft_parseinfo(op, optarg, hints);
ft_parsecsopts(op, optarg, &opts);
break;
case '?':
case 'h':
ft_csusage(argv[0], "Ping pong client and server using counters.");
ft_benchmark_usage();
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_RDM;
hints->caps = FI_MSG;
hints->domain_attr->mr_mode = FI_MR_LOCAL | OFI_MR_BASIC_MAP;
hints->domain_attr->threading = FI_THREAD_DOMAIN;
ret = run();
ft_free_res();
return ft_exit_code(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, &opts);
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->domain_attr->mr_mode = opts.mr_mode;
ret = run();
free_res();
/* Closes the scalable ep that was allocated in the test */
FT_CLOSE_FID(sep);
ft_free_res();
return ft_exit_code(ret);
}
int main(int argc, char **argv)
{
int op, ret;
opts = INIT_OPTS;
opts.options |= FT_OPT_BW;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "h" CS_OPTS INFO_OPTS BENCHMARK_OPTS)) != -1) {
switch (op) {
default:
ft_parse_benchmark_opts(op, optarg);
ft_parseinfo(op, optarg, hints);
ft_parsecsopts(op, optarg, &opts);
break;
case '?':
case 'h':
ft_csusage(argv[0], "Bandwidth test for MSG endpoints.");
ft_benchmark_usage();
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->resource_mgmt = FI_RM_ENABLED;
hints->domain_attr->mr_mode = FI_MR_LOCAL | OFI_MR_BASIC_MAP;
ret = run();
ft_free_res();
return ft_exit_code(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;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "h" CS_OPTS INFO_OPTS BENCHMARK_OPTS)) != -1) {
switch (op) {
default:
ft_parse_benchmark_opts(op, optarg);
ft_parseinfo(op, optarg, hints);
ft_parsecsopts(op, optarg, &opts);
break;
case '?':
case 'h':
ft_csusage(argv[0], "Ping pong client and server using tagged messages.");
ft_benchmark_usage();
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_RDM;
hints->caps = FI_TAGGED;
hints->mode = FI_CONTEXT;
hints->domain_attr->mr_mode = FI_MR_LOCAL | OFI_MR_BASIC_MAP;
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 | 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, 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)
{
int op, ret;
int failed = 0;
buf = NULL;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, FAB_OPTS "h")) != -1) {
switch (op) {
default:
ft_parseinfo(op, optarg, hints, &opts);
break;
case '?':
case 'h':
usage();
return EXIT_FAILURE;
}
}
hints->mode = ~0;
hints->domain_attr->mode = ~0;
hints->domain_attr->mr_mode = ~(FI_MR_BASIC | FI_MR_SCALABLE);
hints->caps |= FI_MSG | FI_RMA;
ret = fi_getinfo(FT_FIVERSION, NULL, 0, 0, hints, &fi);
if (ret) {
hints->caps &= ~FI_RMA;
ret = fi_getinfo(FT_FIVERSION, NULL, 0, 0, hints, &fi);
if (ret) {
FT_PRINTERR("fi_getinfo", ret);
goto out;
}
}
if (!ft_info_to_mr_access(fi))
goto out;
if (!fi->domain_attr->mr_iov_limit) {
ret = -FI_EINVAL;
FT_PRINTERR("mr_iov_limit not set", ret);
goto out;
}
ret = ft_open_fabric_res();
if (ret)
goto out;
buf = malloc(test_size[test_cnt - 1].size);
if (!buf) {
ret = -FI_ENOMEM;
goto out;
}
printf("Testing MR on fabric %s\n", fi->fabric_attr->name);
failed = run_tests(test_array, err_buf);
if (failed > 0) {
printf("Summary: %d tests failed\n", failed);
} else {
printf("Summary: all tests passed\n");
}
out:
ft_free_res();
return ret ? ft_exit_code(ret) : (failed > 0) ? EXIT_FAILURE : EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
return ft_exit_code(FI_ENODATA);
}
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)
{
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);
}
