[mpich2-commits] r4215 - in mpich2/trunk/src/pm/hydra: control/consys demux include launcher/mpiexec pm/pmiserv
balaji at mcs.anl.gov
balaji at mcs.anl.gov
Fri Mar 27 18:36:32 CDT 2009
Author: balaji
Date: 2009-03-27 18:36:32 -0500 (Fri, 27 Mar 2009)
New Revision: 4215
Modified:
mpich2/trunk/src/pm/hydra/control/consys/consys_launch.c
mpich2/trunk/src/pm/hydra/demux/demux.h
mpich2/trunk/src/pm/hydra/include/hydra.h
mpich2/trunk/src/pm/hydra/launcher/mpiexec/utils.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_cb.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_finalize.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c
Log:
White space commit.
Modified: mpich2/trunk/src/pm/hydra/control/consys/consys_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/control/consys/consys_launch.c 2009-03-27 20:18:48 UTC (rev 4214)
+++ mpich2/trunk/src/pm/hydra/control/consys/consys_launch.c 2009-03-27 23:36:32 UTC (rev 4215)
@@ -27,8 +27,9 @@
status = HYD_DMX_register_fd(1, &partition->out, HYD_STDOUT, NULL, handle.stdout_cb);
HYDU_ERR_POP(status, "demux returned error registering fd\n");
- if(partition->err != -1) {
- status = HYD_DMX_register_fd(1, &partition->err, HYD_STDOUT, NULL, handle.stderr_cb);
+ if (partition->err != -1) {
+ status =
+ HYD_DMX_register_fd(1, &partition->err, HYD_STDOUT, NULL, handle.stderr_cb);
HYDU_ERR_POP(status, "demux returned error registering fd\n");
}
}
Modified: mpich2/trunk/src/pm/hydra/demux/demux.h
===================================================================
--- mpich2/trunk/src/pm/hydra/demux/demux.h 2009-03-27 20:18:48 UTC (rev 4214)
+++ mpich2/trunk/src/pm/hydra/demux/demux.h 2009-03-27 23:36:32 UTC (rev 4215)
@@ -10,7 +10,8 @@
#include "hydra.h"
HYD_Status HYD_DMX_register_fd(int num_fds, int *fd, HYD_Event_t events, void *userp,
- HYD_Status(*callback) (int fd, HYD_Event_t events, void *userp));
+ HYD_Status(*callback) (int fd, HYD_Event_t events,
+ void *userp));
HYD_Status HYD_DMX_deregister_fd(int fd);
HYD_Status HYD_DMX_wait_for_event(int time);
HYD_Status HYD_DMX_finalize(void);
Modified: mpich2/trunk/src/pm/hydra/include/hydra.h
===================================================================
--- mpich2/trunk/src/pm/hydra/include/hydra.h 2009-03-27 20:18:48 UTC (rev 4214)
+++ mpich2/trunk/src/pm/hydra/include/hydra.h 2009-03-27 23:36:32 UTC (rev 4215)
@@ -18,7 +18,7 @@
* and hence needs its own port - pproxy_port */
int pproxy_port;
char *bootstrap;
- /* FIXME: We should define a proxy type instead of all these
+ /* FIXME: We should define a proxy type instead of all these
* flags... proxy_type = PROXY_LAUNCHER | PROXY_TERMINATOR
*/
int is_proxy_launcher;
Modified: mpich2/trunk/src/pm/hydra/launcher/mpiexec/utils.c
===================================================================
--- mpich2/trunk/src/pm/hydra/launcher/mpiexec/utils.c 2009-03-27 20:18:48 UTC (rev 4214)
+++ mpich2/trunk/src/pm/hydra/launcher/mpiexec/utils.c 2009-03-27 23:36:32 UTC (rev 4215)
@@ -68,8 +68,8 @@
handle.enablex = !strcmp(*argv, "--enable-x");
continue;
}
-
- if(!strcmp(*argv, "--boot-proxies")) {
+
+ if (!strcmp(*argv, "--boot-proxies")) {
/* FIXME: Prevent usage of incompatible params */
handle.bootstrap = HYDU_strdup("ssh");
handle.is_proxy_launcher = 1;
@@ -77,7 +77,7 @@
continue;
}
- if(!strcmp(*argv, "--remote-proxy")) {
+ if (!strcmp(*argv, "--remote-proxy")) {
/* FIXME: We should get rid of this option eventually.
* This should be the default case. The centralized
* version should use an option like "--local-proxy"
@@ -87,7 +87,7 @@
continue;
}
- if(!strcmp(*argv, "--shutdown-proxies")) {
+ if (!strcmp(*argv, "--shutdown-proxies")) {
handle.is_proxy_remote = 1;
handle.is_proxy_terminator = 1;
handle.prop = HYD_ENV_PROP_ALL;
@@ -303,14 +303,14 @@
}
/* In the case of the proxy launcher, aka --boot-proxies, there is no executable
* specified */
- if(handle.is_proxy_launcher || handle.is_proxy_terminator) {
+ if (handle.is_proxy_launcher || handle.is_proxy_terminator) {
status = HYD_LCHU_get_current_exec_info(&exec_info);
HYDU_ERR_POP(status, "get_current_exec_info returned error\n");
- exec_info->exec[0] = HYDU_strdup(HYD_PROXY_NAME" --persistent");
+ exec_info->exec[0] = HYDU_strdup(HYD_PROXY_NAME " --persistent");
exec_info->exec[1] = NULL;
- if(exec_info->exec_proc_count == 0)
+ if (exec_info->exec_proc_count == 0)
exec_info->exec_proc_count = 1;
env_name = HYDU_strdup("HYD_PROXY_PORT");
@@ -359,8 +359,7 @@
handle.binding = !strcmp(tmp, "none") ? HYD_BIND_NONE :
!strcmp(tmp, "rr") ? HYD_BIND_RR :
!strcmp(tmp, "buddy") ? HYD_BIND_BUDDY :
- !strcmp(tmp, "pack") ? HYD_BIND_PACK :
- HYD_BIND_USER;
+ !strcmp(tmp, "pack") ? HYD_BIND_PACK : HYD_BIND_USER;
if (handle.binding == HYD_BIND_UNSET)
handle.binding = HYD_BIND_NONE;
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c 2009-03-27 20:18:48 UTC (rev 4214)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c 2009-03-27 23:36:32 UTC (rev 4215)
@@ -12,7 +12,8 @@
struct HYD_PMCD_pmi_proxy_params HYD_PMCD_pmi_proxy_params;
int HYD_PMCD_pmi_proxy_listenfd;
-static HYD_Status HYD_PMCD_pmi_pproxy_start(void ) {
+static HYD_Status HYD_PMCD_pmi_pproxy_start(void)
+{
/* If this function exits... its always an error */
HYD_Status status = HYD_INTERNAL_ERROR;
int ret = 0;
@@ -23,62 +24,62 @@
/* Get the limit of fds */
ret = getrlimit(RLIMIT_NOFILE, &rl);
- if(ret == -1)
+ if (ret == -1)
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, "getrlimit() failed (%s)\n",
- HYDU_strerror(errno));
+ HYDU_strerror(errno));
proc_id = fork();
- if(proc_id > 0 ) {
+ if (proc_id > 0) {
/* Ignore exit from child proc - persistent pmi proxy */
status = HYDU_set_signal(SIGCHLD, SIG_IGN);
HYDU_ERR_POP(status, "Setting SIGCHLD handler to SIG_IGN failed\n");
-
+
/* Parent process exits */
- if(!HYD_PMCD_pmi_proxy_params.debug)
+ if (!HYD_PMCD_pmi_proxy_params.debug)
exit(0);
}
- else if(proc_id == 0 ) {
+ else if (proc_id == 0) {
/* Child proc continues */
int i;
pid_t spid;
spid = setsid();
- if(spid == -1)
+ if (spid == -1)
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, "setsid() failed(%s)\n",
- HYDU_strerror(errno));
+ HYDU_strerror(errno));
- if(!HYD_PMCD_pmi_proxy_params.debug)
- for(i=0; i<rl.rlim_max; i++)
- close(i);
+ if (!HYD_PMCD_pmi_proxy_params.debug)
+ for (i = 0; i < rl.rlim_max; i++)
+ close(i);
/* FIXME: dup(0,1,2) to "/dev/null" */
- if(getenv("HYD_PROXY_PORT"))
+ if (getenv("HYD_PROXY_PORT"))
HYD_PMCD_pmi_proxy_params.proxy_port = atoi(getenv("HYD_PROXY_PORT"));
else
HYD_PMCD_pmi_proxy_params.proxy_port = -1;
status = HYDU_sock_listen(&HYD_PMCD_pmi_proxy_listenfd, NULL,
- (uint16_t *) & HYD_PMCD_pmi_proxy_params.proxy_port);
+ (uint16_t *) & HYD_PMCD_pmi_proxy_params.proxy_port);
HYDU_ERR_POP(status, "unable to listen on socket\n");
/* Register the listening socket with the demux engine */
status = HYD_DMX_register_fd(1, &HYD_PMCD_pmi_proxy_listenfd, HYD_STDOUT, NULL,
- HYD_PMCD_pmi_proxy_listen_cb);
+ HYD_PMCD_pmi_proxy_listen_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
}
else {
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, "fork() failed (%s) \n",
- HYDU_strerror(errno));
+ HYDU_strerror(errno));
}
- while(1) {
+ while (1) {
status = HYD_DMX_wait_for_event(-1);
HYDU_ERR_POP(status, "demux engine error waiting for event\n");
}
-fn_exit:
+ fn_exit:
return status;
-fn_fail:
+ fn_fail:
goto fn_exit;
}
@@ -96,7 +97,7 @@
status = HYD_PMCD_pmi_proxy_get_params(argc, argv);
HYDU_ERR_POP(status, "bad parameters passed to the proxy\n");
- if(HYD_PMCD_pmi_proxy_params.is_persistent) {
+ if (HYD_PMCD_pmi_proxy_params.is_persistent) {
status = HYD_PMCD_pmi_pproxy_start();
HYDU_ERR_POP(status, "Error starting persistent PMI proxy\n");
goto fn_exit;
@@ -199,7 +200,8 @@
HYD_PMCD_pmi_proxy_params.stdin_buf_offset = 0;
HYD_PMCD_pmi_proxy_params.stdin_buf_count = 0;
status =
- HYD_DMX_register_fd(1, &stdin_fd, HYD_STDIN, NULL, HYD_PMCD_pmi_proxy_stdin_cb);
+ 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 {
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h 2009-03-27 20:18:48 UTC (rev 4214)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h 2009-03-27 23:36:32 UTC (rev 4215)
@@ -48,7 +48,8 @@
HYD_Status HYD_PMCD_pmi_proxy_cleanup_params(struct HYD_PMCD_pmi_proxy_params *proxy_params);
HYD_Status HYD_PMCD_pmi_proxy_get_params(int t_argc, char **t_argv);
HYD_Status HYD_PMCD_pmi_proxy_get_next_keyvalp(char **bufp, int *buf_lenp, char **keyp,
- int *key_lenp, char **valp, int *val_lenp, char separator);
+ int *key_lenp, char **valp, int *val_lenp,
+ char separator);
HYD_Status HYD_PMCD_pmi_proxy_handle_cmd(int fd, char *cmd, int cmd_len);
HYD_Status HYD_PMCD_pmi_proxy_handle_launch_cmd(int job_connfd, char *launch_cmd, int cmd_len);
HYD_Status HYD_PMCD_pmi_proxy_listen_cb(int fd, HYD_Event_t events, void *userp);
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_cb.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_cb.c 2009-03-27 20:18:48 UTC (rev 4214)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_cb.c 2009-03-27 23:36:32 UTC (rev 4215)
@@ -28,7 +28,8 @@
status = HYDU_sock_accept(fd, &accept_fd);
HYDU_ERR_POP(status, "accept error\n");
- status = HYD_DMX_register_fd(1, &accept_fd, HYD_STDOUT, NULL, HYD_PMCD_pmi_proxy_listen_cb);
+ status =
+ HYD_DMX_register_fd(1, &accept_fd, HYD_STDOUT, NULL, HYD_PMCD_pmi_proxy_listen_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
}
else { /* We got a command from mpiexec */
@@ -59,7 +60,7 @@
struct HYD_PMCD_pmi_proxy_params *proxy_params;
HYDU_FUNC_ENTER();
- proxy_params = (struct HYD_PMCD_pmi_proxy_params *)userp;
+ proxy_params = (struct HYD_PMCD_pmi_proxy_params *) userp;
status = HYDU_sock_stdout_cb(fd, events, proxy_params->rproxy_connfd, &closed);
HYDU_ERR_POP(status, "stdout callback error\n");
@@ -81,9 +82,10 @@
proxy_params->out[i] = -1;
proxy_params->err[i] = -1;
}
- if (proxy_params->out[i] != -1) all_procs_exited = 0;
+ if (proxy_params->out[i] != -1)
+ all_procs_exited = 0;
}
- if(all_procs_exited) {
+ if (all_procs_exited) {
close(proxy_params->rproxy_connfd);
status = HYD_DMX_deregister_fd(proxy_params->rproxy_connfd);
HYDU_ERR_POP(status, "Error deregistering remote job conn fd\n");
@@ -102,7 +104,7 @@
HYD_Status HYD_PMCD_pmi_proxy_remote_cb(int fd, HYD_Event_t events, void *userp)
{
- int closed=0, i;
+ int closed = 0, i;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c 2009-03-27 20:18:48 UTC (rev 4214)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c 2009-03-27 23:36:32 UTC (rev 4215)
@@ -12,7 +12,8 @@
struct HYD_PMCD_pmi_proxy_params HYD_PMCD_pmi_proxy_params;
HYD_Status HYD_PMCD_pmi_proxy_get_next_keyvalp(char **bufp, int *buf_lenp, char **keyp,
- int *key_lenp, char **valp, int *val_lenp, char separator)
+ int *key_lenp, char **valp, int *val_lenp,
+ char separator)
{
char *p = NULL;
int len = 0;
@@ -24,41 +25,53 @@
p = *bufp;
len = *buf_lenp;
- while(len && isspace(*p)) { p++; len--; }
- if(len <= 0)
+ while (len && isspace(*p)) {
+ p++;
+ len--;
+ }
+ if (len <= 0)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "Error reading keyval from command\n");
*keyp = p;
klen = 0;
- while(len && (*p != '=')) {
- p++; len--;
+ while (len && (*p != '=')) {
+ p++;
+ len--;
klen++;
}
- if(key_lenp) *key_lenp = klen;
- p++; len--;
- if(len <= 0)
+ if (key_lenp)
+ *key_lenp = klen;
+ p++;
+ len--;
+ if (len <= 0)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "Error reading keyval from command\n");
*valp = p;
vlen = 0;
/* FIXME: Allow escaping ';' */
- while(len && (*p != separator)) {
- p++; len--;
+ while (len && (*p != separator)) {
+ p++;
+ len--;
vlen++;
}
- if(val_lenp) *val_lenp = vlen;
- p++; len--;
- if(len < 0)
+ if (val_lenp)
+ *val_lenp = vlen;
+ p++;
+ len--;
+ if (len < 0)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "Error reading keyval from command\n");
- while(len && isspace(*p)) { p++; len--; }
+ while (len && isspace(*p)) {
+ p++;
+ len--;
+ }
/* p now points to the next key or the end of string */
*bufp = p;
- if(*p != '\0') {
+ if (*p != '\0') {
/* Remaining length of buffer to be processed */
*buf_lenp = len;
}
- else{
+ else {
/* End of string - no more keyvals */
*buf_lenp = 0;
}
@@ -72,9 +85,9 @@
HYD_Status HYD_PMCD_pmi_proxy_handle_launch_cmd(int job_connfd, char *launch_cmd, int cmd_len)
{
char *key, *val;
- int i=0, key_len=0, val_len = 0, core = 0;
+ int i = 0, key_len = 0, val_len = 0, core = 0;
struct HYD_Partition_exec *exec = NULL;
- HYD_Env_t *env=NULL;
+ HYD_Env_t *env = NULL;
HYD_Status status = HYD_SUCCESS;
/* FIXME: We currently support only one job - We need a list of proxy params for multiple jobs */
@@ -85,7 +98,9 @@
status = HYD_DMX_deregister_fd(job_connfd);
HYDU_ERR_POP(status, "Unable to deregister job conn fd\n");
- status = HYD_DMX_register_fd(1, &job_connfd, HYD_STDIN, (void *)&HYD_PMCD_pmi_proxy_params, HYD_PMCD_pmi_proxy_remote_cb);
+ status =
+ HYD_DMX_register_fd(1, &job_connfd, HYD_STDIN, (void *) &HYD_PMCD_pmi_proxy_params,
+ HYD_PMCD_pmi_proxy_remote_cb);
HYDU_ERR_POP(status, "Unable to register job conn fd\n");
status = HYDU_alloc_partition_exec(&HYD_PMCD_pmi_proxy_params.exec_list);
@@ -93,59 +108,70 @@
exec = HYD_PMCD_pmi_proxy_params.exec_list;
- while(cmd_len > 0){
- status = HYD_PMCD_pmi_proxy_get_next_keyvalp(&launch_cmd, &cmd_len, &key, &key_len, &val, &val_len, HYD_PMCD_CMD_SEP_CHAR);
+ while (cmd_len > 0) {
+ status =
+ HYD_PMCD_pmi_proxy_get_next_keyvalp(&launch_cmd, &cmd_len, &key, &key_len, &val,
+ &val_len, HYD_PMCD_CMD_SEP_CHAR);
HYDU_ERR_POP(status, "Unable to get next key from launch command\n");
/* FIXME: Use pre-defined macros for keys */
- if(!strncmp(key, "exec_name", key_len)) {
+ if (!strncmp(key, "exec_name", key_len)) {
HYDU_MALLOC(exec->exec[0], char *, (val_len + 1), status);
HYDU_ERR_POP(status, "Error allocating memory for executable name\n");
HYDU_snprintf(exec->exec[0], val_len, "%s", val);
exec->exec[1] = NULL;
}
- else if(!strncmp(key, "exec_cnt", key_len)) {
+ else if (!strncmp(key, "exec_cnt", key_len)) {
for (exec = HYD_PMCD_pmi_proxy_params.exec_list; exec->next; exec = exec->next);
- exec->proc_count = atoi(val);
+ exec->proc_count = atoi(val);
}
- else if(!strncmp(key, "env", key_len)) {
+ else if (!strncmp(key, "env", key_len)) {
char *env_str;
int env_str_len;
- env_str = val; env_str_len = val_len;
+ env_str = val;
+ env_str_len = val_len;
exec->prop_env = NULL;
- while(env_str_len > 0) {
- status = HYD_PMCD_pmi_proxy_get_next_keyvalp(&env_str, &env_str_len, &key, &key_len, &val, &val_len, HYD_PMCD_CMD_ENV_SEP_CHAR);
- HYDU_ERR_POP(status, "Error getting next environment variable from launch command\n");
+ while (env_str_len > 0) {
+ status =
+ HYD_PMCD_pmi_proxy_get_next_keyvalp(&env_str, &env_str_len, &key, &key_len,
+ &val, &val_len,
+ HYD_PMCD_CMD_ENV_SEP_CHAR);
+ HYDU_ERR_POP(status,
+ "Error getting next environment variable from launch command\n");
HYDU_MALLOC(env, HYD_Env_t *, sizeof(HYD_Env_t), status);
- HYDU_ERR_POP(status, "Error allocating memory for environment variable in proxy params\n");
+ HYDU_ERR_POP(status,
+ "Error allocating memory for environment variable in proxy params\n");
- HYDU_MALLOC(env->env_name, char *, key_len+1, status);
- HYDU_ERR_POP(status, "Error allocating memory for environment variable in proxy params\n");
- HYDU_snprintf(env->env_name, key_len+1, "%s", key);
+ HYDU_MALLOC(env->env_name, char *, key_len + 1, status);
+ HYDU_ERR_POP(status,
+ "Error allocating memory for environment variable in proxy params\n");
+ HYDU_snprintf(env->env_name, key_len + 1, "%s", key);
- HYDU_MALLOC(env->env_value, char *, val_len+1, status);
- HYDU_ERR_POP(status, "Error allocating memory for environment variable in proxy params\n");
- HYDU_snprintf(env->env_value, val_len+1, "%s", val);
+ HYDU_MALLOC(env->env_value, char *, val_len + 1, status);
+ HYDU_ERR_POP(status,
+ "Error allocating memory for environment variable in proxy params\n");
+ HYDU_snprintf(env->env_value, val_len + 1, "%s", val);
env->next = exec->prop_env;
exec->prop_env = env;
}
}
- else{
- HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "Unrecognized key in launch command\n");
+ else {
+ HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
+ "Unrecognized key in launch command\n");
}
/* FIXME: Set these ... */
/* HYD_PMCD_pmi_proxy_params.wdir =
- HYD_PMCD_pmi_proxy_params.binding =
- HYD_PMCD_pmi_proxy_params.user_bind_map = ;
- HYDU_append_env_to_list(*env, &HYD_PMCD_pmi_proxy_params.global_env);
- HYD_PMCD_pmi_proxy_params.one_pass_count
- status = HYDU_alloc_partition_segment(&segment->next);
- segment->proc_count = ;
- segment->start_pid = ;
- */
+ * HYD_PMCD_pmi_proxy_params.binding =
+ * HYD_PMCD_pmi_proxy_params.user_bind_map = ;
+ * HYDU_append_env_to_list(*env, &HYD_PMCD_pmi_proxy_params.global_env);
+ * HYD_PMCD_pmi_proxy_params.one_pass_count
+ * status = HYDU_alloc_partition_segment(&segment->next);
+ * segment->proc_count = ;
+ * segment->start_pid = ;
+ */
}
HYD_PMCD_pmi_proxy_params.exec_proc_count = 0;
@@ -172,12 +198,15 @@
HYDU_ERR_POP(status, "unable to create env\n");
status = HYDU_putenv(env);
HYDU_ERR_POP(status, "putenv failed\n");
- status = HYDU_create_process(&exec->exec[0], exec->prop_env, NULL,
- &HYD_PMCD_pmi_proxy_params.out[i],
- &HYD_PMCD_pmi_proxy_params.err[i],
- &HYD_PMCD_pmi_proxy_params.pid[i], core);
+ status = HYDU_create_process(&exec->exec[0], exec->prop_env, NULL,
+ &HYD_PMCD_pmi_proxy_params.out[i],
+ &HYD_PMCD_pmi_proxy_params.err[i],
+ &HYD_PMCD_pmi_proxy_params.pid[i], core);
HYDU_ERR_POP(status, "Error launching process\n");
- status = HYD_DMX_register_fd(1, &HYD_PMCD_pmi_proxy_params.out[i], HYD_STDOUT, (void *)&HYD_PMCD_pmi_proxy_params, HYD_PMCD_pmi_proxy_rstdout_cb);
+ status =
+ HYD_DMX_register_fd(1, &HYD_PMCD_pmi_proxy_params.out[i], HYD_STDOUT,
+ (void *) &HYD_PMCD_pmi_proxy_params,
+ HYD_PMCD_pmi_proxy_rstdout_cb);
HYDU_ERR_POP(status, "Error registering process stdout\n");
}
}
@@ -193,16 +222,16 @@
{
char *key = NULL;
char *cmd_name = NULL;
- int i=0, key_len = 0, cmd_name_len = 0;
+ int i = 0, key_len = 0, cmd_name_len = 0;
char *cmdp = NULL;
HYD_Status status = HYD_SUCCESS;
cmdp = cmd;
/* First key/val is the command name */
status = HYD_PMCD_pmi_proxy_get_next_keyvalp(&cmdp, &cmd_len, &key, &key_len, &cmd_name,
- &cmd_name_len, HYD_PMCD_CMD_SEP_CHAR );
+ &cmd_name_len, HYD_PMCD_CMD_SEP_CHAR);
HYDU_ERR_POP(status, "Error retreiving command name from command\n");
-
+
if (!strncmp(cmd_name, HYD_PMCD_CMD_KILLALL_PROCS, key_len)) {
for (i = 0; i < HYD_PMCD_pmi_proxy_params.exec_proc_count; i++)
if (HYD_PMCD_pmi_proxy_params.pid[i] != -1)
@@ -212,11 +241,11 @@
HYDU_ERR_POP(status, "unable to register fd\n");
close(fd);
}
- else if(!strncmp(cmd_name, HYD_PMCD_CMD_LAUNCH_PROCS, key_len)) {
+ else if (!strncmp(cmd_name, HYD_PMCD_CMD_LAUNCH_PROCS, key_len)) {
status = HYD_PMCD_pmi_proxy_handle_launch_cmd(fd, cmdp, cmd_len);
HYDU_ERR_POP(status, "Unable to handle launch command\n");
}
- else if(!strncmp(cmd_name, HYD_PMCD_CMD_SHUTDOWN, key_len)) {
+ else if (!strncmp(cmd_name, HYD_PMCD_CMD_SHUTDOWN, key_len)) {
/* FIXME: Not a clean shutdown... Kill all procs before exiting */
status = HYD_DMX_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to register fd\n");
@@ -262,39 +291,39 @@
}
/* Cleanup proxy params after use */
-HYD_Status HYD_PMCD_pmi_proxy_cleanup_params(struct HYD_PMCD_pmi_proxy_params *proxy_params)
+HYD_Status HYD_PMCD_pmi_proxy_cleanup_params(struct HYD_PMCD_pmi_proxy_params * proxy_params)
{
HYD_Status status = HYD_SUCCESS;
- if(proxy_params->wdir != NULL)
+ if (proxy_params->wdir != NULL)
HYDU_FREE(proxy_params->wdir);
- if(proxy_params->user_bind_map != NULL)
+ if (proxy_params->user_bind_map != NULL)
HYDU_FREE(proxy_params->user_bind_map);
- if(proxy_params->global_env != NULL){
+ if (proxy_params->global_env != NULL) {
HYD_Env_t *p, *q;
do {
p = proxy_params->global_env;
q = p->next;
HYDU_FREE(p);
- }while(q);
+ } while (q);
}
- if(proxy_params->segment_list != NULL) {
+ if (proxy_params->segment_list != NULL) {
/* FIXME : incomplete */
}
- if(proxy_params->exec_list != NULL) {
+ if (proxy_params->exec_list != NULL) {
struct HYD_Partition_exec *p, *q;
- do{
+ do {
p = proxy_params->exec_list;
q = p->next;
HYDU_FREE(p);
- }while(q);
+ } while (q);
}
- if(proxy_params->pid != NULL)
+ if (proxy_params->pid != NULL)
HYDU_FREE(proxy_params->pid);
- if(proxy_params->out != NULL)
+ if (proxy_params->out != NULL)
HYDU_FREE(proxy_params->out);
- if(proxy_params->err != NULL)
+ if (proxy_params->err != NULL)
HYDU_FREE(proxy_params->err);
- if(proxy_params->exit_status != NULL)
+ if (proxy_params->exit_status != NULL)
HYDU_FREE(proxy_params->exit_status);
status = HYD_PMCD_pmi_proxy_init_params(proxy_params);
@@ -325,7 +354,7 @@
if (*argv == NULL)
break;
- if(!strcmp(*argv, "--verbose")) {
+ if (!strcmp(*argv, "--verbose")) {
HYD_PMCD_pmi_proxy_params.debug = 1;
continue;
}
@@ -336,7 +365,7 @@
continue;
}
- if(!strcmp(*argv, "--persistent")) {
+ if (!strcmp(*argv, "--persistent")) {
HYD_PMCD_pmi_proxy_params.is_persistent = 1;
continue;
}
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_cb.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_cb.c 2009-03-27 20:18:48 UTC (rev 4214)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_cb.c 2009-03-27 23:36:32 UTC (rev 4215)
@@ -150,7 +150,7 @@
* bunch of processes to do this. */
/* Connect to all proxies and send a KILL command */
HYDU_snprintf(cmd, HYD_PMCD_MAX_CMD_LEN, "%s=%s %c\n",
- "cmd", HYD_PMCD_CMD_KILLALL_PROCS, HYD_PMCD_CMD_SEP_CHAR);
+ "cmd", HYD_PMCD_CMD_KILLALL_PROCS, HYD_PMCD_CMD_SEP_CHAR);
for (partition = handle.partition_list; partition; partition = partition->next) {
status = HYDU_sock_connect(partition->name, handle.proxy_port, &fd);
if (status != HYD_SUCCESS) {
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_finalize.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_finalize.c 2009-03-27 20:18:48 UTC (rev 4214)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_finalize.c 2009-03-27 23:36:32 UTC (rev 4215)
@@ -31,7 +31,7 @@
HYDU_ERR_POP(status, "unable to finalize process manager utils\n");
/* We use BSC only for local proxies */
- if(!handle.is_proxy_remote) {
+ if (!handle.is_proxy_remote) {
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-03-27 20:18:48 UTC (rev 4214)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c 2009-03-27 23:36:32 UTC (rev 4215)
@@ -16,7 +16,7 @@
extern HYD_Handle handle;
/* Local proxy is a proxy that is local to this process */
-static HYD_Status launch_procs_with_local_proxy(void )
+static HYD_Status launch_procs_with_local_proxy(void)
{
HYD_Status status = HYD_SUCCESS;
int i, arg, process_id;
@@ -129,25 +129,24 @@
}
/* Request remote proxies to shutdown */
-static HYD_Status shutdown_remote_proxies(void )
+static HYD_Status shutdown_remote_proxies(void)
{
char shutdown_proxies_cmd[HYD_PMCD_MAX_CMD_LEN];
- struct HYD_Partition *partition=NULL;
- int HYD_PMCD_pmi_proxy_connfd=-1;
+ struct HYD_Partition *partition = NULL;
+ int HYD_PMCD_pmi_proxy_connfd = -1;
HYD_Status status = HYD_SUCCESS;
for (partition = handle.partition_list; partition; partition = partition->next) {
status = HYDU_sock_connect(partition->name, handle.pproxy_port,
- &HYD_PMCD_pmi_proxy_connfd);
+ &HYD_PMCD_pmi_proxy_connfd);
HYDU_ERR_POP(status, "Error connecting to remote proxy");
/* Create shutdown command */
HYDU_snprintf(shutdown_proxies_cmd, HYD_PMCD_MAX_CMD_LEN,
- "%s=%s %c\n",
- "cmd", HYD_PMCD_CMD_SHUTDOWN, HYD_PMCD_CMD_SEP_CHAR);
+ "%s=%s %c\n", "cmd", HYD_PMCD_CMD_SHUTDOWN, HYD_PMCD_CMD_SEP_CHAR);
status = HYDU_sock_writeline(HYD_PMCD_pmi_proxy_connfd, shutdown_proxies_cmd,
- strlen(shutdown_proxies_cmd));
+ strlen(shutdown_proxies_cmd));
HYDU_ERR_POP(status, "Error writing the launch procs command\n");
/* FIXME: Read result */
@@ -162,21 +161,21 @@
}
/* Remote proxy is a proxy external to this process */
-static HYD_Status launch_procs_with_remote_proxy(void )
+static HYD_Status launch_procs_with_remote_proxy(void)
{
HYD_Status status = HYD_SUCCESS;
char launch_procs_cmd[HYD_PMCD_MAX_CMD_LEN];
- char env_list[HYD_PMCD_MAX_CMD_LEN]; /* FIXME: Wrong *MAX*... */
+ char env_list[HYD_PMCD_MAX_CMD_LEN]; /* FIXME: Wrong *MAX*... */
int env_list_len = 0;
char *p = NULL;
- struct HYD_Partition *partition=NULL;
- struct HYD_Partition_exec *exec=NULL;
- struct HYD_Env *env=NULL;
- int HYD_PMCD_pmi_proxy_connfd=-1;
+ struct HYD_Partition *partition = NULL;
+ struct HYD_Partition_exec *exec = NULL;
+ struct HYD_Env *env = NULL;
+ int HYD_PMCD_pmi_proxy_connfd = -1;
for (partition = handle.partition_list; partition; partition = partition->next) {
status = HYDU_sock_connect(partition->name, handle.pproxy_port,
- &HYD_PMCD_pmi_proxy_connfd);
+ &HYD_PMCD_pmi_proxy_connfd);
HYDU_ERR_POP(status, "Error connecting to remote proxy");
exec = partition->exec_list;
@@ -186,23 +185,23 @@
p = env_list;
*p = '\0';
env_list_len = HYD_PMCD_MAX_CMD_LEN;
- while(env){
- HYDU_snprintf(p, env_list_len,"%s=%s %c",
- env->env_name, env->env_value, HYD_PMCD_CMD_ENV_SEP_CHAR);
+ while (env) {
+ HYDU_snprintf(p, env_list_len, "%s=%s %c",
+ env->env_name, env->env_value, HYD_PMCD_CMD_ENV_SEP_CHAR);
env_list_len -= strlen(p);
p += strlen(p);
- env = env->next;
+ env = env->next;
}
/* Create launch command */
HYDU_snprintf(launch_procs_cmd, HYD_PMCD_MAX_CMD_LEN,
- "%s=%s %c %s=%s %c %s=%d %c %s=%s %c\n",
- "cmd", HYD_PMCD_CMD_LAUNCH_PROCS, HYD_PMCD_CMD_SEP_CHAR,
- "exec_name", exec->exec[0], HYD_PMCD_CMD_SEP_CHAR,
- "exec_cnt", exec->proc_count, HYD_PMCD_CMD_SEP_CHAR,
- "env", env_list, HYD_PMCD_CMD_SEP_CHAR);
+ "%s=%s %c %s=%s %c %s=%d %c %s=%s %c\n",
+ "cmd", HYD_PMCD_CMD_LAUNCH_PROCS, HYD_PMCD_CMD_SEP_CHAR,
+ "exec_name", exec->exec[0], HYD_PMCD_CMD_SEP_CHAR,
+ "exec_cnt", exec->proc_count, HYD_PMCD_CMD_SEP_CHAR,
+ "env", env_list, HYD_PMCD_CMD_SEP_CHAR);
status = HYDU_sock_writeline(HYD_PMCD_pmi_proxy_connfd, launch_procs_cmd,
- strlen(launch_procs_cmd));
+ strlen(launch_procs_cmd));
HYDU_ERR_POP(status, "Error writing the launch procs command\n");
/* FIXME: Read result */
@@ -293,12 +292,12 @@
status = HYD_PMCD_pmi_create_pg();
HYDU_ERR_POP(status, "unable to create process group\n");
- if(handle.is_proxy_remote) {
- if(handle.is_proxy_terminator) {
+ if (handle.is_proxy_remote) {
+ if (handle.is_proxy_terminator) {
status = shutdown_remote_proxies();
HYDU_ERR_POP(status, "Error shutting down remote proxies\n");
}
- else{
+ else {
status = launch_procs_with_remote_proxy();
HYDU_ERR_POP(status, "Error launching procs with remote proxy\n");
}
@@ -323,10 +322,10 @@
HYDU_FUNC_ENTER();
- if(handle.is_proxy_remote) {
+ if (handle.is_proxy_remote) {
status = HYD_SUCCESS;
}
- else{
+ else {
status = HYD_BSCI_wait_for_completion();
if (status != HYD_SUCCESS) {
status = HYD_PMCD_pmi_serv_cleanup();
More information about the mpich2-commits
mailing list