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;
}
