int MPID_Comm_connect(const char *port_name, MPIR_Info * info, int root, MPIR_Comm * comm,
MPIR_Comm ** newcomm_ptr)
{
int mpi_errno = MPI_SUCCESS;
int timeout = MPIR_CVAR_CH4_COMM_CONNECT_TIMEOUT;
MPIR_FUNC_VERBOSE_STATE_DECL(MPID_STATE_MPID_COMM_CONNECT);
MPIR_FUNC_VERBOSE_ENTER(MPID_STATE_MPID_COMM_CONNECT);
if (info != NULL) {
int info_flag = 0;
char info_value[MPI_MAX_INFO_VAL + 1];
MPIR_Info_get_impl(info, "timeout", MPI_MAX_INFO_VAL, info_value, &info_flag);
if (info_flag) {
timeout = atoi(info_value);
}
}
mpi_errno = MPIDI_NM_mpi_comm_connect(port_name, info, root, timeout, comm, newcomm_ptr);
if (mpi_errno != MPI_SUCCESS) {
MPIR_ERR_POP(mpi_errno);
}
fn_exit:
MPIR_FUNC_VERBOSE_EXIT(MPID_STATE_MPID_COMM_CONNECT);
return mpi_errno;
fn_fail:
goto fn_exit;
}
static int mpi_to_pmi_keyvals( MPID_Info *info_ptr, PMI_keyval_t **kv_ptr,
int *nkeys_ptr )
{
char key[MPI_MAX_INFO_KEY];
PMI_keyval_t *kv = 0;
int i, nkeys = 0, vallen, flag, mpi_errno=MPI_SUCCESS;
if (!info_ptr || info_ptr->handle == MPI_INFO_NULL) {
goto fn_exit;
}
MPIR_Info_get_nkeys_impl( info_ptr, &nkeys );
if (nkeys == 0) {
goto fn_exit;
}
kv = (PMI_keyval_t *)MPIU_Malloc( nkeys * sizeof(PMI_keyval_t) );
if (!kv) { MPIU_ERR_POP(mpi_errno); }
for (i=0; i<nkeys; i++) {
mpi_errno = MPIR_Info_get_nthkey_impl( info_ptr, i, key );
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
MPIR_Info_get_valuelen_impl( info_ptr, key, &vallen, &flag );
MPIU_ERR_CHKANDJUMP1(!flag, mpi_errno, MPI_ERR_OTHER,"**infonokey", "**infonokey %s", key);
kv[i].key = MPIU_Strdup(key);
kv[i].val = MPIU_Malloc( vallen + 1 );
if (!kv[i].key || !kv[i].val) {
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**nomem" );
}
MPIR_Info_get_impl( info_ptr, key, vallen+1, kv[i].val, &flag );
MPIU_ERR_CHKANDJUMP1(!flag, mpi_errno, MPI_ERR_OTHER,"**infonokey", "**infonokey %s", key);
MPIU_DBG_PRINTF(("key: <%s>, value: <%s>\n", kv[i].key, kv[i].val));
}
fn_fail:
fn_exit:
*kv_ptr = kv;
*nkeys_ptr = nkeys;
return mpi_errno;
}
static int mpi_to_pmi_keyvals(MPIR_Info * info_ptr, PMI_keyval_t ** kv_ptr, int *nkeys_ptr)
{
char key[MPI_MAX_INFO_KEY];
PMI_keyval_t *kv = 0;
int i, nkeys = 0, vallen, flag, mpi_errno = MPI_SUCCESS;
MPIR_FUNC_VERBOSE_STATE_DECL(MPID_STATE_MPIDI_MPI_TO_PMI_KEYVALS);
MPIR_FUNC_VERBOSE_ENTER(MPID_STATE_MPIDI_MPI_TO_PMI_KEYVALS);
if (!info_ptr || info_ptr->handle == MPI_INFO_NULL)
goto fn_exit;
MPIR_Info_get_nkeys_impl(info_ptr, &nkeys);
if (nkeys == 0)
goto fn_exit;
kv = (PMI_keyval_t *) MPL_malloc(nkeys * sizeof(PMI_keyval_t), MPL_MEM_BUFFER);
for (i = 0; i < nkeys; i++) {
mpi_errno = MPIR_Info_get_nthkey_impl(info_ptr, i, key);
if (mpi_errno)
MPIR_ERR_POP(mpi_errno);
MPIR_Info_get_valuelen_impl(info_ptr, key, &vallen, &flag);
kv[i].key = (const char *) MPL_strdup(key);
kv[i].val = (char *) MPL_malloc(vallen + 1, MPL_MEM_BUFFER);
MPIR_Info_get_impl(info_ptr, key, vallen + 1, kv[i].val, &flag);
}
fn_exit:
*kv_ptr = kv;
*nkeys_ptr = nkeys;
MPIR_FUNC_VERBOSE_EXIT(MPID_STATE_MPIDI_MPI_TO_PMI_KEYVALS);
return mpi_errno;
fn_fail:
goto fn_exit;
}
int MPIR_Comm_split_type_impl(MPIR_Comm * comm_ptr, int split_type, int key,
MPIR_Info * info_ptr, MPIR_Comm ** newcomm_ptr)
{
int mpi_errno = MPI_SUCCESS;
/* Only MPI_COMM_TYPE_SHARED, MPI_UNDEFINED, and
* NEIGHBORHOOD are supported */
MPIR_Assert(split_type == MPI_COMM_TYPE_SHARED ||
split_type == MPI_UNDEFINED ||
split_type == MPIX_COMM_TYPE_NEIGHBORHOOD);
if (split_type == MPIX_COMM_TYPE_NEIGHBORHOOD) {
int flag;
char hintval[MPI_MAX_INFO_VAL+1];
/* We plan on dispatching different NEIGHBORHOOD support to
* different parts of MPICH, based on the key provided in the
* info object. Right now, the one NEIGHBORHOOD we support is
* "nbhd_common_dirname", implementation of which lives in ROMIO */
MPIR_Info_get_impl(info_ptr, "nbhd_common_dirname", MPI_MAX_INFO_VAL, hintval,
&flag);
if (flag) {
#ifdef HAVE_ROMIO
MPI_Comm dummycomm;
MPIR_Comm * dummycomm_ptr;
mpi_errno = MPIR_Comm_split_filesystem(comm_ptr->handle, key,
hintval, &dummycomm);
MPIR_Comm_get_ptr(dummycomm, dummycomm_ptr);
*newcomm_ptr = dummycomm_ptr;
goto fn_exit;
#endif
/* fall through to the "not supported" case if ROMIO was not
* enabled for some reason */
}
/* we don't work with other hints yet, but if we did (e.g.
* nbhd_network, nbhd_partition), we'd do so here */
/* In the mean time, the user passed in COMM_TYPE_NEIGHBORHOOD
* but did not give us an info we know how to work with.
* Throw up our hands and treat it like UNDEFINED. This will
* result in MPI_COMM_NULL being returned to the user. */
split_type = MPI_UNDEFINED;
}
if (MPIR_Comm_fns == NULL || MPIR_Comm_fns->split_type == NULL) {
int color = (split_type == MPI_COMM_TYPE_SHARED) ? comm_ptr->rank : MPI_UNDEFINED;
/* The default implementation is to either pass MPI_UNDEFINED
* or the local rank as the color (in which case a dup of
* MPI_COMM_SELF is returned) */
mpi_errno = MPIR_Comm_split_impl(comm_ptr, color, key, newcomm_ptr);
}
else {
mpi_errno =
MPIR_Comm_fns->split_type(comm_ptr, split_type, key, info_ptr, newcomm_ptr);
}
if (mpi_errno)
MPIR_ERR_POP(mpi_errno);
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}