static HYD_status fn_name_publish(int fd, int pid, int pgid, char *args[]) { struct HYD_string_stash stash; char *cmd, *thrid, *val, *name = NULL, *port = NULL; int token_count, success; struct HYD_pmcd_token *tokens = NULL; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); status = HYD_pmcd_pmi_args_to_tokens(args, &tokens, &token_count); HYDU_ERR_POP(status, "unable to convert args to tokens\n"); thrid = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "thrid"); if ((val = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "name")) == NULL) HYDU_ERR_POP(status, "cannot find token: name\n"); name = HYDU_strdup(val); if ((val = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "port")) == NULL) HYDU_ERR_POP(status, "cannot find token: port\n"); port = HYDU_strdup(val); status = HYD_pmcd_pmi_publish(name, port, &success); HYDU_ERR_POP(status, "error publishing service\n"); HYD_STRING_STASH_INIT(stash); HYD_STRING_STASH(stash, HYDU_strdup("cmd=name-publish-response;"), status); if (thrid) { HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status); HYD_STRING_STASH(stash, HYDU_strdup(thrid), status); HYD_STRING_STASH(stash, HYDU_strdup(";"), status); } if (!success) { HYD_STRING_STASH(stash, HYDU_strdup("rc=1;errmsg=duplicate_service_"), status); HYD_STRING_STASH(stash, HYDU_strdup(name), status); HYD_STRING_STASH(stash, HYDU_strdup(";"), status); } else HYD_STRING_STASH(stash, HYDU_strdup("rc=0;"), status); HYD_STRING_SPIT(stash, cmd, status); status = cmd_response(fd, pid, cmd); HYDU_ERR_POP(status, "send command failed\n"); HYDU_FREE(cmd); fn_exit: if (tokens) HYD_pmcd_pmi_free_tokens(tokens, token_count); if (name) HYDU_FREE(name); if (port) HYDU_FREE(port); HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
HYD_status HYDU_putenv(struct HYD_env *env, HYD_env_overwrite_t overwrite) { char *tmp[HYD_NUM_TMP_STRINGS], *str; int i; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); /* If the overwrite flag is false, just exit */ if (MPL_env2str(env->env_name, (const char **) &str) && overwrite == HYD_ENV_OVERWRITE_FALSE) goto fn_exit; i = 0; tmp[i++] = HYDU_strdup(env->env_name); tmp[i++] = HYDU_strdup("="); tmp[i++] = env->env_value ? HYDU_strdup(env->env_value) : HYDU_strdup(""); tmp[i++] = NULL; status = HYDU_str_alloc_and_join(tmp, &str); HYDU_ERR_POP(status, "unable to join strings\n"); MPL_putenv(str); for (i = 0; tmp[i]; i++) HYDU_FREE(tmp[i]); fn_exit: HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
HYD_status HYDU_strsplit(char *str, char **str1, char **str2, char sep) { int i; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); if (str == NULL) HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, ""); *str1 = HYDU_strdup(str); for (i = 0; (*str1)[i] && ((*str1)[i] != sep); i++); if ((*str1)[i] == 0) /* End of the string */ *str2 = NULL; else { *str2 = HYDU_strdup(&((*str1)[i + 1])); (*str1)[i] = 0; } fn_exit: HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
HYD_status HYDU_correct_wdir(char **wdir) { char *tmp[HYD_NUM_TMP_STRINGS]; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); if (*wdir == NULL) { *wdir = HYDU_getcwd(); } else if (*wdir[0] != '/') { tmp[0] = HYDU_getcwd(); tmp[1] = HYDU_strdup("/"); tmp[2] = HYDU_strdup(*wdir); tmp[3] = NULL; HYDU_FREE(*wdir); status = HYDU_str_alloc_and_join(tmp, wdir); HYDU_ERR_POP(status, "unable to join strings\n"); HYDU_free_strlist(tmp); } fn_exit: HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
HYD_status HYDU_append_env_to_list(const char *env_name, const char *env_value, struct HYD_env ** env_list) { struct HYD_env *run, *tenv; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); status = HYDU_env_create(&tenv, env_name, env_value); HYDU_ERR_POP(status, "unable to create env structure\n"); tenv->next = NULL; /* Add the structure to the end of the list */ if (*env_list == NULL) { *env_list = tenv; } else { run = *env_list; while (1) { if (!strcmp(run->env_name, env_name)) { /* If we found an entry for this environment variable, just update it */ if (run->env_value != NULL && tenv->env_value != NULL) { HYDU_FREE(run->env_value); run->env_value = HYDU_strdup(tenv->env_value); } else if (run->env_value != NULL) { HYDU_FREE(run->env_value); run->env_value = NULL; } else if (env_value != NULL) { run->env_value = HYDU_strdup(tenv->env_value); } HYDU_FREE(tenv->env_name); if (tenv->env_value) HYDU_FREE(tenv->env_value); HYDU_FREE(tenv); break; } else if (run->next == NULL) { run->next = tenv; break; } run = run->next; } } fn_exit: HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
HYD_status HYDT_topo_init(char *user_topolib, char *user_binding, char *user_mapping, char *user_membind) { const char *topolib = NULL, *binding = NULL, *mapping = NULL, *membind = NULL; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); if (user_topolib) HYDT_topo_info.topolib = HYDU_strdup(user_topolib); else if (MPL_env2str("HYDRA_TOPOLIB", &topolib)) HYDT_topo_info.topolib = HYDU_strdup(topolib); else if (HYDRA_DEFAULT_TOPOLIB) HYDT_topo_info.topolib = HYDU_strdup(HYDRA_DEFAULT_TOPOLIB); else HYDT_topo_info.topolib = NULL; if (user_binding) binding = user_binding; else if (MPL_env2str("HYDRA_BINDING", &binding) == 0) binding = NULL; if (user_mapping) mapping = user_mapping; else if (MPL_env2str("HYDRA_MAPPING", &mapping) == 0) mapping = NULL; if (user_membind) membind = user_membind; else if (MPL_env2str("HYDRA_MEMBIND", &membind) == 0) membind = NULL; if (!binding || !strcmp(binding, "none")) { ignore_binding = 1; goto fn_exit; } /* Initialize the topology library requested by the user */ #if defined HAVE_HWLOC if (!strcmp(HYDT_topo_info.topolib, "hwloc")) { status = HYDT_topo_hwloc_init(binding, mapping, membind); HYDU_ERR_POP(status, "unable to initialize hwloc\n"); } #endif /* HAVE_HWLOC */ fn_exit: HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
HYD_status HYDU_append_env_str_to_list(const char *str, struct HYD_env **env_list) { char *my_str = NULL; char *env_name, *env_value; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); my_str = env_value = HYDU_strdup(str); /* don't use strtok, it will mangle env values that contain '=' */ env_name = MPL_strsep(&env_value, "="); HYDU_ASSERT(env_name != NULL, status); status = HYDU_append_env_to_list(env_name, env_value, env_list); HYDU_ERR_POP(status, "unable to append env to list\n"); fn_exit: if (my_str) HYDU_FREE(my_str); HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
static HYD_status exec_args_fn(char *arg, char ***argv) { int i, count; struct HYD_exec *exec = NULL; HYD_status status = HYD_SUCCESS; if (**argv == NULL) HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "NULL argument to exec args\n"); for (exec = HYD_pmcd_pmip.exec_list; exec->next; exec = exec->next); count = atoi(**argv); for (i = 0; i < count; i++) { (*argv)++; exec->exec[i] = HYDU_strdup(**argv); } exec->exec[i] = NULL; (*argv)++; fn_exit: HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
static HYD_status pmi_id_map_fn(char *arg, char ***argv) { char *map, *tmp; HYD_status status = HYD_SUCCESS; /* Split the core map into three different segments */ map = HYDU_strdup(**argv); HYDU_ASSERT(map, status); tmp = strtok(map, ","); HYDU_ASSERT(tmp, status); HYD_pmcd_pmip.system_global.pmi_id_map.filler_start = atoi(tmp); tmp = strtok(NULL, ","); HYDU_ASSERT(tmp, status); HYD_pmcd_pmip.system_global.pmi_id_map.non_filler_start = atoi(tmp); HYDU_FREE(map); (*argv)++; fn_exit: HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
HYD_status HYD_pmcd_pmi_v2_queue_req(int fd, int pid, int pgid, char *args[], char *key, struct HYD_pmcd_pmi_v2_reqs **pending_reqs) { struct HYD_pmcd_pmi_v2_reqs *req, *tmp; HYD_status status = HYD_SUCCESS; HYDU_MALLOC(req, struct HYD_pmcd_pmi_v2_reqs *, sizeof(struct HYD_pmcd_pmi_v2_reqs), status); req->fd = fd; req->pid = pid; req->pgid = pgid; req->prev = NULL; req->next = NULL; status = HYDU_strdup_list(args, &req->args); HYDU_ERR_POP(status, "unable to dup args\n"); req->key = HYDU_strdup(key); if (*pending_reqs == NULL) *pending_reqs = req; else { for (tmp = *pending_reqs; tmp->next; tmp = tmp->next); tmp->next = req; req->prev = tmp; } fn_exit: return status; fn_fail: goto fn_exit; }
static HYD_status parse_ckpoint_prefix(char *pathlist) { int i, prefixes; char *dummy; HYD_status status = HYD_SUCCESS; /* Find the number of prefixes provided */ prefixes = 1; for (i = 0; pathlist[i]; i++) if (pathlist[i] == ':') prefixes++; /* Add one more to the prefix list for a NULL ending string */ prefixes++; HYDU_MALLOC(HYD_pmcd_pmip.local.ckpoint_prefix_list, char **, prefixes * sizeof(char *), status); dummy = strtok(pathlist, ":"); i = 0; while (dummy) { HYD_pmcd_pmip.local.ckpoint_prefix_list[i] = HYDU_strdup(dummy); dummy = strtok(NULL, ":"); i++; } HYD_pmcd_pmip.local.ckpoint_prefix_list[i] = NULL; fn_exit: return status; fn_fail: goto fn_exit; }
HYD_status HYD_pmcd_pmi_args_to_tokens(char *args[], struct HYD_pmcd_token **tokens, int *count) { int i, j; char *arg; HYD_status status = HYD_SUCCESS; for (i = 0; args[i]; i++); *count = i; HYDU_MALLOC(*tokens, struct HYD_pmcd_token *, *count * sizeof(struct HYD_pmcd_token), status); for (i = 0; args[i]; i++) { arg = HYDU_strdup(args[i]); (*tokens)[i].key = arg; for (j = 0; arg[j] && arg[j] != '='; j++); if (!arg[j]) { (*tokens)[i].val = NULL; } else { arg[j] = 0; (*tokens)[i].val = &arg[++j]; } } fn_exit: return status; fn_fail: goto fn_exit; }
static HYD_status process_mfile_token(char *token, int newline, struct HYD_node **node_list) { int num_procs; static int entry_count = 0; static char *hostname; HYD_status status = HYD_SUCCESS; entry_count++; if (newline) { /* The first entry gives the hostname */ entry_count = 1; if (hostname) HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "unexpected token %s\n", token); hostname = HYDU_strdup(token); } else { /* Not a new line */ if (entry_count != 2) goto fn_exit; num_procs = atoi(token); status = HYDU_add_to_node_list(hostname, num_procs, node_list); HYDU_ERR_POP(status, "unable to initialize proxy\n"); hostname = NULL; } fn_exit: return status; fn_fail: goto fn_exit; }
static HYD_status fn_publish_name(int fd, int pid, int pgid, char *args[]) { char *tmp[HYD_NUM_TMP_STRINGS], *cmd, *val; int i, token_count; struct HYD_pmcd_token *tokens; char *name, *port; int success = 0; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); status = HYD_pmcd_pmi_args_to_tokens(args, &tokens, &token_count); HYDU_ERR_POP(status, "unable to convert args to tokens\n"); if ((val = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "service")) == NULL) HYDU_ERR_POP(status, "cannot find token: service\n"); name = HYDU_strdup(val); if ((val = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "port")) == NULL) HYDU_ERR_POP(status, "cannot find token: port\n"); port = HYDU_strdup(val); status = HYD_pmcd_pmi_publish(name, port, &success); HYDU_ERR_POP(status, "error publishing service\n"); i = 0; if (success) tmp[i++] = HYDU_strdup("cmd=publish_result info=ok rc=0 msg=success\n"); else tmp[i++] = HYDU_strdup("cmd=publish_result info=ok rc=1 msg=key_already_present\n"); tmp[i++] = NULL; status = HYDU_str_alloc_and_join(tmp, &cmd); HYDU_ERR_POP(status, "unable to join strings\n"); HYDU_free_strlist(tmp); status = cmd_response(fd, pid, cmd); HYDU_ERR_POP(status, "send command failed\n"); HYDU_FREE(cmd); fn_exit: HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
static HYD_status proxy_list_to_node_str(struct HYD_proxy *proxy_list, char **node_list_str) { int i; char *tmp[HYD_NUM_TMP_STRINGS], *foo = NULL; struct HYD_proxy *proxy; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); i = 0; for (proxy = proxy_list; proxy; proxy = proxy->next) { tmp[i++] = HYDU_strdup(proxy->node->hostname); if (proxy->node->next) tmp[i++] = HYDU_strdup(","); /* If we used up more than half of the array elements, merge * what we have so far */ if (i > (HYD_NUM_TMP_STRINGS / 2)) { tmp[i++] = NULL; status = HYDU_str_alloc_and_join(tmp, &foo); HYDU_ERR_POP(status, "error joining strings\n"); i = 0; tmp[i++] = HYDU_strdup(foo); HYDU_FREE(foo); } } tmp[i++] = NULL; status = HYDU_str_alloc_and_join(tmp, &foo); HYDU_ERR_POP(status, "error joining strings\n"); *node_list_str = foo; foo = NULL; fn_exit: HYDU_free_strlist(tmp); if (foo) HYDU_FREE(foo); HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
HYD_status HYD_pmcd_pmi_parse_pmi_cmd(char *obuf, int pmi_version, char **pmi_cmd, char *args[]) { char *str1 = NULL, *cmd, *buf; const char *delim; int i; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); /* Make a copy of the original buffer */ buf = HYDU_strdup(obuf); if (buf[strlen(obuf) - 1] == '\n') buf[strlen(obuf) - 1] = '\0'; if (pmi_version == 1) { if (!strncmp(buf, "cmd=", strlen("cmd="))) delim = " "; else delim = "\n"; } else { /* PMI-v2 */ delim = ";"; } cmd = strtok(buf, delim); for (i = 0;; i++) { args[i] = strtok(NULL, delim); if (args[i] == NULL) break; args[i] = HYDU_strdup(args[i]); } /* Search for the PMI command in our table */ status = HYDU_strsplit(cmd, &str1, pmi_cmd, '='); HYDU_ERR_POP(status, "string split returned error\n"); fn_exit: HYDU_FREE(buf); if (str1) HYDU_FREE(str1); HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
static HYD_status fn_lookup_name(int fd, int pid, int pgid, char *args[]) { char *tmp[HYD_NUM_TMP_STRINGS], *cmd, *name, *value; int i, token_count; struct HYD_pmcd_token *tokens; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); status = HYD_pmcd_pmi_args_to_tokens(args, &tokens, &token_count); HYDU_ERR_POP(status, "unable to convert args to tokens\n"); if ((name = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "service")) == NULL) HYDU_ERR_POP(status, "cannot find token: service\n"); status = HYD_pmcd_pmi_lookup(name, &value); HYDU_ERR_POP(status, "error while looking up service\n"); i = 0; tmp[i++] = HYDU_strdup("cmd=lookup_result info=ok"); if (value) { tmp[i++] = HYDU_strdup("value="); tmp[i++] = HYDU_strdup(value); tmp[i++] = HYDU_strdup(" rc=0 msg=success\n"); } else { tmp[i++] = HYDU_strdup(" rc=1 msg=service_not_found\n"); } tmp[i++] = NULL; status = HYDU_str_alloc_and_join(tmp, &cmd); HYDU_ERR_POP(status, "unable to join strings\n"); HYDU_free_strlist(tmp); status = cmd_response(fd, pid, cmd); HYDU_ERR_POP(status, "send command failed\n"); HYDU_FREE(cmd); fn_exit: HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
HYD_status HYDU_env_create(struct HYD_env **env, const char *env_name, const char *env_value) { HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); HYDU_MALLOC(*env, struct HYD_env *, sizeof(struct HYD_env), status); (*env)->env_name = HYDU_strdup(env_name); (*env)->env_value = env_value ? HYDU_strdup(env_value) : NULL; (*env)->next = NULL; fn_exit: HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
static HYD_status fn_name_lookup(int fd, int pid, int pgid, char *args[]) { struct HYD_string_stash stash; char *cmd, *thrid, *name, *value; int token_count; struct HYD_pmcd_token *tokens = NULL; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); status = HYD_pmcd_pmi_args_to_tokens(args, &tokens, &token_count); HYDU_ERR_POP(status, "unable to convert args to tokens\n"); thrid = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "thrid"); if ((name = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "name")) == NULL) HYDU_ERR_POP(status, "cannot find token: name\n"); status = HYD_pmcd_pmi_lookup(name, &value); HYDU_ERR_POP(status, "error while looking up service\n"); HYD_STRING_STASH_INIT(stash); HYD_STRING_STASH(stash, HYDU_strdup("cmd=name-lookup-response;"), status); if (thrid) { HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status); HYD_STRING_STASH(stash, HYDU_strdup(thrid), status); HYD_STRING_STASH(stash, HYDU_strdup(";"), status); } if (value) { HYD_STRING_STASH(stash, HYDU_strdup("port="), status); HYD_STRING_STASH(stash, HYDU_strdup(value), status); HYD_STRING_STASH(stash, HYDU_strdup(";found=TRUE;rc=0;"), status); } else { HYD_STRING_STASH(stash, HYDU_strdup("found=FALSE;rc=1;"), status); } HYD_STRING_SPIT(stash, cmd, status); status = cmd_response(fd, pid, cmd); HYDU_ERR_POP(status, "send command failed\n"); HYDU_FREE(cmd); fn_exit: if (tokens) HYD_pmcd_pmi_free_tokens(tokens, token_count); HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
HYD_status HYDU_env_to_str(struct HYD_env *env, char **str) { int i; char *tmp[HYD_NUM_TMP_STRINGS]; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); i = 0; tmp[i++] = HYDU_strdup("'"); tmp[i++] = HYDU_strdup(env->env_name); tmp[i++] = HYDU_strdup("="); tmp[i++] = env->env_value ? HYDU_strdup(env->env_value) : HYDU_strdup(""); tmp[i++] = HYDU_strdup("'"); tmp[i++] = NULL; status = HYDU_str_alloc_and_join(tmp, str); HYDU_ERR_POP(status, "unable to join strings\n"); for (i = 0; tmp[i]; i++) HYDU_FREE(tmp[i]); fn_exit: HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
static HYD_status control_port_fn(char *arg, char ***argv) { char *port = NULL; HYD_status status = HYD_SUCCESS; HYDU_ERR_CHKANDJUMP(status, HYD_pmcd_pmip.upstream.server_name, HYD_INTERNAL_ERROR, "duplicate control port setting\n"); port = HYDU_strdup(**argv); HYD_pmcd_pmip.upstream.server_name = HYDU_strdup(strtok(port, ":")); HYD_pmcd_pmip.upstream.server_port = atoi(strtok(NULL, ":")); (*argv)++; fn_exit: if (port) HYDU_FREE(port); return status; fn_fail: goto fn_exit; }
HYD_status HYDT_dbg_setup_procdesc(struct HYD_pg * pg) { struct HYD_proxy *proxy; struct HYD_exec *exec; int i, j, np; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); HYDU_MALLOC(MPIR_proctable, struct MPIR_PROCDESC *, pg->pg_process_count * sizeof(struct MPIR_PROCDESC), status); for (proxy = pg->proxy_list, i = 0; proxy; proxy = proxy->next) { j = 0; for (exec = proxy->exec_list; exec; exec = exec->next) { for (np = 0; np < exec->proc_count; np++) { MPIR_proctable[i].host_name = HYDU_strdup(proxy->node->hostname); MPIR_proctable[i].pid = proxy->pid[j++]; if (exec->exec[0]) MPIR_proctable[i].executable_name = HYDU_strdup(exec->exec[0]); else MPIR_proctable[i].executable_name = NULL; i++; } } } MPIR_proctable_size = pg->pg_process_count; MPIR_debug_state = MPIR_DEBUG_SPAWNED; (*MPIR_breakpointFn) (); fn_exit: HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
HYD_status HYDU_list_append_strlist(char **src_strlist, char **dest_strlist) { int i, j; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); i = HYDU_strlist_lastidx(dest_strlist); for (j = 0; src_strlist[j]; j++) dest_strlist[i++] = HYDU_strdup(src_strlist[j]); dest_strlist[i++] = NULL; HYDU_FUNC_EXIT(); return status; }
HYD_status HYDT_bscd_lsf_query_node_list(struct HYD_node **node_list) { char *hosts, *hostname, *num_procs_str, *thosts = NULL; int num_procs; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); if (MPL_env2str("LSB_MCPU_HOSTS", (const char **) &hosts) == 0) hosts = NULL; if (hosts == NULL) { *node_list = NULL; HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "No LSF node list found\n"); } else { hosts = HYDU_strdup(hosts); thosts = hosts; hostname = strtok(hosts, " "); while (1) { if (hostname == NULL) break; /* the even fields in the list should be the number of * cores */ num_procs_str = strtok(NULL, " "); HYDU_ASSERT(num_procs_str, status); num_procs = atoi(num_procs_str); status = HYDU_add_to_node_list(hostname, num_procs, node_list); HYDU_ERR_POP(status, "unable to add to node list\n"); hostname = strtok(NULL, " "); } if (thosts) HYDU_FREE(thosts); } fn_exit: HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
static HYD_status add_exec_to_proxy(struct HYD_exec *exec, struct HYD_proxy *proxy, int num_procs) #endif { int i; struct HYD_exec *texec; HYD_status status = HYD_SUCCESS; if (proxy->exec_list == NULL) { status = HYDU_alloc_exec(&proxy->exec_list); HYDU_ERR_POP(status, "unable to allocate proxy exec\n"); for (i = 0; exec->exec[i]; i++) proxy->exec_list->exec[i] = HYDU_strdup(exec->exec[i]); proxy->exec_list->exec[i] = NULL; proxy->exec_list->wdir = HYDU_strdup(exec->wdir); proxy->exec_list->proc_count = num_procs; #if defined(FINEGRAIN_MPI) proxy->exec_list->nfg = exec->nfg; proxy->exec_list->start_rank = current_exec_start_rank; #endif proxy->exec_list->env_prop = exec->env_prop ? HYDU_strdup(exec->env_prop) : NULL; proxy->exec_list->user_env = HYDU_env_list_dup(exec->user_env); proxy->exec_list->appnum = exec->appnum; } else { for (texec = proxy->exec_list; texec->next; texec = texec->next); status = HYDU_alloc_exec(&texec->next); HYDU_ERR_POP(status, "unable to allocate proxy exec\n"); texec = texec->next; for (i = 0; exec->exec[i]; i++) texec->exec[i] = HYDU_strdup(exec->exec[i]); texec->exec[i] = NULL; texec->wdir = HYDU_strdup(exec->wdir); texec->proc_count = num_procs; #if defined(FINEGRAIN_MPI) texec->nfg = exec->nfg; texec->start_rank = current_exec_start_rank; #endif texec->env_prop = exec->env_prop ? HYDU_strdup(exec->env_prop) : NULL; texec->user_env = HYDU_env_list_dup(exec->user_env); texec->appnum = exec->appnum; } proxy->proxy_process_count += num_procs; proxy->node->active_processes += num_procs; fn_exit: return status; fn_fail: goto fn_exit; }
HYD_status HYDU_strdup_list(char *src[], char **dest[]) { int i, count; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); count = HYDU_strlist_lastidx(src); HYDU_MALLOC(*dest, char **, (count + 1) * sizeof(char *), status); for (i = 0; i < count; i++) (*dest)[i] = HYDU_strdup(src[i]); (*dest)[i] = NULL; fn_exit: HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
HYD_status HYDT_bscd_pbs_query_jobid(char **jobid) { const char *tmp_jobid = NULL; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); MPL_env2str("PBS_JOBID", &tmp_jobid); if (tmp_jobid) *jobid = HYDU_strdup(tmp_jobid); else *jobid = NULL; fn_exit: HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
HYD_status HYDU_list_inherited_env(struct HYD_env **env_list) { char *env_str = NULL, *env_name; int i, ret; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); *env_list = NULL; i = 0; while (environ[i]) { env_str = HYDU_strdup(environ[i]); env_name = strtok(env_str, "="); status = HYDT_bsci_query_env_inherit(env_name, &ret); HYDU_ERR_POP(status, "error querying environment propagation\n"); HYDU_FREE(env_str); env_str = NULL; if (!ret) { i++; continue; } status = HYDU_append_env_str_to_list(environ[i], env_list); HYDU_ERR_POP(status, "unable to add env to list\n"); i++; } fn_exit: if (env_str) HYDU_FREE(env_str); HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
HYD_status HYDT_bscd_ll_launch_procs(char **args, struct HYD_proxy *proxy_list, int *control_fd) { int idx, i, total_procs, node_count; int *pid, *fd_list, exec_idx; char *targs[HYD_NUM_TMP_STRINGS], *node_list_str = NULL; char *path = NULL, *extra_arg_list = NULL, *extra_arg, quoted_exec_string[HYD_TMP_STRLEN]; struct HYD_proxy *proxy; struct HYDT_topo_cpuset_t cpuset; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); /* We use the following priority order for the executable path: * (1) user-specified; (2) search in path; (3) Hard-coded * location */ if (HYDT_bsci_info.launcher_exec) path = HYDU_strdup(HYDT_bsci_info.launcher_exec); if (!path) path = HYDU_find_full_path("poe"); if (!path) path = HYDU_strdup("/usr/bin/poe"); idx = 0; targs[idx++] = HYDU_strdup(path); if (!strcmp(HYDT_bsci_info.rmk, "ll")) { HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "ll does not support user-defined host lists\n"); } /* Check how many nodes are being passed for the launch */ status = HYDTI_bscd_ll_query_node_count(&total_procs); HYDU_ERR_POP(status, "unable to query for the node count\n"); node_count = 0; for (proxy = proxy_list; proxy; proxy = proxy->next) node_count++; if (total_procs != node_count) HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "processes to be launched have to cover all nodes\n"); MPL_env2str("HYDRA_LAUNCHER_EXTRA_ARGS", (const char **) &extra_arg_list); if (extra_arg_list) { extra_arg = strtok(extra_arg_list, " "); while (extra_arg) { targs[idx++] = HYDU_strdup(extra_arg); extra_arg = strtok(NULL, " "); } } /* Fill in the remaining arguments */ exec_idx = idx; for (i = 0; args[i]; i++) targs[idx++] = HYDU_strdup(args[i]); /* Create a quoted version of the exec string, which is only used * when the executable is not launched directly, but through an * actual launcher */ HYDU_snprintf(quoted_exec_string, HYD_TMP_STRLEN, "\"%s\"", targs[exec_idx]); HYDU_FREE(targs[exec_idx]); targs[exec_idx] = quoted_exec_string; /* Increase pid list to accommodate the new pid */ HYDU_MALLOC(pid, int *, (HYD_bscu_pid_count + 1) * sizeof(int), status); for (i = 0; i < HYD_bscu_pid_count; i++) pid[i] = HYD_bscu_pid_list[i]; HYDU_FREE(HYD_bscu_pid_list); HYD_bscu_pid_list = pid; /* Increase fd list to accommodate these new fds */ HYDU_MALLOC(fd_list, int *, (HYD_bscu_fd_count + 3) * sizeof(int), status); for (i = 0; i < HYD_bscu_fd_count; i++) fd_list[i] = HYD_bscu_fd_list[i]; HYDU_FREE(HYD_bscu_fd_list); HYD_bscu_fd_list = fd_list; /* append proxy ID as -1 */ targs[idx++] = HYDU_int_to_str(-1); targs[idx++] = NULL; HYDT_topo_cpuset_zero(&cpuset); status = HYDU_create_process(targs, NULL, NULL, &fd_stdout, &fd_stderr, &HYD_bscu_pid_list[HYD_bscu_pid_count++], cpuset); HYDU_ERR_POP(status, "create process returned error\n"); HYD_bscu_fd_list[HYD_bscu_fd_count++] = fd_stdout; HYD_bscu_fd_list[HYD_bscu_fd_count++] = fd_stderr; status = HYDT_dmx_register_fd(1, &fd_stdout, HYD_POLLIN, (void *) (size_t) STDOUT_FILENO, HYDT_bscu_stdio_cb); HYDU_ERR_POP(status, "demux returned error registering fd\n"); status = HYDT_dmx_register_fd(1, &fd_stderr, HYD_POLLIN, (void *) (size_t) STDERR_FILENO, HYDT_bscu_stdio_cb); HYDU_ERR_POP(status, "demux returned error registering fd\n"); fn_exit: if (node_list_str) HYDU_FREE(node_list_str); HYDU_free_strlist(targs); if (path) HYDU_FREE(path); HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }
static HYD_status fn_put(int fd, int pid, int pgid, char *args[]) { int i, ret; struct HYD_proxy *proxy; struct HYD_pmcd_pmi_pg_scratch *pg_scratch; char *kvsname, *key, *val; char *tmp[HYD_NUM_TMP_STRINGS], *cmd; struct HYD_pmcd_token *tokens; int token_count; HYD_status status = HYD_SUCCESS; HYDU_FUNC_ENTER(); status = HYD_pmcd_pmi_args_to_tokens(args, &tokens, &token_count); HYDU_ERR_POP(status, "unable to convert args to tokens\n"); kvsname = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "kvsname"); HYDU_ERR_CHKANDJUMP(status, kvsname == NULL, HYD_INTERNAL_ERROR, "unable to find token: kvsname\n"); key = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "key"); HYDU_ERR_CHKANDJUMP(status, key == NULL, HYD_INTERNAL_ERROR, "unable to find token: key\n"); val = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "value"); if (val == NULL) { /* the user sent an empty string */ val = HYDU_strdup(""); } proxy = HYD_pmcd_pmi_find_proxy(fd); HYDU_ASSERT(proxy, status); pg_scratch = (struct HYD_pmcd_pmi_pg_scratch *) proxy->pg->pg_scratch; if (strcmp(pg_scratch->kvs->kvs_name, kvsname)) HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "kvsname (%s) does not match this group's kvs space (%s)\n", kvsname, pg_scratch->kvs->kvs_name); status = HYD_pmcd_pmi_add_kvs(key, val, pg_scratch->kvs, &ret); HYDU_ERR_POP(status, "unable to add keypair to kvs\n"); i = 0; tmp[i++] = HYDU_strdup("cmd=put_result rc="); tmp[i++] = HYDU_int_to_str(ret); if (ret == 0) { tmp[i++] = HYDU_strdup(" msg=success"); } else { tmp[i++] = HYDU_strdup(" msg=duplicate_key"); tmp[i++] = HYDU_strdup(key); } tmp[i++] = HYDU_strdup("\n"); tmp[i++] = NULL; status = HYDU_str_alloc_and_join(tmp, &cmd); HYDU_ERR_POP(status, "unable to join strings\n"); HYDU_free_strlist(tmp); status = cmd_response(fd, pid, cmd); HYDU_ERR_POP(status, "error writing PMI line\n"); HYDU_FREE(cmd); fn_exit: HYD_pmcd_pmi_free_tokens(tokens, token_count); HYDU_FUNC_EXIT(); return status; fn_fail: goto fn_exit; }