/*
* Add an enviroinment variable to the global list of variables
*/
int MPIE_Putenv( ProcessWorld *pWorld, const char *env_string )
{
EnvInfo *genv;
EnvData *p;
/* FIXME: This should be getGenv (so allocation/init in one place) */
if (!pWorld->genv) {
genv = (EnvInfo *)MPIU_Malloc( sizeof(EnvInfo) );
genv->includeAll = 1;
genv->envPairs = 0;
genv->envNames = 0;
pWorld->genv = genv;
}
genv = pWorld->genv;
p = (EnvData *)MPIU_Malloc( sizeof(EnvData) );
if (!p) return 1;
p->name = 0;
p->value = 0;
p->envvalue = (const char *)MPIU_Strdup( env_string );
if (!p->envvalue) return 1;
p->nextData = genv->envPairs;
genv->envPairs = p;
return 0;
}
static int restore_env(pid_t parent_pid, int rank)
{
FILE *f;
char env_filename[MAX_STR_LEN];
char var_val[MAX_STR_LEN];
int ret;
MPIU_Snprintf(env_filename, MAX_STR_LEN, "/tmp/hydra-env-file-%d:%d", parent_pid, rank);
f = fopen(env_filename, "r");
CHECK_ERR(!f, MPIU_Strerror (errno));
ret = unlink(env_filename);
CHECK_ERR(ret, MPIU_Strerror (errno));
while (fgets(var_val, MAX_STR_LEN, f)) {
size_t len = strlen(var_val);
/* remove newline */
if (var_val[len-1] == '\n')
var_val[len-1] = '\0';
ret = MPL_putenv(MPIU_Strdup(var_val));
CHECK_ERR(ret != 0, MPIU_Strerror (errno));
}
ret = fclose(f);
CHECK_ERR(ret, MPIU_Strerror (errno));
return 0;
}
int MPIR_Info_set_impl(MPID_Info *info_ptr, const char *key, const char *value)
{
int mpi_errno = MPI_SUCCESS;
MPID_Info *curr_ptr, *prev_ptr;
MPID_MPI_STATE_DECL(MPID_STATE_MPIR_INFO_SET_IMPL);
MPID_MPI_FUNC_ENTER(MPID_STATE_MPIR_INFO_SET_IMPL);
prev_ptr = info_ptr;
curr_ptr = info_ptr->next;
while (curr_ptr) {
if (!strncmp(curr_ptr->key, key, MPI_MAX_INFO_KEY)) {
/* Key already present; replace value */
MPIU_Free(curr_ptr->value);
curr_ptr->value = MPIU_Strdup(value);
break;
}
prev_ptr = curr_ptr;
curr_ptr = curr_ptr->next;
}
if (!curr_ptr) {
/* Key not present, insert value */
mpi_errno = MPIU_Info_alloc(&curr_ptr);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
/*printf( "Inserting new elm %x at %x\n", curr_ptr->id, prev_ptr->id );*/
prev_ptr->next = curr_ptr;
curr_ptr->key = MPIU_Strdup(key);
curr_ptr->value = MPIU_Strdup(value);
}
fn_exit:
MPID_MPI_FUNC_EXIT(MPID_STATE_MPIR_INFO_SET_IMPL);
return mpi_errno;
fn_fail:
goto fn_exit;
}
int MPIDI_PG_Create_from_string(const char * str, MPIDI_PG_t ** pg_pptr,
int *flag)
{
int mpi_errno = MPI_SUCCESS;
const char *p;
int vct_sz;
MPIDI_PG_t *existing_pg, *pg_ptr=0;
MPIDI_STATE_DECL(MPID_STATE_MPIDI_PG_CREATE_FROM_STRING);
MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_PG_CREATE_FROM_STRING);
/*printf( "PgCreateFromString: Creating pg from %s\n", str );
fflush(stdout); */
/* The pg_id is at the beginning of the string, so we can just pass
it to the find routine */
/* printf( "Looking for pg with id %s\n", str );fflush(stdout); */
mpi_errno = MPIDI_PG_Find((void *)str, &existing_pg);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
if (existing_pg != NULL) {
/* return the existing PG */
*pg_pptr = existing_pg;
*flag = 0;
/* Note that the memory for the pg_id is freed in the exit */
goto fn_exit;
}
*flag = 1;
/* Get the size from the string */
p = str;
while (*p) p++; p++;
vct_sz = atoi(p);
mpi_errno = MPIDI_PG_Create(vct_sz, (void *)str, pg_pptr);
if (mpi_errno != MPI_SUCCESS) {
MPIR_ERR_POP(mpi_errno);
}
pg_ptr = *pg_pptr;
pg_ptr->id = MPIU_Strdup( str );
/* Set up the functions to use strings to manage connection information */
MPIDI_PG_InitConnString( pg_ptr );
(*pg_ptr->connInfoFromString)( str, pg_ptr );
fn_exit:
MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_PG_CREATE_FROM_STRING);
return mpi_errno;
fn_fail:
goto fn_exit;
}
/* Handle the default info values */
static int fPMIInfoKey( ProcessApp *app, const char key[], const char val[] )
{
if (strcmp( key, "host" ) == 0) {
app->hostname = MPIU_Strdup( val );
}
else if (strcmp( key, "arch" ) == 0) {
app->arch = MPIU_Strdup( val );
}
else if (strcmp( key, "wdir" ) == 0) {
app->wdir = MPIU_Strdup( val );
}
else if (strcmp( key, "path" ) == 0) {
app->path = MPIU_Strdup( val );
}
else if (strcmp( key, "soft" ) == 0) {
MPIE_ParseSoftspec( val, &app->soft );
}
else {
/* FIXME: call user-specified info handler, if any.
Unspecified info keys are ignored */
}
return 0;
}
int MPIR_Info_dup_impl(MPID_Info *info_ptr, MPID_Info **new_info_ptr)
{
int mpi_errno = MPI_SUCCESS;
MPID_Info *curr_old, *curr_new;
*new_info_ptr = NULL;
if (!info_ptr) goto fn_exit;
/* Note that this routine allocates info elements one at a time.
In the multithreaded case, each allocation may need to acquire
and release the allocation lock. If that is ever a problem, we
may want to add an "allocate n elements" routine and execute this
it two steps: count and then allocate */
/* FIXME : multithreaded */
mpi_errno = MPIU_Info_alloc(&curr_new);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
*new_info_ptr = curr_new;
curr_old = info_ptr->next;
while (curr_old)
{
mpi_errno = MPIU_Info_alloc(&curr_new->next);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
curr_new = curr_new->next;
curr_new->key = MPIU_Strdup(curr_old->key);
curr_new->value = MPIU_Strdup(curr_old->value);
curr_old = curr_old->next;
}
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
int MPID_nem_lmt_vmsplice_start_recv(MPIDI_VC_t *vc, MPID_Request *rreq, MPID_IOV s_cookie)
{
int mpi_errno = MPI_SUCCESS;
int i;
int complete = 0;
struct lmt_vmsplice_node *node = NULL;
MPIDI_CH3I_VC *vc_ch = &vc->ch;
int pipe_fd;
MPIDI_STATE_DECL(MPID_STATE_MPID_NEM_LMT_VMSPLICE_START_RECV);
MPIDI_FUNC_ENTER(MPID_STATE_MPID_NEM_LMT_VMSPLICE_START_RECV);
if (vc_ch->lmt_recv_copy_buf_handle == NULL) {
MPIU_Assert(s_cookie.MPID_IOV_BUF != NULL);
vc_ch->lmt_recv_copy_buf_handle = MPIU_Strdup(s_cookie.MPID_IOV_BUF);
}
/* XXX DJG FIXME in a real version we would want to cache the fd on the vc
so that we don't have two open's on the critical path every time. */
pipe_fd = open(vc_ch->lmt_recv_copy_buf_handle, O_NONBLOCK|O_RDONLY);
MPIU_ERR_CHKANDJUMP1(pipe_fd < 0, mpi_errno, MPI_ERR_OTHER, "**open",
"**open %s", MPIU_Strerror(errno));
MPID_nem_lmt_send_CTS(vc, rreq, NULL, 0);
mpi_errno = populate_iov_from_req(rreq);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
mpi_errno = do_readv(rreq, pipe_fd, rreq->dev.iov, &rreq->dev.iov_offset,
&rreq->dev.iov_count, &complete);
/* push request if not complete for progress checks later */
if (!complete) {
node = MPIU_Malloc(sizeof(struct lmt_vmsplice_node));
node->pipe_fd = pipe_fd;
node->req = rreq;
node->next = outstanding_head;
outstanding_head = node;
++MPID_nem_local_lmt_pending;
}
fn_exit:
MPIDI_FUNC_EXIT(MPID_STATE_MPID_NEM_LMT_VMSPLICE_START_RECV);
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;
}
int MPID_nem_lmt_vmsplice_initiate_lmt(MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt, MPID_Request *sreq)
{
int mpi_errno = MPI_SUCCESS;
MPID_nem_pkt_lmt_rts_t * const rts_pkt = (MPID_nem_pkt_lmt_rts_t *)pkt;
MPIDI_CH3I_VC *vc_ch = &vc->ch;
int complete = 0;
MPIDI_STATE_DECL(MPID_STATE_MPID_NEM_LMT_VMSPLICE_INITIATE_LMT);
MPIDI_FUNC_ENTER(MPID_STATE_MPID_NEM_LMT_VMSPLICE_INITIATE_LMT);
/* re-use the same pipe per-pair,per-sender */
if (vc_ch->lmt_copy_buf_handle == NULL) {
int err;
char *pipe_name;
MPIDI_CH3I_VC *vc_ch = &vc->ch;
pipe_name = tempnam(NULL, "lmt_");
MPIU_ERR_CHKANDJUMP2(!pipe_name, mpi_errno, MPI_ERR_OTHER, "**tempnam",
"**tempnam %d %s", errno, MPIU_Strerror(errno));
vc_ch->lmt_copy_buf_handle = MPIU_Strdup(pipe_name);
/* XXX DJG hack */
#undef free
free(pipe_name);
err = mkfifo(vc_ch->lmt_copy_buf_handle, 0660);
MPIU_ERR_CHKANDJUMP2(err < 0, mpi_errno, MPI_ERR_OTHER, "**mkfifo",
"**mkfifo %d %s", errno, MPIU_Strerror(errno));
}
/* can't start sending data yet, need full RTS/CTS handshake */
MPID_nem_lmt_send_RTS(vc, rts_pkt, vc_ch->lmt_copy_buf_handle,
strlen(vc_ch->lmt_copy_buf_handle)+1);
fn_fail:
fn_exit:
MPIDI_FUNC_EXIT(MPID_STATE_MPID_NEM_LMT_VMSPLICE_INITIATE_LMT);
return mpi_errno;
}
int smpd_get_ccp_nodes(int *np, smpd_host_node_t **host_node_ptr_p)
{
smpd_host_node_t *host_node_ptr=NULL, **host_list_tail_p=NULL;
int smpd_node_cnt = 0, np_total, i;
char *p=NULL, *tok=NULL, *next_tok=NULL;
char seps[] = " ,\t\n";
smpd_enter_fn(FCNAME);
if(np == NULL){
smpd_err_printf("Error: Pointer to num procs is NULL\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
if(host_node_ptr_p == NULL){
smpd_err_printf("Error: Invalid pointer to host node ptr\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
host_list_tail_p = host_node_ptr_p;
*np = -1;
np_total = 0;
/* Get the CCP nodes list
* CCP_NODES = <NUM_OF_HOSTS> <HOST1> <NP_HOST1> <HOST2> <NP_HOST2> ...
*/
p = MPIU_Strdup(getenv("CCP_NODES"));
if(p == NULL){
smpd_err_printf("Error: Unable to get the list of CCP nodes\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_dbg_printf("CCP_NODES = %s\n", p);
tok = strtok_s(p, seps, &next_tok);
if(tok == NULL){
smpd_err_printf("Error: Unable to parse th list of CCP nodes\n");
MPIU_Free(p);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_node_cnt = atoi(tok);
for(i=0; i<smpd_node_cnt; i++){
char *host;
int np_host;
host = strtok_s(NULL, seps, &next_tok);
if(host == NULL){
smpd_err_printf("Error: Unable to parse the list of CCP nodes\n");
MPIU_Free(p);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
tok = strtok_s(NULL, seps, &next_tok);
if(tok == NULL){
smpd_err_printf("Error: Unable to parse the list of CCP nodes\n");
MPIU_Free(p);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
np_host = atoi(tok);
np_total += np_host;
/* Allocate memory & set node name */
host_node_ptr = (smpd_host_node_t *)MPIU_Malloc(sizeof(smpd_host_node_t));
if(host_node_ptr == NULL){
smpd_err_printf("Unable to allocate memory for smpd host node \n");
MPIU_Free(p);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
host_node_ptr->next = NULL;
host_node_ptr->left = NULL;
host_node_ptr->right = NULL;
host_node_ptr->connected = SMPD_FALSE;
host_node_ptr->connect_cmd_tag = -1;
host_node_ptr->nproc = np_host;
host_node_ptr->alt_host[0] = '\0';
MPIU_Strncpy(host_node_ptr->host, host, SMPD_MAX_HOST_LENGTH);
/* Add the node to the tail of the list */
*host_list_tail_p = host_node_ptr;
host_list_tail_p = &(host_node_ptr->next);
}
*np = np_total;
MPIU_Free(p);
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
int MPIR_Param_init_params(void)
{
int mpi_errno = MPI_SUCCESS;
int rc;
const char *tmp_str;
static int initialized = FALSE;
/* FIXME any MT issues here? */
if (initialized)
return MPI_SUCCESS;
initialized = TRUE;
rc = MPL_env2int("MPICH_ALLTOALL_SHORT_MSG_SIZE", &(MPIR_PARAM_ALLTOALL_SHORT_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_ALLTOALL_SHORT_MSG_SIZE");
rc = MPL_env2int("MPIR_PARAM_ALLTOALL_SHORT_MSG_SIZE", &(MPIR_PARAM_ALLTOALL_SHORT_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_ALLTOALL_SHORT_MSG_SIZE");
rc = MPL_env2int("MPICH_ALLTOALL_MEDIUM_MSG_SIZE", &(MPIR_PARAM_ALLTOALL_MEDIUM_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_ALLTOALL_MEDIUM_MSG_SIZE");
rc = MPL_env2int("MPIR_PARAM_ALLTOALL_MEDIUM_MSG_SIZE", &(MPIR_PARAM_ALLTOALL_MEDIUM_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_ALLTOALL_MEDIUM_MSG_SIZE");
rc = MPL_env2int("MPICH_ALLTOALL_THROTTLE", &(MPIR_PARAM_ALLTOALL_THROTTLE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_ALLTOALL_THROTTLE");
rc = MPL_env2int("MPIR_PARAM_ALLTOALL_THROTTLE", &(MPIR_PARAM_ALLTOALL_THROTTLE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_ALLTOALL_THROTTLE");
rc = MPL_env2int("MPICH_REDSCAT_COMMUTATIVE_LONG_MSG_SIZE", &(MPIR_PARAM_REDSCAT_COMMUTATIVE_LONG_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_REDSCAT_COMMUTATIVE_LONG_MSG_SIZE");
rc = MPL_env2int("MPIR_PARAM_REDSCAT_COMMUTATIVE_LONG_MSG_SIZE", &(MPIR_PARAM_REDSCAT_COMMUTATIVE_LONG_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_REDSCAT_COMMUTATIVE_LONG_MSG_SIZE");
rc = MPL_env2int("MPICH_BCAST_MIN_PROCS", &(MPIR_PARAM_BCAST_MIN_PROCS));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_BCAST_MIN_PROCS");
rc = MPL_env2int("MPIR_PARAM_BCAST_MIN_PROCS", &(MPIR_PARAM_BCAST_MIN_PROCS));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_BCAST_MIN_PROCS");
rc = MPL_env2int("MPICH_BCAST_SHORT_MSG_SIZE", &(MPIR_PARAM_BCAST_SHORT_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_BCAST_SHORT_MSG_SIZE");
rc = MPL_env2int("MPIR_PARAM_BCAST_SHORT_MSG_SIZE", &(MPIR_PARAM_BCAST_SHORT_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_BCAST_SHORT_MSG_SIZE");
rc = MPL_env2int("MPICH_BCAST_LONG_MSG_SIZE", &(MPIR_PARAM_BCAST_LONG_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_BCAST_LONG_MSG_SIZE");
rc = MPL_env2int("MPIR_PARAM_BCAST_LONG_MSG_SIZE", &(MPIR_PARAM_BCAST_LONG_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_BCAST_LONG_MSG_SIZE");
rc = MPL_env2int("MPICH_ALLGATHER_SHORT_MSG_SIZE", &(MPIR_PARAM_ALLGATHER_SHORT_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_ALLGATHER_SHORT_MSG_SIZE");
rc = MPL_env2int("MPIR_PARAM_ALLGATHER_SHORT_MSG_SIZE", &(MPIR_PARAM_ALLGATHER_SHORT_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_ALLGATHER_SHORT_MSG_SIZE");
rc = MPL_env2int("MPICH_ALLGATHER_LONG_MSG_SIZE", &(MPIR_PARAM_ALLGATHER_LONG_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_ALLGATHER_LONG_MSG_SIZE");
rc = MPL_env2int("MPIR_PARAM_ALLGATHER_LONG_MSG_SIZE", &(MPIR_PARAM_ALLGATHER_LONG_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_ALLGATHER_LONG_MSG_SIZE");
rc = MPL_env2int("MPICH_REDUCE_SHORT_MSG_SIZE", &(MPIR_PARAM_REDUCE_SHORT_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_REDUCE_SHORT_MSG_SIZE");
rc = MPL_env2int("MPIR_PARAM_REDUCE_SHORT_MSG_SIZE", &(MPIR_PARAM_REDUCE_SHORT_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_REDUCE_SHORT_MSG_SIZE");
rc = MPL_env2int("MPICH_ALLREDUCE_SHORT_MSG_SIZE", &(MPIR_PARAM_ALLREDUCE_SHORT_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_ALLREDUCE_SHORT_MSG_SIZE");
rc = MPL_env2int("MPIR_PARAM_ALLREDUCE_SHORT_MSG_SIZE", &(MPIR_PARAM_ALLREDUCE_SHORT_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_ALLREDUCE_SHORT_MSG_SIZE");
rc = MPL_env2int("MPICH_GATHER_VSMALL_MSG_SIZE", &(MPIR_PARAM_GATHER_VSMALL_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_GATHER_VSMALL_MSG_SIZE");
rc = MPL_env2int("MPIR_PARAM_GATHER_VSMALL_MSG_SIZE", &(MPIR_PARAM_GATHER_VSMALL_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_GATHER_VSMALL_MSG_SIZE");
rc = MPL_env2int("MPICH_GATHER_INTER_SHORT_MSG_SIZE", &(MPIR_PARAM_GATHER_INTER_SHORT_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_GATHER_INTER_SHORT_MSG_SIZE");
rc = MPL_env2int("MPIR_PARAM_GATHER_INTER_SHORT_MSG_SIZE", &(MPIR_PARAM_GATHER_INTER_SHORT_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_GATHER_INTER_SHORT_MSG_SIZE");
rc = MPL_env2int("MPICH_GATHERV_MIN_PROCS", &(MPIR_PARAM_GATHERV_INTER_SSEND_MIN_PROCS));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_GATHERV_MIN_PROCS");
rc = MPL_env2int("MPICH_GATHERV_INTER_SSEND_MIN_PROCS", &(MPIR_PARAM_GATHERV_INTER_SSEND_MIN_PROCS));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_GATHERV_INTER_SSEND_MIN_PROCS");
rc = MPL_env2int("MPIR_PARAM_GATHERV_INTER_SSEND_MIN_PROCS", &(MPIR_PARAM_GATHERV_INTER_SSEND_MIN_PROCS));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_GATHERV_INTER_SSEND_MIN_PROCS");
rc = MPL_env2int("MPICH_SCATTER_INTER_SHORT_MSG_SIZE", &(MPIR_PARAM_SCATTER_INTER_SHORT_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_SCATTER_INTER_SHORT_MSG_SIZE");
rc = MPL_env2int("MPIR_PARAM_SCATTER_INTER_SHORT_MSG_SIZE", &(MPIR_PARAM_SCATTER_INTER_SHORT_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_SCATTER_INTER_SHORT_MSG_SIZE");
rc = MPL_env2int("MPICH_ALLGATHERV_PIPELINE_MSG_SIZE", &(MPIR_PARAM_ALLGATHERV_PIPELINE_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_ALLGATHERV_PIPELINE_MSG_SIZE");
rc = MPL_env2int("MPIR_PARAM_ALLGATHERV_PIPELINE_MSG_SIZE", &(MPIR_PARAM_ALLGATHERV_PIPELINE_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_ALLGATHERV_PIPELINE_MSG_SIZE");
rc = MPL_env2bool("MPICH_COMM_SPLIT_USE_QSORT", &(MPIR_PARAM_COMM_SPLIT_USE_QSORT));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_COMM_SPLIT_USE_QSORT");
rc = MPL_env2bool("MPIR_PARAM_COMM_SPLIT_USE_QSORT", &(MPIR_PARAM_COMM_SPLIT_USE_QSORT));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_COMM_SPLIT_USE_QSORT");
rc = MPL_env2bool("MPICH_RMA_ACC_IMMED", &(MPIR_PARAM_RMA_ACC_IMMED));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_RMA_ACC_IMMED");
rc = MPL_env2bool("MPIR_PARAM_RMA_ACC_IMMED", &(MPIR_PARAM_RMA_ACC_IMMED));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_RMA_ACC_IMMED");
rc = MPL_env2int("MPICH_RMA_NREQUEST_THRESHOLD", &(MPIR_PARAM_RMA_NREQUEST_THRESHOLD));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_RMA_NREQUEST_THRESHOLD");
rc = MPL_env2int("MPIR_PARAM_RMA_NREQUEST_THRESHOLD", &(MPIR_PARAM_RMA_NREQUEST_THRESHOLD));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_RMA_NREQUEST_THRESHOLD");
rc = MPL_env2int("MPICH_RMA_NREQUEST_NEW_THRESHOLD", &(MPIR_PARAM_RMA_NREQUEST_NEW_THRESHOLD));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_RMA_NREQUEST_NEW_THRESHOLD");
rc = MPL_env2int("MPIR_PARAM_RMA_NREQUEST_NEW_THRESHOLD", &(MPIR_PARAM_RMA_NREQUEST_NEW_THRESHOLD));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_RMA_NREQUEST_NEW_THRESHOLD");
rc = MPL_env2bool("MPICH_RMA_LOCK_IMMED", &(MPIR_PARAM_RMA_LOCK_IMMED));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_RMA_LOCK_IMMED");
rc = MPL_env2bool("MPIR_PARAM_RMA_LOCK_IMMED", &(MPIR_PARAM_RMA_LOCK_IMMED));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_RMA_LOCK_IMMED");
rc = MPL_env2bool("MPICH_RMA_MERGE_LOCK_OP_UNLOCK", &(MPIR_PARAM_RMA_MERGE_LOCK_OP_UNLOCK));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_RMA_MERGE_LOCK_OP_UNLOCK");
rc = MPL_env2bool("MPIR_PARAM_RMA_MERGE_LOCK_OP_UNLOCK", &(MPIR_PARAM_RMA_MERGE_LOCK_OP_UNLOCK));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_RMA_MERGE_LOCK_OP_UNLOCK");
rc = MPL_env2bool("MPICH_NO_LOCAL", &(MPIR_PARAM_NOLOCAL));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_NO_LOCAL");
rc = MPL_env2bool("MPIR_PARAM_NO_LOCAL", &(MPIR_PARAM_NOLOCAL));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_NO_LOCAL");
rc = MPL_env2bool("MPICH_NOLOCAL", &(MPIR_PARAM_NOLOCAL));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_NOLOCAL");
rc = MPL_env2bool("MPIR_PARAM_NOLOCAL", &(MPIR_PARAM_NOLOCAL));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_NOLOCAL");
rc = MPL_env2bool("MPICH_EVEN_ODD_CLIQUES", &(MPIR_PARAM_ODD_EVEN_CLIQUES));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_EVEN_ODD_CLIQUES");
rc = MPL_env2bool("MPIR_PARAM_EVEN_ODD_CLIQUES", &(MPIR_PARAM_ODD_EVEN_CLIQUES));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_EVEN_ODD_CLIQUES");
rc = MPL_env2bool("MPICH_ODD_EVEN_CLIQUES", &(MPIR_PARAM_ODD_EVEN_CLIQUES));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_ODD_EVEN_CLIQUES");
rc = MPL_env2bool("MPIR_PARAM_ODD_EVEN_CLIQUES", &(MPIR_PARAM_ODD_EVEN_CLIQUES));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_ODD_EVEN_CLIQUES");
rc = MPL_env2int("MPICH_POLLS_BEFORE_YIELD", &(MPIR_PARAM_POLLS_BEFORE_YIELD));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_POLLS_BEFORE_YIELD");
rc = MPL_env2int("MPIR_PARAM_POLLS_BEFORE_YIELD", &(MPIR_PARAM_POLLS_BEFORE_YIELD));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_POLLS_BEFORE_YIELD");
rc = MPL_env2bool("MPICH_MEMDUMP", &(MPIR_PARAM_MEMDUMP));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_MEMDUMP");
rc = MPL_env2bool("MPIR_PARAM_MEMDUMP", &(MPIR_PARAM_MEMDUMP));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_MEMDUMP");
rc = MPL_env2int("MPICH_PROCTABLE_SIZE", &(MPIR_PARAM_PROCTABLE_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_PROCTABLE_SIZE");
rc = MPL_env2int("MPIR_PARAM_PROCTABLE_SIZE", &(MPIR_PARAM_PROCTABLE_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_PROCTABLE_SIZE");
rc = MPL_env2bool("MPICH_PROCTABLE_PRINT", &(MPIR_PARAM_PROCTABLE_PRINT));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_PROCTABLE_PRINT");
rc = MPL_env2bool("MPIR_PARAM_PROCTABLE_PRINT", &(MPIR_PARAM_PROCTABLE_PRINT));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_PROCTABLE_PRINT");
rc = MPL_env2bool("MPICH_ERROR_CHECKING", &(MPIR_PARAM_ERROR_CHECKING));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_ERROR_CHECKING");
rc = MPL_env2bool("MPIR_PARAM_ERROR_CHECKING", &(MPIR_PARAM_ERROR_CHECKING));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_ERROR_CHECKING");
rc = MPL_env2bool("MPICH_PRINT_ERROR_STACK", &(MPIR_PARAM_PRINT_ERROR_STACK));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_PRINT_ERROR_STACK");
rc = MPL_env2bool("MPIR_PARAM_PRINT_ERROR_STACK", &(MPIR_PARAM_PRINT_ERROR_STACK));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_PRINT_ERROR_STACK");
rc = MPL_env2int("MPICH_CHOP_ERROR_STACK", &(MPIR_PARAM_CHOP_ERROR_STACK));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_CHOP_ERROR_STACK");
rc = MPL_env2int("MPIR_PARAM_CHOP_ERROR_STACK", &(MPIR_PARAM_CHOP_ERROR_STACK));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_CHOP_ERROR_STACK");
rc = MPL_env2int("MPICH_NEM_LMT_DMA_THRESHOLD", &(MPIR_PARAM_NEM_LMT_DMA_THRESHOLD));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_NEM_LMT_DMA_THRESHOLD");
rc = MPL_env2int("MPIR_PARAM_NEM_LMT_DMA_THRESHOLD", &(MPIR_PARAM_NEM_LMT_DMA_THRESHOLD));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_NEM_LMT_DMA_THRESHOLD");
MPIR_PARAM_GET_DEFAULT_STRING(NEMESIS_NETMOD, &tmp_str);
rc = MPL_env2str("MPICH_NEMESIS_NETMOD", &tmp_str);
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_NEMESIS_NETMOD");
rc = MPL_env2str("MPIR_PARAM_NEMESIS_NETMOD", &tmp_str);
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_NEMESIS_NETMOD");
if (tmp_str != NULL) {
MPIR_PARAM_NEMESIS_NETMOD = MPIU_Strdup(tmp_str);
MPIR_Param_assert(MPIR_PARAM_NEMESIS_NETMOD);
if (MPIR_PARAM_NEMESIS_NETMOD == NULL) {
MPIU_CHKMEM_SETERR(mpi_errno, strlen(tmp_str), "dup of string for MPIR_PARAM_NEMESIS_NETMOD");
goto fn_fail;
}
}
else {
MPIR_PARAM_NEMESIS_NETMOD = NULL;
}
MPIR_PARAM_GET_DEFAULT_STRING(INTERFACE_HOSTNAME, &tmp_str);
rc = MPL_env2str("MPICH_INTERFACE_HOSTNAME", &tmp_str);
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_INTERFACE_HOSTNAME");
rc = MPL_env2str("MPIR_PARAM_INTERFACE_HOSTNAME", &tmp_str);
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_INTERFACE_HOSTNAME");
if (tmp_str != NULL) {
MPIR_PARAM_INTERFACE_HOSTNAME = MPIU_Strdup(tmp_str);
MPIR_Param_assert(MPIR_PARAM_INTERFACE_HOSTNAME);
if (MPIR_PARAM_INTERFACE_HOSTNAME == NULL) {
MPIU_CHKMEM_SETERR(mpi_errno, strlen(tmp_str), "dup of string for MPIR_PARAM_INTERFACE_HOSTNAME");
goto fn_fail;
}
}
else {
MPIR_PARAM_INTERFACE_HOSTNAME = NULL;
}
MPIR_PARAM_GET_DEFAULT_STRING(NETWORK_IFACE, &tmp_str);
rc = MPL_env2str("MPICH_NETWORK_IFACE", &tmp_str);
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_NETWORK_IFACE");
rc = MPL_env2str("MPIR_PARAM_NETWORK_IFACE", &tmp_str);
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_NETWORK_IFACE");
if (tmp_str != NULL) {
MPIR_PARAM_NETWORK_IFACE = MPIU_Strdup(tmp_str);
MPIR_Param_assert(MPIR_PARAM_NETWORK_IFACE);
if (MPIR_PARAM_NETWORK_IFACE == NULL) {
MPIU_CHKMEM_SETERR(mpi_errno, strlen(tmp_str), "dup of string for MPIR_PARAM_NETWORK_IFACE");
goto fn_fail;
}
}
else {
MPIR_PARAM_NETWORK_IFACE = NULL;
}
rc = MPL_env2int("MPICH_HOST_LOOKUP_RETRIES", &(MPIR_PARAM_HOST_LOOKUP_RETRIES));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_HOST_LOOKUP_RETRIES");
rc = MPL_env2int("MPIR_PARAM_HOST_LOOKUP_RETRIES", &(MPIR_PARAM_HOST_LOOKUP_RETRIES));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_HOST_LOOKUP_RETRIES");
rc = MPL_env2int("MPICH_SHM_EAGER_MAX_SZ", &(MPIR_PARAM_SHM_EAGER_MAX_SZ));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_SHM_EAGER_MAX_SZ");
rc = MPL_env2int("MPIR_PARAM_SHM_EAGER_MAX_SZ", &(MPIR_PARAM_SHM_EAGER_MAX_SZ));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_SHM_EAGER_MAX_SZ");
rc = MPL_env2int("MPICH_SHM_READY_EAGER_MAX_SZ", &(MPIR_PARAM_SHM_READY_EAGER_MAX_SZ));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_SHM_READY_EAGER_MAX_SZ");
rc = MPL_env2int("MPIR_PARAM_SHM_READY_EAGER_MAX_SZ", &(MPIR_PARAM_SHM_READY_EAGER_MAX_SZ));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_SHM_READY_EAGER_MAX_SZ");
rc = MPL_env2bool("MPICH_COMM_OVERRIDES", &(MPIR_PARAM_COMM_OVERRIDES));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_COMM_OVERRIDES");
rc = MPL_env2bool("MPIR_PARAM_COMM_OVERRIDES", &(MPIR_PARAM_COMM_OVERRIDES));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_COMM_OVERRIDES");
rc = MPL_env2int("MPICH_CH3_EAGER_MAX_MSG_SIZE", &(MPIR_PARAM_CH3_EAGER_MAX_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_CH3_EAGER_MAX_MSG_SIZE");
rc = MPL_env2int("MPIR_PARAM_CH3_EAGER_MAX_MSG_SIZE", &(MPIR_PARAM_CH3_EAGER_MAX_MSG_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_CH3_EAGER_MAX_MSG_SIZE");
rc = MPL_env2bool("MPICH_DEBUG_HOLD", &(MPIR_PARAM_DEBUG_HOLD));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_DEBUG_HOLD");
rc = MPL_env2bool("MPIR_PARAM_DEBUG_HOLD", &(MPIR_PARAM_DEBUG_HOLD));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_DEBUG_HOLD");
rc = MPL_env2bool("MPICH_ENABLE_CKPOINT", &(MPIR_PARAM_ENABLE_CKPOINT));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_ENABLE_CKPOINT");
rc = MPL_env2bool("MPIR_PARAM_ENABLE_CKPOINT", &(MPIR_PARAM_ENABLE_CKPOINT));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_ENABLE_CKPOINT");
rc = MPL_env2bool("MPICH_ENABLE_COLL_FT_RET", &(MPIR_PARAM_ENABLE_COLL_FT_RET));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_ENABLE_COLL_FT_RET");
rc = MPL_env2bool("MPIR_PARAM_ENABLE_COLL_FT_RET", &(MPIR_PARAM_ENABLE_COLL_FT_RET));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_ENABLE_COLL_FT_RET");
rc = MPL_env2bool("MPICH_ABORT_ON_LEAKED_HANDLES", &(MPIR_PARAM_ABORT_ON_LEAKED_HANDLES));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_ABORT_ON_LEAKED_HANDLES");
rc = MPL_env2bool("MPIR_PARAM_ABORT_ON_LEAKED_HANDLES", &(MPIR_PARAM_ABORT_ON_LEAKED_HANDLES));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_ABORT_ON_LEAKED_HANDLES");
rc = MPL_env2range("MPICH_PORTRANGE", &(MPIR_PARAM_PORT_RANGE.low), &(MPIR_PARAM_PORT_RANGE.high));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_PORTRANGE");
rc = MPL_env2range("MPIR_PARAM_PORTRANGE", &(MPIR_PARAM_PORT_RANGE.low), &(MPIR_PARAM_PORT_RANGE.high));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_PORTRANGE");
rc = MPL_env2range("MPICH_PORT_RANGE", &(MPIR_PARAM_PORT_RANGE.low), &(MPIR_PARAM_PORT_RANGE.high));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_PORT_RANGE");
rc = MPL_env2range("MPIR_PARAM_PORT_RANGE", &(MPIR_PARAM_PORT_RANGE.low), &(MPIR_PARAM_PORT_RANGE.high));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_PORT_RANGE");
rc = MPL_env2int("MPICH_CTXID_EAGER_SIZE", &(MPIR_PARAM_CTXID_EAGER_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPICH_CTXID_EAGER_SIZE");
rc = MPL_env2int("MPIR_PARAM_CTXID_EAGER_SIZE", &(MPIR_PARAM_CTXID_EAGER_SIZE));
MPIU_ERR_CHKANDJUMP1((-1 == rc),mpi_errno,MPI_ERR_OTHER,"**envvarparse","**envvarparse %s","MPIR_PARAM_CTXID_EAGER_SIZE");
fn_fail:
return mpi_errno;
}
static int fPMI_Handle_spawn( PMIProcess *pentry )
{
char inbuf[PMIU_MAXLINE];
char *(args[PMI_MAX_ARGS]);
char key[MAXKEYLEN];
char outbuf[PMIU_MAXLINE];
ProcessWorld *pWorld;
ProcessApp *app = 0;
int preputNum = 0, rc;
int i;
int totspawns=0, spawnnum=0;
PMIKVSpace *kvs = 0;
/* Variables for info */
char curInfoKey[PMI_MAX_INFO_KEY], curInfoVal[PMI_MAX_INFO_VAL];
int curInfoIdx = -1;
DBG_PRINTFCOND(pmidebug,( "Entering fPMI_Handle_spawn\n" ));
if (!pentry->spawnWorld) {
pWorld = (ProcessWorld *)MPIU_Malloc( sizeof(ProcessWorld) );
if (!pWorld) return 1;
pentry->spawnWorld = pWorld;
pWorld->apps = 0;
pWorld->nProcess = 0;
pWorld->nextWorld = 0;
pWorld->nApps = 0;
pWorld->worldNum = pUniv.nWorlds++;
/* FIXME: What should be the defaults for the spawned env?
Should the default be the env ov the spawner? */
pWorld->genv = 0;
pentry->spawnKVS = fPMIKVSAllocate();
}
else {
pWorld = pentry->spawnWorld;
}
kvs = pentry->spawnKVS;
/* Note that each mcmd=spawn creates an app. When all apps
are present, then then can be linked to a world. A
spawnmultiple command makes use of multiple mcmd=spawn PMI
commands */
/* Create a new app */
app = (ProcessApp *)MPIU_Malloc( sizeof(ProcessApp) );
if (!app) return 1;
app->myAppNum = 0;
app->exename = 0;
app->arch = 0;
app->path = 0;
app->wdir = 0;
app->hostname = 0;
app->args = 0;
app->nArgs = 0;
app->soft.nelm = 0;
app->nProcess = 0;
app->pState = 0;
app->nextApp = 0;
app->env = 0;
app->pWorld = pWorld;
/* Add to the pentry spawn structure */
if (pentry->spawnAppTail) {
pentry->spawnAppTail->nextApp = app;
}
else {
pentry->spawnApp = app;
pWorld->apps = app;
}
pentry->spawnAppTail = app;
for (i=0; i<PMI_MAX_ARGS; i++) args[i] = 0;
/* Get lines until we find either cmd or mcmd (an error) or endcmd
(expected end) */
while ((rc = PMIUBufferedReadLine( pentry, inbuf, sizeof(inbuf) )) > 0) {
char *cmdPtr, *valPtr, *p;
/* Find the command = format */
p = inbuf;
/* Find first nonblank */
while (*p && isascii(*p) && isspace(*p)) p++;
if (!*p) {
/* Empty string. Ignore */
continue;
}
cmdPtr = p++;
/* Find '=' */
while (*p && *p != '=') p++;
if (!*p) {
/* No =. Check for endcmd */
p--;
/* Trim spaces */
while (isascii(*p) && isspace(*p)) p--;
/* Add null to end */
*++p = 0;
if (strcmp( "endcmd", cmdPtr ) == 0) { break; }
/* FIXME: Otherwise, we have a problem */
MPIU_Error_printf( "Malformed PMI command (no endcmd seen\n" );
return 1;
}
else {
*p = 0;
}
/* Found an = . value is the rest of the line */
valPtr = ++p;
while (*p && *p != '\n') p++;
if (*p) *p = 0; /* Remove the newline */
/* Now, process the cmd and value */
if (strcmp( "nprocs", cmdPtr ) == 0) {
app->nProcess = atoi(valPtr);
pWorld->nProcess += app->nProcess;
}
else if (strcmp( "execname", cmdPtr ) == 0) {
app->exename = MPIU_Strdup( valPtr );
}
else if (strcmp( "totspawns", cmdPtr ) == 0) {
/* This tells us how many separate spawn commands
we expect to see (e.g., for spawn multiple).
Each spawn command is a separate "app" */
totspawns = atoi(valPtr);
}
else if (strcmp( "spawnssofar", cmdPtr ) == 0) {
/* This tells us which app we are (starting from 1) */
spawnnum = atoi(valPtr);
app->myAppNum = spawnnum - 1;
}
else if (strcmp( "argcnt", cmdPtr ) == 0) {
/* argcnt may not be set before the args */
app->nArgs = atoi(valPtr);
}
else if (strncmp( "arg", cmdPtr, 3 ) == 0) {
int argnum;
/* argcnt may not be set before the args */
/* Handle arg%d. Values are 1 - origin */
argnum = atoi( cmdPtr + 3 ) - 1;
if (argnum < 0 || argnum >= PMI_MAX_ARGS) {
MPIU_Error_printf( "Malformed PMI Spawn command; the index of an argument in the command is %d but must be between 0 and %d\n",
argnum, PMI_MAX_ARGS );
return 1;
}
args[argnum] = MPIU_Strdup( valPtr );
}
else if (strcmp( "preput_num", cmdPtr ) == 0) {
preputNum = atoi(valPtr);
}
else if (strncmp( "preput_key_", cmdPtr, 11 ) == 0) {
/* Save the key */
MPIU_Strncpy( key, valPtr, sizeof(key) );
}
else if (strncmp( "preput_val_", cmdPtr, 11 ) == 0) {
/* Place the key,val into the space associate with the current
PMI group */
fPMIKVSAddPair( kvs, key, valPtr );
}
/* Info is on a per-app basis (it is an array of info items in
spawn multiple). We can ignore most info values.
The ones that are handled are processed by a
separate routine (not yet implemented).
simple_pmi.c sends (key,value), so we can keep just the
last key and pass the key/value to the registered info
handler, along with tha app structure. Alternately,
we could save all info items and let the user's
spawner handle it */
else if (strcmp( "info_num", cmdPtr ) == 0) {
/* Number of info values */
;
}
else if (strncmp( "info_key_", cmdPtr, 9 ) == 0) {
/* The actual name has a digit, which indicates *which* info
key this is */
curInfoIdx = atoi( cmdPtr + 9 );
MPIU_Strncpy( curInfoKey, valPtr, sizeof(curInfoKey) );
}
else if (strncmp( "info_val_", cmdPtr, 9 ) == 0) {
/* The actual name has a digit, which indicates *which* info
value this is */
int idx = atoi( cmdPtr + 9 );
if (idx != curInfoIdx) {
MPIU_Error_printf( "Malformed PMI command: info keys and values not ordered as expected (expected value %d but got %d)\n", curInfoIdx, idx );
return 1;
}
else {
MPIU_Strncpy( curInfoVal, valPtr, sizeof(curInfoVal) );
/* Apply this info item */
fPMIInfoKey( app, curInfoKey, curInfoVal );
/* printf( "Got info %s+%s\n", curInfoKey, curInfoVal ); */
}
}
else {
MPIU_Error_printf( "Unrecognized PMI subcommand on spawnmult: %s\n",
cmdPtr );
return 1;
}
}
if (app->nArgs > 0) {
app->args = (const char **)MPIU_Malloc( app->nArgs * sizeof(char *) );
for (i=0; i<app->nArgs; i++) {
app->args[i] = args[i];
args[i] = 0;
}
}
pWorld->nApps ++;
/* Now that we've read the commands, invoke the user's spawn command */
if (totspawns == spawnnum) {
PMISetupNewGroup( pWorld->nProcess, kvs );
if (userSpawner) {
rc = (*userSpawner)( pWorld, userSpawnerData );
}
else {
MPIU_Error_printf( "Unable to spawn %s\n", app->exename );
rc = 1;
MPIE_PrintProcessWorld( stdout, pWorld );
}
MPIU_Snprintf( outbuf, PMIU_MAXLINE, "cmd=spawn_result rc=%d\n", rc );
PMIWriteLine( pentry->fd, outbuf );
DBG_PRINTFCOND(pmidebug,( "%s", outbuf ));
/* Clear for the next spawn */
pentry->spawnApp = 0;
pentry->spawnAppTail = 0;
pentry->spawnKVS = 0;
pentry->spawnWorld = 0;
}
/* If totspawnnum != spawnnum, then we are expecting a
spawnmult with additional items */
return 0;
}
int mpi_errno = MPI_SUCCESS;
unsigned long cur_ver;
cur_ver = mxm_get_version();
if (cur_ver != MXM_API) {
MPIU_DBG_MSG_FMT(CH3_CHANNEL, VERBOSE,
(MPIU_DBG_FDEST,
"WARNING: MPICH was compiled with MXM version %d.%d but version %ld.%ld detected.",
MXM_VERNO_MAJOR,
MXM_VERNO_MINOR,
(cur_ver >> MXM_MAJOR_BIT) & 0xff, (cur_ver >> MXM_MINOR_BIT) & 0xff));
}
_mxm_obj.compiletime_version = MXM_VERNO_STRING;
#if MXM_API >= MXM_VERSION(3,0)
_mxm_obj.runtime_version = MPIU_Strdup(mxm_get_version_string());
#else
_mxm_obj.runtime_version = MPIU_Malloc(sizeof(MXM_VERNO_STRING) + 10);
snprintf(_mxm_obj.runtime_version, (sizeof(MXM_VERNO_STRING) + 9),
"%ld.%ld", (cur_ver >> MXM_MAJOR_BIT) & 0xff, (cur_ver >> MXM_MINOR_BIT) & 0xff);
#endif
_mxm_obj.conf.bulk_connect = cur_ver < MXM_VERSION(3, 2) ? 0 : MPIR_CVAR_NEMESIS_MXM_BULK_CONNECT;
_mxm_obj.conf.bulk_disconnect = cur_ver < MXM_VERSION(3, 2) ? 0 : MPIR_CVAR_NEMESIS_MXM_BULK_DISCONNECT;
if (cur_ver < MXM_VERSION(3, 2) &&
(_mxm_obj.conf.bulk_connect || _mxm_obj.conf.bulk_disconnect)) {
_mxm_obj.conf.bulk_connect = 0;
_mxm_obj.conf.bulk_disconnect = 0;
MPIU_DBG_MSG_FMT(CH3_CHANNEL, VERBOSE,
(MPIU_DBG_FDEST,
/*
* This routine may be called by MPIE_Args to handle any environment arguments
* Returns the number of arguments to skip (0 if argument is not recognized
* as an environment control)
*/
int MPIE_ArgsCheckForEnv( int argc, char *argv[], ProcessWorld *pWorld,
EnvInfo **appEnv )
{
int i, incr=0;
EnvInfo *env;
char *cmd;
if ( strncmp( argv[0], "-env", 4) == 0) {
if (!*appEnv) {
env = (EnvInfo *)MPIU_Malloc( sizeof(EnvInfo) );
env->includeAll = 1;
env->envPairs = 0;
env->envNames = 0;
*appEnv = env;
}
else
env = *appEnv;
cmd = argv[0] + 4;
}
else if (strncmp( argv[0], "-genv", 5 ) == 0) {
if (!pWorld->genv) {
env = (EnvInfo *)MPIU_Malloc( sizeof(EnvInfo) );
env->includeAll = 1;
env->envPairs = 0;
env->envNames = 0;
pWorld->genv = env;
}
env = pWorld->genv;
cmd = argv[0] + 5;
}
else
return 0;
/* genv and env commands have the same form, just affect different
env structures. We handle this by identifying which structure,
then checkout the remaining command */
if (!cmd[0]) {
/* A basic name value command */
EnvData *p;
if (!argv[1] || !argv[2]) {
mpiexec_usage( "Missing arguments to -env or -genv" );
}
p = (EnvData *)MPIU_Malloc( sizeof(EnvData) );
p->name = (const char *)MPIU_Strdup( argv[1] );
p->value = (const char *)MPIU_Strdup( argv[2] );
p->envvalue = 0;
p->nextData = env->envPairs;
env->envPairs = p;
incr = 3;
}
else if (strcmp( cmd, "none" ) == 0) {
env->includeAll = 0;
incr = 1;
}
else if (strcmp( cmd, "list" ) == 0) {
/* argv[1] has a list of names, separated by commas */
EnvData *p;
char *lPtr = argv[1], *name;
int namelen;
if (!argv[1]) {
mpiexec_usage( "Missing argument to -envlist or -genvlist" );
}
while (*lPtr) {
name = lPtr++;
while (*lPtr && *lPtr != ',') lPtr++;
/* The length of any environment string will fit in an int */
namelen = (int)(lPtr - name);
p = (EnvData *)MPIU_Malloc( sizeof(EnvData) );
p->value = 0;
p->name = (const char *)MPIU_Malloc( namelen + 1 );
p->envvalue = 0;
for (i=0; i<namelen; i++) ((char *)p->name)[i] = name[i];
((char *)p->name)[namelen] = 0;
p->nextData = env->envNames;
env->envNames = p;
if (*lPtr == ',') lPtr++;
}
incr = 2;
}
else {
/* Unrecognized env argument. */
incr = 0;
}
return incr;
}
/*
* If MPICH is built with the --enable-debugger option, MPI_Init and
* MPI_Init_thread will call MPIR_WaitForDebugger. This ensures both that
* the debugger can gather information on the MPI job before the MPI_Init
* returns to the user and that the necessary symbols for providing
* information such as message queues is available.
*
* In addition, the environment variable MPIEXEC_DEBUG, if set, will cause
* all MPI processes to wait in this routine until the variable
* MPIR_debug_gate is set to 1.
*/
void MPIR_WaitForDebugger( void )
{
#ifdef MPIU_PROCTABLE_NEEDED
int rank = MPIR_Process.comm_world->rank;
#if defined(FINEGRAIN_MPI)
int size = MPIR_Process.comm_world->num_osprocs;
#else
int size = MPIR_Process.comm_world->local_size;
#endif
int i, maxsize;
/* FIXME: In MPICH, the executables may not have the information
on the other processes; this is part of the Process Manager Interface
(PMI). We need another way to provide this information to
a debugger */
/* The process manager probably has all of this data - the MPI2
debugger interface API provides (at least originally) a way
to access this. */
/* Also, to avoid scaling problems, we only populate the first 64
entries (default) */
maxsize = MPIR_CVAR_PROCTABLE_SIZE;
if (maxsize > size) maxsize = size;
if (rank == 0) {
char hostname[MPI_MAX_PROCESSOR_NAME+1];
int hostlen;
int val;
MPIR_proctable = (MPIR_PROCDESC *)MPIU_Malloc(
size * sizeof(MPIR_PROCDESC) );
for (i=0; i<size; i++) {
/* Initialize the proctable */
MPIR_proctable[i].host_name = 0;
MPIR_proctable[i].executable_name = 0;
MPIR_proctable[i].pid = -1;
}
PMPI_Get_processor_name( hostname, &hostlen );
MPIR_proctable[0].host_name = (char *)MPIU_Strdup( hostname );
MPIR_proctable[0].executable_name = 0;
MPIR_proctable[0].pid = getpid();
for (i=1; i<maxsize; i++) {
int msg[2];
PMPI_Recv( msg, 2, MPI_INT, i, 0, MPI_COMM_WORLD,MPI_STATUS_IGNORE);
MPIR_proctable[i].pid = msg[1];
MPIR_proctable[i].host_name = (char *)MPIU_Malloc( msg[0] + 1 );
PMPI_Recv( MPIR_proctable[i].host_name, msg[0]+1, MPI_CHAR,
i, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE );
MPIR_proctable[i].host_name[msg[0]] = 0;
}
MPIR_proctable_size = size;
/* Debugging hook */
if (MPIR_CVAR_PROCTABLE_PRINT) {
for (i=0; i<maxsize; i++) {
printf( "PT[%d].pid = %d, .host_name = %s\n",
i, MPIR_proctable[i].pid, MPIR_proctable[i].host_name );
}
fflush( stdout );
}
MPIR_Add_finalize( MPIR_FreeProctable, MPIR_proctable, 0 );
}
else {
char hostname[MPI_MAX_PROCESSOR_NAME+1];
int hostlen;
int mypid = getpid();
int msg[2];
if (rank < maxsize) {
PMPI_Get_processor_name( hostname, &hostlen );
msg[0] = hostlen;
msg[1] = mypid;
/* Deliver to the root process the proctable information */
PMPI_Ssend( msg, 2, MPI_INT, 0, 0, MPI_COMM_WORLD );
PMPI_Ssend( hostname, hostlen, MPI_CHAR, 0, 0, MPI_COMM_WORLD );
}
}
#endif /* MPIU_PROCTABLE_NEEDED */
/* Put the breakpoint after setting up the proctable */
MPIR_debug_state = MPIR_DEBUG_SPAWNED;
#ifdef MPIU_BREAKPOINT_NEEDED
(void)MPIR_Breakpoint();
#endif
/* After we exit the MPIR_Breakpoint routine, the debugger may have
set variables such as MPIR_being_debugged */
/* Initialize the sendq support */
SendqInit();
if (getenv("MPIEXEC_DEBUG")) {
while (!MPIR_debug_gate) ;
}
}
