void rdm_api_setup(void)
{
int i;
for (i = 0; i < NUMEPS; i++) {
hints[i] = fi_allocinfo();
cr_assert(hints[i], "fi_allocinfo");
hints[i]->domain_attr->cq_data_size = NUMEPS * 2;
hints[i]->domain_attr->data_progress = FI_PROGRESS_AUTO;
hints[i]->mode = ~0;
hints[i]->domain_attr->mr_mode = FI_MR_BASIC;
hints[i]->fabric_attr->name = strdup("gni");
}
}
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, ret;
int failed;
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);
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 err;
}
ret = ft_open_fabric_res();
if (ret)
goto err;
printf("Testing CQs 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");
}
err:
ft_free_res();
return ret ? ft_exit_code(ret) : (failed > 0) ? EXIT_FAILURE : EXIT_SUCCESS;
}
struct fi_info *sock_fi_info(enum fi_ep_type ep_type, struct fi_info *hints,
void *src_addr, void *dest_addr)
{
struct fi_info *info;
info = fi_allocinfo();
if (!info)
return NULL;
info->src_addr = calloc(1, sizeof(struct sockaddr_in));
info->mode = SOCK_MODE;
info->addr_format = FI_SOCKADDR_IN;
if (src_addr) {
memcpy(info->src_addr, src_addr, sizeof(struct sockaddr_in));
info->src_addrlen = sizeof(struct sockaddr_in);
}
if (dest_addr) {
info->dest_addr = calloc(1, sizeof(struct sockaddr_in));
info->dest_addrlen = sizeof(struct sockaddr_in);
memcpy(info->dest_addr, dest_addr, sizeof(struct sockaddr_in));
}
if (hints) {
if (hints->caps)
info->caps = hints->caps;
if (hints->ep_attr)
*(info->ep_attr) = *(hints->ep_attr);
if (hints->tx_attr)
*(info->tx_attr) = *(hints->tx_attr);
if (hints->rx_attr)
*(info->rx_attr) = *(hints->rx_attr);
}
info->ep_attr->type = ep_type;
*(info->domain_attr) = sock_domain_attr;
*(info->fabric_attr) = sock_fabric_attr;
info->domain_attr->name = strdup(sock_dom_name);
info->fabric_attr->name = strdup(sock_fab_name);
info->fabric_attr->prov_name = strdup(sock_prov_name);
return info;
}
static int fi_bgq_getinfo(uint32_t version, const char *node,
const char *service, uint64_t flags,
struct fi_info *hints, struct fi_info **info)
{
int ret;
struct fi_info *fi, *prev_fi, *curr;
if (!fi_bgq_count) {
errno = FI_ENODATA;
return -errno;
}
if (hints) {
ret = fi_bgq_check_info(hints);
if (ret) {
return ret;
}
if (!(fi = fi_allocinfo())) {
return -FI_ENOMEM;
}
if (fi_bgq_fillinfo(fi, node, service,
hints, flags)) {
return -errno;
}
*info = fi;
} else {
if(node || service) {
errno = FI_ENODATA;
return -errno;
} else {
curr = fi_bgq_global.info;
*info = curr;
prev_fi = NULL;
do {
if (!(fi = fi_dupinfo(curr))) {
return -FI_ENOMEM;
}
if (prev_fi) {
prev_fi->next = fi;
}
prev_fi = fi;
curr = curr->next;
} while(curr);
}
}
return 0;
}
void _setup(void)
{
int ret = 0;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo failed.");
hints->mode = ~0;
hints->fabric_attr->name = strdup("gni");
ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints, &fi);
cr_assert_eq(ret, FI_SUCCESS, "fi_getinfo failed.");
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
cr_assert_eq(ret, FI_SUCCESS, "fi_fabric failed.");
}
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);
}
void wait_setup(void)
{
int ret = 0;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
hints->mode = ~0;
hints->fabric_attr->prov_name = strdup("gni");
ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
}
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;
}
void vc_lookup_setup(int av_type, int av_size)
{
int ret = 0;
struct fi_av_attr attr;
hints = fi_allocinfo();
hints->mode = mode_bits;
hints->domain_attr->mr_mode = GNIX_DEFAULT_MR_MODE;
hints->fabric_attr->prov_name = strdup("gni");
/* Create endpoint */
ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
ret = fi_domain(fab, fi, &dom, NULL);
cr_assert(!ret, "fi_domain");
attr.type = av_type;
attr.count = av_size;
ret = fi_av_open(dom, &attr, &av, NULL);
cr_assert(!ret, "fi_av_open");
ret = fi_endpoint(dom, fi, &ep, NULL);
cr_assert(!ret, "fi_endpoint");
gnix_ep = container_of(ep, struct gnix_fid_ep, ep_fid);
ret = fi_getname(&ep->fid, NULL, &ep_name_len);
ret = fi_getname(&ep->fid, &ep_name, &ep_name_len);
cr_assert(ret == FI_SUCCESS);
ret = fi_ep_bind(ep, &av->fid, 0);
cr_assert(!ret, "fi_ep_bind");
ret = fi_enable(ep);
cr_assert(!ret, "fi_ep_enable");
fi_freeinfo(hints);
}
static void setup(void)
{
int ret;
struct fi_info *hints;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
hints->fabric_attr->name = strdup("gni");
ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints, &fi);
cr_assert(ret == FI_SUCCESS, "fi_getinfo");
ret = fi_fabric(fi->fabric_attr, &fabric, NULL);
cr_assert(ret == FI_SUCCESS, "fi_fabric");
fi_freeinfo(hints);
}
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;
}
static void setup(void)
{
int ret;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
hints->fabric_attr->prov_name = strdup("gni");
ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
ret = fi_domain(fab, fi, &dom, NULL);
cr_assert(!ret, "fi_domain");
}
int main(int argc, char **argv)
{
int op, ret;
opts = INIT_OPTS;
opts.transfer_size = 64;
hints = fi_allocinfo();
if (!hints) {
FT_PRINTERR("fi_allocinfo", -FI_ENOMEM);
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], "Ping pong client and server using inject.");
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;
if (opts.transfer_size)
hints->tx_attr->inject_size = opts.transfer_size;
else
hints->tx_attr->inject_size = 16;
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;
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;
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;
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);
}
/*
* Make a dummy info object for each provider, and copy in the
* provider name and version. We report utility providers directly
* to export their version.
*/
static int ofi_getprovinfo(struct fi_info **info)
{
struct ofi_prov *prov;
struct fi_info *tail, *cur;
int ret = -FI_ENODATA;
*info = tail = NULL;
for (prov = prov_head; prov; prov = prov->next) {
if (!prov->provider)
continue;
cur = fi_allocinfo();
if (!cur) {
ret = -FI_ENOMEM;
goto err;
}
cur->fabric_attr->prov_name = strdup(prov->provider->name);
cur->fabric_attr->prov_version = prov->provider->version;
if (!*info) {
*info = tail = cur;
} else {
tail->next = cur;
}
tail = cur;
ret = 0;
}
return ret;
err:
while (tail) {
cur = tail->next;
fi_freeinfo(tail);
tail = cur;
}
return ret;
}
static int ft_fw_client(void)
{
struct fi_info *hints, *info;
int ret;
hints = fi_allocinfo();
if (!hints)
return -FI_ENOMEM;
for (fts_start(series, test_start_index);
!fts_end(series, test_end_index);
fts_next(series)) {
fts_cur_info(series, &test_info);
ft_fw_convert_info(hints, &test_info);
printf("Starting test %d / %d\n", test_info.test_index, series->test_count);
ret = fi_getinfo(FT_FIVERSION, ft_strptr(test_info.node),
ft_strptr(test_info.service), 0, hints, &info);
if (ret) {
FT_PRINTERR("fi_getinfo", ret);
} else {
ret = ft_fw_process_list(hints, info);
fi_freeinfo(info);
}
if (ret) {
fprintf(stderr, "Node: %s\nService: %s\n",
test_info.node, test_info.service);
fprintf(stderr, "%s\n", fi_tostr(hints, FI_TYPE_INFO));
}
printf("Ending test %d / %d, result: %s\n",
test_info.test_index, series->test_count, fi_strerror(-ret));
results[ft_fw_result_index(-ret)]++;
}
fi_freeinfo(hints);
return 0;
}
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 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;
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_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);
}
static void _setup(uint32_t version)
{
int ret;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
if (FI_VERSION_LT(version, FI_VERSION(1, 5)))
hints->domain_attr->mr_mode = FI_MR_BASIC;
else
hints->domain_attr->mr_mode = GNIX_DEFAULT_MR_MODE;
hints->fabric_attr->prov_name = strdup("gni");
ret = fi_getinfo(version, NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
cr_assert(!ret, "fi_fabric");
ret = fi_domain(fab, fi, &dom, NULL);
cr_assert(!ret, "fi_domain");
}
void rdm_str_addr_sr_setup(void)
{
int ret = 0, i = 0;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
hints->domain_attr->mr_mode = GNIX_DEFAULT_MR_MODE;
hints->domain_attr->cq_data_size = NUMEPS * 2;
hints->mode = FI_CONTEXT;
hints->caps = FI_SOURCE | FI_MSG | FI_SOURCE | FI_SOURCE_ERR;
hints->fabric_attr->prov_name = strdup("gni");
hints->addr_format = FI_ADDR_STR;
/* Get info about fabric services with the provided hints */
for (; i < NUMEPS; i++) {
ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi[i]);
cr_assert(!ret, "fi_getinfo");
}
rdm_str_addr_sr_setup_common();
}
static void av_setup(void)
{
int ret = 0;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
hints->domain_attr->cq_data_size = 4;
hints->mode = ~0;
hints->fabric_attr->prov_name = strdup("gni");
ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints, &fi);
cr_assert_eq(ret, FI_SUCCESS, "fi_getinfo");
ret = fi_fabric(fi->fabric_attr, &fab, NULL);
cr_assert_eq(ret, FI_SUCCESS, "fi_fabric");
ret = fi_domain(fab, fi, &dom, NULL);
cr_assert_eq(ret, FI_SUCCESS, "fi_domain");
}
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, "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, &opts);
if (ret)
return ret;
break;
case '?':
case 'h':
ft_csusage(argv[0], "Streaming client-server using RMA operations between MSG endpoints.");
fprintf(stderr, " -o <op>\trma op type: read|write|writedata (default: write)]\n");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_MSG;
hints->caps = FI_MSG | FI_RMA;
hints->mode = FI_LOCAL_MR | FI_RX_CQ_DATA;
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;
}
