[mpich2-commits] r5454 - in mpich2/trunk/src/pm/hydra: include pm/pmiserv rmk/src ui/mpiexec ui/utils
balaji at mcs.anl.gov
balaji at mcs.anl.gov
Wed Oct 14 06:35:36 CDT 2009
Author: balaji
Date: 2009-10-14 06:35:35 -0500 (Wed, 14 Oct 2009)
New Revision: 5454
Modified:
mpich2/trunk/src/pm/hydra/include/hydra.h
mpich2/trunk/src/pm/hydra/include/hydra_base.h
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v1.c
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
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_finalize.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c
mpich2/trunk/src/pm/hydra/rmk/src/rmki_init.c.in
mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.c
mpich2/trunk/src/pm/hydra/ui/mpiexec/utils.c
mpich2/trunk/src/pm/hydra/ui/utils/uiu.c
Log:
Organize the proxy parameters to allow for better structure sharing
between the UI and the proxies.
Modified: mpich2/trunk/src/pm/hydra/include/hydra.h
===================================================================
--- mpich2/trunk/src/pm/hydra/include/hydra.h 2009-10-14 11:35:29 UTC (rev 5453)
+++ mpich2/trunk/src/pm/hydra/include/hydra.h 2009-10-14 11:35:35 UTC (rev 5454)
@@ -12,34 +12,22 @@
#include "hydra_utils.h"
struct HYD_Handle_ {
+ struct HYD_User_global user_global;
+
char *base_path;
int proxy_port;
- HYD_Launch_mode_t launch_mode;
- char *bootstrap;
char *css;
char *rmk;
- char *binding;
- char *bindlib;
-
- char *ckpointlib;
int ckpoint_int;
- char *ckpoint_prefix;
- int ckpoint_restart;
- int debug;
int print_rank_map;
int print_all_exitcodes;
- int enablex;
int pm_env;
- char *wdir;
int ranks_per_proc;
- char *bootstrap_exec;
- struct HYD_Env_global global_env;
-
HYD_Status(*stdin_cb) (int fd, HYD_Event_t events, void *userp);
HYD_Status(*stdout_cb) (int fd, HYD_Event_t events, void *userp);
HYD_Status(*stderr_cb) (int fd, HYD_Event_t events, void *userp);
Modified: mpich2/trunk/src/pm/hydra/include/hydra_base.h
===================================================================
--- mpich2/trunk/src/pm/hydra/include/hydra_base.h 2009-10-14 11:35:29 UTC (rev 5453)
+++ mpich2/trunk/src/pm/hydra/include/hydra_base.h 2009-10-14 11:35:35 UTC (rev 5454)
@@ -55,11 +55,6 @@
#define HYDRA_MAX_PATH 4096
-#if defined MANUAL_EXTERN_ENVIRON
-extern char **environ;
-#endif /* MANUAL_EXTERN_ENVIRON */
-
-
/* sockets required headers */
#include <poll.h>
#include <fcntl.h>
@@ -71,26 +66,44 @@
#include <sys/socket.h>
#endif
-#if defined(HAVE_PUTENV) && defined(NEEDS_PUTENV_DECL)
-extern int putenv(char *string);
-#endif
-
-#if defined(NEEDS_GETHOSTNAME_DECL)
-int gethostname(char *name, size_t len);
-#endif
-
#define HYD_DEFAULT_PROXY_PORT 9899
#define HYD_STDOUT (1)
#define HYD_STDIN (2)
-typedef unsigned short HYD_Event_t;
-
#define HYD_TMPBUF_SIZE (64 * 1024)
#define HYD_TMP_STRLEN 1024
#define HYD_NUM_TMP_STRINGS 200
+#if !defined HAVE_PTHREAD_H
+#error "pthread.h needed"
+#else
+#include <pthread.h>
+#endif
+#define dprintf(...)
+
+#ifndef ATTRIBUTE
+#ifdef HAVE_GCC_ATTRIBUTE
+#define ATTRIBUTE(a_) __attribute__(a_)
+#else
+#define ATTRIBUTE(a_)
+#endif
+#endif
+
+#define PROXY_IS_ACTIVE(proxy, total_procs) \
+ ((proxy)->segment_list->start_pid <= (total_procs))
+
+#define FORALL_ACTIVE_PROXIES(proxy, proxy_list) \
+ for ((proxy) = (proxy_list); (proxy) && (proxy)->active; (proxy) = (proxy)->next)
+
+#define FORALL_PROXIES(proxy, proxy_list) \
+ for ((proxy) = (proxy_list); (proxy); (proxy) = (proxy)->next)
+
+#if defined MANUAL_EXTERN_ENVIRON
+extern char **environ;
+#endif /* MANUAL_EXTERN_ENVIRON */
+
/* Status information */
typedef enum {
HYD_SUCCESS = 0,
@@ -101,7 +114,6 @@
HYD_INTERNAL_ERROR
} HYD_Status;
-
/* Proxy type */
typedef enum {
HYD_LAUNCH_UNSET,
@@ -114,7 +126,16 @@
HYD_LAUNCH_PERSISTENT
} HYD_Launch_mode_t;
+#if defined(HAVE_PUTENV) && defined(NEEDS_PUTENV_DECL)
+extern int putenv(char *string);
+#endif
+#if defined(NEEDS_GETHOSTNAME_DECL)
+int gethostname(char *name, size_t len);
+#endif
+
+typedef unsigned short HYD_Event_t;
+
/* Environment information */
typedef struct HYD_Env {
char *env_name;
@@ -141,31 +162,6 @@
char *prop;
};
-#if !defined HAVE_PTHREAD_H
-#error "pthread.h needed"
-#else
-#include <pthread.h>
-#endif
-
-#define dprintf(...)
-
-#ifndef ATTRIBUTE
-#ifdef HAVE_GCC_ATTRIBUTE
-#define ATTRIBUTE(a_) __attribute__(a_)
-#else
-#define ATTRIBUTE(a_)
-#endif
-#endif
-
-#define PROXY_IS_ACTIVE(proxy, total_procs) \
- ((proxy)->segment_list->start_pid <= (total_procs))
-
-#define FORALL_ACTIVE_PROXIES(proxy, proxy_list) \
- for ((proxy) = (proxy_list); (proxy) && (proxy)->active; (proxy) = (proxy)->next)
-
-#define FORALL_PROXIES(proxy, proxy_list) \
- for ((proxy) = (proxy_list); (proxy); (proxy) = (proxy)->next)
-
/* List of contiguous segments of processes on a proxy */
struct HYD_Proxy_segment {
int start_pid;
@@ -222,4 +218,27 @@
struct HYD_Exec_info *next;
};
+/* Global user parameters */
+struct HYD_User_global {
+ /* Bootstrap server */
+ char *bootstrap;
+ char *bootstrap_exec;
+
+ /* Process binding */
+ char *binding;
+ char *bindlib;
+
+ /* Checkpoint restart */
+ char *ckpointlib;
+ char *ckpoint_prefix;
+ int ckpoint_restart;
+
+ /* Other random parameters */
+ int enablex;
+ int debug;
+ char *wdir;
+ HYD_Launch_mode_t launch_mode;
+ struct HYD_Env_global global_env;
+};
+
#endif /* HYDRA_BASE_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v1.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v1.c 2009-10-14 11:35:29 UTC (rev 5453)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v1.c 2009-10-14 11:35:35 UTC (rev 5454)
@@ -51,7 +51,7 @@
tmp[i++] = HYDU_int_to_str(rank);
tmp[i++] = HYDU_strdup("\ncmd=set debug=");
- tmp[i++] = HYDU_int_to_str(HYD_handle.debug);
+ tmp[i++] = HYDU_int_to_str(HYD_handle.user_global.debug);
tmp[i++] = HYDU_strdup("\n");
tmp[i++] = NULL;
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c 2009-10-14 11:35:29 UTC (rev 5453)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c 2009-10-14 11:35:35 UTC (rev 5454)
@@ -25,17 +25,17 @@
* are, we will just wait for more events. */
out_count = 0;
err_count = 0;
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.exec_proc_count; i++) {
- if (HYD_PMCD_pmi_proxy_params.out[i] != -1)
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.process_count; i++) {
+ if (HYD_PMCD_pmi_proxy_params.downstream.out[i] != -1)
out_count++;
- if (HYD_PMCD_pmi_proxy_params.err[i] != -1)
+ if (HYD_PMCD_pmi_proxy_params.downstream.err[i] != -1)
err_count++;
if (out_count && err_count)
break;
}
- if (HYD_PMCD_pmi_proxy_params.procs_are_launched) {
+ if (HYD_PMCD_pmi_proxy_params.local.procs_are_launched) {
if (out_count == 0)
close(HYD_PMCD_pmi_proxy_params.upstream.out);
@@ -49,21 +49,21 @@
}
do {
- if (HYD_PMCD_pmi_proxy_params.procs_are_launched == 0)
+ if (HYD_PMCD_pmi_proxy_params.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.exec_proc_count; i++)
- if (HYD_PMCD_pmi_proxy_params.pid[i] == pid)
- HYD_PMCD_pmi_proxy_params.exit_status[i] = ret_status;
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.process_count; i++)
+ if (HYD_PMCD_pmi_proxy_params.downstream.pid[i] == pid)
+ HYD_PMCD_pmi_proxy_params.downstream.exit_status[i] = ret_status;
/* Check how many more processes are pending */
count = 0;
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.exec_proc_count; i++) {
- if (HYD_PMCD_pmi_proxy_params.exit_status[i] == -1) {
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.process_count; i++) {
+ if (HYD_PMCD_pmi_proxy_params.downstream.exit_status[i] == -1) {
count++;
break;
}
@@ -96,20 +96,20 @@
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.proxy.launch_mode == HYD_LAUNCH_RUNTIME) {
+ 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;
/* Connect back upstream and the socket to a demux engine */
- status = HYDU_sock_connect(HYD_PMCD_pmi_proxy_params.proxy.server_name,
- HYD_PMCD_pmi_proxy_params.proxy.server_port,
+ 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);
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.proxy.proxy_id,
- sizeof(HYD_PMCD_pmi_proxy_params.proxy.proxy_id));
+ &HYD_PMCD_pmi_proxy_params.local.id,
+ sizeof(HYD_PMCD_pmi_proxy_params.local.id));
HYDU_ERR_POP(status, "unable to send the proxy ID to the server\n");
status = HYD_DMX_register_fd(1, &HYD_PMCD_pmi_proxy_params.upstream.control,
@@ -122,8 +122,8 @@
/* Send the exit status upstream */
status = HYDU_sock_write(HYD_PMCD_pmi_proxy_params.upstream.control,
- HYD_PMCD_pmi_proxy_params.exit_status,
- HYD_PMCD_pmi_proxy_params.exec_proc_count * sizeof(int));
+ HYD_PMCD_pmi_proxy_params.downstream.exit_status,
+ HYD_PMCD_pmi_proxy_params.local.process_count * sizeof(int));
HYDU_ERR_POP(status, "unable to return exit status upstream\n");
status = HYD_DMX_deregister_fd(HYD_PMCD_pmi_proxy_params.upstream.control);
@@ -136,7 +136,7 @@
}
else { /* Persistent mode */
status = HYDU_sock_listen(&listenfd, NULL,
- (uint16_t *) & HYD_PMCD_pmi_proxy_params.proxy.server_port);
+ (uint16_t *) & HYD_PMCD_pmi_proxy_params.upstream.server_port);
HYDU_ERR_POP(status, "unable to listen on socket\n");
/* Register the listening socket with the demux engine */
@@ -144,7 +144,7 @@
HYD_PMCD_pmi_proxy_control_connect_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
- if (HYD_PMCD_pmi_proxy_params.proxy.launch_mode == HYD_LAUNCH_BOOT) {
+ if (HYD_PMCD_pmi_proxy_params.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");
@@ -159,11 +159,11 @@
/* If processes had been launched and terminated, find the
* exit status, return it and cleanup everything. */
- if (HYD_PMCD_pmi_proxy_params.procs_are_launched) {
+ if (HYD_PMCD_pmi_proxy_params.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.exit_status,
- HYD_PMCD_pmi_proxy_params.exec_proc_count *
+ HYD_PMCD_pmi_proxy_params.downstream.exit_status,
+ HYD_PMCD_pmi_proxy_params.local.process_count *
sizeof(int));
HYDU_ERR_POP(status, "unable to return exit status upstream\n");
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h 2009-10-14 11:35:29 UTC (rev 5453)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h 2009-10-14 11:35:35 UTC (rev 5454)
@@ -12,56 +12,55 @@
#include "pmi_common.h"
struct HYD_PMCD_pmi_proxy_params {
- /* Proxy details */
+ struct HYD_User_global user_global;
+
struct {
+ int global_core_count;
+
+ /* PMI */
+ char *pmi_port_str;
+ } system_global; /* Global system parameters */
+
+ struct {
+ /* Upstream server contact information */
char *server_name;
int server_port;
- HYD_Launch_mode_t launch_mode;
- int proxy_id;
- char *bootstrap;
- char *bootstrap_exec;
- int enablex;
- int debug;
- } proxy;
- char *wdir;
- char *pmi_port_str;
+ int out;
+ int err;
+ int in;
+ int control;
+ } upstream;
- char *binding;
- char *bindlib;
+ /* Currently our downstream only consists of actual MPI
+ * processes */
+ struct {
+ int *out;
+ int *err;
+ int in;
- char *ckpointlib;
- char *ckpoint_prefix;
- int ckpoint_restart;
+ int *pid;
+ int *exit_status;
+ } downstream;
- struct HYD_Env_global global_env;
+ /* Proxy details */
+ struct {
+ int id;
+ int core_count;
+ int process_count;
- int global_core_count;
- int proxy_core_count;
- int exec_proc_count;
+ /* Flag to tell whether the processes are launched */
+ int procs_are_launched;
- int procs_are_launched;
+ /* stdin related variables */
+ int stdin_buf_offset;
+ int stdin_buf_count;
+ char stdin_tmp_buf[HYD_TMPBUF_SIZE];
+ } local;
/* Process segmentation information for this proxy */
struct HYD_Proxy_segment *segment_list;
struct HYD_Proxy_exec *exec_list;
-
- struct {
- int out;
- int err;
- int in;
- int control;
- } upstream;
-
- int *pid;
- int *out;
- int *err;
- int *exit_status;
- int in;
-
- int stdin_buf_offset;
- int stdin_buf_count;
- char stdin_tmp_buf[HYD_TMPBUF_SIZE];
};
extern struct HYD_PMCD_pmi_proxy_params HYD_PMCD_pmi_proxy_params;
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-14 11:35:29 UTC (rev 5453)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_cb.c 2009-10-14 11:35:35 UTC (rev 5454)
@@ -135,9 +135,9 @@
status = HYD_DMX_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.exec_proc_count; i++)
- if (HYD_PMCD_pmi_proxy_params.out[i] == fd)
- HYD_PMCD_pmi_proxy_params.out[i] = -1;
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.process_count; i++)
+ if (HYD_PMCD_pmi_proxy_params.downstream.out[i] == fd)
+ HYD_PMCD_pmi_proxy_params.downstream.out[i] = -1;
close(fd);
}
@@ -166,9 +166,9 @@
status = HYD_DMX_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.exec_proc_count; i++)
- if (HYD_PMCD_pmi_proxy_params.err[i] == fd)
- HYD_PMCD_pmi_proxy_params.err[i] = -1;
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.process_count; i++)
+ if (HYD_PMCD_pmi_proxy_params.downstream.err[i] == fd)
+ HYD_PMCD_pmi_proxy_params.downstream.err[i] = -1;
close(fd);
}
@@ -189,11 +189,11 @@
HYDU_FUNC_ENTER();
- status = HYDU_sock_stdin_cb(HYD_PMCD_pmi_proxy_params.in, events,
+ 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.stdin_tmp_buf,
- &HYD_PMCD_pmi_proxy_params.stdin_buf_count,
- &HYD_PMCD_pmi_proxy_params.stdin_buf_offset, &closed);
+ 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);
HYDU_ERR_POP(status, "stdin callback error\n");
if (closed) {
@@ -202,8 +202,8 @@
HYDU_ERR_POP(status, "unable to deregister fd\n");
close(HYD_PMCD_pmi_proxy_params.upstream.in);
- close(HYD_PMCD_pmi_proxy_params.in);
- HYD_PMCD_pmi_proxy_params.in = -1;
+ close(HYD_PMCD_pmi_proxy_params.downstream.in);
+ HYD_PMCD_pmi_proxy_params.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-14 11:35:29 UTC (rev 5453)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c 2009-10-14 11:35:35 UTC (rev 5454)
@@ -15,34 +15,35 @@
{
HYD_Status status = HYD_SUCCESS;
- HYD_PMCD_pmi_proxy_params.proxy.server_name = NULL;
- HYD_PMCD_pmi_proxy_params.proxy.server_port = -1;
- HYD_PMCD_pmi_proxy_params.proxy.launch_mode = HYD_LAUNCH_UNSET;
- HYD_PMCD_pmi_proxy_params.proxy.proxy_id = -1;
- HYD_PMCD_pmi_proxy_params.proxy.bootstrap = NULL;
- HYD_PMCD_pmi_proxy_params.proxy.bootstrap_exec = NULL;
- HYD_PMCD_pmi_proxy_params.proxy.debug = 0;
- HYD_PMCD_pmi_proxy_params.proxy.enablex = -1;
+ HYD_PMCD_pmi_proxy_params.user_global.bootstrap = NULL;
+ HYD_PMCD_pmi_proxy_params.user_global.bootstrap_exec = NULL;
+ HYD_PMCD_pmi_proxy_params.user_global.launch_mode = HYD_LAUNCH_UNSET;
- HYD_PMCD_pmi_proxy_params.wdir = NULL;
- HYD_PMCD_pmi_proxy_params.pmi_port_str = NULL;
- HYD_PMCD_pmi_proxy_params.binding = NULL;
- HYD_PMCD_pmi_proxy_params.bindlib = NULL;
+ HYD_PMCD_pmi_proxy_params.upstream.server_name = NULL;
+ HYD_PMCD_pmi_proxy_params.upstream.server_port = -1;
+ HYD_PMCD_pmi_proxy_params.local.id = -1;
+ HYD_PMCD_pmi_proxy_params.user_global.debug = 0;
+ HYD_PMCD_pmi_proxy_params.user_global.enablex = -1;
- HYD_PMCD_pmi_proxy_params.ckpointlib = NULL;
- HYD_PMCD_pmi_proxy_params.ckpoint_prefix = NULL;
- HYD_PMCD_pmi_proxy_params.ckpoint_restart = 0;
+ HYD_PMCD_pmi_proxy_params.user_global.wdir = NULL;
+ HYD_PMCD_pmi_proxy_params.system_global.pmi_port_str = NULL;
+ HYD_PMCD_pmi_proxy_params.user_global.binding = NULL;
+ HYD_PMCD_pmi_proxy_params.user_global.bindlib = NULL;
- HYD_PMCD_pmi_proxy_params.global_env.system = NULL;
- HYD_PMCD_pmi_proxy_params.global_env.user = NULL;
- HYD_PMCD_pmi_proxy_params.global_env.inherited = NULL;
+ HYD_PMCD_pmi_proxy_params.user_global.ckpointlib = NULL;
+ HYD_PMCD_pmi_proxy_params.user_global.ckpoint_prefix = NULL;
+ HYD_PMCD_pmi_proxy_params.user_global.ckpoint_restart = 0;
- HYD_PMCD_pmi_proxy_params.global_core_count = 0;
- HYD_PMCD_pmi_proxy_params.proxy_core_count = 0;
- HYD_PMCD_pmi_proxy_params.exec_proc_count = 0;
+ HYD_PMCD_pmi_proxy_params.user_global.global_env.system = NULL;
+ HYD_PMCD_pmi_proxy_params.user_global.global_env.user = NULL;
+ HYD_PMCD_pmi_proxy_params.user_global.global_env.inherited = NULL;
- HYD_PMCD_pmi_proxy_params.procs_are_launched = 0;
+ HYD_PMCD_pmi_proxy_params.system_global.global_core_count = 0;
+ HYD_PMCD_pmi_proxy_params.local.core_count = 0;
+ HYD_PMCD_pmi_proxy_params.local.process_count = 0;
+ HYD_PMCD_pmi_proxy_params.local.procs_are_launched = 0;
+
HYD_PMCD_pmi_proxy_params.segment_list = NULL;
HYD_PMCD_pmi_proxy_params.exec_list = NULL;
@@ -51,15 +52,15 @@
HYD_PMCD_pmi_proxy_params.upstream.in = -1;
HYD_PMCD_pmi_proxy_params.upstream.control = -1;
- HYD_PMCD_pmi_proxy_params.pid = NULL;
- HYD_PMCD_pmi_proxy_params.out = NULL;
- HYD_PMCD_pmi_proxy_params.err = NULL;
- HYD_PMCD_pmi_proxy_params.exit_status = NULL;
- HYD_PMCD_pmi_proxy_params.in = -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_pmi_proxy_params.stdin_buf_offset = 0;
- HYD_PMCD_pmi_proxy_params.stdin_buf_count = 0;
- HYD_PMCD_pmi_proxy_params.stdin_tmp_buf[0] = '\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';
return status;
}
@@ -83,7 +84,7 @@
/* Working directory */
if (!strcmp(*argv, "--wdir")) {
argv++;
- HYD_PMCD_pmi_proxy_params.wdir = HYDU_strdup(*argv);
+ HYD_PMCD_pmi_proxy_params.user_global.wdir = HYDU_strdup(*argv);
continue;
}
@@ -91,9 +92,9 @@
if (!strcmp(*argv, "--pmi-port-str")) {
argv++;
if (!strcmp(*argv, "HYDRA_NULL"))
- HYD_PMCD_pmi_proxy_params.pmi_port_str = NULL;
+ HYD_PMCD_pmi_proxy_params.system_global.pmi_port_str = NULL;
else
- HYD_PMCD_pmi_proxy_params.pmi_port_str = HYDU_strdup(*argv);
+ HYD_PMCD_pmi_proxy_params.system_global.pmi_port_str = HYDU_strdup(*argv);
continue;
}
@@ -101,9 +102,9 @@
if (!strcmp(*argv, "--binding")) {
argv++;
if (!strcmp(*argv, "HYDRA_NULL"))
- HYD_PMCD_pmi_proxy_params.binding = NULL;
+ HYD_PMCD_pmi_proxy_params.user_global.binding = NULL;
else
- HYD_PMCD_pmi_proxy_params.binding = HYDU_strdup(*argv);
+ HYD_PMCD_pmi_proxy_params.user_global.binding = HYDU_strdup(*argv);
continue;
}
@@ -111,28 +112,28 @@
/* Binding library */
if (!strcmp(*argv, "--bindlib")) {
argv++;
- HYD_PMCD_pmi_proxy_params.bindlib = HYDU_strdup(*argv);
+ HYD_PMCD_pmi_proxy_params.user_global.bindlib = HYDU_strdup(*argv);
continue;
}
/* Checkpointing library */
if (!strcmp(*argv, "--ckpointlib")) {
argv++;
- HYD_PMCD_pmi_proxy_params.ckpointlib = HYDU_strdup(*argv);
+ HYD_PMCD_pmi_proxy_params.user_global.ckpointlib = HYDU_strdup(*argv);
continue;
}
if (!strcmp(*argv, "--ckpoint-prefix")) {
argv++;
if (!strcmp(*argv, "HYDRA_NULL"))
- HYD_PMCD_pmi_proxy_params.ckpoint_prefix = NULL;
+ HYD_PMCD_pmi_proxy_params.user_global.ckpoint_prefix = NULL;
else
- HYD_PMCD_pmi_proxy_params.ckpoint_prefix = HYDU_strdup(*argv);
+ HYD_PMCD_pmi_proxy_params.user_global.ckpoint_prefix = HYDU_strdup(*argv);
continue;
}
if (!strcmp(*argv, "--ckpoint-restart")) {
- HYD_PMCD_pmi_proxy_params.ckpoint_restart = 1;
+ HYD_PMCD_pmi_proxy_params.user_global.ckpoint_restart = 1;
continue;
}
@@ -161,13 +162,13 @@
if (!strcmp(argtype, "--global-inherited-env"))
HYDU_append_env_to_list(*env,
- &HYD_PMCD_pmi_proxy_params.global_env.inherited);
+ &HYD_PMCD_pmi_proxy_params.user_global.global_env.inherited);
else if (!strcmp(argtype, "--global-system-env"))
HYDU_append_env_to_list(*env,
- &HYD_PMCD_pmi_proxy_params.global_env.system);
+ &HYD_PMCD_pmi_proxy_params.user_global.global_env.system);
else if (!strcmp(argtype, "--global-user-env"))
HYDU_append_env_to_list(*env,
- &HYD_PMCD_pmi_proxy_params.global_env.user);
+ &HYD_PMCD_pmi_proxy_params.user_global.global_env.user);
HYDU_FREE(env);
}
@@ -178,16 +179,16 @@
if (!strcmp(*argv, "--genv-prop")) {
argv++;
if (strcmp(*argv, "HYDRA_NULL"))
- HYD_PMCD_pmi_proxy_params.global_env.prop = HYDU_strdup(*argv);
+ HYD_PMCD_pmi_proxy_params.user_global.global_env.prop = HYDU_strdup(*argv);
else
- HYD_PMCD_pmi_proxy_params.global_env.prop = NULL;
+ HYD_PMCD_pmi_proxy_params.user_global.global_env.prop = NULL;
continue;
}
/* One-pass Count */
if (!strcmp(*argv, "--global-core-count")) {
argv++;
- HYD_PMCD_pmi_proxy_params.global_core_count = atoi(*argv);
+ HYD_PMCD_pmi_proxy_params.system_global.global_core_count = atoi(*argv);
continue;
}
@@ -319,60 +320,60 @@
while (++argv && *argv) {
if (!strcmp(*argv, "--launch-mode")) {
++argv;
- HYD_PMCD_pmi_proxy_params.proxy.launch_mode =
+ HYD_PMCD_pmi_proxy_params.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.proxy.launch_mode == HYD_LAUNCH_RUNTIME) {
- HYD_PMCD_pmi_proxy_params.proxy.server_name = HYDU_strdup(strtok(*argv, ":"));
- HYD_PMCD_pmi_proxy_params.proxy.server_port = atoi(strtok(NULL, ":"));
+ 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, ":"));
}
else {
- HYD_PMCD_pmi_proxy_params.proxy.server_port = atoi(*argv);
+ HYD_PMCD_pmi_proxy_params.upstream.server_port = atoi(*argv);
}
continue;
}
if (!strcmp(*argv, "--proxy-id")) {
++argv;
- HYD_PMCD_pmi_proxy_params.proxy.proxy_id = atoi(*argv);
+ HYD_PMCD_pmi_proxy_params.local.id = atoi(*argv);
continue;
}
if (!strcmp(*argv, "--debug")) {
- HYD_PMCD_pmi_proxy_params.proxy.debug = 1;
+ HYD_PMCD_pmi_proxy_params.user_global.debug = 1;
continue;
}
if (!strcmp(*argv, "--enable-x")) {
- HYD_PMCD_pmi_proxy_params.proxy.enablex = 1;
+ HYD_PMCD_pmi_proxy_params.user_global.enablex = 1;
continue;
}
if (!strcmp(*argv, "--disable-x")) {
- HYD_PMCD_pmi_proxy_params.proxy.enablex = 0;
+ HYD_PMCD_pmi_proxy_params.user_global.enablex = 0;
continue;
}
if (!strcmp(*argv, "--bootstrap")) {
++argv;
- HYD_PMCD_pmi_proxy_params.proxy.bootstrap = HYDU_strdup(*argv);
+ HYD_PMCD_pmi_proxy_params.user_global.bootstrap = HYDU_strdup(*argv);
continue;
}
if (!strcmp(*argv, "--bootstrap-exec")) {
++argv;
- HYD_PMCD_pmi_proxy_params.proxy.bootstrap_exec = HYDU_strdup(*argv);
+ HYD_PMCD_pmi_proxy_params.user_global.bootstrap_exec = HYDU_strdup(*argv);
continue;
}
}
- status = HYD_BSCI_init(HYD_PMCD_pmi_proxy_params.proxy.bootstrap,
- HYD_PMCD_pmi_proxy_params.proxy.bootstrap_exec,
- HYD_PMCD_pmi_proxy_params.proxy.enablex,
- HYD_PMCD_pmi_proxy_params.proxy.debug);
+ status = HYD_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);
HYDU_ERR_POP(status, "proxy unable to initialize bootstrap\n");
- if (HYD_PMCD_pmi_proxy_params.proxy.proxy_id == -1) {
+ if (HYD_PMCD_pmi_proxy_params.local.id == -1) {
/* We didn't get a proxy ID during launch; query the
* bootstrap server for it. */
- status = HYD_BSCI_query_proxy_id(&HYD_PMCD_pmi_proxy_params.proxy.proxy_id);
+ status = HYD_BSCI_query_proxy_id(&HYD_PMCD_pmi_proxy_params.local.id);
HYDU_ERR_POP(status, "unable to query bootstrap server for proxy ID\n");
}
@@ -393,41 +394,41 @@
HYDU_FUNC_ENTER();
- if (HYD_PMCD_pmi_proxy_params.proxy.server_name)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.proxy.server_name);
+ if (HYD_PMCD_pmi_proxy_params.upstream.server_name)
+ HYDU_FREE(HYD_PMCD_pmi_proxy_params.upstream.server_name);
- if (HYD_PMCD_pmi_proxy_params.proxy.bootstrap)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.proxy.bootstrap);
+ if (HYD_PMCD_pmi_proxy_params.user_global.bootstrap)
+ HYDU_FREE(HYD_PMCD_pmi_proxy_params.user_global.bootstrap);
- if (HYD_PMCD_pmi_proxy_params.proxy.bootstrap_exec)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.proxy.bootstrap_exec);
+ if (HYD_PMCD_pmi_proxy_params.user_global.bootstrap_exec)
+ HYDU_FREE(HYD_PMCD_pmi_proxy_params.user_global.bootstrap_exec);
- if (HYD_PMCD_pmi_proxy_params.wdir)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.wdir);
+ if (HYD_PMCD_pmi_proxy_params.user_global.wdir)
+ HYDU_FREE(HYD_PMCD_pmi_proxy_params.user_global.wdir);
- if (HYD_PMCD_pmi_proxy_params.pmi_port_str)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.pmi_port_str);
+ 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_pmi_proxy_params.binding)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.binding);
+ if (HYD_PMCD_pmi_proxy_params.user_global.binding)
+ HYDU_FREE(HYD_PMCD_pmi_proxy_params.user_global.binding);
- if (HYD_PMCD_pmi_proxy_params.bindlib)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.bindlib);
+ if (HYD_PMCD_pmi_proxy_params.user_global.bindlib)
+ HYDU_FREE(HYD_PMCD_pmi_proxy_params.user_global.bindlib);
- if (HYD_PMCD_pmi_proxy_params.ckpointlib)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.ckpointlib);
+ if (HYD_PMCD_pmi_proxy_params.user_global.ckpointlib)
+ HYDU_FREE(HYD_PMCD_pmi_proxy_params.user_global.ckpointlib);
- if (HYD_PMCD_pmi_proxy_params.ckpoint_prefix)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.ckpoint_prefix);
+ if (HYD_PMCD_pmi_proxy_params.user_global.ckpoint_prefix)
+ HYDU_FREE(HYD_PMCD_pmi_proxy_params.user_global.ckpoint_prefix);
- if (HYD_PMCD_pmi_proxy_params.global_env.system)
- HYDU_env_free_list(HYD_PMCD_pmi_proxy_params.global_env.system);
+ 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_pmi_proxy_params.global_env.user)
- HYDU_env_free_list(HYD_PMCD_pmi_proxy_params.global_env.user);
+ 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_pmi_proxy_params.global_env.inherited)
- HYDU_env_free_list(HYD_PMCD_pmi_proxy_params.global_env.inherited);
+ 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_pmi_proxy_params.segment_list) {
segment = HYD_PMCD_pmi_proxy_params.segment_list;
@@ -450,17 +451,17 @@
}
}
- if (HYD_PMCD_pmi_proxy_params.pid)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.pid);
+ if (HYD_PMCD_pmi_proxy_params.downstream.pid)
+ HYDU_FREE(HYD_PMCD_pmi_proxy_params.downstream.pid);
- if (HYD_PMCD_pmi_proxy_params.out)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.out);
+ if (HYD_PMCD_pmi_proxy_params.downstream.out)
+ HYDU_FREE(HYD_PMCD_pmi_proxy_params.downstream.out);
- if (HYD_PMCD_pmi_proxy_params.err)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.err);
+ if (HYD_PMCD_pmi_proxy_params.downstream.err)
+ HYDU_FREE(HYD_PMCD_pmi_proxy_params.downstream.err);
- if (HYD_PMCD_pmi_proxy_params.exit_status)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.exit_status);
+ if (HYD_PMCD_pmi_proxy_params.downstream.exit_status)
+ HYDU_FREE(HYD_PMCD_pmi_proxy_params.downstream.exit_status);
/* Reinitialize all params to set everything to "NULL" or
* equivalent. */
@@ -536,54 +537,54 @@
HYDU_FUNC_ENTER();
- HYD_PMCD_pmi_proxy_params.proxy_core_count = 0;
+ HYD_PMCD_pmi_proxy_params.local.core_count = 0;
for (segment = HYD_PMCD_pmi_proxy_params.segment_list; segment; segment = segment->next)
- HYD_PMCD_pmi_proxy_params.proxy_core_count += segment->proc_count;
+ HYD_PMCD_pmi_proxy_params.local.core_count += segment->proc_count;
- HYD_PMCD_pmi_proxy_params.exec_proc_count = 0;
+ HYD_PMCD_pmi_proxy_params.local.process_count = 0;
for (exec = HYD_PMCD_pmi_proxy_params.exec_list; exec; exec = exec->next)
- HYD_PMCD_pmi_proxy_params.exec_proc_count += exec->proc_count;
+ HYD_PMCD_pmi_proxy_params.local.process_count += exec->proc_count;
- HYDU_MALLOC(pmi_ids, int *, HYD_PMCD_pmi_proxy_params.exec_proc_count * sizeof(int), status);
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.exec_proc_count; i++) {
+ HYDU_MALLOC(pmi_ids, int *, HYD_PMCD_pmi_proxy_params.local.process_count * sizeof(int), status);
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.process_count; i++) {
pmi_ids[i] = HYDU_local_to_global_id(i,
- HYD_PMCD_pmi_proxy_params.proxy_core_count,
+ HYD_PMCD_pmi_proxy_params.local.core_count,
HYD_PMCD_pmi_proxy_params.segment_list,
- HYD_PMCD_pmi_proxy_params.global_core_count);
+ HYD_PMCD_pmi_proxy_params.system_global.global_core_count);
}
- HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.out, int *,
- HYD_PMCD_pmi_proxy_params.exec_proc_count * sizeof(int), status);
- HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.err, int *,
- HYD_PMCD_pmi_proxy_params.exec_proc_count * sizeof(int), status);
- HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.pid, int *,
- HYD_PMCD_pmi_proxy_params.exec_proc_count * sizeof(int), status);
- HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.exit_status, int *,
- HYD_PMCD_pmi_proxy_params.exec_proc_count * sizeof(int), status);
+ HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.downstream.out, int *,
+ HYD_PMCD_pmi_proxy_params.local.process_count * sizeof(int), status);
+ HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.downstream.err, int *,
+ HYD_PMCD_pmi_proxy_params.local.process_count * sizeof(int), status);
+ HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.downstream.pid, int *,
+ HYD_PMCD_pmi_proxy_params.local.process_count * sizeof(int), status);
+ HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.downstream.exit_status, int *,
+ HYD_PMCD_pmi_proxy_params.local.process_count * sizeof(int), status);
/* Initialize the exit status */
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.exec_proc_count; i++)
- HYD_PMCD_pmi_proxy_params.exit_status[i] = -1;
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.process_count; i++)
+ HYD_PMCD_pmi_proxy_params.downstream.exit_status[i] = -1;
- status = HYDU_bind_init(HYD_PMCD_pmi_proxy_params.binding,
- HYD_PMCD_pmi_proxy_params.bindlib);
+ status = HYDU_bind_init(HYD_PMCD_pmi_proxy_params.user_global.binding,
+ HYD_PMCD_pmi_proxy_params.user_global.bindlib);
HYDU_ERR_POP(status, "unable to initialize process binding\n");
- status = HYDU_ckpoint_init(HYD_PMCD_pmi_proxy_params.ckpointlib,
- HYD_PMCD_pmi_proxy_params.ckpoint_prefix);
+ status = HYDU_ckpoint_init(HYD_PMCD_pmi_proxy_params.user_global.ckpointlib,
+ HYD_PMCD_pmi_proxy_params.user_global.ckpoint_prefix);
HYDU_ERR_POP(status, "unable to initialize checkpointing\n");
- if (HYD_PMCD_pmi_proxy_params.ckpoint_restart) {
-
- status = HYDU_env_create(&env, "PMI_PORT", HYD_PMCD_pmi_proxy_params.pmi_port_str);
+ 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);
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 = HYDU_ckpoint_restart(env, HYD_PMCD_pmi_proxy_params.exec_proc_count,
+ status = HYDU_ckpoint_restart(env, HYD_PMCD_pmi_proxy_params.local.process_count,
pmi_ids,
- pmi_ids[0] ? NULL : &HYD_PMCD_pmi_proxy_params.in,
- HYD_PMCD_pmi_proxy_params.out,
- HYD_PMCD_pmi_proxy_params.err);
+ 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);
HYDU_ERR_POP(status, "checkpoint restart failure\n");
goto fn_spawn_complete;
}
@@ -602,24 +603,24 @@
/* Global inherited env */
if ((exec->env_prop && !strcmp(exec->env_prop, "all")) ||
- (!exec->env_prop && !strcmp(HYD_PMCD_pmi_proxy_params.global_env.prop, "all"))) {
- for (env = HYD_PMCD_pmi_proxy_params.global_env.inherited; env; env = env->next) {
+ (!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) {
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.global_env.prop, "list",
+ !strncmp(HYD_PMCD_pmi_proxy_params.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.global_env.prop + strlen("list:"));
+ list = HYDU_strdup(HYD_PMCD_pmi_proxy_params.user_global.global_env.prop + strlen("list:"));
envstr = strtok(list, ",");
while (envstr) {
- env = HYDU_env_lookup(envstr, HYD_PMCD_pmi_proxy_params.global_env.inherited);
+ env = HYDU_env_lookup(envstr, HYD_PMCD_pmi_proxy_params.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");
@@ -629,7 +630,7 @@
}
/* Next priority order is the global user env */
- for (env = HYD_PMCD_pmi_proxy_params.global_env.user; env; env = env->next) {
+ for (env = HYD_PMCD_pmi_proxy_params.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");
}
@@ -641,15 +642,16 @@
}
/* Highest priority is the system env */
- for (env = HYD_PMCD_pmi_proxy_params.global_env.system; env; env = env->next) {
+ for (env = HYD_PMCD_pmi_proxy_params.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.pmi_port_str) {
- status = HYDU_env_create(&env, "PMI_PORT", HYD_PMCD_pmi_proxy_params.pmi_port_str);
+ if (HYD_PMCD_pmi_proxy_params.system_global.pmi_port_str) {
+ status = HYDU_env_create(&env, "PMI_PORT",
+ HYD_PMCD_pmi_proxy_params.system_global.pmi_port_str);
HYDU_ERR_POP(status, "unable to create env\n");
status = HYDU_append_env_to_list(*env, &prop_env);
@@ -658,11 +660,11 @@
for (i = 0; i < exec->proc_count; i++) {
pmi_id = HYDU_local_to_global_id(process_id,
- HYD_PMCD_pmi_proxy_params.proxy_core_count,
+ HYD_PMCD_pmi_proxy_params.local.core_count,
HYD_PMCD_pmi_proxy_params.segment_list,
- HYD_PMCD_pmi_proxy_params.global_core_count);
+ HYD_PMCD_pmi_proxy_params.system_global.global_core_count);
- if (HYD_PMCD_pmi_proxy_params.pmi_port_str) {
+ if (HYD_PMCD_pmi_proxy_params.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");
@@ -671,7 +673,7 @@
HYDU_ERR_POP(status, "unable to add env to list\n");
}
- if (chdir(HYD_PMCD_pmi_proxy_params.wdir) < 0)
+ if (chdir(HYD_PMCD_pmi_proxy_params.user_global.wdir) < 0)
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unable to change wdir (%s)\n", HYDU_strerror(errno));
@@ -682,27 +684,29 @@
core = HYDU_bind_get_core_id(process_id);
if (pmi_id == 0) {
status = HYDU_create_process(client_args, prop_env,
- &HYD_PMCD_pmi_proxy_params.in,
- &HYD_PMCD_pmi_proxy_params.out[process_id],
- &HYD_PMCD_pmi_proxy_params.err[process_id],
- &HYD_PMCD_pmi_proxy_params.pid[process_id], core);
+ &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_pmi_proxy_params.stdin_buf_offset = 0;
- HYD_PMCD_pmi_proxy_params.stdin_buf_count = 0;
+ HYD_PMCD_pmi_proxy_params.local.stdin_buf_offset = 0;
+ HYD_PMCD_pmi_proxy_params.local.stdin_buf_count = 0;
status = HYDU_sock_set_nonblock(HYD_PMCD_pmi_proxy_params.upstream.in);
HYDU_ERR_POP(status, "unable to set upstream stdin fd to nonblocking\n");
- stdin_fd = HYD_PMCD_pmi_proxy_params.in;
+ stdin_fd = HYD_PMCD_pmi_proxy_params.downstream.in;
status = HYD_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.out[process_id],
- &HYD_PMCD_pmi_proxy_params.err[process_id],
- &HYD_PMCD_pmi_proxy_params.pid[process_id], core);
+ &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);
}
HYDU_ERR_POP(status, "create process returned error\n");
@@ -715,18 +719,18 @@
fn_spawn_complete:
/* Everything is spawned, register the required FDs */
- status = HYD_DMX_register_fd(HYD_PMCD_pmi_proxy_params.exec_proc_count,
- HYD_PMCD_pmi_proxy_params.out,
+ status = HYD_DMX_register_fd(HYD_PMCD_pmi_proxy_params.local.process_count,
+ HYD_PMCD_pmi_proxy_params.downstream.out,
HYD_STDOUT, NULL, HYD_PMCD_pmi_proxy_stdout_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
- status = HYD_DMX_register_fd(HYD_PMCD_pmi_proxy_params.exec_proc_count,
- HYD_PMCD_pmi_proxy_params.err,
+ status = HYD_DMX_register_fd(HYD_PMCD_pmi_proxy_params.local.process_count,
+ HYD_PMCD_pmi_proxy_params.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.procs_are_launched = 1;
+ HYD_PMCD_pmi_proxy_params.local.procs_are_launched = 1;
fn_exit:
HYDU_FUNC_EXIT();
@@ -744,10 +748,10 @@
HYDU_FUNC_ENTER();
/* Send the kill signal to all processes */
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.exec_proc_count; i++) {
- if (HYD_PMCD_pmi_proxy_params.pid[i] != -1) {
- kill(HYD_PMCD_pmi_proxy_params.pid[i], SIGTERM);
- kill(HYD_PMCD_pmi_proxy_params.pid[i], SIGKILL);
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.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);
}
}
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_finalize.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_finalize.c 2009-10-14 11:35:29 UTC (rev 5453)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_finalize.c 2009-10-14 11:35:35 UTC (rev 5454)
@@ -20,7 +20,7 @@
status = HYD_PMCD_pmi_finalize();
HYDU_ERR_POP(status, "unable to finalize process manager utils\n");
- if (HYD_handle.launch_mode == HYD_LAUNCH_RUNTIME) {
+ if (HYD_handle.user_global.launch_mode == HYD_LAUNCH_RUNTIME) {
status = HYD_BSCI_finalize();
HYDU_ERR_POP(status, "unable to finalize bootstrap server\n");
}
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c 2009-10-14 11:35:29 UTC (rev 5453)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c 2009-10-14 11:35:35 UTC (rev 5454)
@@ -169,20 +169,20 @@
else
proxy_args[arg++] = HYDU_int_to_str(HYD_handle.proxy_port);
- if (HYD_handle.debug)
+ if (HYD_handle.user_global.debug)
proxy_args[arg++] = HYDU_strdup("--debug");
- if (HYD_handle.enablex != -1) {
+ if (HYD_handle.user_global.enablex != -1) {
proxy_args[arg++] = HYDU_strdup("--enable-x");
- proxy_args[arg++] = HYDU_int_to_str(HYD_handle.enablex);
+ proxy_args[arg++] = HYDU_int_to_str(HYD_handle.user_global.enablex);
}
proxy_args[arg++] = HYDU_strdup("--bootstrap");
- proxy_args[arg++] = HYDU_strdup(HYD_handle.bootstrap);
+ proxy_args[arg++] = HYDU_strdup(HYD_handle.user_global.bootstrap);
- if (HYD_handle.bootstrap_exec) {
+ if (HYD_handle.user_global.bootstrap_exec) {
proxy_args[arg++] = HYDU_strdup("--bootstrap-exec");
- proxy_args[arg++] = HYDU_strdup(HYD_handle.bootstrap_exec);
+ proxy_args[arg++] = HYDU_strdup(HYD_handle.user_global.bootstrap_exec);
}
proxy_args[arg++] = NULL;
@@ -209,11 +209,11 @@
/* Create the arguments list for each proxy */
process_id = 0;
FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
- for (inherited_env_count = 0, env = HYD_handle.global_env.inherited; env;
+ for (inherited_env_count = 0, env = HYD_handle.user_global.global_env.inherited; env;
env = env->next, inherited_env_count++);
- for (user_env_count = 0, env = HYD_handle.global_env.user; env;
+ for (user_env_count = 0, env = HYD_handle.user_global.global_env.user; env;
env = env->next, user_env_count++);
- for (system_env_count = 0, env = HYD_handle.global_env.system; env;
+ for (system_env_count = 0, env = HYD_handle.user_global.global_env.system; env;
env = env->next, system_env_count++);
for (segment_count = 0, segment = proxy->segment_list; segment;
@@ -244,7 +244,7 @@
proxy->exec_args[arg++] = HYDU_int_to_str(HYD_handle.global_core_count);
proxy->exec_args[arg++] = HYDU_strdup("--wdir");
- proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.wdir);
+ proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.user_global.wdir);
proxy->exec_args[arg++] = HYDU_strdup("--pmi-port-str");
if (HYD_handle.pm_env)
@@ -253,31 +253,31 @@
proxy->exec_args[arg++] = HYDU_strdup("HYDRA_NULL");
proxy->exec_args[arg++] = HYDU_strdup("--binding");
- if (HYD_handle.binding)
- proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.binding);
+ if (HYD_handle.user_global.binding)
+ proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.user_global.binding);
else
proxy->exec_args[arg++] = HYDU_strdup("HYDRA_NULL");
proxy->exec_args[arg++] = HYDU_strdup("--bindlib");
- proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.bindlib);
+ proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.user_global.bindlib);
proxy->exec_args[arg++] = HYDU_strdup("--ckpointlib");
- proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.ckpointlib);
+ proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.user_global.ckpointlib);
proxy->exec_args[arg++] = HYDU_strdup("--ckpoint-prefix");
- if (HYD_handle.ckpoint_prefix)
- proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.ckpoint_prefix);
+ if (HYD_handle.user_global.ckpoint_prefix)
+ proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.user_global.ckpoint_prefix);
else
proxy->exec_args[arg++] = HYDU_strdup("HYDRA_NULL");
- if (HYD_handle.ckpoint_restart)
+ if (HYD_handle.user_global.ckpoint_restart)
proxy->exec_args[arg++] = HYDU_strdup("--ckpoint-restart");
proxy->exec_args[arg++] = HYDU_strdup("--global-inherited-env");
- for (i = 0, env = HYD_handle.global_env.inherited; env; env = env->next, i++);
+ for (i = 0, env = HYD_handle.user_global.global_env.inherited; env; env = env->next, i++);
proxy->exec_args[arg++] = HYDU_int_to_str(i);
- for (env = HYD_handle.global_env.inherited; env; env = env->next) {
+ for (env = HYD_handle.user_global.global_env.inherited; env; env = env->next) {
status = HYDU_env_to_str(env, &proxy->exec_args[arg++]);
HYDU_ERR_POP(status, "error converting env to string\n");
}
@@ -285,10 +285,10 @@
arg = HYDU_strlist_lastidx(proxy->exec_args);
proxy->exec_args[arg++] = HYDU_strdup("--global-user-env");
- for (i = 0, env = HYD_handle.global_env.user; env; env = env->next, i++);
+ for (i = 0, env = HYD_handle.user_global.global_env.user; env; env = env->next, i++);
proxy->exec_args[arg++] = HYDU_int_to_str(i);
- for (env = HYD_handle.global_env.user; env; env = env->next) {
+ for (env = HYD_handle.user_global.global_env.user; env; env = env->next) {
status = HYDU_env_to_str(env, &proxy->exec_args[arg++]);
HYDU_ERR_POP(status, "error converting env to string\n");
}
@@ -296,10 +296,10 @@
arg = HYDU_strlist_lastidx(proxy->exec_args);
proxy->exec_args[arg++] = HYDU_strdup("--global-system-env");
- for (i = 0, env = HYD_handle.global_env.system; env; env = env->next, i++);
+ for (i = 0, env = HYD_handle.user_global.global_env.system; env; env = env->next, i++);
proxy->exec_args[arg++] = HYDU_int_to_str(i);
- for (env = HYD_handle.global_env.system; env; env = env->next) {
+ for (env = HYD_handle.user_global.global_env.system; env; env = env->next) {
status = HYDU_env_to_str(env, &proxy->exec_args[arg++]);
HYDU_ERR_POP(status, "error converting env to string\n");
}
@@ -307,7 +307,7 @@
arg = HYDU_strlist_lastidx(proxy->exec_args);
proxy->exec_args[arg++] = HYDU_strdup("--genv-prop");
- proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.global_env.prop);
+ proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.user_global.global_env.prop);
proxy->exec_args[arg++] = NULL;
/* Pass the segment information */
@@ -352,7 +352,7 @@
process_id += exec->proc_count;
}
- if (HYD_handle.debug) {
+ if (HYD_handle.user_global.debug) {
printf("Arguments being passed to proxy %d:\n", proxy_count++);
HYDU_print_strlist(proxy->exec_args);
printf("\n");
@@ -385,20 +385,20 @@
/* Initialize PMI */
status = create_and_listen_portstr(HYD_PMCD_pmi_connect_cb, &pmi_port_str);
HYDU_ERR_POP(status, "unable to create PMI port\n");
- if (HYD_handle.debug)
+ if (HYD_handle.user_global.debug)
HYDU_dump(stdout, "Got a PMI port string of %s\n", pmi_port_str);
status = HYD_PMCD_pmi_init();
HYDU_ERR_POP(status, "unable to create process group\n");
- if (HYD_handle.launch_mode == HYD_LAUNCH_RUNTIME) {
+ if (HYD_handle.user_global.launch_mode == HYD_LAUNCH_RUNTIME) {
status = create_and_listen_portstr(HYD_PMCD_pmi_serv_control_connect_cb,
&proxy_port_str);
HYDU_ERR_POP(status, "unable to create PMI port\n");
- if (HYD_handle.debug)
+ if (HYD_handle.user_global.debug)
HYDU_dump(stdout, "Got a proxy port string of %s\n", proxy_port_str);
- status = fill_in_proxy_args(HYD_handle.launch_mode, proxy_args);
+ status = fill_in_proxy_args(HYD_handle.user_global.launch_mode, proxy_args);
HYDU_ERR_POP(status, "unable to fill in proxy arguments\n");
status = fill_in_exec_args();
@@ -407,15 +407,15 @@
status = HYD_BSCI_launch_procs(proxy_args, "--proxy-id", HYD_handle.proxy_list);
HYDU_ERR_POP(status, "bootstrap server cannot launch processes\n");
}
- else if (HYD_handle.launch_mode == HYD_LAUNCH_BOOT ||
- HYD_handle.launch_mode == HYD_LAUNCH_BOOT_FOREGROUND) {
- status = fill_in_proxy_args(HYD_handle.launch_mode, proxy_args);
+ else if (HYD_handle.user_global.launch_mode == HYD_LAUNCH_BOOT ||
+ HYD_handle.user_global.launch_mode == HYD_LAUNCH_BOOT_FOREGROUND) {
+ status = fill_in_proxy_args(HYD_handle.user_global.launch_mode, proxy_args);
HYDU_ERR_POP(status, "unable to fill in proxy arguments\n");
status = HYD_BSCI_launch_procs(proxy_args, "--proxy-id", HYD_handle.proxy_list);
HYDU_ERR_POP(status, "bootstrap server cannot launch processes\n");
}
- else if (HYD_handle.launch_mode == HYD_LAUNCH_SHUTDOWN) {
+ else if (HYD_handle.user_global.launch_mode == HYD_LAUNCH_SHUTDOWN) {
FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
status = HYDU_sock_connect(proxy->hostname, HYD_handle.proxy_port, &fd);
if (status != HYD_SUCCESS) {
@@ -431,7 +431,7 @@
close(fd);
}
}
- else if (HYD_handle.launch_mode == HYD_LAUNCH_PERSISTENT) {
+ else if (HYD_handle.user_global.launch_mode == HYD_LAUNCH_PERSISTENT) {
status = fill_in_exec_args();
HYDU_ERR_POP(status, "unable to fill in proxy arguments\n");
@@ -497,8 +497,8 @@
HYDU_FUNC_ENTER();
- if ((HYD_handle.launch_mode == HYD_LAUNCH_BOOT) ||
- (HYD_handle.launch_mode == HYD_LAUNCH_SHUTDOWN)) {
+ if ((HYD_handle.user_global.launch_mode == HYD_LAUNCH_BOOT) ||
+ (HYD_handle.user_global.launch_mode == HYD_LAUNCH_SHUTDOWN)) {
status = HYD_SUCCESS;
}
else {
Modified: mpich2/trunk/src/pm/hydra/rmk/src/rmki_init.c.in
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/src/rmki_init.c.in 2009-10-14 11:35:29 UTC (rev 5453)
+++ mpich2/trunk/src/pm/hydra/rmk/src/rmki_init.c.in 2009-10-14 11:35:35 UTC (rev 5454)
@@ -39,8 +39,10 @@
if (HYD_RMKI_fns.query_node_list == NULL)
HYD_RMKI_fns.query_node_list = HYD_RMKU_query_node_list;
- status = HYD_BSCI_init(HYD_handle.bootstrap, HYD_handle.bootstrap_exec, HYD_handle.enablex,
- HYD_handle.debug);
+ status = HYD_BSCI_init(HYD_handle.user_global.bootstrap,
+ HYD_handle.user_global.bootstrap_exec,
+ HYD_handle.user_global.enablex,
+ HYD_handle.user_global.debug);
HYDU_ERR_POP(status, "unable to initialize the bootstrap server\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.c
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.c 2009-10-14 11:35:29 UTC (rev 5453)
+++ mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.c 2009-10-14 11:35:35 UTC (rev 5454)
@@ -12,7 +12,7 @@
#include "uiu.h"
#include "demux.h"
-HYD_Handle HYD_handle = { 0 };
+HYD_Handle HYD_handle = { { 0 } };
static void usage(void)
{
@@ -161,8 +161,8 @@
* PERSISTENT modes, only proxys which have an executable are
* active. In BOOT, BOOT_FOREGROUND and SHUTDOWN modes, all
* proxys are active. */
- if (HYD_handle.launch_mode == HYD_LAUNCH_RUNTIME ||
- HYD_handle.launch_mode == HYD_LAUNCH_PERSISTENT) {
+ if (HYD_handle.user_global.launch_mode == HYD_LAUNCH_RUNTIME ||
+ HYD_handle.user_global.launch_mode == HYD_LAUNCH_PERSISTENT) {
for (proxy = HYD_handle.proxy_list;
proxy && (proxy->segment_list->start_pid <= HYD_handle.global_process_count);
proxy = proxy->next)
@@ -176,7 +176,7 @@
status = HYD_UIU_merge_exec_info_to_proxy();
HYDU_ERR_POP(status, "unable to merge exec info\n");
- if (HYD_handle.debug)
+ if (HYD_handle.user_global.debug)
HYD_UIU_print_params();
HYDU_time_set(&HYD_handle.start, NULL); /* NULL implies right now */
@@ -185,7 +185,7 @@
else
timeout = -1; /* Set a negative timeout */
HYDU_time_set(&HYD_handle.timeout, &timeout);
- if (HYD_handle.debug)
+ if (HYD_handle.user_global.debug)
HYDU_dump(stdout, "Timeout set to %d (-1 means infinite)\n", timeout);
if (HYD_handle.print_rank_map) {
@@ -220,7 +220,7 @@
* instead of assuming this. For example, it is possible to have a
* PM implementation that launches separate "new" proxies on a
* different port and kills the original proxies using them. */
- if (HYD_handle.launch_mode == HYD_LAUNCH_SHUTDOWN) {
+ if (HYD_handle.user_global.launch_mode == HYD_LAUNCH_SHUTDOWN) {
/* Call finalize functions for lower layers to cleanup their resources */
status = HYD_PMCI_finalize();
HYDU_ERR_POP(status, "process manager error on finalize\n");
Modified: mpich2/trunk/src/pm/hydra/ui/mpiexec/utils.c
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/mpiexec/utils.c 2009-10-14 11:35:29 UTC (rev 5453)
+++ mpich2/trunk/src/pm/hydra/ui/mpiexec/utils.c 2009-10-14 11:35:35 UTC (rev 5454)
@@ -65,7 +65,7 @@
status = HYDU_env_create(&env, env_name, env_value);
HYDU_ERR_POP(status, "unable to create env struct\n");
- HYDU_append_env_to_list(*env, &HYD_handle.global_env.user);
+ HYDU_append_env_to_list(*env, &HYD_handle.user_global.global_env.user);
fn_exit:
return status;
@@ -79,7 +79,7 @@
int len;
HYD_Status status = HYD_SUCCESS;
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.global_env.prop,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.global_env.prop,
HYD_INTERNAL_ERROR, "duplicate environment setting\n");
if (**argv && IS_HELP(**argv)) {
@@ -93,8 +93,8 @@
}
len = strlen("list:") + strlen(**argv) + 1;
- HYDU_MALLOC(HYD_handle.global_env.prop, char *, len, status);
- HYDU_snprintf(HYD_handle.global_env.prop, len, "list:%s", **argv);
+ HYDU_MALLOC(HYD_handle.user_global.global_env.prop, char *, len, status);
+ HYDU_snprintf(HYD_handle.user_global.global_env.prop, len, "list:%s", **argv);
(*argv)++;
fn_exit:
@@ -108,7 +108,7 @@
{
HYD_Status status = HYD_SUCCESS;
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.global_env.prop,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.global_env.prop,
HYD_INTERNAL_ERROR, "duplicate environment setting\n");
if (**argv && IS_HELP(**argv)) {
@@ -118,7 +118,7 @@
HYDU_ERR_SETANDJUMP(status, HYD_GRACEFUL_ABORT, "");
}
- HYD_handle.global_env.prop = HYDU_strdup("none");
+ HYD_handle.user_global.global_env.prop = HYDU_strdup("none");
fn_exit:
return status;
@@ -131,7 +131,7 @@
{
HYD_Status status = HYD_SUCCESS;
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.global_env.prop,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.global_env.prop,
HYD_INTERNAL_ERROR, "duplicate environment setting\n");
if (**argv && IS_HELP(**argv)) {
@@ -141,7 +141,7 @@
HYDU_ERR_SETANDJUMP(status, HYD_GRACEFUL_ABORT, "");
}
- HYD_handle.global_env.prop = HYDU_strdup("all");
+ HYD_handle.user_global.global_env.prop = HYDU_strdup("all");
fn_exit:
return status;
@@ -277,7 +277,7 @@
{
HYD_Status status = HYD_SUCCESS;
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.wdir, HYD_INTERNAL_ERROR,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.wdir, HYD_INTERNAL_ERROR,
"duplicate wdir setting\n");
if (**argv && IS_HELP(**argv)) {
@@ -286,7 +286,7 @@
HYDU_ERR_SETANDJUMP(status, HYD_GRACEFUL_ABORT, "");
}
- HYD_handle.wdir = HYDU_strdup(**argv);
+ HYD_handle.user_global.wdir = HYDU_strdup(**argv);
(*argv)++;
fn_exit:
@@ -465,7 +465,7 @@
{
HYD_Status status = HYD_SUCCESS;
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.bootstrap, HYD_INTERNAL_ERROR,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.bootstrap, HYD_INTERNAL_ERROR,
"duplicate -bootstrap option\n");
if (**argv == NULL)
@@ -479,7 +479,7 @@
HYDU_ERR_SETANDJUMP(status, HYD_GRACEFUL_ABORT, "");
}
- HYD_handle.bootstrap = HYDU_strdup(**argv);
+ HYD_handle.user_global.bootstrap = HYDU_strdup(**argv);
(*argv)++;
fn_exit:
@@ -493,7 +493,7 @@
{
HYD_Status status = HYD_SUCCESS;
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.bootstrap_exec, HYD_INTERNAL_ERROR,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.bootstrap_exec, HYD_INTERNAL_ERROR,
"duplicate -bootstrap-exec option\n");
if (**argv == NULL)
@@ -507,7 +507,7 @@
HYDU_ERR_SETANDJUMP(status, HYD_GRACEFUL_ABORT, "");
}
- HYD_handle.bootstrap_exec = HYDU_strdup(**argv);
+ HYD_handle.user_global.bootstrap_exec = HYDU_strdup(**argv);
(*argv)++;
fn_exit:
@@ -521,7 +521,7 @@
{
HYD_Status status = HYD_SUCCESS;
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.enablex != -1, HYD_INTERNAL_ERROR,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.enablex != -1, HYD_INTERNAL_ERROR,
"duplicate -enable-x argument\n");
if (**argv && IS_HELP(**argv)) {
@@ -532,9 +532,9 @@
}
if (!strcmp(arg, "enable-x"))
- HYD_handle.enablex = 1;
+ HYD_handle.user_global.enablex = 1;
else
- HYD_handle.enablex = 0;
+ HYD_handle.user_global.enablex = 0;
fn_exit:
return status;
@@ -547,7 +547,7 @@
{
HYD_Status status = HYD_SUCCESS;
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.launch_mode != HYD_LAUNCH_UNSET,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.launch_mode != HYD_LAUNCH_UNSET,
HYD_INTERNAL_ERROR, "duplicate launch mode\n");
if (**argv && IS_HELP(**argv)) {
@@ -560,11 +560,11 @@
}
if (!strcmp(arg, "boot-proxies"))
- HYD_handle.launch_mode = HYD_LAUNCH_BOOT;
+ HYD_handle.user_global.launch_mode = HYD_LAUNCH_BOOT;
else if (!strcmp(arg, "boot-foreground-proxies"))
- HYD_handle.launch_mode = HYD_LAUNCH_BOOT_FOREGROUND;
+ HYD_handle.user_global.launch_mode = HYD_LAUNCH_BOOT_FOREGROUND;
else if (!strcmp(arg, "shutdown-proxies"))
- HYD_handle.launch_mode = HYD_LAUNCH_SHUTDOWN;
+ HYD_handle.user_global.launch_mode = HYD_LAUNCH_SHUTDOWN;
fn_exit:
return status;
@@ -603,7 +603,7 @@
{
HYD_Status status = HYD_SUCCESS;
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.launch_mode != HYD_LAUNCH_UNSET,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.launch_mode != HYD_LAUNCH_UNSET,
HYD_INTERNAL_ERROR, "duplicate launch mode\n");
if (**argv && IS_HELP(**argv)) {
@@ -614,9 +614,9 @@
}
if (!strcmp(arg, "use-persistent"))
- HYD_handle.launch_mode = HYD_LAUNCH_PERSISTENT;
+ HYD_handle.user_global.launch_mode = HYD_LAUNCH_PERSISTENT;
else
- HYD_handle.launch_mode = HYD_LAUNCH_RUNTIME;
+ HYD_handle.user_global.launch_mode = HYD_LAUNCH_RUNTIME;
fn_exit:
return status;
@@ -735,7 +735,7 @@
{
HYD_Status status = HYD_SUCCESS;
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.binding, HYD_INTERNAL_ERROR,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.binding, HYD_INTERNAL_ERROR,
"duplicate binding\n");
if (**argv == NULL)
@@ -754,7 +754,7 @@
HYDU_ERR_SETANDJUMP(status, HYD_GRACEFUL_ABORT, "");
}
- HYD_handle.binding = HYDU_strdup(**argv);
+ HYD_handle.user_global.binding = HYDU_strdup(**argv);
(*argv)++;
fn_exit:
@@ -768,7 +768,7 @@
{
HYD_Status status = HYD_SUCCESS;
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.bindlib, HYD_INTERNAL_ERROR,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.bindlib, HYD_INTERNAL_ERROR,
"duplicate -bindlib option\n");
if (**argv == NULL)
@@ -782,7 +782,7 @@
HYDU_ERR_SETANDJUMP(status, HYD_GRACEFUL_ABORT, "");
}
- HYD_handle.bindlib = HYDU_strdup(**argv);
+ HYD_handle.user_global.bindlib = HYDU_strdup(**argv);
(*argv)++;
fn_exit:
@@ -822,7 +822,7 @@
{
HYD_Status status = HYD_SUCCESS;
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.ckpoint_prefix, HYD_INTERNAL_ERROR,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.ckpoint_prefix, HYD_INTERNAL_ERROR,
"duplicate -ckpoint-prefix option\n");
if (**argv == NULL)
@@ -834,7 +834,7 @@
HYDU_ERR_SETANDJUMP(status, HYD_GRACEFUL_ABORT, "");
}
- HYD_handle.ckpoint_prefix = HYDU_strdup(**argv);
+ HYD_handle.user_global.ckpoint_prefix = HYDU_strdup(**argv);
(*argv)++;
fn_exit:
@@ -848,7 +848,7 @@
{
HYD_Status status = HYD_SUCCESS;
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.ckpointlib, HYD_INTERNAL_ERROR,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.ckpointlib, HYD_INTERNAL_ERROR,
"duplicate -ckpointlib option\n");
if (**argv == NULL)
@@ -862,7 +862,7 @@
HYDU_ERR_SETANDJUMP(status, HYD_GRACEFUL_ABORT, "");
}
- HYD_handle.ckpointlib = HYDU_strdup(**argv);
+ HYD_handle.user_global.ckpointlib = HYDU_strdup(**argv);
(*argv)++;
fn_exit:
@@ -876,7 +876,8 @@
{
HYD_Status status = HYD_SUCCESS;
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.ckpoint_restart, HYD_INTERNAL_ERROR, "duplicate restart mode\n");
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.ckpoint_restart,
+ HYD_INTERNAL_ERROR, "duplicate restart mode\n");
if (**argv && IS_HELP(**argv)) {
printf("\n");
@@ -884,7 +885,7 @@
HYDU_ERR_SETANDJUMP(status, HYD_GRACEFUL_ABORT, "");
}
- HYD_handle.ckpoint_restart = 1;
+ HYD_handle.user_global.ckpoint_restart = 1;
fn_exit:
return status;
@@ -897,7 +898,7 @@
{
HYD_Status status = HYD_SUCCESS;
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.debug != -1, HYD_INTERNAL_ERROR,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.debug != -1, HYD_INTERNAL_ERROR,
"duplicate verbose setting\n");
if (**argv && IS_HELP(**argv)) {
@@ -906,7 +907,7 @@
HYDU_ERR_SETANDJUMP(status, HYD_GRACEFUL_ABORT, "");
}
- HYD_handle.debug = 1;
+ HYD_handle.user_global.debug = 1;
fn_exit:
return status;
@@ -1110,18 +1111,18 @@
HYD_Status status = HYD_SUCCESS;
/* Proxy launch or checkpoint restart */
- if ((HYD_handle.launch_mode == HYD_LAUNCH_BOOT) ||
- (HYD_handle.launch_mode == HYD_LAUNCH_BOOT_FOREGROUND) ||
- (HYD_handle.launch_mode == HYD_LAUNCH_SHUTDOWN)) {
+ if ((HYD_handle.user_global.launch_mode == HYD_LAUNCH_BOOT) ||
+ (HYD_handle.user_global.launch_mode == HYD_LAUNCH_BOOT_FOREGROUND) ||
+ (HYD_handle.user_global.launch_mode == HYD_LAUNCH_SHUTDOWN)) {
/* No environment */
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.global_env.prop, HYD_INTERNAL_ERROR,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.global_env.prop, HYD_INTERNAL_ERROR,
"env setting not required for booting/shutting proxies\n");
/* No binding */
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.binding, HYD_INTERNAL_ERROR,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.binding, HYD_INTERNAL_ERROR,
"binding not allowed while booting/shutting proxies\n");
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.bindlib, HYD_INTERNAL_ERROR,
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.bindlib, HYD_INTERNAL_ERROR,
"binding not allowed while booting/shutting proxies\n");
/* No executables */
@@ -1130,11 +1131,11 @@
}
else { /* Application launch */
/* On a checkpoint restart, we set the prefix as the application */
- if (HYD_handle.ckpoint_restart == 1) {
+ if (HYD_handle.user_global.ckpoint_restart == 1) {
status = HYD_UIU_get_current_exec_info(&exec_info);
HYDU_ERR_POP(status, "get_current_exec_info returned error\n");
- exec_info->exec[0] = HYDU_strdup(HYD_handle.ckpoint_prefix);
+ exec_info->exec[0] = HYDU_strdup(HYD_handle.user_global.ckpoint_prefix);
exec_info->exec[1] = NULL;
}
@@ -1167,10 +1168,10 @@
HYD_handle.print_all_exitcodes = 0;
tmp = getenv("HYDRA_DEBUG");
- if (HYD_handle.debug == -1 && tmp)
- HYD_handle.debug = atoi(tmp) ? 1 : 0;
- if (HYD_handle.debug == -1)
- HYD_handle.debug = 0;
+ if (HYD_handle.user_global.debug == -1 && tmp)
+ HYD_handle.user_global.debug = atoi(tmp) ? 1 : 0;
+ if (HYD_handle.user_global.debug == -1)
+ HYD_handle.user_global.debug = 0;
tmp = getenv("HYDRA_PM_ENV");
if (HYD_handle.pm_env == -1 && tmp)
@@ -1179,10 +1180,10 @@
HYD_handle.pm_env = 1; /* Default is to pass the PM environment */
tmp = getenv("HYDRA_BOOTSTRAP");
- if (HYD_handle.bootstrap == NULL && tmp)
- HYD_handle.bootstrap = HYDU_strdup(tmp);
- if (HYD_handle.bootstrap == NULL)
- HYD_handle.bootstrap = HYDU_strdup(HYDRA_DEFAULT_BSS);
+ if (HYD_handle.user_global.bootstrap == NULL && tmp)
+ HYD_handle.user_global.bootstrap = HYDU_strdup(tmp);
+ if (HYD_handle.user_global.bootstrap == NULL)
+ HYD_handle.user_global.bootstrap = HYDU_strdup(HYDRA_DEFAULT_BSS);
tmp = getenv("HYDRA_CSS");
if (HYD_handle.css == NULL && tmp)
@@ -1209,61 +1210,61 @@
HYD_handle.proxy_port = HYD_DEFAULT_PROXY_PORT;
tmp = getenv("HYDRA_LAUNCH_MODE");
- if (HYD_handle.launch_mode == HYD_LAUNCH_UNSET && tmp) {
+ if (HYD_handle.user_global.launch_mode == HYD_LAUNCH_UNSET && tmp) {
if (!strcmp(tmp, "persistent"))
- HYD_handle.launch_mode = HYD_LAUNCH_PERSISTENT;
+ HYD_handle.user_global.launch_mode = HYD_LAUNCH_PERSISTENT;
else if (!strcmp(tmp, "runtime"))
- HYD_handle.launch_mode = HYD_LAUNCH_RUNTIME;
+ HYD_handle.user_global.launch_mode = HYD_LAUNCH_RUNTIME;
}
- if (HYD_handle.launch_mode == HYD_LAUNCH_UNSET)
- HYD_handle.launch_mode = HYD_LAUNCH_RUNTIME;
+ if (HYD_handle.user_global.launch_mode == HYD_LAUNCH_UNSET)
+ HYD_handle.user_global.launch_mode = HYD_LAUNCH_RUNTIME;
tmp = getenv("HYDRA_BOOT_FOREGROUND_PROXIES");
- if (HYD_handle.launch_mode == HYD_LAUNCH_UNSET && tmp) {
+ if (HYD_handle.user_global.launch_mode == HYD_LAUNCH_UNSET && tmp) {
if (atoi(tmp) == 1) {
- HYD_handle.launch_mode = HYD_LAUNCH_BOOT_FOREGROUND;
+ HYD_handle.user_global.launch_mode = HYD_LAUNCH_BOOT_FOREGROUND;
}
}
tmp = getenv("HYDRA_BOOTSTRAP_EXEC");
- if (HYD_handle.bootstrap_exec == NULL && tmp)
- HYD_handle.bootstrap_exec = HYDU_strdup(tmp);
+ if (HYD_handle.user_global.bootstrap_exec == NULL && tmp)
+ HYD_handle.user_global.bootstrap_exec = HYDU_strdup(tmp);
/* Check environment for setting binding */
tmp = getenv("HYDRA_BINDING");
- if (HYD_handle.binding == NULL && tmp)
- HYD_handle.binding = HYDU_strdup(tmp);
+ if (HYD_handle.user_global.binding == NULL && tmp)
+ HYD_handle.user_global.binding = HYDU_strdup(tmp);
tmp = getenv("HYDRA_BINDLIB");
- if (HYD_handle.bindlib == NULL && tmp)
- HYD_handle.bindlib = HYDU_strdup(tmp);
- if (HYD_handle.bindlib == NULL && strcmp(HYDRA_DEFAULT_BINDLIB, ""))
- HYD_handle.bindlib = HYDU_strdup(HYDRA_DEFAULT_BINDLIB);
- if (HYD_handle.bindlib == NULL)
- HYD_handle.bindlib = HYDU_strdup("none");
+ if (HYD_handle.user_global.bindlib == NULL && tmp)
+ HYD_handle.user_global.bindlib = HYDU_strdup(tmp);
+ if (HYD_handle.user_global.bindlib == NULL && strcmp(HYDRA_DEFAULT_BINDLIB, ""))
+ HYD_handle.user_global.bindlib = HYDU_strdup(HYDRA_DEFAULT_BINDLIB);
+ if (HYD_handle.user_global.bindlib == NULL)
+ HYD_handle.user_global.bindlib = HYDU_strdup("none");
/* Check environment for checkpointing */
tmp = getenv("HYDRA_CKPOINTLIB");
- if (HYD_handle.ckpointlib == NULL && tmp)
- HYD_handle.ckpointlib = HYDU_strdup(tmp);
- if (HYD_handle.ckpointlib == NULL && strcmp(HYDRA_DEFAULT_CKPOINTLIB, ""))
- HYD_handle.ckpointlib = HYDU_strdup(HYDRA_DEFAULT_CKPOINTLIB);
- if (HYD_handle.ckpointlib == NULL)
- HYD_handle.ckpointlib = HYDU_strdup("none");
+ if (HYD_handle.user_global.ckpointlib == NULL && tmp)
+ HYD_handle.user_global.ckpointlib = HYDU_strdup(tmp);
+ if (HYD_handle.user_global.ckpointlib == NULL && strcmp(HYDRA_DEFAULT_CKPOINTLIB, ""))
+ HYD_handle.user_global.ckpointlib = HYDU_strdup(HYDRA_DEFAULT_CKPOINTLIB);
+ if (HYD_handle.user_global.ckpointlib == NULL)
+ HYD_handle.user_global.ckpointlib = HYDU_strdup("none");
tmp = getenv("HYDRA_CKPOINT_PREFIX");
- if (HYD_handle.ckpoint_prefix == NULL && tmp)
- HYD_handle.ckpoint_prefix = HYDU_strdup(tmp);
+ if (HYD_handle.user_global.ckpoint_prefix == NULL && tmp)
+ HYD_handle.user_global.ckpoint_prefix = HYDU_strdup(tmp);
/* Check environment for setting the inherited environment */
tmp = getenv("HYDRA_ENV");
- if (HYD_handle.global_env.prop == NULL && tmp)
- HYD_handle.global_env.prop =
+ if (HYD_handle.user_global.global_env.prop == NULL && tmp)
+ HYD_handle.user_global.global_env.prop =
!strcmp(tmp, "all") ? HYDU_strdup("all") : HYDU_strdup("none");
/* If no global environment is set, use the default */
- if (HYD_handle.global_env.prop == NULL)
- HYD_handle.global_env.prop = HYDU_strdup("all");
+ if (HYD_handle.user_global.global_env.prop == NULL)
+ HYD_handle.user_global.global_env.prop = HYDU_strdup("all");
fn_exit:
return status;
@@ -1284,7 +1285,7 @@
HYD_UIU_init_params();
- status = HYDU_list_inherited_env(&HYD_handle.global_env.inherited);
+ status = HYDU_list_inherited_env(&HYD_handle.user_global.global_env.inherited);
HYDU_ERR_POP(status, "unable to get the inherited env list\n");
argv++;
@@ -1323,12 +1324,12 @@
HYDU_ERR_POP(status, "argument verification failed\n");
/* Get the base path for the proxy */
- if (HYD_handle.wdir == NULL) {
- HYD_handle.wdir = HYDU_getcwd();
- HYDU_ERR_CHKANDJUMP(status, HYD_handle.wdir == NULL, HYD_INTERNAL_ERROR,
+ if (HYD_handle.user_global.wdir == NULL) {
+ HYD_handle.user_global.wdir = HYDU_getcwd();
+ HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.wdir == NULL, HYD_INTERNAL_ERROR,
"unable to get current working directory\n");
}
- status = HYDU_get_base_path(progname, HYD_handle.wdir, &HYD_handle.base_path);
+ status = HYDU_get_base_path(progname, HYD_handle.user_global.wdir, &HYD_handle.base_path);
HYDU_ERR_POP(status, "unable to get base path\n");
status = set_default_values();
Modified: mpich2/trunk/src/pm/hydra/ui/utils/uiu.c
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/utils/uiu.c 2009-10-14 11:35:29 UTC (rev 5453)
+++ mpich2/trunk/src/pm/hydra/ui/utils/uiu.c 2009-10-14 11:35:35 UTC (rev 5454)
@@ -12,33 +12,33 @@
{
HYD_handle.base_path = NULL;
HYD_handle.proxy_port = -1;
- HYD_handle.launch_mode = HYD_LAUNCH_UNSET;
+ HYD_handle.user_global.launch_mode = HYD_LAUNCH_UNSET;
- HYD_handle.bootstrap = NULL;
+ HYD_handle.user_global.bootstrap = NULL;
HYD_handle.css = NULL;
HYD_handle.rmk = NULL;
- HYD_handle.binding = NULL;
- HYD_handle.bindlib = NULL;
+ HYD_handle.user_global.binding = NULL;
+ HYD_handle.user_global.bindlib = NULL;
- HYD_handle.ckpointlib = NULL;
+ HYD_handle.user_global.ckpointlib = NULL;
HYD_handle.ckpoint_int = -1;
- HYD_handle.ckpoint_prefix = NULL;
- HYD_handle.ckpoint_restart = 0;
+ HYD_handle.user_global.ckpoint_prefix = NULL;
+ HYD_handle.user_global.ckpoint_restart = 0;
- HYD_handle.debug = -1;
+ HYD_handle.user_global.debug = -1;
HYD_handle.print_rank_map = -1;
HYD_handle.print_all_exitcodes = -1;
- HYD_handle.enablex = -1;
+ HYD_handle.user_global.enablex = -1;
HYD_handle.pm_env = -1;
- HYD_handle.wdir = NULL;
+ HYD_handle.user_global.wdir = NULL;
HYD_handle.ranks_per_proc = -1;
- HYD_handle.bootstrap_exec = NULL;
+ HYD_handle.user_global.bootstrap_exec = NULL;
- HYD_handle.global_env.inherited = NULL;
- HYD_handle.global_env.system = NULL;
- HYD_handle.global_env.user = NULL;
- HYD_handle.global_env.prop = NULL;
+ HYD_handle.user_global.global_env.inherited = NULL;
+ HYD_handle.user_global.global_env.system = NULL;
+ HYD_handle.user_global.global_env.user = NULL;
+ HYD_handle.user_global.global_env.prop = NULL;
HYD_handle.stdin_cb = NULL;
HYD_handle.stdout_cb = NULL;
@@ -62,8 +62,8 @@
if (HYD_handle.base_path)
HYDU_FREE(HYD_handle.base_path);
- if (HYD_handle.bootstrap)
- HYDU_FREE(HYD_handle.bootstrap);
+ if (HYD_handle.user_global.bootstrap)
+ HYDU_FREE(HYD_handle.user_global.bootstrap);
if (HYD_handle.css)
HYDU_FREE(HYD_handle.css);
@@ -71,35 +71,35 @@
if (HYD_handle.rmk)
HYDU_FREE(HYD_handle.rmk);
- if (HYD_handle.binding)
- HYDU_FREE(HYD_handle.binding);
+ if (HYD_handle.user_global.binding)
+ HYDU_FREE(HYD_handle.user_global.binding);
- if (HYD_handle.bindlib)
- HYDU_FREE(HYD_handle.bindlib);
+ if (HYD_handle.user_global.bindlib)
+ HYDU_FREE(HYD_handle.user_global.bindlib);
- if (HYD_handle.ckpointlib)
- HYDU_FREE(HYD_handle.ckpointlib);
+ if (HYD_handle.user_global.ckpointlib)
+ HYDU_FREE(HYD_handle.user_global.ckpointlib);
- if (HYD_handle.ckpoint_prefix)
- HYDU_FREE(HYD_handle.ckpoint_prefix);
+ if (HYD_handle.user_global.ckpoint_prefix)
+ HYDU_FREE(HYD_handle.user_global.ckpoint_prefix);
- if (HYD_handle.wdir)
- HYDU_FREE(HYD_handle.wdir);
+ if (HYD_handle.user_global.wdir)
+ HYDU_FREE(HYD_handle.user_global.wdir);
- if (HYD_handle.bootstrap_exec)
- HYDU_FREE(HYD_handle.bootstrap_exec);
+ if (HYD_handle.user_global.bootstrap_exec)
+ HYDU_FREE(HYD_handle.user_global.bootstrap_exec);
- if (HYD_handle.global_env.inherited)
- HYDU_env_free_list(HYD_handle.global_env.inherited);
+ if (HYD_handle.user_global.global_env.inherited)
+ HYDU_env_free_list(HYD_handle.user_global.global_env.inherited);
- if (HYD_handle.global_env.system)
- HYDU_env_free_list(HYD_handle.global_env.system);
+ if (HYD_handle.user_global.global_env.system)
+ HYDU_env_free_list(HYD_handle.user_global.global_env.system);
- if (HYD_handle.global_env.user)
- HYDU_env_free_list(HYD_handle.global_env.user);
+ if (HYD_handle.user_global.global_env.user)
+ HYDU_env_free_list(HYD_handle.user_global.global_env.user);
- if (HYD_handle.global_env.prop)
- HYDU_FREE(HYD_handle.global_env.prop);
+ if (HYD_handle.user_global.global_env.prop)
+ HYDU_FREE(HYD_handle.user_global.global_env.prop);
if (HYD_handle.exec_info_list)
HYDU_free_exec_info_list(HYD_handle.exec_info_list);
@@ -254,30 +254,30 @@
HYDU_dump(stdout, "----------------\n");
HYDU_dump(stdout, " Base path: %s\n", HYD_handle.base_path);
HYDU_dump(stdout, " Proxy port: %d\n", HYD_handle.proxy_port);
- HYDU_dump(stdout, " Bootstrap server: %s\n", HYD_handle.bootstrap);
- HYDU_dump(stdout, " Debug level: %d\n", HYD_handle.debug);
- HYDU_dump(stdout, " Enable X: %d\n", HYD_handle.enablex);
- HYDU_dump(stdout, " Working dir: %s\n", HYD_handle.wdir);
+ HYDU_dump(stdout, " Bootstrap server: %s\n", HYD_handle.user_global.bootstrap);
+ HYDU_dump(stdout, " Debug level: %d\n", HYD_handle.user_global.debug);
+ HYDU_dump(stdout, " Enable X: %d\n", HYD_handle.user_global.enablex);
+ HYDU_dump(stdout, " Working dir: %s\n", HYD_handle.user_global.wdir);
HYDU_dump(stdout, "\n");
HYDU_dump(stdout, " Global environment:\n");
HYDU_dump(stdout, " -------------------\n");
- for (env = HYD_handle.global_env.inherited; env; env = env->next)
+ for (env = HYD_handle.user_global.global_env.inherited; env; env = env->next)
HYDU_dump(stdout, " %s=%s\n", env->env_name, env->env_value);
- if (HYD_handle.global_env.system) {
+ if (HYD_handle.user_global.global_env.system) {
HYDU_dump(stdout, "\n");
HYDU_dump(stdout, " Hydra internal environment:\n");
HYDU_dump(stdout, " ---------------------------\n");
- for (env = HYD_handle.global_env.system; env; env = env->next)
+ for (env = HYD_handle.user_global.global_env.system; env; env = env->next)
HYDU_dump(stdout, " %s=%s\n", env->env_name, env->env_value);
}
- if (HYD_handle.global_env.user) {
+ if (HYD_handle.user_global.global_env.user) {
HYDU_dump(stdout, "\n");
HYDU_dump(stdout, " User set environment:\n");
HYDU_dump(stdout, " ---------------------\n");
- for (env = HYD_handle.global_env.user; env; env = env->next)
+ for (env = HYD_handle.user_global.global_env.user; env; env = env->next)
HYDU_dump(stdout, " %s=%s\n", env->env_name, env->env_value);
}
More information about the mpich2-commits
mailing list