static void psmx2_init_env(void)
{
if (getenv("OMPI_COMM_WORLD_RANK") || getenv("PMI_RANK"))
psmx2_env.name_server = 0;
fi_param_get_bool(&psmx2_prov, "name_server", &psmx2_env.name_server);
fi_param_get_bool(&psmx2_prov, "tagged_rma", &psmx2_env.tagged_rma);
fi_param_get_str(&psmx2_prov, "uuid", &psmx2_env.uuid);
fi_param_get_int(&psmx2_prov, "delay", &psmx2_env.delay);
fi_param_get_int(&psmx2_prov, "timeout", &psmx2_env.timeout);
fi_param_get_int(&psmx2_prov, "prog_interval", &psmx2_env.prog_interval);
fi_param_get_str(&psmx2_prov, "prog_affinity", &psmx2_env.prog_affinity);
}
static void rxd_init_env(void)
{
fi_param_get_int(&rxd_prov, "spin_count", &rxd_env.spin_count);
fi_param_get_bool(&rxd_prov, "retry", &rxd_env.retry);
fi_param_get_int(&rxd_prov, "max_peers", &rxd_env.max_peers);
fi_param_get_int(&rxd_prov, "max_unacked", &rxd_env.max_unacked);
}
static int efa_get_param_bool(char *param_name, char *param_str,
int *param_default)
{
int param, ret = FI_SUCCESS;
size_t len, ret_len;
char *param_help;
len = strlen(param_str) + 50;
param_help = calloc(1, len);
if (!param_help)
return -FI_ENOMEM;
ret_len = snprintf(param_help, len, "%s (default: %d)", param_str,
*param_default);
if (ret_len >= len) {
EFA_WARN(FI_LOG_EP_DATA,
"param_help string size insufficient!\n");
assert(0);
ret = -FI_ETOOSMALL;
goto out;
}
fi_param_define(&efa_prov, param_name, FI_PARAM_BOOL, param_help);
if (!fi_param_get_bool(&efa_prov, param_name, ¶m))
*param_default = param;
out:
free(param_help);
return ret;
}
/*
* Initialize all available memory monitors
*/
void ofi_monitor_init(void)
{
fastlock_init(&uffd_monitor->lock);
dlist_init(&uffd_monitor->list);
fi_param_define(NULL, "mr_cache_max_size", FI_PARAM_SIZE_T,
"Defines the total number of bytes for all memory"
" regions that may be tracked by the MR cache."
" Setting this will reduce the amount of memory"
" not actively in use that may be registered."
" (default: 0 no limit is enforced)");
fi_param_define(NULL, "mr_cache_max_count", FI_PARAM_SIZE_T,
"Defines the total number of memory regions that"
" may be store in the cache. Setting this will"
" reduce the number of registered regions, regardless"
" of their size, stored in the cache. Setting this"
" to zero will disable MR caching. (default: 1024)");
fi_param_define(NULL, "mr_cache_merge_regions", FI_PARAM_BOOL,
"If set to true, overlapping or adjacent memory"
" regions will be combined into a single, larger"
" region. Merging regions can reduce the cache"
" memory footprint, but can negatively impact"
" performance in some situations. (default: false)");
fi_param_get_size_t(NULL, "mr_cache_max_size", &cache_params.max_size);
fi_param_get_size_t(NULL, "mr_cache_max_count", &cache_params.max_cnt);
fi_param_get_bool(NULL, "mr_cache_merge_regions",
&cache_params.merge_regions);
if (!cache_params.max_size)
cache_params.max_size = SIZE_MAX;
}
int rxm_info_to_core(uint32_t version, const struct fi_info *hints,
struct fi_info *core_info)
{
int use_srx = 0;
rxm_info_to_core_mr_modes(version, hints, core_info);
core_info->mode |= FI_RX_CQ_DATA | FI_CONTEXT;
if (hints) {
core_info->caps = hints->caps & RXM_PASSTHRU_CAPS;
if (hints->caps & (FI_ATOMIC | FI_TAGGED))
core_info->caps |= FI_MSG | FI_SEND | FI_RECV;
/* FI_RMA cap is needed for large message transfer protocol */
if (core_info->caps & FI_MSG)
core_info->caps |= FI_RMA | FI_READ | FI_REMOTE_READ;
if (hints->domain_attr) {
core_info->domain_attr->caps |= hints->domain_attr->caps;
core_info->domain_attr->threading = hints->domain_attr->threading;
}
if (hints->tx_attr) {
core_info->tx_attr->msg_order = hints->tx_attr->msg_order;
core_info->tx_attr->comp_order = hints->tx_attr->comp_order;
}
if (hints->rx_attr) {
core_info->rx_attr->msg_order = hints->rx_attr->msg_order;
core_info->rx_attr->comp_order = hints->rx_attr->comp_order;
}
}
core_info->ep_attr->type = FI_EP_MSG;
if (!fi_param_get_bool(&rxm_prov, "use_srx", &use_srx) && use_srx) {
FI_DBG(&rxm_prov, FI_LOG_FABRIC,
"Requesting shared receive context from core provider\n");
core_info->ep_attr->rx_ctx_cnt = FI_SHARED_CONTEXT;
}
core_info->tx_attr->size = rxm_msg_tx_size;
core_info->rx_attr->size = rxm_msg_rx_size;
return 0;
}
int fi_ibv_init_info(void)
{
struct ibv_context **ctx_list;
struct fi_info *fi = NULL, *tail = NULL;
int ret = 0, i, num_devices, fork_unsafe = 0;
if (verbs_info)
return 0;
pthread_mutex_lock(&verbs_info_lock);
if (verbs_info)
goto unlock;
if (!fi_ibv_have_device()) {
VERBS_INFO(FI_LOG_FABRIC, "No RDMA devices found\n");
ret = -FI_ENODATA;
goto unlock;
}
fi_param_get_bool(NULL, "fork_unsafe", &fork_unsafe);
if (!fork_unsafe) {
FI_INFO(&fi_ibv_prov, FI_LOG_CORE, "Enabling IB fork support\n");
ret = ibv_fork_init();
if (ret) {
FI_WARN(&fi_ibv_prov, FI_LOG_CORE,
"Enabling IB fork support failed: %s (%d)\n",
strerror(ret), ret);
goto unlock;
}
} else {
FI_INFO(&fi_ibv_prov, FI_LOG_CORE, "Not enabling IB fork support\n");
}
ctx_list = rdma_get_devices(&num_devices);
if (!num_devices) {
VERBS_INFO_ERRNO(FI_LOG_FABRIC, "rdma_get_devices", errno);
ret = -errno;
goto unlock;
}
for (i = 0; i < num_devices; i++) {
ret = fi_ibv_alloc_info(ctx_list[i], &fi, &verbs_msg_domain);
if (!ret) {
if (!verbs_info)
verbs_info = fi;
else
tail->next = fi;
tail = fi;
ret = fi_ibv_alloc_info(ctx_list[i], &fi,
&verbs_rdm_domain);
if (!ret) {
tail->next = fi;
tail = fi;
}
}
}
ret = verbs_info ? 0 : ret;
rdma_free_devices(ctx_list);
unlock:
pthread_mutex_unlock(&verbs_info_lock);
return ret;
}
void fi_ini(void)
{
char *param_val = NULL;
pthread_mutex_lock(&common_locks.ini_lock);
if (ofi_init)
goto unlock;
ofi_ordered_provs_init();
fi_param_init();
fi_log_init();
ofi_osd_init();
ofi_pmem_init();
ofi_perf_init();
ofi_hook_init();
fi_param_define(NULL, "provider", FI_PARAM_STRING,
"Only use specified provider (default: all available)");
fi_param_define(NULL, "fork_unsafe", FI_PARAM_BOOL,
"Whether use of fork() may be unsafe for some providers"
" (default: no). Setting this to yes could improve"
" performance at the expense of making fork() potentially"
" unsafe");
fi_param_define(NULL, "universe_size", FI_PARAM_SIZE_T,
"Defines the maximum number of processes that will be"
" used by distribute OFI application. The provider uses"
" this to optimize resource allocations"
" (default: OFI service specific)");
fi_param_get_str(NULL, "provider", ¶m_val);
ofi_create_filter(&prov_filter, param_val);
#ifdef HAVE_LIBDL
int n = 0;
char **dirs;
char *provdir = NULL;
void *dlhandle;
/* If dlopen fails, assume static linking and just return
without error */
dlhandle = dlopen(NULL, RTLD_NOW);
if (dlhandle == NULL) {
goto libdl_done;
}
dlclose(dlhandle);
fi_param_define(NULL, "provider_path", FI_PARAM_STRING,
"Search for providers in specific path (default: "
PROVDLDIR ")");
fi_param_get_str(NULL, "provider_path", &provdir);
if (!provdir)
provdir = PROVDLDIR;
dirs = ofi_split_and_alloc(provdir, ":", NULL);
if (dirs) {
for (n = 0; dirs[n]; ++n) {
ofi_ini_dir(dirs[n]);
}
ofi_free_string_array(dirs);
}
libdl_done:
#endif
ofi_register_provider(PSM2_INIT, NULL);
ofi_register_provider(PSM_INIT, NULL);
ofi_register_provider(USNIC_INIT, NULL);
ofi_register_provider(MLX_INIT, NULL);
ofi_register_provider(GNI_INIT, NULL);
ofi_register_provider(BGQ_INIT, NULL);
ofi_register_provider(NETDIR_INIT, NULL);
ofi_register_provider(SHM_INIT, NULL);
ofi_register_provider(RXM_INIT, NULL);
ofi_register_provider(VERBS_INIT, NULL);
//ofi_register_provider(MRAIL_INIT, NULL);
ofi_register_provider(RSTREAM_INIT, NULL);
{
/* TODO: RXD is not stable for now. Disable it by default */
int enable_rxd = 0;
fi_param_define(NULL, "rxd_enable", FI_PARAM_BOOL,
"Enable RXD provider (default: no)");
fi_param_get_bool(NULL, "rxd_enable", &enable_rxd);
if (enable_rxd)
ofi_register_provider(RXD_INIT, NULL);
}
ofi_register_provider(UDP_INIT, NULL);
ofi_register_provider(SOCKETS_INIT, NULL);
ofi_register_provider(TCP_INIT, NULL);
ofi_init = 1;
unlock:
pthread_mutex_unlock(&common_locks.ini_lock);
}
