[mpich2-commits] r5474 - mpich2/trunk/src/pm/hydra/pm/pmiserv
balaji at mcs.anl.gov
balaji at mcs.anl.gov
Thu Oct 15 23:44:28 CDT 2009
Author: balaji
Date: 2009-10-15 23:44:28 -0500 (Thu, 15 Oct 2009)
New Revision: 5474
Modified:
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_cb.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c
Log:
Use smaller variable names where possible.
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c 2009-10-16 04:40:40 UTC (rev 5473)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c 2009-10-16 04:44:28 UTC (rev 5474)
@@ -9,7 +9,7 @@
#include "demux.h"
#include "pmi_proxy.h"
-struct HYD_pmcd_pmi_proxy_params HYD_pmcd_pmi_proxy_params;
+struct HYD_pmcd_pmip HYD_pmcd_pmip;
static HYD_status wait_for_procs_to_finish(void)
{
@@ -25,22 +25,22 @@
* are, we will just wait for more events. */
out_count = 0;
err_count = 0;
- for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++) {
- if (HYD_pmcd_pmi_proxy_params.downstream.out[i] != -1)
+ for (i = 0; i < HYD_pmcd_pmip.local.proxy_process_count; i++) {
+ if (HYD_pmcd_pmip.downstream.out[i] != -1)
out_count++;
- if (HYD_pmcd_pmi_proxy_params.downstream.err[i] != -1)
+ if (HYD_pmcd_pmip.downstream.err[i] != -1)
err_count++;
if (out_count && err_count)
break;
}
- if (HYD_pmcd_pmi_proxy_params.local.procs_are_launched) {
+ if (HYD_pmcd_pmip.local.procs_are_launched) {
if (out_count == 0)
- close(HYD_pmcd_pmi_proxy_params.upstream.out);
+ close(HYD_pmcd_pmip.upstream.out);
if (err_count == 0)
- close(HYD_pmcd_pmi_proxy_params.upstream.err);
+ close(HYD_pmcd_pmip.upstream.err);
/* We are done */
if (!out_count && !err_count)
@@ -49,21 +49,21 @@
}
do {
- if (HYD_pmcd_pmi_proxy_params.local.procs_are_launched == 0)
+ if (HYD_pmcd_pmip.local.procs_are_launched == 0)
break;
pid = waitpid(-1, &ret_status, 0);
/* Find the pid and mark it as complete. */
if (pid > 0)
- for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++)
- if (HYD_pmcd_pmi_proxy_params.downstream.pid[i] == pid)
- HYD_pmcd_pmi_proxy_params.downstream.exit_status[i] = ret_status;
+ for (i = 0; i < HYD_pmcd_pmip.local.proxy_process_count; i++)
+ if (HYD_pmcd_pmip.downstream.pid[i] == pid)
+ HYD_pmcd_pmip.downstream.exit_status[i] = ret_status;
/* Check how many more processes are pending */
count = 0;
- for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++) {
- if (HYD_pmcd_pmi_proxy_params.downstream.exit_status[i] == -1) {
+ for (i = 0; i < HYD_pmcd_pmip.local.proxy_process_count; i++) {
+ if (HYD_pmcd_pmip.downstream.exit_status[i] == -1) {
count++;
break;
}
@@ -96,23 +96,22 @@
HYDU_ERR_POP(status, "bad parameters passed to the proxy\n");
/* Process launching only happens in the runtime case over here */
- if (HYD_pmcd_pmi_proxy_params.user_global.launch_mode == HYD_LAUNCH_RUNTIME) {
- HYD_pmcd_pmi_proxy_params.upstream.out = 1;
- HYD_pmcd_pmi_proxy_params.upstream.err = 2;
- HYD_pmcd_pmi_proxy_params.upstream.in = 0;
+ if (HYD_pmcd_pmip.user_global.launch_mode == HYD_LAUNCH_RUNTIME) {
+ HYD_pmcd_pmip.upstream.out = 1;
+ HYD_pmcd_pmip.upstream.err = 2;
+ HYD_pmcd_pmip.upstream.in = 0;
/* Connect back upstream and the socket to a demux engine */
- status = HYDU_sock_connect(HYD_pmcd_pmi_proxy_params.upstream.server_name,
- HYD_pmcd_pmi_proxy_params.upstream.server_port,
- &HYD_pmcd_pmi_proxy_params.upstream.control);
+ status = HYDU_sock_connect(HYD_pmcd_pmip.upstream.server_name,
+ HYD_pmcd_pmip.upstream.server_port,
+ &HYD_pmcd_pmip.upstream.control);
HYDU_ERR_POP(status, "unable to connect to the main server\n");
- status = HYDU_sock_write(HYD_pmcd_pmi_proxy_params.upstream.control,
- &HYD_pmcd_pmi_proxy_params.local.id,
- sizeof(HYD_pmcd_pmi_proxy_params.local.id));
+ status = HYDU_sock_write(HYD_pmcd_pmip.upstream.control,
+ &HYD_pmcd_pmip.local.id, sizeof(HYD_pmcd_pmip.local.id));
HYDU_ERR_POP(status, "unable to send the proxy ID to the server\n");
- status = HYDT_dmx_register_fd(1, &HYD_pmcd_pmi_proxy_params.upstream.control,
+ status = HYDT_dmx_register_fd(1, &HYD_pmcd_pmip.upstream.control,
HYD_STDOUT, NULL, HYD_pmcd_pmi_proxy_control_cmd_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
@@ -121,15 +120,14 @@
HYDU_ERR_POP(status, "error waiting for processes to finish\n");
/* Send the exit status upstream */
- status = HYDU_sock_write(HYD_pmcd_pmi_proxy_params.upstream.control,
- HYD_pmcd_pmi_proxy_params.downstream.exit_status,
- HYD_pmcd_pmi_proxy_params.local.proxy_process_count *
- sizeof(int));
+ status = HYDU_sock_write(HYD_pmcd_pmip.upstream.control,
+ HYD_pmcd_pmip.downstream.exit_status,
+ HYD_pmcd_pmip.local.proxy_process_count * sizeof(int));
HYDU_ERR_POP(status, "unable to return exit status upstream\n");
- status = HYDT_dmx_deregister_fd(HYD_pmcd_pmi_proxy_params.upstream.control);
+ status = HYDT_dmx_deregister_fd(HYD_pmcd_pmip.upstream.control);
HYDU_ERR_POP(status, "unable to deregister fd\n");
- close(HYD_pmcd_pmi_proxy_params.upstream.control);
+ close(HYD_pmcd_pmip.upstream.control);
/* cleanup the params structure for the next job */
status = HYD_pmcd_pmi_proxy_cleanup_params();
@@ -137,8 +135,7 @@
}
else { /* Persistent mode */
status = HYDU_sock_listen(&listenfd, NULL,
- (uint16_t *) & HYD_pmcd_pmi_proxy_params.upstream.
- server_port);
+ (uint16_t *) & HYD_pmcd_pmip.upstream.server_port);
HYDU_ERR_POP(status, "unable to listen on socket\n");
/* Register the listening socket with the demux engine */
@@ -146,7 +143,7 @@
HYD_pmcd_pmi_proxy_control_connect_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
- if (HYD_pmcd_pmi_proxy_params.user_global.launch_mode == HYD_LAUNCH_BOOT) {
+ if (HYD_pmcd_pmip.user_global.launch_mode == HYD_LAUNCH_BOOT) {
/* Spawn a persistent daemon proxy and exit parent proxy */
status = HYDU_fork_and_exit(-1);
HYDU_ERR_POP(status, "Error spawning persistent proxy\n");
@@ -161,17 +158,17 @@
/* If processes had been launched and terminated, find the
* exit status, return it and cleanup everything. */
- if (HYD_pmcd_pmi_proxy_params.local.procs_are_launched) {
+ if (HYD_pmcd_pmip.local.procs_are_launched) {
/* Send the exit status upstream */
- status = HYDU_sock_write(HYD_pmcd_pmi_proxy_params.upstream.control,
- HYD_pmcd_pmi_proxy_params.downstream.exit_status,
- HYD_pmcd_pmi_proxy_params.local.proxy_process_count *
+ status = HYDU_sock_write(HYD_pmcd_pmip.upstream.control,
+ HYD_pmcd_pmip.downstream.exit_status,
+ HYD_pmcd_pmip.local.proxy_process_count *
sizeof(int));
HYDU_ERR_POP(status, "unable to return exit status upstream\n");
- status = HYDT_dmx_deregister_fd(HYD_pmcd_pmi_proxy_params.upstream.control);
+ status = HYDT_dmx_deregister_fd(HYD_pmcd_pmip.upstream.control);
HYDU_ERR_POP(status, "unable to deregister fd\n");
- close(HYD_pmcd_pmi_proxy_params.upstream.control);
+ close(HYD_pmcd_pmip.upstream.control);
/* cleanup the params structure for the next job */
status = HYD_pmcd_pmi_proxy_cleanup_params();
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h 2009-10-16 04:40:40 UTC (rev 5473)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h 2009-10-16 04:44:28 UTC (rev 5474)
@@ -11,7 +11,7 @@
#include "hydra_utils.h"
#include "pmi_common.h"
-struct HYD_pmcd_pmi_proxy_params {
+struct HYD_pmcd_pmip {
struct HYD_user_global user_global;
struct {
@@ -63,7 +63,7 @@
struct HYD_proxy_exec *exec_list;
};
-extern struct HYD_pmcd_pmi_proxy_params HYD_pmcd_pmi_proxy_params;
+extern struct HYD_pmcd_pmip HYD_pmcd_pmip;
/* utils */
HYD_status HYD_pmcd_pmi_proxy_get_params(char **t_argv);
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_cb.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_cb.c 2009-10-16 04:40:40 UTC (rev 5473)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_cb.c 2009-10-16 04:44:28 UTC (rev 5474)
@@ -10,7 +10,7 @@
#include "pmi_proxy.h"
#include "demux.h"
-struct HYD_pmcd_pmi_proxy_params HYD_pmcd_pmi_proxy_params;
+struct HYD_pmcd_pmip HYD_pmcd_pmip;
HYD_status HYD_pmcd_pmi_proxy_control_connect_cb(int fd, HYD_event_t events, void *userp)
{
@@ -65,17 +65,17 @@
status = HYD_pmcd_pmi_proxy_procinfo(fd);
}
else if (cmd == USE_AS_STDOUT) {
- HYD_pmcd_pmi_proxy_params.upstream.out = fd;
+ HYD_pmcd_pmip.upstream.out = fd;
status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
}
else if (cmd == USE_AS_STDERR) {
- HYD_pmcd_pmi_proxy_params.upstream.err = fd;
+ HYD_pmcd_pmip.upstream.err = fd;
status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
}
else if (cmd == USE_AS_STDIN) {
- HYD_pmcd_pmi_proxy_params.upstream.in = fd;
+ HYD_pmcd_pmip.upstream.in = fd;
status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
}
@@ -104,11 +104,9 @@
* since they can arrive in any order. */
if ((cmd == PROC_INFO) || (cmd == USE_AS_STDOUT) || (cmd == USE_AS_STDERR) ||
(cmd == USE_AS_STDIN))
- if ((HYD_pmcd_pmi_proxy_params.start_pid != -1) &&
- (HYD_pmcd_pmi_proxy_params.upstream.out != -1) &&
- (HYD_pmcd_pmi_proxy_params.upstream.err != -1))
- if ((HYD_pmcd_pmi_proxy_params.start_pid != 0) ||
- (HYD_pmcd_pmi_proxy_params.upstream.in != -1)) {
+ if ((HYD_pmcd_pmip.start_pid != -1) &&
+ (HYD_pmcd_pmip.upstream.out != -1) && (HYD_pmcd_pmip.upstream.err != -1))
+ if ((HYD_pmcd_pmip.start_pid != 0) || (HYD_pmcd_pmip.upstream.in != -1)) {
status = HYD_pmcd_pmi_proxy_launch_procs();
HYDU_ERR_POP(status, "HYD_pmcd_pmi_proxy_launch_procs returned error\n");
}
@@ -128,7 +126,7 @@
HYDU_FUNC_ENTER();
- status = HYDU_sock_stdout_cb(fd, events, HYD_pmcd_pmi_proxy_params.upstream.out, &closed);
+ status = HYDU_sock_stdout_cb(fd, events, HYD_pmcd_pmip.upstream.out, &closed);
HYDU_ERR_POP(status, "stdout callback error\n");
if (closed) {
@@ -136,9 +134,9 @@
status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
- for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++)
- if (HYD_pmcd_pmi_proxy_params.downstream.out[i] == fd)
- HYD_pmcd_pmi_proxy_params.downstream.out[i] = -1;
+ for (i = 0; i < HYD_pmcd_pmip.local.proxy_process_count; i++)
+ if (HYD_pmcd_pmip.downstream.out[i] == fd)
+ HYD_pmcd_pmip.downstream.out[i] = -1;
close(fd);
}
@@ -159,7 +157,7 @@
HYDU_FUNC_ENTER();
- status = HYDU_sock_stdout_cb(fd, events, HYD_pmcd_pmi_proxy_params.upstream.err, &closed);
+ status = HYDU_sock_stdout_cb(fd, events, HYD_pmcd_pmip.upstream.err, &closed);
HYDU_ERR_POP(status, "stdout callback error\n");
if (closed) {
@@ -167,9 +165,9 @@
status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
- for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++)
- if (HYD_pmcd_pmi_proxy_params.downstream.err[i] == fd)
- HYD_pmcd_pmi_proxy_params.downstream.err[i] = -1;
+ for (i = 0; i < HYD_pmcd_pmip.local.proxy_process_count; i++)
+ if (HYD_pmcd_pmip.downstream.err[i] == fd)
+ HYD_pmcd_pmip.downstream.err[i] = -1;
close(fd);
}
@@ -190,11 +188,11 @@
HYDU_FUNC_ENTER();
- status = HYDU_sock_stdin_cb(HYD_pmcd_pmi_proxy_params.downstream.in, events,
- HYD_pmcd_pmi_proxy_params.upstream.in,
- HYD_pmcd_pmi_proxy_params.local.stdin_tmp_buf,
- &HYD_pmcd_pmi_proxy_params.local.stdin_buf_count,
- &HYD_pmcd_pmi_proxy_params.local.stdin_buf_offset, &closed);
+ status = HYDU_sock_stdin_cb(HYD_pmcd_pmip.downstream.in, events,
+ HYD_pmcd_pmip.upstream.in,
+ HYD_pmcd_pmip.local.stdin_tmp_buf,
+ &HYD_pmcd_pmip.local.stdin_buf_count,
+ &HYD_pmcd_pmip.local.stdin_buf_offset, &closed);
HYDU_ERR_POP(status, "stdin callback error\n");
if (closed) {
@@ -202,9 +200,9 @@
status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
- close(HYD_pmcd_pmi_proxy_params.upstream.in);
- close(HYD_pmcd_pmi_proxy_params.downstream.in);
- HYD_pmcd_pmi_proxy_params.downstream.in = -1;
+ close(HYD_pmcd_pmip.upstream.in);
+ close(HYD_pmcd_pmip.downstream.in);
+ HYD_pmcd_pmip.downstream.in = -1;
}
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c 2009-10-16 04:40:40 UTC (rev 5473)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c 2009-10-16 04:44:28 UTC (rev 5474)
@@ -10,40 +10,40 @@
#include "hydra_utils.h"
#include "hydra_tools.h"
-struct HYD_pmcd_pmi_proxy_params HYD_pmcd_pmi_proxy_params;
+struct HYD_pmcd_pmip HYD_pmcd_pmip;
static HYD_status init_params(void)
{
HYD_status status = HYD_SUCCESS;
- HYDU_init_user_global(&HYD_pmcd_pmi_proxy_params.user_global);
+ HYDU_init_user_global(&HYD_pmcd_pmip.user_global);
- HYD_pmcd_pmi_proxy_params.system_global.global_core_count = 0;
- HYD_pmcd_pmi_proxy_params.system_global.pmi_port_str = NULL;
+ HYD_pmcd_pmip.system_global.global_core_count = 0;
+ HYD_pmcd_pmip.system_global.pmi_port_str = NULL;
- HYD_pmcd_pmi_proxy_params.upstream.server_name = NULL;
- HYD_pmcd_pmi_proxy_params.upstream.server_port = -1;
- HYD_pmcd_pmi_proxy_params.upstream.out = -1;
- HYD_pmcd_pmi_proxy_params.upstream.err = -1;
- HYD_pmcd_pmi_proxy_params.upstream.in = -1;
- HYD_pmcd_pmi_proxy_params.upstream.control = -1;
+ HYD_pmcd_pmip.upstream.server_name = NULL;
+ HYD_pmcd_pmip.upstream.server_port = -1;
+ HYD_pmcd_pmip.upstream.out = -1;
+ HYD_pmcd_pmip.upstream.err = -1;
+ HYD_pmcd_pmip.upstream.in = -1;
+ HYD_pmcd_pmip.upstream.control = -1;
- HYD_pmcd_pmi_proxy_params.downstream.out = NULL;
- HYD_pmcd_pmi_proxy_params.downstream.err = NULL;
- HYD_pmcd_pmi_proxy_params.downstream.in = -1;
- HYD_pmcd_pmi_proxy_params.downstream.pid = NULL;
- HYD_pmcd_pmi_proxy_params.downstream.exit_status = NULL;
+ HYD_pmcd_pmip.downstream.out = NULL;
+ HYD_pmcd_pmip.downstream.err = NULL;
+ HYD_pmcd_pmip.downstream.in = -1;
+ HYD_pmcd_pmip.downstream.pid = NULL;
+ HYD_pmcd_pmip.downstream.exit_status = NULL;
- HYD_pmcd_pmi_proxy_params.local.id = -1;
- HYD_pmcd_pmi_proxy_params.local.proxy_core_count = 0;
- HYD_pmcd_pmi_proxy_params.local.proxy_process_count = 0;
- HYD_pmcd_pmi_proxy_params.local.procs_are_launched = 0;
- HYD_pmcd_pmi_proxy_params.local.stdin_buf_offset = 0;
- HYD_pmcd_pmi_proxy_params.local.stdin_buf_count = 0;
- HYD_pmcd_pmi_proxy_params.local.stdin_tmp_buf[0] = '\0';
+ HYD_pmcd_pmip.local.id = -1;
+ HYD_pmcd_pmip.local.proxy_core_count = 0;
+ HYD_pmcd_pmip.local.proxy_process_count = 0;
+ HYD_pmcd_pmip.local.procs_are_launched = 0;
+ HYD_pmcd_pmip.local.stdin_buf_offset = 0;
+ HYD_pmcd_pmip.local.stdin_buf_count = 0;
+ HYD_pmcd_pmip.local.stdin_tmp_buf[0] = '\0';
- HYD_pmcd_pmi_proxy_params.start_pid = -1;
- HYD_pmcd_pmi_proxy_params.exec_list = NULL;
+ HYD_pmcd_pmip.start_pid = -1;
+ HYD_pmcd_pmip.exec_list = NULL;
return status;
}
@@ -66,7 +66,7 @@
/* Working directory */
if (!strcmp(*argv, "--wdir")) {
argv++;
- HYD_pmcd_pmi_proxy_params.user_global.wdir = HYDU_strdup(*argv);
+ HYD_pmcd_pmip.user_global.wdir = HYDU_strdup(*argv);
continue;
}
@@ -74,9 +74,9 @@
if (!strcmp(*argv, "--pmi-port-str")) {
argv++;
if (!strcmp(*argv, "HYDRA_NULL"))
- HYD_pmcd_pmi_proxy_params.system_global.pmi_port_str = NULL;
+ HYD_pmcd_pmip.system_global.pmi_port_str = NULL;
else
- HYD_pmcd_pmi_proxy_params.system_global.pmi_port_str = HYDU_strdup(*argv);
+ HYD_pmcd_pmip.system_global.pmi_port_str = HYDU_strdup(*argv);
continue;
}
@@ -84,9 +84,9 @@
if (!strcmp(*argv, "--binding")) {
argv++;
if (!strcmp(*argv, "HYDRA_NULL"))
- HYD_pmcd_pmi_proxy_params.user_global.binding = NULL;
+ HYD_pmcd_pmip.user_global.binding = NULL;
else
- HYD_pmcd_pmi_proxy_params.user_global.binding = HYDU_strdup(*argv);
+ HYD_pmcd_pmip.user_global.binding = HYDU_strdup(*argv);
continue;
}
@@ -94,28 +94,28 @@
/* Binding library */
if (!strcmp(*argv, "--bindlib")) {
argv++;
- HYD_pmcd_pmi_proxy_params.user_global.bindlib = HYDU_strdup(*argv);
+ HYD_pmcd_pmip.user_global.bindlib = HYDU_strdup(*argv);
continue;
}
/* Checkpointing library */
if (!strcmp(*argv, "--ckpointlib")) {
argv++;
- HYD_pmcd_pmi_proxy_params.user_global.ckpointlib = HYDU_strdup(*argv);
+ HYD_pmcd_pmip.user_global.ckpointlib = HYDU_strdup(*argv);
continue;
}
if (!strcmp(*argv, "--ckpoint-prefix")) {
argv++;
if (!strcmp(*argv, "HYDRA_NULL"))
- HYD_pmcd_pmi_proxy_params.user_global.ckpoint_prefix = NULL;
+ HYD_pmcd_pmip.user_global.ckpoint_prefix = NULL;
else
- HYD_pmcd_pmi_proxy_params.user_global.ckpoint_prefix = HYDU_strdup(*argv);
+ HYD_pmcd_pmip.user_global.ckpoint_prefix = HYDU_strdup(*argv);
continue;
}
if (!strcmp(*argv, "--ckpoint-restart")) {
- HYD_pmcd_pmi_proxy_params.user_global.ckpoint_restart = 1;
+ HYD_pmcd_pmip.user_global.ckpoint_restart = 1;
continue;
}
@@ -143,16 +143,12 @@
if (!strcmp(argtype, "--global-inherited-env"))
HYDU_append_env_to_list(*env,
- &HYD_pmcd_pmi_proxy_params.user_global.global_env.
- inherited);
+ &HYD_pmcd_pmip.user_global.global_env.inherited);
else if (!strcmp(argtype, "--global-system-env"))
HYDU_append_env_to_list(*env,
- &HYD_pmcd_pmi_proxy_params.user_global.global_env.
- system);
+ &HYD_pmcd_pmip.user_global.global_env.system);
else if (!strcmp(argtype, "--global-user-env"))
- HYDU_append_env_to_list(*env,
- &HYD_pmcd_pmi_proxy_params.user_global.global_env.
- user);
+ HYDU_append_env_to_list(*env, &HYD_pmcd_pmip.user_global.global_env.user);
HYDU_FREE(env);
}
@@ -163,42 +159,41 @@
if (!strcmp(*argv, "--genv-prop")) {
argv++;
if (strcmp(*argv, "HYDRA_NULL"))
- HYD_pmcd_pmi_proxy_params.user_global.global_env.prop = HYDU_strdup(*argv);
+ HYD_pmcd_pmip.user_global.global_env.prop = HYDU_strdup(*argv);
else
- HYD_pmcd_pmi_proxy_params.user_global.global_env.prop = NULL;
+ HYD_pmcd_pmip.user_global.global_env.prop = NULL;
continue;
}
/* One-pass Count */
if (!strcmp(*argv, "--global-core-count")) {
argv++;
- HYD_pmcd_pmi_proxy_params.system_global.global_core_count = atoi(*argv);
+ HYD_pmcd_pmip.system_global.global_core_count = atoi(*argv);
continue;
}
/* Process count */
if (!strcmp(*argv, "--proxy-core-count")) {
argv++;
- HYD_pmcd_pmi_proxy_params.local.proxy_core_count = atoi(*argv);
+ HYD_pmcd_pmip.local.proxy_core_count = atoi(*argv);
continue;
}
/* Process count */
if (!strcmp(*argv, "--start-pid")) {
argv++;
- HYD_pmcd_pmi_proxy_params.start_pid = atoi(*argv);
+ HYD_pmcd_pmip.start_pid = atoi(*argv);
continue;
}
/* New executable */
if (!strcmp(*argv, "--exec")) {
- if (HYD_pmcd_pmi_proxy_params.exec_list == NULL) {
- status = HYDU_alloc_proxy_exec(&HYD_pmcd_pmi_proxy_params.exec_list);
+ if (HYD_pmcd_pmip.exec_list == NULL) {
+ status = HYDU_alloc_proxy_exec(&HYD_pmcd_pmip.exec_list);
HYDU_ERR_POP(status, "unable to allocate proxy exec\n");
}
else {
- for (exec = HYD_pmcd_pmi_proxy_params.exec_list; exec->next;
- exec = exec->next);
+ for (exec = HYD_pmcd_pmip.exec_list; exec->next; exec = exec->next);
status = HYDU_alloc_proxy_exec(&exec->next);
HYDU_ERR_POP(status, "unable to allocate proxy exec\n");
}
@@ -208,7 +203,7 @@
/* Process count */
if (!strcmp(*argv, "--exec-proc-count")) {
argv++;
- for (exec = HYD_pmcd_pmi_proxy_params.exec_list; exec->next; exec = exec->next);
+ for (exec = HYD_pmcd_pmip.exec_list; exec->next; exec = exec->next);
exec->proc_count = atoi(*argv);
continue;
}
@@ -248,7 +243,7 @@
/* Fall through case is application parameters. Load
* everything into the args variable. */
- for (exec = HYD_pmcd_pmi_proxy_params.exec_list; exec->next; exec = exec->next);
+ for (exec = HYD_pmcd_pmip.exec_list; exec->next; exec = exec->next);
for (arg = 0; *argv && strcmp(*argv, "--exec");) {
exec->exec[arg++] = HYDU_strdup(*argv);
++argv;
@@ -285,61 +280,60 @@
while (++argv && *argv) {
if (!strcmp(*argv, "--launch-mode")) {
++argv;
- HYD_pmcd_pmi_proxy_params.user_global.launch_mode =
+ HYD_pmcd_pmip.user_global.launch_mode =
(HYD_launch_mode_t) (unsigned int) atoi(*argv);
continue;
}
if (!strcmp(*argv, "--proxy-port")) {
++argv;
- if (HYD_pmcd_pmi_proxy_params.user_global.launch_mode == HYD_LAUNCH_RUNTIME) {
- HYD_pmcd_pmi_proxy_params.upstream.server_name =
- HYDU_strdup(strtok(*argv, ":"));
- HYD_pmcd_pmi_proxy_params.upstream.server_port = atoi(strtok(NULL, ":"));
+ if (HYD_pmcd_pmip.user_global.launch_mode == HYD_LAUNCH_RUNTIME) {
+ HYD_pmcd_pmip.upstream.server_name = HYDU_strdup(strtok(*argv, ":"));
+ HYD_pmcd_pmip.upstream.server_port = atoi(strtok(NULL, ":"));
}
else {
- HYD_pmcd_pmi_proxy_params.upstream.server_port = atoi(*argv);
+ HYD_pmcd_pmip.upstream.server_port = atoi(*argv);
}
continue;
}
if (!strcmp(*argv, "--proxy-id")) {
++argv;
- HYD_pmcd_pmi_proxy_params.local.id = atoi(*argv);
+ HYD_pmcd_pmip.local.id = atoi(*argv);
continue;
}
if (!strcmp(*argv, "--debug")) {
- HYD_pmcd_pmi_proxy_params.user_global.debug = 1;
+ HYD_pmcd_pmip.user_global.debug = 1;
continue;
}
if (!strcmp(*argv, "--enable-x")) {
- HYD_pmcd_pmi_proxy_params.user_global.enablex = 1;
+ HYD_pmcd_pmip.user_global.enablex = 1;
continue;
}
if (!strcmp(*argv, "--disable-x")) {
- HYD_pmcd_pmi_proxy_params.user_global.enablex = 0;
+ HYD_pmcd_pmip.user_global.enablex = 0;
continue;
}
if (!strcmp(*argv, "--bootstrap")) {
++argv;
- HYD_pmcd_pmi_proxy_params.user_global.bootstrap = HYDU_strdup(*argv);
+ HYD_pmcd_pmip.user_global.bootstrap = HYDU_strdup(*argv);
continue;
}
if (!strcmp(*argv, "--bootstrap-exec")) {
++argv;
- HYD_pmcd_pmi_proxy_params.user_global.bootstrap_exec = HYDU_strdup(*argv);
+ HYD_pmcd_pmip.user_global.bootstrap_exec = HYDU_strdup(*argv);
continue;
}
}
- status = HYDT_bsci_init(HYD_pmcd_pmi_proxy_params.user_global.bootstrap,
- HYD_pmcd_pmi_proxy_params.user_global.bootstrap_exec,
- HYD_pmcd_pmi_proxy_params.user_global.enablex,
- HYD_pmcd_pmi_proxy_params.user_global.debug);
+ status = HYDT_bsci_init(HYD_pmcd_pmip.user_global.bootstrap,
+ HYD_pmcd_pmip.user_global.bootstrap_exec,
+ HYD_pmcd_pmip.user_global.enablex,
+ HYD_pmcd_pmip.user_global.debug);
HYDU_ERR_POP(status, "proxy unable to initialize bootstrap\n");
- if (HYD_pmcd_pmi_proxy_params.local.id == -1) {
+ if (HYD_pmcd_pmip.local.id == -1) {
/* We didn't get a proxy ID during launch; query the
* bootstrap server for it. */
- status = HYDT_bsci_query_proxy_id(&HYD_pmcd_pmi_proxy_params.local.id);
+ status = HYDT_bsci_query_proxy_id(&HYD_pmcd_pmip.local.id);
HYDU_ERR_POP(status, "unable to query bootstrap server for proxy ID\n");
}
@@ -359,44 +353,44 @@
HYDU_FUNC_ENTER();
- if (HYD_pmcd_pmi_proxy_params.upstream.server_name)
- HYDU_FREE(HYD_pmcd_pmi_proxy_params.upstream.server_name);
+ if (HYD_pmcd_pmip.upstream.server_name)
+ HYDU_FREE(HYD_pmcd_pmip.upstream.server_name);
- if (HYD_pmcd_pmi_proxy_params.user_global.bootstrap)
- HYDU_FREE(HYD_pmcd_pmi_proxy_params.user_global.bootstrap);
+ if (HYD_pmcd_pmip.user_global.bootstrap)
+ HYDU_FREE(HYD_pmcd_pmip.user_global.bootstrap);
- if (HYD_pmcd_pmi_proxy_params.user_global.bootstrap_exec)
- HYDU_FREE(HYD_pmcd_pmi_proxy_params.user_global.bootstrap_exec);
+ if (HYD_pmcd_pmip.user_global.bootstrap_exec)
+ HYDU_FREE(HYD_pmcd_pmip.user_global.bootstrap_exec);
- if (HYD_pmcd_pmi_proxy_params.user_global.wdir)
- HYDU_FREE(HYD_pmcd_pmi_proxy_params.user_global.wdir);
+ if (HYD_pmcd_pmip.user_global.wdir)
+ HYDU_FREE(HYD_pmcd_pmip.user_global.wdir);
- if (HYD_pmcd_pmi_proxy_params.system_global.pmi_port_str)
- HYDU_FREE(HYD_pmcd_pmi_proxy_params.system_global.pmi_port_str);
+ if (HYD_pmcd_pmip.system_global.pmi_port_str)
+ HYDU_FREE(HYD_pmcd_pmip.system_global.pmi_port_str);
- if (HYD_pmcd_pmi_proxy_params.user_global.binding)
- HYDU_FREE(HYD_pmcd_pmi_proxy_params.user_global.binding);
+ if (HYD_pmcd_pmip.user_global.binding)
+ HYDU_FREE(HYD_pmcd_pmip.user_global.binding);
- if (HYD_pmcd_pmi_proxy_params.user_global.bindlib)
- HYDU_FREE(HYD_pmcd_pmi_proxy_params.user_global.bindlib);
+ if (HYD_pmcd_pmip.user_global.bindlib)
+ HYDU_FREE(HYD_pmcd_pmip.user_global.bindlib);
- if (HYD_pmcd_pmi_proxy_params.user_global.ckpointlib)
- HYDU_FREE(HYD_pmcd_pmi_proxy_params.user_global.ckpointlib);
+ if (HYD_pmcd_pmip.user_global.ckpointlib)
+ HYDU_FREE(HYD_pmcd_pmip.user_global.ckpointlib);
- if (HYD_pmcd_pmi_proxy_params.user_global.ckpoint_prefix)
- HYDU_FREE(HYD_pmcd_pmi_proxy_params.user_global.ckpoint_prefix);
+ if (HYD_pmcd_pmip.user_global.ckpoint_prefix)
+ HYDU_FREE(HYD_pmcd_pmip.user_global.ckpoint_prefix);
- if (HYD_pmcd_pmi_proxy_params.user_global.global_env.system)
- HYDU_env_free_list(HYD_pmcd_pmi_proxy_params.user_global.global_env.system);
+ if (HYD_pmcd_pmip.user_global.global_env.system)
+ HYDU_env_free_list(HYD_pmcd_pmip.user_global.global_env.system);
- if (HYD_pmcd_pmi_proxy_params.user_global.global_env.user)
- HYDU_env_free_list(HYD_pmcd_pmi_proxy_params.user_global.global_env.user);
+ if (HYD_pmcd_pmip.user_global.global_env.user)
+ HYDU_env_free_list(HYD_pmcd_pmip.user_global.global_env.user);
- if (HYD_pmcd_pmi_proxy_params.user_global.global_env.inherited)
- HYDU_env_free_list(HYD_pmcd_pmi_proxy_params.user_global.global_env.inherited);
+ if (HYD_pmcd_pmip.user_global.global_env.inherited)
+ HYDU_env_free_list(HYD_pmcd_pmip.user_global.global_env.inherited);
- if (HYD_pmcd_pmi_proxy_params.exec_list) {
- exec = HYD_pmcd_pmi_proxy_params.exec_list;
+ if (HYD_pmcd_pmip.exec_list) {
+ exec = HYD_pmcd_pmip.exec_list;
while (exec) {
texec = exec->next;
HYDU_free_strlist(exec->exec);
@@ -407,17 +401,17 @@
}
}
- if (HYD_pmcd_pmi_proxy_params.downstream.pid)
- HYDU_FREE(HYD_pmcd_pmi_proxy_params.downstream.pid);
+ if (HYD_pmcd_pmip.downstream.pid)
+ HYDU_FREE(HYD_pmcd_pmip.downstream.pid);
- if (HYD_pmcd_pmi_proxy_params.downstream.out)
- HYDU_FREE(HYD_pmcd_pmi_proxy_params.downstream.out);
+ if (HYD_pmcd_pmip.downstream.out)
+ HYDU_FREE(HYD_pmcd_pmip.downstream.out);
- if (HYD_pmcd_pmi_proxy_params.downstream.err)
- HYDU_FREE(HYD_pmcd_pmi_proxy_params.downstream.err);
+ if (HYD_pmcd_pmip.downstream.err)
+ HYDU_FREE(HYD_pmcd_pmip.downstream.err);
- if (HYD_pmcd_pmi_proxy_params.downstream.exit_status)
- HYDU_FREE(HYD_pmcd_pmi_proxy_params.downstream.exit_status);
+ if (HYD_pmcd_pmip.downstream.exit_status)
+ HYDU_FREE(HYD_pmcd_pmip.downstream.exit_status);
HYDT_bind_finalize();
@@ -471,7 +465,7 @@
/* Save this fd as we need to send back the exit status on
* this. */
- HYD_pmcd_pmi_proxy_params.upstream.control = fd;
+ HYD_pmcd_pmip.upstream.control = fd;
fn_exit:
HYDU_FUNC_EXIT();
@@ -494,59 +488,57 @@
HYDU_FUNC_ENTER();
- HYD_pmcd_pmi_proxy_params.local.proxy_process_count = 0;
- for (exec = HYD_pmcd_pmi_proxy_params.exec_list; exec; exec = exec->next)
- HYD_pmcd_pmi_proxy_params.local.proxy_process_count += exec->proc_count;
+ HYD_pmcd_pmip.local.proxy_process_count = 0;
+ for (exec = HYD_pmcd_pmip.exec_list; exec; exec = exec->next)
+ HYD_pmcd_pmip.local.proxy_process_count += exec->proc_count;
- HYDU_MALLOC(pmi_ids, int *, HYD_pmcd_pmi_proxy_params.local.proxy_process_count *
- sizeof(int), status);
- for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++) {
+ HYDU_MALLOC(pmi_ids, int *, HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
+ for (i = 0; i < HYD_pmcd_pmip.local.proxy_process_count; i++) {
pmi_ids[i] =
- HYDU_local_to_global_id(i, HYD_pmcd_pmi_proxy_params.start_pid,
- HYD_pmcd_pmi_proxy_params.local.proxy_core_count,
- HYD_pmcd_pmi_proxy_params.system_global.global_core_count);
+ HYDU_local_to_global_id(i, HYD_pmcd_pmip.start_pid,
+ HYD_pmcd_pmip.local.proxy_core_count,
+ HYD_pmcd_pmip.system_global.global_core_count);
}
- HYDU_MALLOC(HYD_pmcd_pmi_proxy_params.downstream.out, int *,
- HYD_pmcd_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
- HYDU_MALLOC(HYD_pmcd_pmi_proxy_params.downstream.err, int *,
- HYD_pmcd_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
- HYDU_MALLOC(HYD_pmcd_pmi_proxy_params.downstream.pid, int *,
- HYD_pmcd_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
- HYDU_MALLOC(HYD_pmcd_pmi_proxy_params.downstream.exit_status, int *,
- HYD_pmcd_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
+ HYDU_MALLOC(HYD_pmcd_pmip.downstream.out, int *,
+ HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
+ HYDU_MALLOC(HYD_pmcd_pmip.downstream.err, int *,
+ HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
+ HYDU_MALLOC(HYD_pmcd_pmip.downstream.pid, int *,
+ HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
+ HYDU_MALLOC(HYD_pmcd_pmip.downstream.exit_status, int *,
+ HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
/* Initialize the exit status */
- for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++)
- HYD_pmcd_pmi_proxy_params.downstream.exit_status[i] = -1;
+ for (i = 0; i < HYD_pmcd_pmip.local.proxy_process_count; i++)
+ HYD_pmcd_pmip.downstream.exit_status[i] = -1;
- status = HYDT_bind_init(HYD_pmcd_pmi_proxy_params.user_global.binding,
- HYD_pmcd_pmi_proxy_params.user_global.bindlib);
+ status = HYDT_bind_init(HYD_pmcd_pmip.user_global.binding,
+ HYD_pmcd_pmip.user_global.bindlib);
HYDU_ERR_POP(status, "unable to initialize process binding\n");
- status = HYDT_ckpoint_init(HYD_pmcd_pmi_proxy_params.user_global.ckpointlib,
- HYD_pmcd_pmi_proxy_params.user_global.ckpoint_prefix);
+ status = HYDT_ckpoint_init(HYD_pmcd_pmip.user_global.ckpointlib,
+ HYD_pmcd_pmip.user_global.ckpoint_prefix);
HYDU_ERR_POP(status, "unable to initialize checkpointing\n");
- if (HYD_pmcd_pmi_proxy_params.user_global.ckpoint_restart) {
- status = HYDU_env_create(&env, "PMI_PORT",
- HYD_pmcd_pmi_proxy_params.system_global.pmi_port_str);
+ if (HYD_pmcd_pmip.user_global.ckpoint_restart) {
+ status = HYDU_env_create(&env, "PMI_PORT", HYD_pmcd_pmip.system_global.pmi_port_str);
HYDU_ERR_POP(status, "unable to create env\n");
/* Restart the proxy. Specify stdin fd only if pmi_id 0 is in this proxy. */
- status = HYDT_ckpoint_restart(env, HYD_pmcd_pmi_proxy_params.local.proxy_process_count,
+ status = HYDT_ckpoint_restart(env, HYD_pmcd_pmip.local.proxy_process_count,
pmi_ids,
pmi_ids[0] ? NULL :
- &HYD_pmcd_pmi_proxy_params.downstream.in,
- HYD_pmcd_pmi_proxy_params.downstream.out,
- HYD_pmcd_pmi_proxy_params.downstream.err);
+ &HYD_pmcd_pmip.downstream.in,
+ HYD_pmcd_pmip.downstream.out,
+ HYD_pmcd_pmip.downstream.err);
HYDU_ERR_POP(status, "checkpoint restart failure\n");
goto fn_spawn_complete;
}
/* Spawn the processes */
process_id = 0;
- for (exec = HYD_pmcd_pmi_proxy_params.exec_list; exec; exec = exec->next) {
+ for (exec = HYD_pmcd_pmip.exec_list; exec; exec = exec->next) {
/*
* Increasing priority order:
@@ -558,30 +550,25 @@
/* Global inherited env */
if ((exec->env_prop && !strcmp(exec->env_prop, "all")) ||
- (!exec->env_prop && !strcmp(HYD_pmcd_pmi_proxy_params.user_global.global_env.prop,
- "all"))) {
- for (env = HYD_pmcd_pmi_proxy_params.user_global.global_env.inherited; env;
- env = env->next) {
+ (!exec->env_prop && !strcmp(HYD_pmcd_pmip.user_global.global_env.prop, "all"))) {
+ for (env = HYD_pmcd_pmip.user_global.global_env.inherited; env; env = env->next) {
status = HYDU_append_env_to_list(*env, &prop_env);
HYDU_ERR_POP(status, "unable to add env to list\n");
}
}
else if ((exec->env_prop && !strncmp(exec->env_prop, "list", strlen("list"))) ||
(!exec->env_prop &&
- !strncmp(HYD_pmcd_pmi_proxy_params.user_global.global_env.prop, "list",
+ !strncmp(HYD_pmcd_pmip.user_global.global_env.prop, "list",
strlen("list")))) {
if (exec->env_prop)
list = HYDU_strdup(exec->env_prop + strlen("list:"));
else
- list = HYDU_strdup(HYD_pmcd_pmi_proxy_params.user_global.global_env.prop +
+ list = HYDU_strdup(HYD_pmcd_pmip.user_global.global_env.prop +
strlen("list:"));
envstr = strtok(list, ",");
while (envstr) {
- env =
- HYDU_env_lookup(envstr,
- HYD_pmcd_pmi_proxy_params.user_global.global_env.
- inherited);
+ env = HYDU_env_lookup(envstr, HYD_pmcd_pmip.user_global.global_env.inherited);
if (env) {
status = HYDU_append_env_to_list(*env, &prop_env);
HYDU_ERR_POP(status, "unable to add env to list\n");
@@ -591,7 +578,7 @@
}
/* Next priority order is the global user env */
- for (env = HYD_pmcd_pmi_proxy_params.user_global.global_env.user; env; env = env->next) {
+ for (env = HYD_pmcd_pmip.user_global.global_env.user; env; env = env->next) {
status = HYDU_append_env_to_list(*env, &prop_env);
HYDU_ERR_POP(status, "unable to add env to list\n");
}
@@ -603,17 +590,16 @@
}
/* Highest priority is the system env */
- for (env = HYD_pmcd_pmi_proxy_params.user_global.global_env.system; env;
- env = env->next) {
+ for (env = HYD_pmcd_pmip.user_global.global_env.system; env; env = env->next) {
status = HYDU_append_env_to_list(*env, &prop_env);
HYDU_ERR_POP(status, "unable to add env to list\n");
}
/* Set the PMI port string to connect to. We currently just
* use the global PMI port. */
- if (HYD_pmcd_pmi_proxy_params.system_global.pmi_port_str) {
+ if (HYD_pmcd_pmip.system_global.pmi_port_str) {
status = HYDU_env_create(&env, "PMI_PORT",
- HYD_pmcd_pmi_proxy_params.system_global.pmi_port_str);
+ HYD_pmcd_pmip.system_global.pmi_port_str);
HYDU_ERR_POP(status, "unable to create env\n");
status = HYDU_append_env_to_list(*env, &prop_env);
@@ -622,12 +608,11 @@
for (i = 0; i < exec->proc_count; i++) {
pmi_id = HYDU_local_to_global_id(process_id,
- HYD_pmcd_pmi_proxy_params.start_pid,
- HYD_pmcd_pmi_proxy_params.local.proxy_core_count,
- HYD_pmcd_pmi_proxy_params.system_global.
- global_core_count);
+ HYD_pmcd_pmip.start_pid,
+ HYD_pmcd_pmip.local.proxy_core_count,
+ HYD_pmcd_pmip.system_global.global_core_count);
- if (HYD_pmcd_pmi_proxy_params.system_global.pmi_port_str) {
+ if (HYD_pmcd_pmip.system_global.pmi_port_str) {
str = HYDU_int_to_str(pmi_id);
status = HYDU_env_create(&env, "PMI_ID", str);
HYDU_ERR_POP(status, "unable to create env\n");
@@ -636,7 +621,7 @@
HYDU_ERR_POP(status, "unable to add env to list\n");
}
- if (chdir(HYD_pmcd_pmi_proxy_params.user_global.wdir) < 0)
+ if (chdir(HYD_pmcd_pmip.user_global.wdir) < 0)
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unable to change wdir (%s)\n", HYDU_strerror(errno));
@@ -647,33 +632,27 @@
core = HYDT_bind_get_core_id(process_id);
if (pmi_id == 0) {
status = HYDU_create_process(client_args, prop_env,
- &HYD_pmcd_pmi_proxy_params.downstream.in,
- &HYD_pmcd_pmi_proxy_params.downstream.
- out[process_id],
- &HYD_pmcd_pmi_proxy_params.downstream.
- err[process_id],
- &HYD_pmcd_pmi_proxy_params.downstream.
- pid[process_id], core);
+ &HYD_pmcd_pmip.downstream.in,
+ &HYD_pmcd_pmip.downstream.out[process_id],
+ &HYD_pmcd_pmip.downstream.err[process_id],
+ &HYD_pmcd_pmip.downstream.pid[process_id], core);
- HYD_pmcd_pmi_proxy_params.local.stdin_buf_offset = 0;
- HYD_pmcd_pmi_proxy_params.local.stdin_buf_count = 0;
+ HYD_pmcd_pmip.local.stdin_buf_offset = 0;
+ HYD_pmcd_pmip.local.stdin_buf_count = 0;
- status = HYDU_sock_set_nonblock(HYD_pmcd_pmi_proxy_params.upstream.in);
+ status = HYDU_sock_set_nonblock(HYD_pmcd_pmip.upstream.in);
HYDU_ERR_POP(status, "unable to set upstream stdin fd to nonblocking\n");
- stdin_fd = HYD_pmcd_pmi_proxy_params.downstream.in;
+ stdin_fd = HYD_pmcd_pmip.downstream.in;
status = HYDT_dmx_register_fd(1, &stdin_fd, HYD_STDIN, NULL,
HYD_pmcd_pmi_proxy_stdin_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
}
else {
status = HYDU_create_process(client_args, prop_env, NULL,
- &HYD_pmcd_pmi_proxy_params.downstream.
- out[process_id],
- &HYD_pmcd_pmi_proxy_params.downstream.
- err[process_id],
- &HYD_pmcd_pmi_proxy_params.downstream.
- pid[process_id], core);
+ &HYD_pmcd_pmip.downstream.out[process_id],
+ &HYD_pmcd_pmip.downstream.err[process_id],
+ &HYD_pmcd_pmip.downstream.pid[process_id], core);
}
HYDU_ERR_POP(status, "create process returned error\n");
@@ -686,18 +665,18 @@
fn_spawn_complete:
/* Everything is spawned, register the required FDs */
- status = HYDT_dmx_register_fd(HYD_pmcd_pmi_proxy_params.local.proxy_process_count,
- HYD_pmcd_pmi_proxy_params.downstream.out,
+ status = HYDT_dmx_register_fd(HYD_pmcd_pmip.local.proxy_process_count,
+ HYD_pmcd_pmip.downstream.out,
HYD_STDOUT, NULL, HYD_pmcd_pmi_proxy_stdout_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
- status = HYDT_dmx_register_fd(HYD_pmcd_pmi_proxy_params.local.proxy_process_count,
- HYD_pmcd_pmi_proxy_params.downstream.err,
+ status = HYDT_dmx_register_fd(HYD_pmcd_pmip.local.proxy_process_count,
+ HYD_pmcd_pmip.downstream.err,
HYD_STDOUT, NULL, HYD_pmcd_pmi_proxy_stderr_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
/* Indicate that the processes have been launched */
- HYD_pmcd_pmi_proxy_params.local.procs_are_launched = 1;
+ HYD_pmcd_pmip.local.procs_are_launched = 1;
fn_exit:
if (pmi_ids)
@@ -717,10 +696,10 @@
HYDU_FUNC_ENTER();
/* Send the kill signal to all processes */
- for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++) {
- if (HYD_pmcd_pmi_proxy_params.downstream.pid[i] != -1) {
- kill(HYD_pmcd_pmi_proxy_params.downstream.pid[i], SIGTERM);
- kill(HYD_pmcd_pmi_proxy_params.downstream.pid[i], SIGKILL);
+ for (i = 0; i < HYD_pmcd_pmip.local.proxy_process_count; i++) {
+ if (HYD_pmcd_pmip.downstream.pid[i] != -1) {
+ kill(HYD_pmcd_pmip.downstream.pid[i], SIGTERM);
+ kill(HYD_pmcd_pmip.downstream.pid[i], SIGKILL);
}
}
More information about the mpich2-commits
mailing list