/* * 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) ; } }