static HYD_status list_to_nodes(char *str)
{
hostlist_t hostlist;
char *host;
int k = 0;
HYD_status status = HYD_SUCCESS;
if ((hostlist = slurm_hostlist_create(str)) == NULL) {
status = HYD_FAILURE;
goto fn_fail;
}
for (host = slurm_hostlist_shift(hostlist); host; host = slurm_hostlist_shift(hostlist)) {
status = HYDU_add_to_node_list(host, tasks_per_node[k++], &global_node_list);
HYDU_ERR_POP(status, "unable to add to node list\n");
}
slurm_hostlist_destroy(hostlist);
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;
}
HYD_status HYDU_process_mfile_token(char *token, int newline, struct HYD_node **node_list)
{
int num_procs;
char *hostname, *procs, *binding, *tmp, *user, *saveptr;
struct HYD_node *node;
HYD_status status = HYD_SUCCESS;
if (newline) { /* The first entry gives the hostname and processes */
hostname = strtok_r(token, ":", &saveptr);
procs = strtok_r(NULL, ":", &saveptr);
num_procs = procs ? atoi(procs) : 1;
status = HYDU_add_to_node_list(hostname, num_procs, node_list);
HYDU_ERR_POP(status, "unable to add to node list\n");
}
else { /* Not a new line */
tmp = strtok_r(token, "=", &saveptr);
if (!strcmp(tmp, "binding")) {
binding = strtok_r(NULL, "=", &saveptr);
for (node = *node_list; node->next; node = node->next);
if (node->local_binding)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
"duplicate local binding setting\n");
node->local_binding = MPL_strdup(binding);
}
else if (!strcmp(tmp, "user")) {
user = strtok_r(NULL, "=", &saveptr);
for (node = *node_list; node->next; node = node->next);
if (node->user)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "duplicate username setting\n");
node->user = MPL_strdup(user);
}
else {
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
"token %s not supported at this time\n", token);
}
}
fn_exit:
return status;
fn_fail:
goto fn_exit;
}
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 list_to_nodes(char *str)
{
regex_t gmatch_old[2];
regex_t gmatch_new[2];
regex_t rmatch_old;
regex_t rmatch_new;
regex_t ematch_old;
regex_t ematch_new;
regmatch_t gmatch[2][MAX_GMATCH];
regmatch_t rmatch[MAX_RMATCH];
regmatch_t ematch[MAX_EMATCH];
char hostname[MAX_HOSTNAME_LEN];
char basename[MAX_HOSTNAME_LEN];
char rbegin[MAX_NNODES_STRLEN];
char rend[MAX_NNODES_STRLEN];
char *gpattern[2];
char *rpattern;
char *epattern;
char *string;
char tmp[2];
int j, begin, end, k = 0;
HYD_status status = HYD_SUCCESS;
string = MPL_strdup(str);
/* compile regex patterns for nodelist matching */
/* compile group-0 regex for old format: "[h00-h12,h14] | h00-h12 | h14" */
regcomp(&gmatch_old[0],
"(,|^)(\\[[-,a-zA-Z0-9]+\\]|[a-zA-Z]+[0-9]+-[a-zA-Z]+[0-9]+|[a-zA-Z]+[0-9]+)(,|$)",
REG_EXTENDED);
/* compile group-1 regex for old format: "h00-h12 | h14" */
regcomp(&gmatch_old[1],
"([[,]|^)([a-zA-Z]+[0-9]+-[a-zA-Z]+[0-9]+|[a-zA-Z]+[0-9]+)([],]|$)", REG_EXTENDED);
/* compile range regex for old format: "h00-h12" */
regcomp(&rmatch_old, "([a-zA-Z]+)([0-9]+)-([a-zA-Z]+)([0-9]+)", REG_EXTENDED);
/* compile element regex for old format: "h14" */
regcomp(&ematch_old, "([a-zA-Z]+[0-9]+)", REG_EXTENDED);
/* compile group-0 regex for new format: "h-[00-12,14] | h-14" */
regcomp(&gmatch_new[0], "(,|^)([a-zA-Z]+[0-9]*-)(\\[[-,0-9]+\\]|[0-9]+)(,|$)", REG_EXTENDED);
/* compile group-1 regex for new format: "00-12 | 14" */
regcomp(&gmatch_new[1], "([[,]|^)([0-9]+-[0-9]+|[0-9]+)([],]|$)", REG_EXTENDED);
/* compile range regex for new format: "00-12" */
regcomp(&rmatch_new, "([0-9]+)-([0-9]+)", REG_EXTENDED);
/* compile element regex for new format: "14" */
regcomp(&ematch_new, "([0-9]+)", REG_EXTENDED);
gpattern[0] = string;
/* match old group-0 pattern: (,|^)([h00-h12,h14] | h00-h12 | h14)(,|$) */
while (*gpattern[0] && regexec(&gmatch_old[0], gpattern[0], MAX_GMATCH, gmatch[0], 0) == 0) {
/* bound group-0 for group-1 matching: [h00-h12,h14],... -> [h00-h12,h14]\0... */
tmp[0] = *(gpattern[0] + gmatch[0][0].rm_eo);
*(gpattern[0] + gmatch[0][0].rm_eo) = 0;
/* select second atom in group-0 */
gpattern[1] = gpattern[0] + gmatch[0][2].rm_so;
/* match group-1 pattern: ([|,|^)(h00-h12 | h14)(]|,|$) */
while (*gpattern[1] && regexec(&gmatch_old[1], gpattern[1], MAX_GMATCH, gmatch[1], 0) == 0) {
/* bound group-1 for range/element matching: h00-h12, -> h00-h12\0 | h14] -> h14\0 */
tmp[1] = *(gpattern[1] + gmatch[1][0].rm_eo);
*(gpattern[1] + gmatch[1][0].rm_eo) = 0;
/* select second atom in group-1 */
rpattern = gpattern[1] + gmatch[1][2].rm_so;
epattern = rpattern;
if (regexec(&rmatch_old, rpattern, MAX_RMATCH, rmatch, 0) == 0) {
/* matched range: (h)(00)-(h)(12) */
snprintf(basename, MAX_HOSTNAME_LEN, "%.*s%c",
(int) (rmatch[1].rm_eo - rmatch[1].rm_so), rpattern + rmatch[1].rm_so,
'\0');
snprintf(rbegin, MAX_NNODES_STRLEN, "%.*s%c",
(int) (rmatch[2].rm_eo - rmatch[2].rm_so), rpattern + rmatch[2].rm_so,
'\0');
snprintf(rend, MAX_NNODES_STRLEN, "%.*s%c",
(int) (rmatch[4].rm_eo - rmatch[4].rm_so), rpattern + rmatch[4].rm_so,
'\0');
begin = atoi(rbegin);
end = atoi(rend);
/* expand range and add nodes to global node list */
for (j = begin; j <= end; j++) {
snprintf(hostname, MAX_HOSTNAME_LEN, "%s%.*d%c",
basename, (int) (rmatch[2].rm_eo - rmatch[2].rm_so), j, '\0');
status =
HYDU_add_to_node_list(hostname, tasks_per_node[k++], &global_node_list);
HYDU_ERR_POP(status, "unable to add to node list\n");
}
} else if (regexec(&ematch_old, epattern, MAX_EMATCH, ematch, 0) == 0) {
/* matched element: (h14) */
snprintf(hostname, MAX_HOSTNAME_LEN, "%.*s%c",
(int) (ematch[1].rm_eo - ematch[1].rm_so), epattern + ematch[1].rm_so,
'\0');
status = HYDU_add_to_node_list(hostname, tasks_per_node[k++], &global_node_list);
HYDU_ERR_POP(status, "unable to add to node list\n");
}
/* unbound group-1 and move to next group-1: h00-h12\0 -> h00-h12, | h14\0 -> h14] */
*(gpattern[1] + gmatch[1][0].rm_eo) = tmp[1];
gpattern[1] += gmatch[1][0].rm_eo;
}
/* unbound group-0 and move to next group-0: [h00-h12,h14]\0... -> [h00-h12,h14],... */
*(gpattern[0] + gmatch[0][0].rm_eo) = tmp[0];
gpattern[0] += gmatch[0][0].rm_eo;
}
/* match new group-0 pattern: (,|^)(h-)([00-12,14] | 00-12 | 14)(,|$) */
while (*gpattern[0] && regexec(&gmatch_new[0], gpattern[0], MAX_GMATCH, gmatch[0], 0) == 0) {
/* bound group-0 for group-1 matching: h-[00-h12,14],... -> h-[00-12,14]\0... */
tmp[0] = *(gpattern[0] + gmatch[0][0].rm_eo);
*(gpattern[0] + gmatch[0][0].rm_eo) = 0;
/* extranct basename from atom 2 in group-0 */
sprintf(basename, "%.*s%c",
(int) (gmatch[0][2].rm_eo - gmatch[0][2].rm_so), gpattern[0] + gmatch[0][2].rm_so,
'\0');
/* select third atom in group-0 */
gpattern[1] = gpattern[0] + gmatch[0][3].rm_so;
/* match new group-1 pattern: ([|,|^)(00-12 | 14)(]|,|$) */
while (*gpattern[1] && regexec(&gmatch_new[1], gpattern[1], MAX_GMATCH, gmatch[1], 0) == 0) {
/* bound group-1 for range/element matching: 00-12, -> 00-12\0 | 14] -> 14\0 */
tmp[1] = *(gpattern[1] + gmatch[1][0].rm_eo);
*(gpattern[1] + gmatch[1][0].rm_eo) = 0;
/* select second atom in group-1 */
rpattern = gpattern[1] + gmatch[1][2].rm_so;
epattern = rpattern;
if (regexec(&rmatch_new, rpattern, MAX_RMATCH, rmatch, 0) == 0) {
/* matched range: (00)-(10) */
snprintf(rbegin, MAX_NNODES_STRLEN, "%.*s%c",
(int) (rmatch[1].rm_eo - rmatch[1].rm_so), rpattern + rmatch[1].rm_so,
'\0');
snprintf(rend, MAX_NNODES_STRLEN, "%.*s%c",
(int) (rmatch[2].rm_eo - rmatch[2].rm_so), rpattern + rmatch[2].rm_so,
'\0');
begin = atoi(rbegin);
end = atoi(rend);
/* expand range and add nodes to global node list */
for (j = begin; j <= end; j++) {
sprintf(hostname, "%s%.*d%c",
basename, (int) (rmatch[1].rm_eo - rmatch[1].rm_so), j, '\0');
status =
HYDU_add_to_node_list(hostname, tasks_per_node[k++], &global_node_list);
HYDU_ERR_POP(status, "unable to add to node list\n");
}
} else if (regexec(&ematch_new, epattern, MAX_EMATCH, ematch, 0) == 0) {
/* matched element: (14) */
sprintf(rbegin, "%.*s%c",
(int) (ematch[1].rm_eo - ematch[1].rm_so), epattern + ematch[1].rm_so,
'\0');
sprintf(hostname, "%s%s%c", basename, rbegin, '\0');
status = HYDU_add_to_node_list(hostname, tasks_per_node[k++], &global_node_list);
HYDU_ERR_POP(status, "unable to add to node list\n");
}
/* unbound group-1 and move to next group-1: 00-10\0 -> 00-10, | 14\0 -> 14] */
*(gpattern[1] + gmatch[1][0].rm_eo) = tmp[1];
gpattern[1] += gmatch[1][0].rm_eo;
}
/* unbound group-0 and move to next group-0: h-[00-12,14]\0... -> h-[00-12,14],... */
*(gpattern[0] + gmatch[0][0].rm_eo) = tmp[0];
gpattern[0] += gmatch[0][0].rm_eo;
}
/* clean up match patterns */
regfree(&gmatch_old[0]);
regfree(&gmatch_new[0]);
regfree(&gmatch_old[1]);
regfree(&gmatch_new[1]);
regfree(&rmatch_old);
regfree(&rmatch_new);
regfree(&ematch_old);
regfree(&ematch_new);
/* free local nodelist */
MPL_free(string);
fn_exit:
return status;
fn_fail:
goto fn_exit;
}
static HYD_status group_to_nodes(char *str)
{
char *nodes, *tnodes, *tmp, *start_str, *end_str, **set;
int start, end, i, j, k = 0;
HYD_status status = HYD_SUCCESS;
for (tmp = str; *tmp != '[' && *tmp != 0; tmp++);
if (*tmp == 0) { /* only one node in the group */
status = HYDU_add_to_node_list(str, tasks_per_node[k++], &global_node_list);
HYDU_ERR_POP(status, "unable to add to node list\n");
goto fn_exit;
}
/* more than one node in the group */
*tmp = 0;
nodes = tmp + 1;
for (tmp = nodes; *tmp != ']' && *tmp != 0; tmp++);
*tmp = 0; /* remove the closing ']' */
/* Find the number of sets */
tnodes = MPL_strdup(nodes);
tmp = strtok(tnodes, ",");
for (i = 1; tmp; i++)
tmp = strtok(NULL, ",");
HYDU_MALLOC_OR_JUMP(set, char **, i * sizeof(char *), status);
/* Find the actual node sets */
set[0] = strtok(nodes, ",");
for (i = 1; set[i - 1]; i++)
set[i] = strtok(NULL, ",");
for (i = 0; set[i]; i++) {
start_str = strtok(set[i], "-");
if ((end_str = strtok(NULL, "-")) == NULL)
end_str = start_str;
start = atoi(start_str);
end = atoi(end_str);
for (j = start; j <= end; j++) {
char *node_str[HYD_NUM_TMP_STRINGS];
node_str[0] = MPL_strdup(str);
node_str[1] = HYDU_int_to_str_pad(j, strlen(start_str));
node_str[2] = NULL;
status = HYDU_str_alloc_and_join(node_str, &tmp);
HYDU_ERR_POP(status, "unable to join strings\n");
HYDU_free_strlist(node_str);
status = HYDU_add_to_node_list(tmp, tasks_per_node[k++], &global_node_list);
HYDU_ERR_POP(status, "unable to add to node list\n");
}
}
fn_exit:
return status;
fn_fail:
goto fn_exit;
}
int main(int argc, char **argv)
{
struct HYD_proxy *proxy;
struct HYD_exec *exec;
struct HYD_node *node;
int exit_status = 0, i, timeout, reset_rmk, global_core_count;
HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
/* Initialize engines that don't require use to know anything
* about the user preferences first */
status = HYDU_dbg_init("mpiexec");
HYDU_ERR_POP(status, "unable to initialization debugging\n");
status = HYDU_set_common_signals(signal_cb);
HYDU_ERR_POP(status, "unable to set signal\n");
status = HYDT_ftb_init();
HYDU_ERR_POP(status, "unable to initialize FTB\n");
/* Get user preferences */
status = HYD_uii_mpx_get_parameters(argv);
HYDU_ERR_POP(status, "error parsing parameters\n");
/* Now we initialize engines that require us to know user
* preferences */
#if HAVE_ALARM
if (HYD_ui_mpich_info.ckpoint_int != -1)
alarm(HYD_ui_mpich_info.ckpoint_int);
#endif /* HAVE_ALARM */
/* The demux engine should be initialized before any sockets are
* created, since it checks for STDIN's validity. If STDIN was
* closed and we opened a socket that got the same fd as STDIN,
* this test will not be possible. */
status = HYDT_dmx_init(&HYD_server_info.user_global.demux);
HYDU_ERR_POP(status, "unable to initialize the demux engine\n");
status =
HYDT_bsci_init(HYD_server_info.user_global.rmk, HYD_server_info.user_global.launcher,
HYD_server_info.user_global.launcher_exec,
HYD_server_info.user_global.enablex, HYD_server_info.user_global.debug);
HYDU_ERR_POP(status, "unable to initialize the bootstrap server\n");
reset_rmk = 0;
if (HYD_server_info.node_list == NULL) {
/* Node list is not created yet. The user might not have
* provided the host file. Query the RMK. */
status = HYDT_bsci_query_node_list(&HYD_server_info.node_list);
HYDU_ERR_POP(status, "unable to query the RMK for a node list\n");
if (HYD_server_info.node_list == NULL) {
char localhost[MAX_HOSTNAME_LEN] = { 0 };
/* The RMK didn't give us anything back; use localhost */
status = HYDU_gethostname(localhost);
HYDU_ERR_POP(status, "unable to get local hostname\n");
status = HYDU_add_to_node_list(localhost, 1, &HYD_server_info.node_list);
HYDU_ERR_POP(status, "unable to add to node list\n");
reset_rmk = 1;
}
}
/*
* If this is a checkpoint-restart, if the user specified the
* number of processes, we already have a dummy executable. If the
* number of processes came from the RMK, our executable list is
* still NULL; a dummy executable needs to be created.
*/
if (HYD_uii_mpx_exec_list == NULL) {
HYDU_ASSERT(HYD_server_info.user_global.ckpoint_prefix, status);
/* create a dummy executable */
status = HYDU_alloc_exec(&HYD_uii_mpx_exec_list);
HYDU_ERR_POP(status, "unable to allocate exec\n");
HYD_uii_mpx_exec_list->appnum = 0;
}
if (HYD_server_info.user_global.debug)
for (node = HYD_server_info.node_list; node; node = node->next)
HYDU_dump_noprefix(stdout, "host: %s\n", node->hostname);
/* Reset the host list to use only the number of processes per
* node as specified by the ppn option. */
if (HYD_ui_mpich_info.ppn != -1) {
for (node = HYD_server_info.node_list; node; node = node->next)
node->core_count = HYD_ui_mpich_info.ppn;
reset_rmk = 1;
}
/* The RMK returned a node list. See if the user requested us to
* manipulate it in some way */
if (HYD_ui_mpich_info.sort_order != NONE) {
qsort_node_list();
reset_rmk = 1;
}
if (reset_rmk) {
/* Reassign node IDs to each node */
for (node = HYD_server_info.node_list, i = 0; node; node = node->next, i++)
node->node_id = i;
/* Reinitialize the bootstrap server with the "user" RMK, so
* it knows that we are not using the node list provided by
* the RMK */
status = HYDT_bsci_finalize();
HYDU_ERR_POP(status, "unable to finalize bootstrap device\n");
status = HYDT_bsci_init("user", HYDT_bsci_info.launcher, HYDT_bsci_info.launcher_exec,
HYDT_bsci_info.enablex, HYDT_bsci_info.debug);
HYDU_ERR_POP(status, "unable to reinitialize the bootstrap server\n");
}
/* If the number of processes is not given, we allocate all the
* available nodes to each executable */
HYD_server_info.pg_list.pg_process_count = 0;
for (exec = HYD_uii_mpx_exec_list; exec; exec = exec->next) {
if (exec->proc_count == -1) {
global_core_count = 0;
for (node = HYD_server_info.node_list, i = 0; node; node = node->next, i++)
global_core_count += node->core_count;
exec->proc_count = global_core_count;
}
HYD_server_info.pg_list.pg_process_count += exec->proc_count;
}
status = HYDU_list_inherited_env(&HYD_server_info.user_global.global_env.inherited);
HYDU_ERR_POP(status, "unable to get the inherited env list\n");
status = HYDU_create_proxy_list(HYD_uii_mpx_exec_list, HYD_server_info.node_list,
&HYD_server_info.pg_list);
HYDU_ERR_POP(status, "unable to create proxy list\n");
/* calculate the core count used by the PG */
HYD_server_info.pg_list.pg_core_count = 0;
for (proxy = HYD_server_info.pg_list.proxy_list; proxy; proxy = proxy->next)
HYD_server_info.pg_list.pg_core_count += proxy->node->core_count;
/* If the user didn't specify a local hostname, try to find one in
* the list of nodes passed to us */
if (HYD_server_info.localhost == NULL) {
/* See if the node list contains a remotely accessible localhost */
for (node = HYD_server_info.node_list; node; node = node->next) {
int is_local, remote_access;
status = HYDU_sock_is_local(node->hostname, &is_local);
HYDU_ERR_POP(status, "unable to check if %s is local\n", node->hostname);
if (is_local) {
status = HYDU_sock_remote_access(node->hostname, &remote_access);
HYDU_ERR_POP(status, "unable to check if %s is remotely accessible\n",
node->hostname);
if (remote_access)
break;
}
}
if (node)
HYD_server_info.localhost = HYDU_strdup(node->hostname);
else {
HYDU_MALLOC(HYD_server_info.localhost, char *, MAX_HOSTNAME_LEN, status);
status = HYDU_gethostname(HYD_server_info.localhost);
HYDU_ERR_POP(status, "unable to get local hostname\n");
}
}
if (HYD_server_info.user_global.debug)
HYD_uiu_print_params();
if (MPL_env2int("MPIEXEC_TIMEOUT", &timeout) == 0)
timeout = -1; /* Infinite timeout */
if (HYD_server_info.user_global.debug)
HYDU_dump(stdout, "Timeout set to %d (-1 means infinite)\n", timeout);
/* Check if the user wants us to use a port within a certain
* range. */
if (MPL_env2str("MPIEXEC_PORTRANGE", (const char **) &HYD_server_info.port_range) ||
MPL_env2str("MPIEXEC_PORT_RANGE", (const char **) &HYD_server_info.port_range) ||
MPL_env2str("MPICH_PORT_RANGE", (const char **) &HYD_server_info.port_range))
HYD_server_info.port_range = HYDU_strdup(HYD_server_info.port_range);
/* Add the stdout/stderr callback handlers */
HYD_server_info.stdout_cb = HYD_uiu_stdout_cb;
HYD_server_info.stderr_cb = HYD_uiu_stderr_cb;
/* Create a pipe connection to wake up the process manager */
if (pipe(HYD_server_info.cmd_pipe) < 0)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "pipe error\n");
/* Launch the processes */
status = HYD_pmci_launch_procs();
HYDU_ERR_POP(status, "process manager returned error launching processes\n");
/* Wait for their completion */
status = HYD_pmci_wait_for_completion(timeout);
HYDU_ERR_POP(status, "process manager error waiting for completion\n");
/* Check for the exit status for all the processes */
if (HYD_ui_mpich_info.print_all_exitcodes)
HYDU_dump(stdout, "Exit codes: ");
exit_status = 0;
for (proxy = HYD_server_info.pg_list.proxy_list; proxy; proxy = proxy->next) {
if (proxy->exit_status == NULL) {
/* We didn't receive the exit status for this proxy */
continue;
}
if (HYD_ui_mpich_info.print_all_exitcodes)
HYDU_dump_noprefix(stdout, "[%s] ", proxy->node->hostname);
for (i = 0; i < proxy->proxy_process_count; i++) {
if (HYD_ui_mpich_info.print_all_exitcodes) {
HYDU_dump_noprefix(stdout, "%d", proxy->exit_status[i]);
if (i < proxy->proxy_process_count - 1)
HYDU_dump_noprefix(stdout, ",");
}
exit_status |= proxy->exit_status[i];
}
if (HYD_ui_mpich_info.print_all_exitcodes)
HYDU_dump_noprefix(stdout, "\n");
}
/* Call finalize functions for lower layers to cleanup their resources */
status = HYD_pmci_finalize();
HYDU_ERR_POP(status, "process manager error on finalize\n");
status = HYDT_ftb_finalize();
HYDU_ERR_POP(status, "error finalizing FTB\n");
#if defined ENABLE_PROFILING
if (HYD_server_info.enable_profiling) {
HYDU_dump_noprefix(stdout, "\n");
HYD_DRAW_LINE(80);
HYDU_dump(stdout, "Number of PMI calls seen by the server: %d\n",
HYD_server_info.num_pmi_calls);
HYD_DRAW_LINE(80);
HYDU_dump_noprefix(stdout, "\n");
}
#endif /* ENABLE_PROFILING */
/* Free the mpiexec params */
HYD_uiu_free_params();
HYDU_free_exec_list(HYD_uii_mpx_exec_list);
fn_exit:
HYDU_dbg_finalize();
HYDU_FUNC_EXIT();
if (status == HYD_GRACEFUL_ABORT)
return 0;
else if (status != HYD_SUCCESS)
return -1;
else if (WIFSIGNALED(exit_status)) {
printf("YOUR APPLICATION TERMINATED WITH THE EXIT STRING: %s (signal %d)\n",
strsignal(WTERMSIG(exit_status)), WTERMSIG(exit_status));
printf("This typically refers to a problem with your application.\n");
printf("Please see the FAQ page for debugging suggestions\n");
return exit_status;
}
else if (WIFEXITED(exit_status)) {
return WEXITSTATUS(exit_status);
}
else if (WIFSTOPPED(exit_status)) {
return WSTOPSIG(exit_status);
}
else {
return exit_status;
}
fn_fail:
goto fn_exit;
}
