[mpich2-commits] r5472 - in mpich2/trunk/src/pm/hydra: . css/include css/none css/src include pm/include pm/pmiserv rmk/dummy rmk/include rmk/pbs rmk/src rmk/utils tools/bind tools/bind/plpa tools/bootstrap/fork tools/bootstrap/include tools/bootstrap/rsh tools/bootstrap/slurm tools/bootstrap/src tools/bootstrap/ssh tools/bootstrap/utils tools/ckpoint tools/ckpoint/blcr tools/demux ui/mpiexec ui/utils utils/alloc utils/args utils/dbg utils/env utils/launch utils/others utils/signals utils/sock utils/string utils/timer
balaji at mcs.anl.gov
balaji at mcs.anl.gov
Thu Oct 15 23:24:59 CDT 2009
Author: balaji
Date: 2009-10-15 23:24:58 -0500 (Thu, 15 Oct 2009)
New Revision: 5472
Modified:
mpich2/trunk/src/pm/hydra/configure.in
mpich2/trunk/src/pm/hydra/css/include/cssi.h.in
mpich2/trunk/src/pm/hydra/css/none/none.h
mpich2/trunk/src/pm/hydra/css/none/none_finalize.c
mpich2/trunk/src/pm/hydra/css/none/none_init.c
mpich2/trunk/src/pm/hydra/css/none/none_query_string.c
mpich2/trunk/src/pm/hydra/css/src/cssi_finalize.c
mpich2/trunk/src/pm/hydra/css/src/cssi_init.c.in
mpich2/trunk/src/pm/hydra/css/src/cssi_query_string.c
mpich2/trunk/src/pm/hydra/include/hydra.h
mpich2/trunk/src/pm/hydra/include/hydra_base.h
mpich2/trunk/src/pm/hydra/include/hydra_tools.h
mpich2/trunk/src/pm/hydra/include/hydra_utils.h
mpich2/trunk/src/pm/hydra/pm/include/pmci.h
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_common.h
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.h
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_common.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_common.h
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v1.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v1.h
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v2.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v2.h
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.h
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
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_utils.c
mpich2/trunk/src/pm/hydra/rmk/dummy/rmk_dummy_init.c
mpich2/trunk/src/pm/hydra/rmk/include/rmki.h.in
mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs.h
mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_init.c
mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_query_node_list.c
mpich2/trunk/src/pm/hydra/rmk/src/rmki_init.c.in
mpich2/trunk/src/pm/hydra/rmk/src/rmki_query_node_list.c
mpich2/trunk/src/pm/hydra/rmk/utils/rmku.h
mpich2/trunk/src/pm/hydra/rmk/utils/rmku_query_node_list.c
mpich2/trunk/src/pm/hydra/tools/bind/bind.c
mpich2/trunk/src/pm/hydra/tools/bind/bind.h
mpich2/trunk/src/pm/hydra/tools/bind/plpa/bind_plpa.c
mpich2/trunk/src/pm/hydra/tools/bind/plpa/bind_plpa.h
mpich2/trunk/src/pm/hydra/tools/bootstrap/fork/fork.h
mpich2/trunk/src/pm/hydra/tools/bootstrap/fork/fork_init.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/fork/fork_launch.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/include/bsci.h.in
mpich2/trunk/src/pm/hydra/tools/bootstrap/rsh/rsh.h
mpich2/trunk/src/pm/hydra/tools/bootstrap/rsh/rsh_init.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/rsh/rsh_launch.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm.h
mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_init.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_launch.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_query_node_list.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_query_proxy_id.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_finalize.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_init.c.in
mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_launch.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_query_node_list.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_query_proxy_id.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_usize.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_wait.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/ssh/ssh.h
mpich2/trunk/src/pm/hydra/tools/bootstrap/ssh/ssh_init.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/ssh/ssh_launch.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu.h
mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_finalize.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_query_node_list.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_query_proxy_id.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_usize.c
mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_wait.c
mpich2/trunk/src/pm/hydra/tools/ckpoint/blcr/ckpoint_blcr.c
mpich2/trunk/src/pm/hydra/tools/ckpoint/blcr/ckpoint_blcr.h
mpich2/trunk/src/pm/hydra/tools/ckpoint/ckpoint.c
mpich2/trunk/src/pm/hydra/tools/ckpoint/ckpoint.h
mpich2/trunk/src/pm/hydra/tools/demux/demux.c
mpich2/trunk/src/pm/hydra/tools/demux/demux.h
mpich2/trunk/src/pm/hydra/ui/mpiexec/callback.c
mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.c
mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.h
mpich2/trunk/src/pm/hydra/ui/mpiexec/utils.c
mpich2/trunk/src/pm/hydra/ui/utils/uiu.c
mpich2/trunk/src/pm/hydra/ui/utils/uiu.h
mpich2/trunk/src/pm/hydra/utils/alloc/alloc.c
mpich2/trunk/src/pm/hydra/utils/args/args.c
mpich2/trunk/src/pm/hydra/utils/dbg/dbg.c
mpich2/trunk/src/pm/hydra/utils/env/env.c
mpich2/trunk/src/pm/hydra/utils/launch/launch.c
mpich2/trunk/src/pm/hydra/utils/others/others.c
mpich2/trunk/src/pm/hydra/utils/signals/signals.c
mpich2/trunk/src/pm/hydra/utils/sock/sock.c
mpich2/trunk/src/pm/hydra/utils/string/string.c
mpich2/trunk/src/pm/hydra/utils/timer/timer.c
Log:
Use a consistent naming convention everywhere as a part of the overall
maintenance cleanup. Tools functionality is all HYDT_, utilities are
all HYDU_ and the rest are HYD_.
Modified: mpich2/trunk/src/pm/hydra/configure.in
===================================================================
--- mpich2/trunk/src/pm/hydra/configure.in 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/configure.in 2009-10-16 04:24:58 UTC (rev 5472)
@@ -104,9 +104,9 @@
fi
hydra_bss_makefiles="$hydra_bss_makefiles bootstrap/${hydra_bss_name}/Makefile"
hydra_bss_init_decl="${hydra_bss_init_decl}
-HYD_Status HYD_BSCI_${hydra_bss_name}_init(void);"
+HYD_status HYDT_bsci_${hydra_bss_name}_init(void);"
hydra_bss_name_array="${hydra_bss_name_array} \"${hydra_bss_name}\", "
- hydra_bss_init_array="${hydra_bss_init_array} HYD_BSCI_${hydra_bss_name}_init, "
+ hydra_bss_init_array="${hydra_bss_init_array} HYDT_bsci_${hydra_bss_name}_init, "
case "$hydra_bss_name" in
ssh)
@@ -161,9 +161,9 @@
fi
hydra_css_makefiles="$hydra_css_makefiles css/${hydra_css_name}/Makefile"
hydra_css_init_decl="${hydra_css_init_decl}
-HYD_Status HYD_CSSI_${hydra_css_name}_init(void);"
+HYD_status HYD_cssi_${hydra_css_name}_init(void);"
hydra_css_name_array="${hydra_css_name_array} \"${hydra_css_name}\", "
- hydra_css_init_array="${hydra_css_init_array} HYD_CSSI_${hydra_css_name}_init, "
+ hydra_css_init_array="${hydra_css_init_array} HYD_cssi_${hydra_css_name}_init, "
case "$hydra_css_name" in
dummy)
@@ -206,9 +206,9 @@
fi
hydra_rmk_makefiles="$hydra_rmk_makefiles rmk/${hydra_rmk_name}/Makefile"
hydra_rmk_init_decl="${hydra_rmk_init_decl}
-HYD_Status HYD_RMKI_${hydra_rmk_name}_init(void);"
+HYD_status HYD_rmki_${hydra_rmk_name}_init(void);"
hydra_rmk_name_array="${hydra_rmk_name_array} \"${hydra_rmk_name}\", "
- hydra_rmk_init_array="${hydra_rmk_init_array} HYD_RMKI_${hydra_rmk_name}_init, "
+ hydra_rmk_init_array="${hydra_rmk_init_array} HYD_rmki_${hydra_rmk_name}_init, "
case "$hydra_rmk_name" in
dummy)
Modified: mpich2/trunk/src/pm/hydra/css/include/cssi.h.in
===================================================================
--- mpich2/trunk/src/pm/hydra/css/include/cssi.h.in 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/css/include/cssi.h.in 2009-10-16 04:24:58 UTC (rev 5472)
@@ -7,17 +7,17 @@
#ifndef CSSI_H_INCLUDED
#define CSSI_H_INCLUDED
-struct HYD_CSSI_fns {
- HYD_Status(*init) (void);
- HYD_Status(*query_string) (char *str);
- HYD_Status(*finalize) (void);
+struct HYD_cssi_fns {
+ HYD_status(*init) (void);
+ HYD_status(*query_string) (char *str);
+ HYD_status(*finalize) (void);
};
-extern struct HYD_CSSI_fns HYD_CSSI_fns;
+extern struct HYD_cssi_fns HYD_cssi_fns;
-HYD_Status HYD_CSSI_init(char *css);
-HYD_Status HYD_CSSI_query_string(char *str);
-HYD_Status HYD_CSSI_finalize(void);
+HYD_status HYD_cssi_init(char *css);
+HYD_status HYD_cssi_query_string(char *str);
+HYD_status HYD_cssi_finalize(void);
/* Each communication sub-system has to expose an initialization function */
@hydra_css_init_decl@
Modified: mpich2/trunk/src/pm/hydra/css/none/none.h
===================================================================
--- mpich2/trunk/src/pm/hydra/css/none/none.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/css/none/none.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,7 +9,7 @@
#include "hydra_base.h"
-HYD_Status HYD_CSSD_none_query_string(char *str);
-HYD_Status HYD_CSSD_none_finalize(void);
+HYD_status HYD_cssd_none_query_string(char *str);
+HYD_status HYD_cssd_none_finalize(void);
#endif /* NONE_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/css/none/none_finalize.c
===================================================================
--- mpich2/trunk/src/pm/hydra/css/none/none_finalize.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/css/none/none_finalize.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,9 +8,9 @@
#include "cssi.h"
#include "none.h"
-HYD_Status HYD_CSSD_none_finalize(void)
+HYD_status HYD_cssd_none_finalize(void)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/css/none/none_init.c
===================================================================
--- mpich2/trunk/src/pm/hydra/css/none/none_init.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/css/none/none_init.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,14 +8,14 @@
#include "cssi.h"
#include "none.h"
-HYD_Status HYD_CSSI_none_init(void)
+HYD_status HYD_cssi_none_init(void)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYD_CSSI_fns.query_string = HYD_CSSD_none_query_string;
- HYD_CSSI_fns.finalize = HYD_CSSD_none_finalize;
+ HYD_cssi_fns.query_string = HYD_cssd_none_query_string;
+ HYD_cssi_fns.finalize = HYD_cssd_none_finalize;
HYDU_FUNC_EXIT();
Modified: mpich2/trunk/src/pm/hydra/css/none/none_query_string.c
===================================================================
--- mpich2/trunk/src/pm/hydra/css/none/none_query_string.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/css/none/none_query_string.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,9 +8,9 @@
#include "cssi.h"
#include "none.h"
-HYD_Status HYD_CSSD_none_query_string(char *str)
+HYD_status HYD_cssd_none_query_string(char *str)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/css/src/cssi_finalize.c
===================================================================
--- mpich2/trunk/src/pm/hydra/css/src/cssi_finalize.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/css/src/cssi_finalize.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -7,13 +7,13 @@
#include "hydra_utils.h"
#include "cssi.h"
-HYD_Status HYD_CSSI_finalize(void)
+HYD_status HYD_cssi_finalize(void)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_CSSI_fns.finalize();
+ status = HYD_cssi_fns.finalize();
HYDU_FUNC_EXIT();
Modified: mpich2/trunk/src/pm/hydra/css/src/cssi_init.c.in
===================================================================
--- mpich2/trunk/src/pm/hydra/css/src/cssi_init.c.in 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/css/src/cssi_init.c.in 2009-10-16 04:24:58 UTC (rev 5472)
@@ -7,34 +7,34 @@
#include "hydra_utils.h"
#include "cssi.h"
-struct HYD_CSSI_fns HYD_CSSI_fns = { 0 };
+struct HYD_cssi_fns HYD_cssi_fns = { 0 };
-const char *HYD_CSSI_comp_array[] = { @hydra_css_name_array@ };
-HYD_Status(*HYD_CSSI_comp_init[])(void) = { @hydra_css_init_array@ };
+const char *HYD_cssi_comp_array[] = { @hydra_css_name_array@ };
+HYD_status(*HYD_cssi_comp_init[])(void) = { @hydra_css_init_array@ };
-HYD_Status HYD_CSSI_init(char *css)
+HYD_status HYD_cssi_init(char *css)
{
int i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- for (i = 0; HYD_CSSI_comp_array[i]; i++) {
- if (!strcmp(css, HYD_CSSI_comp_array[i])) {
- status = (*HYD_CSSI_comp_init[i])();
+ for (i = 0; HYD_cssi_comp_array[i]; i++) {
+ if (!strcmp(css, HYD_cssi_comp_array[i])) {
+ status = (*HYD_cssi_comp_init[i])();
break;
}
}
- if (HYD_CSSI_comp_array[i] == NULL)
+ if (HYD_cssi_comp_array[i] == NULL)
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unrecognized communication sub-system: %s\n", css);
/* These functions are mandatory */
- if (HYD_CSSI_fns.query_string == NULL)
+ if (HYD_cssi_fns.query_string == NULL)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
"mandatory communication sub-system function undefined\n");
- if (HYD_CSSI_fns.finalize == NULL)
+ if (HYD_cssi_fns.finalize == NULL)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
"mandatory communication sub-system function undefined\n");
Modified: mpich2/trunk/src/pm/hydra/css/src/cssi_query_string.c
===================================================================
--- mpich2/trunk/src/pm/hydra/css/src/cssi_query_string.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/css/src/cssi_query_string.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -7,13 +7,13 @@
#include "hydra_utils.h"
#include "cssi.h"
-HYD_Status HYD_CSSI_query_string(char *str)
+HYD_status HYD_cssi_query_string(char *str)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_CSSI_fns.query_string(str);
+ status = HYD_cssi_fns.query_string(str);
HYDU_FUNC_EXIT();
Modified: mpich2/trunk/src/pm/hydra/include/hydra.h
===================================================================
--- mpich2/trunk/src/pm/hydra/include/hydra.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/include/hydra.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -11,8 +11,8 @@
#include "hydra_base.h"
#include "hydra_utils.h"
-struct HYD_Handle_ {
- struct HYD_User_global user_global;
+struct HYD_handle {
+ struct HYD_user_global user_global;
char *base_path;
int proxy_port;
@@ -28,20 +28,20 @@
int ranks_per_proc;
- 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);
+ 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);
/* Start time and timeout. These are filled in by the launcher,
* but are utilized by the demux engine and the boot-strap server
* to decide how long we need to wait for. */
- HYD_Time start;
- HYD_Time timeout;
+ HYD_time start;
+ HYD_time timeout;
- struct HYD_Proxy *proxy_list;
+ struct HYD_proxy *proxy_list;
int global_core_count;
- struct HYD_Exec_info *exec_info_list;
+ struct HYD_exec_info *exec_info_list;
int global_process_count;
/* Random parameters used for internal code */
@@ -51,8 +51,6 @@
int stdin_buf_count;
};
-typedef struct HYD_Handle_ HYD_Handle;
+extern struct HYD_handle HYD_handle;
-extern HYD_Handle HYD_handle;
-
#endif /* HYDRA_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/include/hydra_base.h
===================================================================
--- mpich2/trunk/src/pm/hydra/include/hydra_base.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/include/hydra_base.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -112,7 +112,7 @@
HYD_SOCK_ERROR,
HYD_INVALID_PARAM,
HYD_INTERNAL_ERROR
-} HYD_Status;
+} HYD_status;
/* Proxy type */
typedef enum {
@@ -124,7 +124,7 @@
HYD_LAUNCH_BOOT_FOREGROUND,
HYD_LAUNCH_SHUTDOWN,
HYD_LAUNCH_PERSISTENT
-} HYD_Launch_mode_t;
+} HYD_launch_mode_t;
#if defined(HAVE_PUTENV) && defined(NEEDS_PUTENV_DECL)
extern int putenv(char *string);
@@ -134,46 +134,46 @@
int gethostname(char *name, size_t len);
#endif
-typedef unsigned short HYD_Event_t;
+typedef unsigned short HYD_event_t;
/* Environment information */
-typedef struct HYD_Env {
+typedef struct HYD_env {
char *env_name;
char *env_value;
- struct HYD_Env *next;
-} HYD_Env_t;
+ struct HYD_env *next;
+} HYD_env_t;
-typedef enum HYD_Env_overwrite {
+typedef enum HYD_env_overwrite {
HYD_ENV_OVERWRITE_TRUE,
HYD_ENV_OVERWRITE_FALSE
-} HYD_Env_overwrite_t;
+} HYD_env_overwrite_t;
typedef enum {
HYD_ENV_PROP_UNSET,
HYD_ENV_PROP_ALL,
HYD_ENV_PROP_NONE,
HYD_ENV_PROP_LIST
-} HYD_Env_prop_t;
+} HYD_env_prop_t;
-struct HYD_Env_global {
- HYD_Env_t *system;
- HYD_Env_t *user;
- HYD_Env_t *inherited;
+struct HYD_env_global {
+ HYD_env_t *system;
+ HYD_env_t *user;
+ HYD_env_t *inherited;
char *prop;
};
/* Executables on a proxy */
-struct HYD_Proxy_exec {
+struct HYD_proxy_exec {
char *exec[HYD_NUM_TMP_STRINGS];
int proc_count;
- HYD_Env_t *user_env;
+ HYD_env_t *user_env;
char *env_prop;
- struct HYD_Proxy_exec *next;
+ struct HYD_proxy_exec *next;
};
/* Proxy information */
-struct HYD_Proxy {
+struct HYD_proxy {
char *hostname;
char **exec_launch_info;
@@ -189,27 +189,27 @@
int proxy_core_count;
int proxy_process_count;
- struct HYD_Proxy_exec *exec_list;
+ struct HYD_proxy_exec *exec_list;
int *exit_status;
int control_fd;
- struct HYD_Proxy *next;
+ struct HYD_proxy *next;
};
-struct HYD_Exec_info {
+struct HYD_exec_info {
int process_count;
char *exec[HYD_NUM_TMP_STRINGS];
/* Local environment */
- HYD_Env_t *user_env;
+ HYD_env_t *user_env;
char *env_prop;
- struct HYD_Exec_info *next;
+ struct HYD_exec_info *next;
};
/* Global user parameters */
-struct HYD_User_global {
+struct HYD_user_global {
/* Bootstrap server */
char *bootstrap;
char *bootstrap_exec;
@@ -227,8 +227,8 @@
int enablex;
int debug;
char *wdir;
- HYD_Launch_mode_t launch_mode;
- struct HYD_Env_global global_env;
+ HYD_launch_mode_t launch_mode;
+ struct HYD_env_global global_env;
};
#endif /* HYDRA_BASE_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/include/hydra_tools.h
===================================================================
--- mpich2/trunk/src/pm/hydra/include/hydra_tools.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/include/hydra_tools.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -10,15 +10,15 @@
#include "hydra_base.h"
/* bind */
-HYD_Status HYDU_bind_init(char *binding, char *bindlib);
-void HYDU_bind_finalize(void);
-HYD_Status HYDU_bind_process(int core);
-int HYDU_bind_get_core_id(int id);
+HYD_status HYDT_bind_init(char *binding, char *bindlib);
+void HYDT_bind_finalize(void);
+HYD_status HYDT_bind_process(int core);
+int HYDT_bind_get_core_id(int id);
/* checkpointing */
-HYD_Status HYDU_ckpoint_init(char *ckpointlib, char *ckpoint_prefix);
-HYD_Status HYDU_ckpoint_suspend(void);
-HYD_Status HYDU_ckpoint_restart(HYD_Env_t * envlist, int num_ranks, int ranks[], int *in,
+HYD_status HYDT_ckpoint_init(char *ckpointlib, char *ckpoint_prefix);
+HYD_status HYDT_ckpoint_suspend(void);
+HYD_status HYDT_ckpoint_restart(HYD_env_t * envlist, int num_ranks, int ranks[], int *in,
int *out, int *err);
#endif /* HYDRA_TOOLS_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/include/hydra_utils.h
===================================================================
--- mpich2/trunk/src/pm/hydra/include/hydra_utils.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/include/hydra_utils.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -19,23 +19,23 @@
#endif
#if !defined COMPILER_ACCEPTS_VA_ARGS
-#define HYDU_Error_printf printf
+#define HYDU_error_printf printf
#elif defined __FILE__ && defined HYDU_FUNC
-#define HYDU_Error_printf(...) \
+#define HYDU_error_printf(...) \
{ \
HYDU_dump_prefix(stderr); \
HYDU_dump_noprefix(stderr, "%s (%s:%d): ", __func__, __FILE__, __LINE__); \
HYDU_dump_noprefix(stderr, __VA_ARGS__); \
}
#elif defined __FILE__
-#define HYDU_Error_printf(...) \
+#define HYDU_error_printf(...) \
{ \
HYDU_dump_prefix(stderr); \
HYDU_dump_noprefix(stderr, "%s (%d): ", __FILE__, __LINE__); \
HYDU_dump_noprefix(stderr, __VA_ARGS__); \
}
#else
-#define HYDU_Error_printf(...) \
+#define HYDU_error_printf(...) \
{ \
HYDU_dump_prefix(stderr); \
HYDU_dump_noprefix(stderr, __VA_ARGS__); \
@@ -46,7 +46,7 @@
{ \
if (status != HYD_SUCCESS && status != HYD_GRACEFUL_ABORT) { \
if (strlen(message)) \
- HYDU_Error_printf(message); \
+ HYDU_error_printf(message); \
goto fn_fail; \
} \
else if (status == HYD_GRACEFUL_ABORT) { \
@@ -59,7 +59,7 @@
status = error; \
if (status != HYD_SUCCESS && status != HYD_GRACEFUL_ABORT) { \
if (strlen(message)) \
- HYDU_Error_printf(message); \
+ HYDU_error_printf(message); \
goto fn_fail; \
} \
else if (status == HYD_GRACEFUL_ABORT) { \
@@ -84,7 +84,7 @@
status = error; \
if (status != HYD_SUCCESS && status != HYD_GRACEFUL_ABORT) { \
if (strlen(message)) \
- HYDU_Error_printf(message, arg1); \
+ HYDU_error_printf(message, arg1); \
goto fn_fail; \
} \
else if (status == HYD_GRACEFUL_ABORT) { \
@@ -97,7 +97,7 @@
status = error; \
if (status != HYD_SUCCESS && status != HYD_GRACEFUL_ABORT) { \
if (strlen(message)) \
- HYDU_Error_printf(message, arg1, arg2); \
+ HYDU_error_printf(message, arg1, arg2); \
goto fn_fail; \
} \
else if (status == HYD_GRACEFUL_ABORT) { \
@@ -106,9 +106,9 @@
}
#if defined ENABLE_WARNINGS
-#define HYDU_Warn_printf HYDU_Error_printf
+#define HYDU_warn_printf HYDU_error_printf
#else
-#define HYDU_Warn_printf(...) {}
+#define HYDU_warn_printf(...) {}
#endif /* ENABLE_WARNINGS */
/* We need to add more information in here later */
@@ -122,60 +122,60 @@
/* alloc */
-void HYDU_init_user_global(struct HYD_User_global *user_global);
-void HYDU_init_global_env(struct HYD_Env_global *global_env);
-HYD_Status HYDU_alloc_proxy(struct HYD_Proxy **proxy);
-HYD_Status HYDU_alloc_exec_info(struct HYD_Exec_info **exec_info);
-void HYDU_free_exec_info_list(struct HYD_Exec_info *exec_info_list);
-void HYDU_free_proxy_list(struct HYD_Proxy *proxy_list);
-HYD_Status HYDU_alloc_proxy_exec(struct HYD_Proxy_exec **exec);
+void HYDU_init_user_global(struct HYD_user_global *user_global);
+void HYDU_init_global_env(struct HYD_env_global *global_env);
+HYD_status HYDU_alloc_proxy(struct HYD_proxy **proxy);
+HYD_status HYDU_alloc_exec_info(struct HYD_exec_info **exec_info);
+void HYDU_free_exec_info_list(struct HYD_exec_info *exec_info_list);
+void HYDU_free_proxy_list(struct HYD_proxy *proxy_list);
+HYD_status HYDU_alloc_proxy_exec(struct HYD_proxy_exec **exec);
/* args */
-HYD_Status HYDU_find_in_path(const char *execname, char **path);
+HYD_status HYDU_find_in_path(const char *execname, char **path);
char *HYDU_getcwd(void);
-HYD_Status HYDU_get_base_path(const char *execname, char *wdir, char **path);
-HYD_Status HYDU_parse_hostfile(char *hostfile,
- HYD_Status(*process_token) (char *token, int newline));
+HYD_status HYDU_get_base_path(const char *execname, char *wdir, char **path);
+HYD_status HYDU_parse_hostfile(char *hostfile,
+ HYD_status(*process_token) (char *token, int newline));
/* debug */
-HYD_Status HYDU_dbg_init(const char *str);
+HYD_status HYDU_dbg_init(const char *str);
void HYDU_dump_prefix(FILE * fp);
void HYDU_dump_noprefix(FILE * fp, const char *str, ...);
void HYDU_dump(FILE * fp, const char *str, ...);
/* env */
-HYD_Status HYDU_env_to_str(HYD_Env_t * env, char **str);
-HYD_Status HYDU_str_to_env(char *str, HYD_Env_t ** env);
-HYD_Status HYDU_list_inherited_env(HYD_Env_t ** env_list);
-HYD_Env_t *HYDU_env_list_dup(HYD_Env_t * env);
-HYD_Status HYDU_env_create(HYD_Env_t ** env, const char *env_name, char *env_value);
-HYD_Status HYDU_env_free(HYD_Env_t * env);
-HYD_Status HYDU_env_free_list(HYD_Env_t * env);
-HYD_Env_t *HYDU_env_lookup(char *env_name, HYD_Env_t * env_list);
-HYD_Status HYDU_append_env_to_list(HYD_Env_t env, HYD_Env_t ** env_list);
-HYD_Status HYDU_putenv(HYD_Env_t * env, HYD_Env_overwrite_t overwrite);
-HYD_Status HYDU_putenv_list(HYD_Env_t * env_list, HYD_Env_overwrite_t overwrite);
-HYD_Status HYDU_comma_list_to_env_list(char *str, HYD_Env_t ** env_list);
+HYD_status HYDU_env_to_str(HYD_env_t * env, char **str);
+HYD_status HYDU_str_to_env(char *str, HYD_env_t ** env);
+HYD_status HYDU_list_inherited_env(HYD_env_t ** env_list);
+HYD_env_t *HYDU_env_list_dup(HYD_env_t * env);
+HYD_status HYDU_env_create(HYD_env_t ** env, const char *env_name, char *env_value);
+HYD_status HYDU_env_free(HYD_env_t * env);
+HYD_status HYDU_env_free_list(HYD_env_t * env);
+HYD_env_t *HYDU_env_lookup(char *env_name, HYD_env_t * env_list);
+HYD_status HYDU_append_env_to_list(HYD_env_t env, HYD_env_t ** env_list);
+HYD_status HYDU_putenv(HYD_env_t * env, HYD_env_overwrite_t overwrite);
+HYD_status HYDU_putenv_list(HYD_env_t * env_list, HYD_env_overwrite_t overwrite);
+HYD_status HYDU_comma_list_to_env_list(char *str, HYD_env_t ** env_list);
/* launch */
#if defined HAVE_THREAD_SUPPORT
-struct HYD_Thread_context {
+struct HYD_thread_context {
pthread_t thread;
};
#endif /* HAVE_THREAD_SUPPORT */
-HYD_Status HYDU_create_process(char **client_arg, HYD_Env_t * env_list,
+HYD_status HYDU_create_process(char **client_arg, HYD_env_t * env_list,
int *in, int *out, int *err, int *pid, int core);
-HYD_Status HYDU_fork_and_exit(int core);
+HYD_status HYDU_fork_and_exit(int core);
#if defined HAVE_THREAD_SUPPORT
-HYD_Status HYDU_create_thread(void *(*func) (void *), void *args,
- struct HYD_Thread_context *ctxt);
-HYD_Status HYDU_join_thread(struct HYD_Thread_context ctxt);
+HYD_status HYDU_create_thread(void *(*func) (void *), void *args,
+ struct HYD_thread_context *ctxt);
+HYD_status HYDU_join_thread(struct HYD_thread_context ctxt);
#endif /* HAVE_THREAD_SUPPORT */
/* others */
-HYD_Status HYDU_merge_proxy_segment(char *name, int start_pid, int core_count,
- struct HYD_Proxy **proxy_list);
+HYD_status HYDU_merge_proxy_segment(char *name, int start_pid, int core_count,
+ struct HYD_proxy **proxy_list);
int HYDU_local_to_global_id(int local_id, int start_pid, int core_count,
int global_core_count);
@@ -194,27 +194,27 @@
extern char *strsignal(int);
#endif
-HYD_Status HYDU_set_signal(int signum, void (*handler) (int));
-HYD_Status HYDU_set_common_signals(void (*handler) (int));
+HYD_status HYDU_set_signal(int signum, void (*handler) (int));
+HYD_status HYDU_set_common_signals(void (*handler) (int));
/* Sock utilities */
enum HYDU_sock_comm_flag {
HYDU_SOCK_COMM_MSGWAIT = 0x01
};
-HYD_Status HYDU_sock_listen(int *listen_fd, char *port_range, uint16_t * port);
-HYD_Status HYDU_sock_connect(const char *host, uint16_t port, int *fd);
-HYD_Status HYDU_sock_accept(int listen_fd, int *fd);
-HYD_Status HYDU_sock_readline(int fd, char *buf, int maxlen, int *linelen);
-HYD_Status HYDU_sock_writeline(int fd, const char *buf, int maxsize);
-HYD_Status HYDU_sock_read(int fd, void *buf, int maxlen, int *count,
+HYD_status HYDU_sock_listen(int *listen_fd, char *port_range, uint16_t * port);
+HYD_status HYDU_sock_connect(const char *host, uint16_t port, int *fd);
+HYD_status HYDU_sock_accept(int listen_fd, int *fd);
+HYD_status HYDU_sock_readline(int fd, char *buf, int maxlen, int *linelen);
+HYD_status HYDU_sock_writeline(int fd, const char *buf, int maxsize);
+HYD_status HYDU_sock_read(int fd, void *buf, int maxlen, int *count,
enum HYDU_sock_comm_flag flag);
-HYD_Status HYDU_sock_write(int fd, const void *buf, int maxsize);
-HYD_Status HYDU_sock_trywrite(int fd, const void *buf, int maxsize);
-HYD_Status HYDU_sock_set_nonblock(int fd);
-HYD_Status HYDU_sock_set_cloexec(int fd);
-HYD_Status HYDU_sock_stdout_cb(int fd, HYD_Event_t events, int stdout_fd, int *closed);
-HYD_Status HYDU_sock_stdin_cb(int fd, HYD_Event_t events, int stdin_fd, char *buf,
+HYD_status HYDU_sock_write(int fd, const void *buf, int maxsize);
+HYD_status HYDU_sock_trywrite(int fd, const void *buf, int maxsize);
+HYD_status HYDU_sock_set_nonblock(int fd);
+HYD_status HYDU_sock_set_cloexec(int fd);
+HYD_status HYDU_sock_stdout_cb(int fd, HYD_event_t events, int stdout_fd, int *closed);
+HYD_status HYDU_sock_stdin_cb(int fd, HYD_event_t events, int stdin_fd, char *buf,
int *buf_count, int *buf_offset, int *closed);
/* Memory utilities */
@@ -264,24 +264,24 @@
} \
}
-HYD_Status HYDU_list_append_strlist(char **exec, char **client_arg);
-HYD_Status HYDU_print_strlist(char **args);
+HYD_status HYDU_list_append_strlist(char **exec, char **client_arg);
+HYD_status HYDU_print_strlist(char **args);
void HYDU_free_strlist(char **args);
-HYD_Status HYDU_str_alloc_and_join(char **strlist, char **strjoin);
-HYD_Status HYDU_strsplit(char *str, char **str1, char **str2, char sep);
-HYD_Status HYDU_strdup_list(char *src[], char **dest[]);
+HYD_status HYDU_str_alloc_and_join(char **strlist, char **strjoin);
+HYD_status HYDU_strsplit(char *str, char **str1, char **str2, char sep);
+HYD_status HYDU_strdup_list(char *src[], char **dest[]);
char *HYDU_int_to_str(int x);
char *HYDU_strerror(int error);
int HYDU_strlist_lastidx(char **strlist);
char **HYDU_str_to_strlist(char *str);
/* Timer utilities */
-/* FIXME: HYD_Time should be OS specific */
+/* FIXME: HYD_time should be OS specific */
#ifdef HAVE_TIME
#include <time.h>
#endif /* HAVE_TIME */
-typedef struct timeval HYD_Time;
-void HYDU_time_set(HYD_Time * time, int *val);
-int HYDU_time_left(HYD_Time start, HYD_Time timeout);
+typedef struct timeval HYD_time;
+void HYDU_time_set(HYD_time * time, int *val);
+int HYDU_time_left(HYD_time start, HYD_time timeout);
#endif /* HYDRA_UTILS_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/pm/include/pmci.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/include/pmci.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/include/pmci.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -7,8 +7,8 @@
#ifndef PMCI_H_INCLUDED
#define PMCI_H_INCLUDED
-HYD_Status HYD_PMCI_launch_procs(void);
-HYD_Status HYD_PMCI_wait_for_completion(void);
-HYD_Status HYD_PMCI_finalize(void);
+HYD_status HYD_pmci_launch_procs(void);
+HYD_status HYD_pmci_wait_for_completion(void);
+HYD_status HYD_pmci_finalize(void);
#endif /* PMCI_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_common.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_common.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_common.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,7 +8,7 @@
#define PMI_COMMON_H_INCLUDED
/* The set of commands supported */
-enum HYD_PMCD_pmi_proxy_cmds {
+enum HYD_pmcd_pmi_proxy_cmds {
PROC_INFO,
KILL_JOB,
PROXY_SHUTDOWN,
@@ -22,7 +22,7 @@
* only support single job environments with no dynamic
* processes. When there are multiple jobs or dynamic processes, we
* will need a process group ID as well. */
-struct HYD_PMCD_pmi_header {
+struct HYD_pmcd_pmi_header {
int pmi_id;
};
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,8 +9,8 @@
#include "pmi_handle_v1.h"
#include "pmi_handle_v2.h"
-HYD_PMCD_pmi_pg_t *HYD_pg_list = NULL;
-struct HYD_PMCD_pmi_handle *HYD_PMCD_pmi_handle = { 0 };
+HYD_pmcd_pmi_pg_t *HYD_pg_list = NULL;
+struct HYD_pmcd_pmi_handle *HYD_pmcd_pmi_handle = { 0 };
struct segment {
int start_pid;
@@ -26,13 +26,13 @@
struct block *next;
};
-static HYD_Status allocate_kvs(HYD_PMCD_pmi_kvs_t ** kvs, int pgid)
+static HYD_status allocate_kvs(HYD_pmcd_pmi_kvs_t ** kvs, int pgid)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*kvs, HYD_PMCD_pmi_kvs_t *, sizeof(HYD_PMCD_pmi_kvs_t), status);
+ HYDU_MALLOC(*kvs, HYD_pmcd_pmi_kvs_t *, sizeof(HYD_pmcd_pmi_kvs_t), status);
HYDU_snprintf((*kvs)->kvs_name, MAXNAMELEN, "kvs_%d_%d", (int) getpid(), pgid);
(*kvs)->key_pair = NULL;
@@ -45,13 +45,13 @@
}
-static HYD_Status create_pg(HYD_PMCD_pmi_pg_t ** pg, int pgid)
+static HYD_status create_pg(HYD_pmcd_pmi_pg_t ** pg, int pgid)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*pg, HYD_PMCD_pmi_pg_t *, sizeof(HYD_PMCD_pmi_pg_t), status);
+ HYDU_MALLOC(*pg, HYD_pmcd_pmi_pg_t *, sizeof(HYD_pmcd_pmi_pg_t), status);
(*pg)->id = pgid;
(*pg)->num_procs = 0;
(*pg)->num_subgroups = 0;
@@ -73,10 +73,10 @@
}
-static HYD_Status free_pmi_process_list(HYD_PMCD_pmi_process_t * process_list)
+static HYD_status free_pmi_process_list(HYD_pmcd_pmi_process_t * process_list)
{
- HYD_PMCD_pmi_process_t *process, *tmp;
- HYD_Status status = HYD_SUCCESS;
+ HYD_pmcd_pmi_process_t *process, *tmp;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -92,10 +92,10 @@
}
-static HYD_Status free_pmi_kvs_list(HYD_PMCD_pmi_kvs_t * kvs_list)
+static HYD_status free_pmi_kvs_list(HYD_pmcd_pmi_kvs_t * kvs_list)
{
- HYD_PMCD_pmi_kvs_pair_t *key_pair, *tmp;
- HYD_Status status = HYD_SUCCESS;
+ HYD_pmcd_pmi_kvs_pair_t *key_pair, *tmp;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -112,10 +112,10 @@
}
-static HYD_Status free_pmi_node_list(HYD_PMCD_pmi_node_t * node_list)
+static HYD_status free_pmi_node_list(HYD_pmcd_pmi_node_t * node_list)
{
- HYD_PMCD_pmi_node_t *node, *tmp;
- HYD_Status status = HYD_SUCCESS;
+ HYD_pmcd_pmi_node_t *node, *tmp;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -133,14 +133,14 @@
}
-static struct HYD_PMCD_pmi_node *allocate_node(HYD_PMCD_pmi_pg_t * pg, int node_id)
+static struct HYD_pmcd_pmi_node *allocate_node(HYD_pmcd_pmi_pg_t * pg, int node_id)
{
- struct HYD_PMCD_pmi_node *node;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_pmcd_pmi_node *node;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_MALLOC(node, HYD_PMCD_pmi_node_t *, sizeof(HYD_PMCD_pmi_node_t), status);
+ HYDU_MALLOC(node, HYD_pmcd_pmi_node_t *, sizeof(HYD_pmcd_pmi_node_t), status);
node->node_id = node_id;
node->pg = pg;
node->process_list = NULL;
@@ -157,14 +157,14 @@
}
-HYD_Status HYD_PMCD_pmi_add_kvs(const char *key, char *val, HYD_PMCD_pmi_kvs_t * kvs, int *ret)
+HYD_status HYD_pmcd_pmi_add_kvs(const char *key, char *val, HYD_pmcd_pmi_kvs_t * kvs, int *ret)
{
- HYD_PMCD_pmi_kvs_pair_t *key_pair, *run;
- HYD_Status status = HYD_SUCCESS;
+ HYD_pmcd_pmi_kvs_pair_t *key_pair, *run;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_MALLOC(key_pair, HYD_PMCD_pmi_kvs_pair_t *, sizeof(HYD_PMCD_pmi_kvs_pair_t), status);
+ HYDU_MALLOC(key_pair, HYD_pmcd_pmi_kvs_pair_t *, sizeof(HYD_pmcd_pmi_kvs_pair_t), status);
HYDU_snprintf(key_pair->key, MAXKEYLEN, "%s", key);
HYDU_snprintf(key_pair->val, MAXVALLEN, "%s", val);
key_pair->next = NULL;
@@ -196,9 +196,9 @@
}
-HYD_Status HYD_PMCD_pmi_id_to_rank(int id, int *rank)
+HYD_status HYD_pmcd_pmi_id_to_rank(int id, int *rank)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -216,16 +216,16 @@
}
-HYD_Status HYD_PMCD_pmi_process_mapping(HYD_PMCD_pmi_process_t * process,
- enum HYD_PMCD_pmi_process_mapping_type type,
+HYD_status HYD_pmcd_pmi_process_mapping(HYD_pmcd_pmi_process_t * process,
+ enum HYD_pmcd_pmi_process_mapping_type type,
char **process_mapping_str)
{
int i, node_id;
char *tmp[HYD_NUM_TMP_STRINGS];
- struct HYD_Proxy *proxy;
+ struct HYD_proxy *proxy;
struct segment *seglist_head, *seglist_tail = NULL, *seg, *nseg;
struct block *blocklist_head, *blocklist_tail = NULL, *block, *nblock;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -275,7 +275,7 @@
}
}
- if (type == HYD_PMCD_pmi_vector) {
+ if (type == HYD_pmcd_pmi_vector) {
i = 0;
tmp[i++] = HYDU_strdup("(");
tmp[i++] = HYDU_strdup("vector,");
@@ -321,12 +321,12 @@
}
-static struct HYD_PMCD_pmi_node *find_node(HYD_PMCD_pmi_pg_t * pg, int rank)
+static struct HYD_pmcd_pmi_node *find_node(HYD_pmcd_pmi_pg_t * pg, int rank)
{
int node_id, srank;
- struct HYD_Proxy *proxy;
- struct HYD_PMCD_pmi_node *node, *tmp;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_proxy *proxy;
+ struct HYD_pmcd_pmi_node *node, *tmp;
+ HYD_status status = HYD_SUCCESS;
srank = rank % HYD_handle.global_core_count;
@@ -366,11 +366,11 @@
goto fn_exit;
}
-HYD_Status HYD_PMCD_pmi_add_process_to_pg(HYD_PMCD_pmi_pg_t * pg, int fd, int rank)
+HYD_status HYD_pmcd_pmi_add_process_to_pg(HYD_pmcd_pmi_pg_t * pg, int fd, int rank)
{
- HYD_PMCD_pmi_process_t *process, *tmp;
- struct HYD_PMCD_pmi_node *node;
- HYD_Status status = HYD_SUCCESS;
+ HYD_pmcd_pmi_process_t *process, *tmp;
+ struct HYD_pmcd_pmi_node *node;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -378,7 +378,7 @@
node = find_node(pg, rank);
/* Add process to the node */
- HYDU_MALLOC(process, HYD_PMCD_pmi_process_t *, sizeof(HYD_PMCD_pmi_process_t), status);
+ HYDU_MALLOC(process, HYD_pmcd_pmi_process_t *, sizeof(HYD_pmcd_pmi_process_t), status);
process->fd = fd;
process->rank = rank;
process->epoch = 0;
@@ -402,11 +402,11 @@
}
-HYD_PMCD_pmi_process_t *HYD_PMCD_pmi_find_process(int fd)
+HYD_pmcd_pmi_process_t *HYD_pmcd_pmi_find_process(int fd)
{
- HYD_PMCD_pmi_pg_t *pg;
- HYD_PMCD_pmi_node_t *node;
- HYD_PMCD_pmi_process_t *process = NULL;
+ HYD_pmcd_pmi_pg_t *pg;
+ HYD_pmcd_pmi_node_t *node;
+ HYD_pmcd_pmi_process_t *process = NULL;
for (pg = HYD_pg_list; pg; pg = pg->next) {
for (node = pg->node_list; node; node = node->next) {
@@ -421,12 +421,12 @@
}
-HYD_Status HYD_PMCD_pmi_init(void)
+HYD_status HYD_pmcd_pmi_init(void)
{
- struct HYD_Proxy *proxy;
- struct HYD_Proxy_exec *exec;
+ struct HYD_proxy *proxy;
+ struct HYD_proxy_exec *exec;
int i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -460,10 +460,10 @@
}
-HYD_Status HYD_PMCD_pmi_finalize(void)
+HYD_status HYD_pmcd_pmi_finalize(void)
{
- HYD_PMCD_pmi_pg_t *pg, *tmp;
- HYD_Status status = HYD_SUCCESS;
+ HYD_pmcd_pmi_pg_t *pg, *tmp;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -15,44 +15,44 @@
#define MAXNAMELEN 256 /* max length of various names */
#define MAXKVSNAME MAXNAMELEN /* max length of a kvsname */
-typedef struct HYD_PMCD_pmi_kvs_pair {
+typedef struct HYD_pmcd_pmi_kvs_pair {
char key[MAXKEYLEN];
char val[MAXVALLEN];
- struct HYD_PMCD_pmi_kvs_pair *next;
-} HYD_PMCD_pmi_kvs_pair_t;
+ struct HYD_pmcd_pmi_kvs_pair *next;
+} HYD_pmcd_pmi_kvs_pair_t;
-typedef struct HYD_PMCD_pmi_kvs {
+typedef struct HYD_pmcd_pmi_kvs {
char kvs_name[MAXNAMELEN]; /* Name of this kvs */
- HYD_PMCD_pmi_kvs_pair_t *key_pair;
-} HYD_PMCD_pmi_kvs_t;
+ HYD_pmcd_pmi_kvs_pair_t *key_pair;
+} HYD_pmcd_pmi_kvs_t;
-typedef struct HYD_PMCD_pmi_pg HYD_PMCD_pmi_pg_t;
-typedef struct HYD_PMCD_pmi_node HYD_PMCD_pmi_node_t;
-typedef struct HYD_PMCD_pmi_process HYD_PMCD_pmi_process_t;
+typedef struct HYD_pmcd_pmi_pg HYD_pmcd_pmi_pg_t;
+typedef struct HYD_pmcd_pmi_node HYD_pmcd_pmi_node_t;
+typedef struct HYD_pmcd_pmi_process HYD_pmcd_pmi_process_t;
-struct HYD_PMCD_pmi_process {
+struct HYD_pmcd_pmi_process {
/* This is a bad design if we need to tie in an FD to a PMI
* process. This essentially kills any chance of PMI server
* masquerading. */
int fd;
int rank; /* COMM_WORLD rank of this process */
int epoch; /* Epoch this process has reached */
- struct HYD_PMCD_pmi_node *node; /* Back pointer to the PMI node */
- struct HYD_PMCD_pmi_process *next;
+ struct HYD_pmcd_pmi_node *node; /* Back pointer to the PMI node */
+ struct HYD_pmcd_pmi_process *next;
};
-struct HYD_PMCD_pmi_node {
+struct HYD_pmcd_pmi_node {
int node_id; /* This corresponds to the proxy ID of the
* launched processes */
- struct HYD_PMCD_pmi_pg *pg; /* Back pointer to the group */
- struct HYD_PMCD_pmi_process *process_list;
+ struct HYD_pmcd_pmi_pg *pg; /* Back pointer to the group */
+ struct HYD_pmcd_pmi_process *process_list;
- HYD_PMCD_pmi_kvs_t *kvs; /* Node-level KVS space for node attributes */
+ HYD_pmcd_pmi_kvs_t *kvs; /* Node-level KVS space for node attributes */
- struct HYD_PMCD_pmi_node *next;
+ struct HYD_pmcd_pmi_node *next;
};
-struct HYD_PMCD_pmi_pg {
+struct HYD_pmcd_pmi_pg {
int id;
int num_procs; /* Number of processes in the group */
@@ -61,39 +61,39 @@
int barrier_count;
- struct HYD_PMCD_pmi_node *node_list;
- HYD_PMCD_pmi_kvs_t *kvs;
+ struct HYD_pmcd_pmi_node *node_list;
+ HYD_pmcd_pmi_kvs_t *kvs;
- struct HYD_PMCD_pmi_pg *next;
+ struct HYD_pmcd_pmi_pg *next;
};
-enum HYD_PMCD_pmi_process_mapping_type {
- HYD_PMCD_pmi_vector
+enum HYD_pmcd_pmi_process_mapping_type {
+ HYD_pmcd_pmi_vector
};
-HYD_Status HYD_PMCD_pmi_add_process_to_pg(HYD_PMCD_pmi_pg_t * pg, int fd, int rank);
-HYD_Status HYD_PMCD_pmi_id_to_rank(int id, int *rank);
-HYD_PMCD_pmi_process_t *HYD_PMCD_pmi_find_process(int fd);
-HYD_Status HYD_PMCD_pmi_add_kvs(const char *key, char *val, HYD_PMCD_pmi_kvs_t * kvs,
+HYD_status HYD_pmcd_pmi_add_process_to_pg(HYD_pmcd_pmi_pg_t * pg, int fd, int rank);
+HYD_status HYD_pmcd_pmi_id_to_rank(int id, int *rank);
+HYD_pmcd_pmi_process_t *HYD_pmcd_pmi_find_process(int fd);
+HYD_status HYD_pmcd_pmi_add_kvs(const char *key, char *val, HYD_pmcd_pmi_kvs_t * kvs,
int *ret);
-HYD_Status HYD_PMCD_pmi_process_mapping(HYD_PMCD_pmi_process_t * process,
- enum HYD_PMCD_pmi_process_mapping_type type,
+HYD_status HYD_pmcd_pmi_process_mapping(HYD_pmcd_pmi_process_t * process,
+ enum HYD_pmcd_pmi_process_mapping_type type,
char **process_mapping);
-HYD_Status HYD_PMCD_pmi_init(void);
-HYD_Status HYD_PMCD_pmi_finalize(void);
+HYD_status HYD_pmcd_pmi_init(void);
+HYD_status HYD_pmcd_pmi_finalize(void);
-extern HYD_PMCD_pmi_pg_t *HYD_pg_list;
+extern HYD_pmcd_pmi_pg_t *HYD_pg_list;
-struct HYD_PMCD_pmi_handle_fns {
+struct HYD_pmcd_pmi_handle_fns {
const char *cmd;
- HYD_Status(*handler) (int fd, char *args[]);
+ HYD_status(*handler) (int fd, char *args[]);
};
-struct HYD_PMCD_pmi_handle {
+struct HYD_pmcd_pmi_handle {
const char *delim;
- struct HYD_PMCD_pmi_handle_fns *handle_fns;
+ struct HYD_pmcd_pmi_handle_fns *handle_fns;
};
-extern struct HYD_PMCD_pmi_handle *HYD_PMCD_pmi_handle;
+extern struct HYD_pmcd_pmi_handle *HYD_pmcd_pmi_handle;
#endif /* PMI_HANDLE_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_common.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_common.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_common.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -10,11 +10,11 @@
#include "pmi_handle_v1.h"
#include "pmi_handle_v2.h"
-HYD_Status HYD_PMCD_pmi_handle_init(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_init(int fd, char *args[])
{
int pmi_version, pmi_subversion;
const char *tmp;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -27,13 +27,13 @@
tmp = "cmd=response_to_init pmi_version=1 pmi_subversion=1 rc=0\n";
status = HYDU_sock_writeline(fd, tmp, strlen(tmp));
HYDU_ERR_POP(status, "error writing PMI line\n");
- HYD_PMCD_pmi_handle = HYD_PMCD_pmi_v1;
+ HYD_pmcd_pmi_handle = HYD_pmcd_pmi_v1;
}
else if (pmi_version == 2 && pmi_subversion == 0) {
tmp = "cmd=response_to_init pmi_version=2 pmi_subversion=0 rc=0\n";
status = HYDU_sock_writeline(fd, tmp, strlen(tmp));
HYDU_ERR_POP(status, "error writing PMI line\n");
- HYD_PMCD_pmi_handle = HYD_PMCD_pmi_v2;
+ HYD_pmcd_pmi_handle = HYD_pmcd_pmi_v2;
}
else {
/* PMI version mismatch */
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_common.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_common.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_common.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -10,6 +10,6 @@
#include "hydra_base.h"
#include "pmi_handle.h"
-HYD_Status HYD_PMCD_pmi_handle_init(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_init(int fd, char *args[]);
#endif /* PMI_HANDLE_COMMON_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-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v1.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -12,29 +12,29 @@
#include "pmi_handle_v1.h"
/* TODO: abort, create_kvs, destroy_kvs, getbyidx, spawn */
-static struct HYD_PMCD_pmi_handle_fns pmi_v1_handle_fns_foo[] = {
- {"initack", HYD_PMCD_pmi_handle_v1_initack},
- {"get_maxes", HYD_PMCD_pmi_handle_v1_get_maxes},
- {"get_appnum", HYD_PMCD_pmi_handle_v1_get_appnum},
- {"get_my_kvsname", HYD_PMCD_pmi_handle_v1_get_my_kvsname},
- {"barrier_in", HYD_PMCD_pmi_handle_v1_barrier_in},
- {"put", HYD_PMCD_pmi_handle_v1_put},
- {"get", HYD_PMCD_pmi_handle_v1_get},
- {"get_universe_size", HYD_PMCD_pmi_handle_v1_get_usize},
- {"finalize", HYD_PMCD_pmi_handle_v1_finalize},
+static struct HYD_pmcd_pmi_handle_fns pmi_v1_handle_fns_foo[] = {
+ {"initack", HYD_pmcd_pmi_handle_v1_initack},
+ {"get_maxes", HYD_pmcd_pmi_handle_v1_get_maxes},
+ {"get_appnum", HYD_pmcd_pmi_handle_v1_get_appnum},
+ {"get_my_kvsname", HYD_pmcd_pmi_handle_v1_get_my_kvsname},
+ {"barrier_in", HYD_pmcd_pmi_handle_v1_barrier_in},
+ {"put", HYD_pmcd_pmi_handle_v1_put},
+ {"get", HYD_pmcd_pmi_handle_v1_get},
+ {"get_universe_size", HYD_pmcd_pmi_handle_v1_get_usize},
+ {"finalize", HYD_pmcd_pmi_handle_v1_finalize},
{"\0", NULL}
};
-static struct HYD_PMCD_pmi_handle pmi_v1_foo = { PMI_V1_DELIM, pmi_v1_handle_fns_foo };
+static struct HYD_pmcd_pmi_handle pmi_v1_foo = { PMI_V1_DELIM, pmi_v1_handle_fns_foo };
-struct HYD_PMCD_pmi_handle *HYD_PMCD_pmi_v1 = &pmi_v1_foo;
+struct HYD_pmcd_pmi_handle *HYD_pmcd_pmi_v1 = &pmi_v1_foo;
-HYD_Status HYD_PMCD_pmi_handle_v1_initack(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v1_initack(int fd, char *args[])
{
int id, rank, i;
char *tmp[HYD_NUM_TMP_STRINGS], *cmd;
- HYD_PMCD_pmi_pg_t *run;
- HYD_Status status = HYD_SUCCESS;
+ HYD_pmcd_pmi_pg_t *run;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -46,7 +46,7 @@
tmp[i++] = HYDU_int_to_str(HYD_pg_list->num_procs);
tmp[i++] = HYDU_strdup("\ncmd=set rank=");
- status = HYD_PMCD_pmi_id_to_rank(id, &rank);
+ status = HYD_pmcd_pmi_id_to_rank(id, &rank);
HYDU_ERR_POP(status, "unable to convert ID to rank\n");
tmp[i++] = HYDU_int_to_str(rank);
@@ -69,7 +69,7 @@
run = run->next;
/* Add the process to the last PG */
- status = HYD_PMCD_pmi_add_process_to_pg(run, fd, id);
+ status = HYD_pmcd_pmi_add_process_to_pg(run, fd, id);
HYDU_ERR_POP(status, "unable to add process to pg\n");
fn_exit:
@@ -81,11 +81,11 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v1_get_maxes(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v1_get_maxes(int fd, char *args[])
{
int i;
char *tmp[HYD_NUM_TMP_STRINGS], *cmd;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -116,17 +116,17 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v1_get_appnum(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v1_get_appnum(int fd, char *args[])
{
char *tmp[HYD_NUM_TMP_STRINGS], *cmd;
int i;
- HYD_PMCD_pmi_process_t *process;
- HYD_Status status = HYD_SUCCESS;
+ HYD_pmcd_pmi_process_t *process;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
/* Find the group id corresponding to this fd */
- process = HYD_PMCD_pmi_find_process(fd);
+ process = HYD_pmcd_pmi_find_process(fd);
if (process == NULL) /* We didn't find the process */
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "unable to find process structure\n");
@@ -153,17 +153,17 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v1_get_my_kvsname(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v1_get_my_kvsname(int fd, char *args[])
{
char *tmp[HYD_NUM_TMP_STRINGS], *cmd;
int i;
- HYD_PMCD_pmi_process_t *process;
- HYD_Status status = HYD_SUCCESS;
+ HYD_pmcd_pmi_process_t *process;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
/* Find the group id corresponding to this fd */
- process = HYD_PMCD_pmi_find_process(fd);
+ process = HYD_pmcd_pmi_find_process(fd);
if (process == NULL) /* We didn't find the process */
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unable to find process structure for fd %d\n", fd);
@@ -191,17 +191,17 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v1_barrier_in(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v1_barrier_in(int fd, char *args[])
{
- HYD_PMCD_pmi_process_t *process, *prun;
- HYD_PMCD_pmi_node_t *node;
+ HYD_pmcd_pmi_process_t *process, *prun;
+ HYD_pmcd_pmi_node_t *node;
const char *cmd;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
/* Find the group id corresponding to this fd */
- process = HYD_PMCD_pmi_find_process(fd);
+ process = HYD_pmcd_pmi_find_process(fd);
if (process == NULL) /* We didn't find the process */
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unable to find process structure for fd %d\n", fd);
@@ -231,13 +231,13 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v1_put(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v1_put(int fd, char *args[])
{
int i, ret;
- HYD_PMCD_pmi_process_t *process;
+ HYD_pmcd_pmi_process_t *process;
char *kvsname, *key, *val;
char *tmp[HYD_NUM_TMP_STRINGS], *cmd;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -249,7 +249,7 @@
val = strtok(NULL, "=");
/* Find the group id corresponding to this fd */
- process = HYD_PMCD_pmi_find_process(fd);
+ process = HYD_pmcd_pmi_find_process(fd);
if (process == NULL) /* We didn't find the process */
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unable to find process structure for fd %d\n", fd);
@@ -259,7 +259,7 @@
"kvsname (%s) does not match this process' kvs space (%s)\n",
kvsname, process->node->pg->kvs->kvs_name);
- status = HYD_PMCD_pmi_add_kvs(key, val, process->node->pg->kvs, &ret);
+ status = HYD_pmcd_pmi_add_kvs(key, val, process->node->pg->kvs, &ret);
HYDU_ERR_POP(status, "unable to add keypair to kvs\n");
i = 0;
@@ -292,14 +292,14 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v1_get(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v1_get(int fd, char *args[])
{
int i, found, ret;
- HYD_PMCD_pmi_process_t *process;
- HYD_PMCD_pmi_kvs_pair_t *run;
+ HYD_pmcd_pmi_process_t *process;
+ HYD_pmcd_pmi_kvs_pair_t *run;
char *kvsname, *key, *node_list;
char *tmp[HYD_NUM_TMP_STRINGS], *cmd;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -309,7 +309,7 @@
key = strtok(NULL, "=");
/* Find the group id corresponding to this fd */
- process = HYD_PMCD_pmi_find_process(fd);
+ process = HYD_pmcd_pmi_find_process(fd);
if (process == NULL) /* We didn't find the process */
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unable to find process structure for fd %d\n", fd);
@@ -333,14 +333,14 @@
* generate it */
if (strcmp(key, "process-mapping") == 0) {
/* Create a vector format */
- status = HYD_PMCD_pmi_process_mapping(process, HYD_PMCD_pmi_vector, &node_list);
+ status = HYD_pmcd_pmi_process_mapping(process, HYD_pmcd_pmi_vector, &node_list);
HYDU_ERR_POP(status, "Unable to get process mapping information\n");
if (strlen(node_list) > MAXVALLEN)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
"key value larger than maximum allowed\n");
- status = HYD_PMCD_pmi_add_kvs("process-mapping", node_list,
+ status = HYD_pmcd_pmi_add_kvs("process-mapping", node_list,
process->node->pg->kvs, &ret);
HYDU_ERR_POP(status, "unable to add process_mapping to KVS\n");
@@ -387,10 +387,10 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v1_finalize(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v1_finalize(int fd, char *args[])
{
const char *cmd;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -399,7 +399,7 @@
HYDU_ERR_POP(status, "error writing PMI line\n");
if (status == HYD_SUCCESS) {
- status = HYD_DMX_deregister_fd(fd);
+ status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to register fd\n");
close(fd);
}
@@ -413,15 +413,15 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v1_get_usize(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v1_get_usize(int fd, char *args[])
{
int usize, i;
char *tmp[HYD_NUM_TMP_STRINGS], *cmd;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_BSCI_query_usize(&usize);
+ status = HYDT_bsci_query_usize(&usize);
HYDU_ERR_POP(status, "unable to get bootstrap universe size\n");
i = 0;
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v1.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v1.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v1.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -11,17 +11,17 @@
#define PMI_V1_DELIM " "
-extern struct HYD_PMCD_pmi_handle *HYD_PMCD_pmi_v1;
+extern struct HYD_pmcd_pmi_handle *HYD_pmcd_pmi_v1;
/* PMI handles */
-HYD_Status HYD_PMCD_pmi_handle_v1_initack(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v1_get_maxes(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v1_get_appnum(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v1_get_my_kvsname(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v1_barrier_in(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v1_put(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v1_get(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v1_get_usize(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v1_finalize(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v1_initack(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v1_get_maxes(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v1_get_appnum(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v1_get_my_kvsname(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v1_barrier_in(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v1_put(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v1_get(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v1_get_usize(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v1_finalize(int fd, char *args[]);
#endif /* PMI_HANDLE_V1_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v2.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v2.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v2.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -12,22 +12,22 @@
#include "pmi_handle_v2.h"
/* TODO: abort, create_kvs, destroy_kvs, getbyidx, spawn */
-static struct HYD_PMCD_pmi_handle_fns pmi_v2_handle_fns_foo[] = {
- {"fullinit", HYD_PMCD_pmi_handle_v2_fullinit},
- {"job-getid", HYD_PMCD_pmi_handle_v2_job_getid},
- {"info-putnodeattr", HYD_PMCD_pmi_handle_v2_info_putnodeattr},
- {"info-getnodeattr", HYD_PMCD_pmi_handle_v2_info_getnodeattr},
- {"info-getjobattr", HYD_PMCD_pmi_handle_v2_info_getjobattr},
- {"kvs-put", HYD_PMCD_pmi_handle_v2_kvs_put},
- {"kvs-get", HYD_PMCD_pmi_handle_v2_kvs_get},
- {"kvs-fence", HYD_PMCD_pmi_handle_v2_kvs_fence},
- {"finalize", HYD_PMCD_pmi_handle_v2_finalize},
+static struct HYD_pmcd_pmi_handle_fns pmi_v2_handle_fns_foo[] = {
+ {"fullinit", HYD_pmcd_pmi_handle_v2_fullinit},
+ {"job-getid", HYD_pmcd_pmi_handle_v2_job_getid},
+ {"info-putnodeattr", HYD_pmcd_pmi_handle_v2_info_putnodeattr},
+ {"info-getnodeattr", HYD_pmcd_pmi_handle_v2_info_getnodeattr},
+ {"info-getjobattr", HYD_pmcd_pmi_handle_v2_info_getjobattr},
+ {"kvs-put", HYD_pmcd_pmi_handle_v2_kvs_put},
+ {"kvs-get", HYD_pmcd_pmi_handle_v2_kvs_get},
+ {"kvs-fence", HYD_pmcd_pmi_handle_v2_kvs_fence},
+ {"finalize", HYD_pmcd_pmi_handle_v2_finalize},
{"\0", NULL}
};
-static struct HYD_PMCD_pmi_handle pmi_v2_foo = { PMI_V2_DELIM, pmi_v2_handle_fns_foo };
+static struct HYD_pmcd_pmi_handle pmi_v2_foo = { PMI_V2_DELIM, pmi_v2_handle_fns_foo };
-struct HYD_PMCD_pmi_handle *HYD_PMCD_pmi_v2 = &pmi_v2_foo;
+struct HYD_pmcd_pmi_handle *HYD_pmcd_pmi_v2 = &pmi_v2_foo;
struct token {
char *key;
@@ -64,10 +64,10 @@
dprintf("\n");
}
-static HYD_Status send_command(int fd, char *cmd)
+static HYD_status send_command(int fd, char *cmd)
{
char cmdlen[7];
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -87,11 +87,11 @@
}
-static HYD_Status args_to_tokens(char *args[], struct token **tokens, int *count)
+static HYD_status args_to_tokens(char *args[], struct token **tokens, int *count)
{
int i;
char *arg;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
for (i = 0; args[i]; i++);
*count = i;
@@ -119,10 +119,10 @@
HYDU_FREE(areq);
}
-static HYD_Status queue_outstanding_req(int fd, enum req_type req_type, char *args[])
+static HYD_status queue_outstanding_req(int fd, enum req_type req_type, char *args[])
{
struct attr_reqs *attr_req, *a;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_MALLOC(attr_req, struct attr_reqs *, sizeof(struct attr_reqs), status);
attr_req->fd = fd;
@@ -149,10 +149,10 @@
goto fn_exit;
}
-static HYD_Status poke_progress(void)
+static HYD_status poke_progress(void)
{
struct attr_reqs *areq, *tmp;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
progress_nest_count++;
@@ -163,11 +163,11 @@
req_complete = 0;
if (areq->type == GET_NODE_ATTR) {
- status = HYD_PMCD_pmi_handle_v2_info_getnodeattr(areq->fd, areq->req);
+ status = HYD_pmcd_pmi_handle_v2_info_getnodeattr(areq->fd, areq->req);
HYDU_ERR_POP(status, "getnodeattr returned error\n");
}
else if (areq->type == KVS_GET) {
- status = HYD_PMCD_pmi_handle_v2_kvs_get(areq->fd, areq->req);
+ status = HYD_pmcd_pmi_handle_v2_kvs_get(areq->fd, areq->req);
HYDU_ERR_POP(status, "kvs_get returned error\n");
}
@@ -210,14 +210,14 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v2_fullinit(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v2_fullinit(int fd, char *args[])
{
int id, rank, i;
char *tmp[HYD_NUM_TMP_STRINGS], *cmd, *rank_str;
- HYD_PMCD_pmi_pg_t *run;
+ HYD_pmcd_pmi_pg_t *run;
struct token *tokens;
int token_count;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -232,7 +232,7 @@
i = 0;
tmp[i++] = HYDU_strdup("cmd=fullinit-response;pmi-version=2;pmi-subversion=0;rank=");
- status = HYD_PMCD_pmi_id_to_rank(id, &rank);
+ status = HYD_pmcd_pmi_id_to_rank(id, &rank);
HYDU_ERR_POP(status, "unable to convert ID to rank\n");
tmp[i++] = HYDU_int_to_str(rank);
@@ -257,7 +257,7 @@
run = run->next;
/* Add the process to the last PG */
- status = HYD_PMCD_pmi_add_process_to_pg(run, fd, rank);
+ status = HYD_pmcd_pmi_add_process_to_pg(run, fd, rank);
HYDU_ERR_POP(status, "unable to add process to pg\n");
fn_exit:
@@ -269,14 +269,14 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v2_job_getid(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v2_job_getid(int fd, char *args[])
{
char *tmp[HYD_NUM_TMP_STRINGS], *cmd, *thrid;
int i;
- HYD_PMCD_pmi_process_t *process;
+ HYD_pmcd_pmi_process_t *process;
struct token *tokens;
int token_count;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -286,7 +286,7 @@
thrid = find_token_keyval(tokens, token_count, "thrid");
/* Find the group id corresponding to this fd */
- process = HYD_PMCD_pmi_find_process(fd);
+ process = HYD_pmcd_pmi_find_process(fd);
if (process == NULL) /* We didn't find the process */
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unable to find process structure for fd %d\n", fd);
@@ -322,15 +322,15 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v2_info_putnodeattr(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v2_info_putnodeattr(int fd, char *args[])
{
char *tmp[HYD_NUM_TMP_STRINGS], *cmd;
char *key, *val, *thrid;
int i, ret;
- HYD_PMCD_pmi_process_t *process;
+ HYD_pmcd_pmi_process_t *process;
struct token *tokens;
int token_count;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -347,12 +347,12 @@
thrid = find_token_keyval(tokens, token_count, "thrid");
/* Find the group id corresponding to this fd */
- process = HYD_PMCD_pmi_find_process(fd);
+ process = HYD_pmcd_pmi_find_process(fd);
if (process == NULL) /* We didn't find the process */
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unable to find process structure for fd %d\n", fd);
- status = HYD_PMCD_pmi_add_kvs(key, val, process->node->kvs, &ret);
+ status = HYD_pmcd_pmi_add_kvs(key, val, process->node->kvs, &ret);
HYDU_ERR_POP(status, "unable to put data into kvs\n");
i = 0;
@@ -390,16 +390,16 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v2_info_getnodeattr(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v2_info_getnodeattr(int fd, char *args[])
{
int i, found;
- HYD_PMCD_pmi_process_t *process;
- HYD_PMCD_pmi_kvs_pair_t *run;
+ HYD_pmcd_pmi_process_t *process;
+ HYD_pmcd_pmi_kvs_pair_t *run;
char *key, *waitval, *thrid;
char *tmp[HYD_NUM_TMP_STRINGS] = { 0 }, *cmd;
struct token *tokens;
int token_count;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -413,7 +413,7 @@
thrid = find_token_keyval(tokens, token_count, "thrid");
/* Find the group id corresponding to this fd */
- process = HYD_PMCD_pmi_find_process(fd);
+ process = HYD_pmcd_pmi_find_process(fd);
if (process == NULL) /* We didn't find the process */
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unable to find process structure for fd %d\n", fd);
@@ -491,17 +491,17 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v2_info_getjobattr(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v2_info_getjobattr(int fd, char *args[])
{
int i, ret;
- HYD_PMCD_pmi_process_t *process;
- HYD_PMCD_pmi_kvs_pair_t *run;
+ HYD_pmcd_pmi_process_t *process;
+ HYD_pmcd_pmi_kvs_pair_t *run;
const char *key;
char *thrid;
char *tmp[HYD_NUM_TMP_STRINGS], *cmd, *node_list;
struct token *tokens;
int token_count, found;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -514,7 +514,7 @@
thrid = find_token_keyval(tokens, token_count, "thrid");
/* Find the group id corresponding to this fd */
- process = HYD_PMCD_pmi_find_process(fd);
+ process = HYD_pmcd_pmi_find_process(fd);
if (process == NULL) /* We didn't find the process */
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unable to find process structure for fd %d\n", fd);
@@ -533,14 +533,14 @@
* generate it */
if (strcmp(key, "process-mapping") == 0) {
/* Create a vector format */
- status = HYD_PMCD_pmi_process_mapping(process, HYD_PMCD_pmi_vector, &node_list);
+ status = HYD_pmcd_pmi_process_mapping(process, HYD_pmcd_pmi_vector, &node_list);
HYDU_ERR_POP(status, "Unable to get process mapping information\n");
if (strlen(node_list) > MAXVALLEN)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
"key value larger than maximum allowed\n");
- status = HYD_PMCD_pmi_add_kvs("process-mapping", node_list,
+ status = HYD_pmcd_pmi_add_kvs("process-mapping", node_list,
process->node->pg->kvs, &ret);
HYDU_ERR_POP(status, "unable to add process_mapping to KVS\n");
}
@@ -591,15 +591,15 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v2_kvs_put(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v2_kvs_put(int fd, char *args[])
{
char *tmp[HYD_NUM_TMP_STRINGS], *cmd;
char *key, *val, *thrid;
int i, ret;
- HYD_PMCD_pmi_process_t *process;
+ HYD_pmcd_pmi_process_t *process;
struct token *tokens;
int token_count;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -616,12 +616,12 @@
thrid = find_token_keyval(tokens, token_count, "thrid");
/* Find the group id corresponding to this fd */
- process = HYD_PMCD_pmi_find_process(fd);
+ process = HYD_pmcd_pmi_find_process(fd);
if (process == NULL) /* We didn't find the process */
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unable to find process structure for fd %d\n", fd);
- status = HYD_PMCD_pmi_add_kvs(key, val, process->node->pg->kvs, &ret);
+ status = HYD_pmcd_pmi_add_kvs(key, val, process->node->pg->kvs, &ret);
HYDU_ERR_POP(status, "unable to put data into kvs\n");
i = 0;
@@ -659,17 +659,17 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v2_kvs_get(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v2_kvs_get(int fd, char *args[])
{
int i, found, node_count;
- HYD_PMCD_pmi_process_t *process, *prun;
- HYD_PMCD_pmi_node_t *node;
- HYD_PMCD_pmi_kvs_pair_t *run;
+ HYD_pmcd_pmi_process_t *process, *prun;
+ HYD_pmcd_pmi_node_t *node;
+ HYD_pmcd_pmi_kvs_pair_t *run;
char *key, *thrid;
char *tmp[HYD_NUM_TMP_STRINGS], *cmd;
struct token *tokens;
int token_count, consistent_epoch;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -682,7 +682,7 @@
thrid = find_token_keyval(tokens, token_count, "thrid");
/* Find the group id corresponding to this fd */
- process = HYD_PMCD_pmi_find_process(fd);
+ process = HYD_pmcd_pmi_find_process(fd);
if (process == NULL) /* We didn't find the process */
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unable to find process structure for fd %d\n", fd);
@@ -762,13 +762,13 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v2_kvs_fence(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v2_kvs_fence(int fd, char *args[])
{
- HYD_PMCD_pmi_process_t *process;
+ HYD_pmcd_pmi_process_t *process;
char *tmp[HYD_NUM_TMP_STRINGS], *cmd, *thrid;
struct token *tokens;
int token_count, i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -778,7 +778,7 @@
thrid = find_token_keyval(tokens, token_count, "thrid");
/* Find the group id corresponding to this fd */
- process = HYD_PMCD_pmi_find_process(fd);
+ process = HYD_pmcd_pmi_find_process(fd);
if (process == NULL) /* We didn't find the process */
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unable to find process structure for fd %d\n", fd);
@@ -817,13 +817,13 @@
}
-HYD_Status HYD_PMCD_pmi_handle_v2_finalize(int fd, char *args[])
+HYD_status HYD_pmcd_pmi_handle_v2_finalize(int fd, char *args[])
{
char *thrid;
char *tmp[HYD_NUM_TMP_STRINGS], *cmd;
struct token *tokens;
int token_count, i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -851,7 +851,7 @@
HYDU_FREE(cmd);
if (status == HYD_SUCCESS) {
- status = HYD_DMX_deregister_fd(fd);
+ status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to register fd\n");
close(fd);
}
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v2.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v2.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle_v2.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -11,17 +11,17 @@
#define PMI_V2_DELIM ";"
-extern struct HYD_PMCD_pmi_handle *HYD_PMCD_pmi_v2;
+extern struct HYD_pmcd_pmi_handle *HYD_pmcd_pmi_v2;
/* PMI handles */
-HYD_Status HYD_PMCD_pmi_handle_v2_fullinit(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v2_job_getid(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v2_info_putnodeattr(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v2_info_getnodeattr(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v2_info_getjobattr(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v2_kvs_put(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v2_kvs_get(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v2_kvs_fence(int fd, char *args[]);
-HYD_Status HYD_PMCD_pmi_handle_v2_finalize(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v2_fullinit(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v2_job_getid(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v2_info_putnodeattr(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v2_info_getnodeattr(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v2_info_getjobattr(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v2_kvs_put(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v2_kvs_get(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v2_kvs_fence(int fd, char *args[]);
+HYD_status HYD_pmcd_pmi_handle_v2_finalize(int fd, char *args[]);
#endif /* PMI_HANDLE_V2_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,38 +9,38 @@
#include "demux.h"
#include "pmi_proxy.h"
-struct HYD_PMCD_pmi_proxy_params HYD_PMCD_pmi_proxy_params;
+struct HYD_pmcd_pmi_proxy_params HYD_pmcd_pmi_proxy_params;
-static HYD_Status wait_for_procs_to_finish(void)
+static HYD_status wait_for_procs_to_finish(void)
{
int i, out_count, err_count, count, pid, ret_status;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
while (1) {
/* Wait for some event to occur */
- status = HYD_DMX_wait_for_event(-1);
+ status = HYDT_dmx_wait_for_event(-1);
HYDU_ERR_POP(status, "demux engine error waiting for event\n");
/* Check to see if there's any open read socket left; if there
* are, we will just wait for more events. */
out_count = 0;
err_count = 0;
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.proxy_process_count; i++) {
- if (HYD_PMCD_pmi_proxy_params.downstream.out[i] != -1)
+ for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++) {
+ if (HYD_pmcd_pmi_proxy_params.downstream.out[i] != -1)
out_count++;
- if (HYD_PMCD_pmi_proxy_params.downstream.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.local.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);
+ close(HYD_pmcd_pmi_proxy_params.upstream.out);
if (err_count == 0)
- close(HYD_PMCD_pmi_proxy_params.upstream.err);
+ close(HYD_pmcd_pmi_proxy_params.upstream.err);
/* We are done */
if (!out_count && !err_count)
@@ -49,21 +49,21 @@
}
do {
- if (HYD_PMCD_pmi_proxy_params.local.procs_are_launched == 0)
+ if (HYD_pmcd_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.local.proxy_process_count; i++)
- if (HYD_PMCD_pmi_proxy_params.downstream.pid[i] == pid)
- HYD_PMCD_pmi_proxy_params.downstream.exit_status[i] = ret_status;
+ for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++)
+ if (HYD_pmcd_pmi_proxy_params.downstream.pid[i] == pid)
+ HYD_pmcd_pmi_proxy_params.downstream.exit_status[i] = ret_status;
/* Check how many more processes are pending */
count = 0;
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.proxy_process_count; i++) {
- if (HYD_PMCD_pmi_proxy_params.downstream.exit_status[i] == -1) {
+ for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++) {
+ if (HYD_pmcd_pmi_proxy_params.downstream.exit_status[i] == -1) {
count++;
break;
}
@@ -73,7 +73,7 @@
break;
/* Check if there are any messages from the launcher */
- status = HYD_DMX_wait_for_event(0);
+ status = HYDT_dmx_wait_for_event(0);
HYDU_ERR_POP(status, "demux engine error waiting for event\n");
} while (1);
@@ -87,33 +87,33 @@
int main(int argc, char **argv)
{
int listenfd;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
status = HYDU_dbg_init("proxy");
HYDU_ERR_POP(status, "unable to initialization debugging\n");
- status = HYD_PMCD_pmi_proxy_get_params(argv);
+ status = HYD_pmcd_pmi_proxy_get_params(argv);
HYDU_ERR_POP(status, "bad parameters passed to the proxy\n");
/* Process launching only happens in the runtime case over here */
- if (HYD_PMCD_pmi_proxy_params.user_global.launch_mode == HYD_LAUNCH_RUNTIME) {
- HYD_PMCD_pmi_proxy_params.upstream.out = 1;
- HYD_PMCD_pmi_proxy_params.upstream.err = 2;
- HYD_PMCD_pmi_proxy_params.upstream.in = 0;
+ if (HYD_pmcd_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.upstream.server_name,
- HYD_PMCD_pmi_proxy_params.upstream.server_port,
- &HYD_PMCD_pmi_proxy_params.upstream.control);
+ 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.local.id,
- sizeof(HYD_PMCD_pmi_proxy_params.local.id));
+ status = HYDU_sock_write(HYD_pmcd_pmi_proxy_params.upstream.control,
+ &HYD_pmcd_pmi_proxy_params.local.id,
+ sizeof(HYD_pmcd_pmi_proxy_params.local.id));
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,
- HYD_STDOUT, NULL, HYD_PMCD_pmi_proxy_control_cmd_cb);
+ status = HYDT_dmx_register_fd(1, &HYD_pmcd_pmi_proxy_params.upstream.control,
+ HYD_STDOUT, NULL, HYD_pmcd_pmi_proxy_control_cmd_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
/* Now wait for the processes to finish */
@@ -121,32 +121,32 @@
HYDU_ERR_POP(status, "error waiting for processes to finish\n");
/* Send the exit status upstream */
- status = HYDU_sock_write(HYD_PMCD_pmi_proxy_params.upstream.control,
- HYD_PMCD_pmi_proxy_params.downstream.exit_status,
- HYD_PMCD_pmi_proxy_params.local.proxy_process_count *
+ status = HYDU_sock_write(HYD_pmcd_pmi_proxy_params.upstream.control,
+ HYD_pmcd_pmi_proxy_params.downstream.exit_status,
+ HYD_pmcd_pmi_proxy_params.local.proxy_process_count *
sizeof(int));
HYDU_ERR_POP(status, "unable to return exit status upstream\n");
- status = HYD_DMX_deregister_fd(HYD_PMCD_pmi_proxy_params.upstream.control);
+ status = HYDT_dmx_deregister_fd(HYD_pmcd_pmi_proxy_params.upstream.control);
HYDU_ERR_POP(status, "unable to deregister fd\n");
- close(HYD_PMCD_pmi_proxy_params.upstream.control);
+ close(HYD_pmcd_pmi_proxy_params.upstream.control);
/* cleanup the params structure for the next job */
- status = HYD_PMCD_pmi_proxy_cleanup_params();
+ status = HYD_pmcd_pmi_proxy_cleanup_params();
HYDU_ERR_POP(status, "unable to cleanup params\n");
}
else { /* Persistent mode */
status = HYDU_sock_listen(&listenfd, NULL,
- (uint16_t *) & HYD_PMCD_pmi_proxy_params.
- upstream.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 */
- status = HYD_DMX_register_fd(1, &listenfd, HYD_STDOUT, NULL,
- HYD_PMCD_pmi_proxy_control_connect_cb);
+ status = HYDT_dmx_register_fd(1, &listenfd, HYD_STDOUT, NULL,
+ HYD_pmcd_pmi_proxy_control_connect_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
- if (HYD_PMCD_pmi_proxy_params.user_global.launch_mode == HYD_LAUNCH_BOOT) {
+ if (HYD_pmcd_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");
@@ -161,20 +161,20 @@
/* If processes had been launched and terminated, find the
* exit status, return it and cleanup everything. */
- if (HYD_PMCD_pmi_proxy_params.local.procs_are_launched) {
+ if (HYD_pmcd_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.downstream.exit_status,
- HYD_PMCD_pmi_proxy_params.local.proxy_process_count *
+ status = HYDU_sock_write(HYD_pmcd_pmi_proxy_params.upstream.control,
+ HYD_pmcd_pmi_proxy_params.downstream.exit_status,
+ HYD_pmcd_pmi_proxy_params.local.proxy_process_count *
sizeof(int));
HYDU_ERR_POP(status, "unable to return exit status upstream\n");
- status = HYD_DMX_deregister_fd(HYD_PMCD_pmi_proxy_params.upstream.control);
+ status = HYDT_dmx_deregister_fd(HYD_pmcd_pmi_proxy_params.upstream.control);
HYDU_ERR_POP(status, "unable to deregister fd\n");
- close(HYD_PMCD_pmi_proxy_params.upstream.control);
+ close(HYD_pmcd_pmi_proxy_params.upstream.control);
/* cleanup the params structure for the next job */
- status = HYD_PMCD_pmi_proxy_cleanup_params();
+ status = HYD_pmcd_pmi_proxy_cleanup_params();
HYDU_ERR_POP(status, "unable to cleanup params\n");
}
} while (1);
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -11,8 +11,8 @@
#include "hydra_utils.h"
#include "pmi_common.h"
-struct HYD_PMCD_pmi_proxy_params {
- struct HYD_User_global user_global;
+struct HYD_pmcd_pmi_proxy_params {
+ struct HYD_user_global user_global;
struct {
int global_core_count;
@@ -60,23 +60,23 @@
/* Process segmentation information for this proxy */
int start_pid;
- struct HYD_Proxy_exec *exec_list;
+ struct HYD_proxy_exec *exec_list;
};
-extern struct HYD_PMCD_pmi_proxy_params HYD_PMCD_pmi_proxy_params;
+extern struct HYD_pmcd_pmi_proxy_params HYD_pmcd_pmi_proxy_params;
/* utils */
-HYD_Status HYD_PMCD_pmi_proxy_get_params(char **t_argv);
-HYD_Status HYD_PMCD_pmi_proxy_cleanup_params(void);
-HYD_Status HYD_PMCD_pmi_proxy_procinfo(int fd);
-HYD_Status HYD_PMCD_pmi_proxy_launch_procs(void);
-void HYD_PMCD_pmi_proxy_killjob(void);
+HYD_status HYD_pmcd_pmi_proxy_get_params(char **t_argv);
+HYD_status HYD_pmcd_pmi_proxy_cleanup_params(void);
+HYD_status HYD_pmcd_pmi_proxy_procinfo(int fd);
+HYD_status HYD_pmcd_pmi_proxy_launch_procs(void);
+void HYD_pmcd_pmi_proxy_killjob(void);
/* callback */
-HYD_Status HYD_PMCD_pmi_proxy_control_connect_cb(int fd, HYD_Event_t events, void *userp);
-HYD_Status HYD_PMCD_pmi_proxy_control_cmd_cb(int fd, HYD_Event_t events, void *userp);
-HYD_Status HYD_PMCD_pmi_proxy_stdout_cb(int fd, HYD_Event_t events, void *userp);
-HYD_Status HYD_PMCD_pmi_proxy_stderr_cb(int fd, HYD_Event_t events, void *userp);
-HYD_Status HYD_PMCD_pmi_proxy_stdin_cb(int fd, HYD_Event_t events, void *userp);
+HYD_status HYD_pmcd_pmi_proxy_control_connect_cb(int fd, HYD_event_t events, void *userp);
+HYD_status HYD_pmcd_pmi_proxy_control_cmd_cb(int fd, HYD_event_t events, void *userp);
+HYD_status HYD_pmcd_pmi_proxy_stdout_cb(int fd, HYD_event_t events, void *userp);
+HYD_status HYD_pmcd_pmi_proxy_stderr_cb(int fd, HYD_event_t events, void *userp);
+HYD_status HYD_pmcd_pmi_proxy_stdin_cb(int fd, HYD_event_t events, void *userp);
#endif /* PMI_PROXY_H_INCLUDED */
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-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_cb.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -10,12 +10,12 @@
#include "pmi_proxy.h"
#include "demux.h"
-struct HYD_PMCD_pmi_proxy_params HYD_PMCD_pmi_proxy_params;
+struct HYD_pmcd_pmi_proxy_params HYD_pmcd_pmi_proxy_params;
-HYD_Status HYD_PMCD_pmi_proxy_control_connect_cb(int fd, HYD_Event_t events, void *userp)
+HYD_status HYD_pmcd_pmi_proxy_control_connect_cb(int fd, HYD_event_t events, void *userp)
{
int accept_fd = -1;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -26,8 +26,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_control_cmd_cb);
+ status = HYDT_dmx_register_fd(1, &accept_fd, HYD_STDOUT, NULL,
+ HYD_pmcd_pmi_proxy_control_cmd_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
fn_exit:
@@ -38,11 +38,11 @@
goto fn_exit;
}
-HYD_Status HYD_PMCD_pmi_proxy_control_cmd_cb(int fd, HYD_Event_t events, void *userp)
+HYD_status HYD_pmcd_pmi_proxy_control_cmd_cb(int fd, HYD_event_t events, void *userp)
{
int cmd_len;
- enum HYD_PMCD_pmi_proxy_cmds cmd;
- HYD_Status status = HYD_SUCCESS;
+ enum HYD_pmcd_pmi_proxy_cmds cmd;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -50,37 +50,37 @@
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "stdout handler got stdin event\n");
/* We got a command from upstream */
- status = HYDU_sock_read(fd, &cmd, sizeof(enum HYD_PMCD_pmi_proxy_cmds), &cmd_len,
+ status = HYDU_sock_read(fd, &cmd, sizeof(enum HYD_pmcd_pmi_proxy_cmds), &cmd_len,
HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "error reading command from launcher\n");
if (cmd_len == 0) {
/* The connection has closed */
- status = HYD_DMX_deregister_fd(fd);
+ status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
close(fd);
goto fn_exit;
}
if (cmd == PROC_INFO) {
- status = HYD_PMCD_pmi_proxy_procinfo(fd);
+ status = HYD_pmcd_pmi_proxy_procinfo(fd);
}
else if (cmd == USE_AS_STDOUT) {
- HYD_PMCD_pmi_proxy_params.upstream.out = fd;
- status = HYD_DMX_deregister_fd(fd);
+ HYD_pmcd_pmi_proxy_params.upstream.out = fd;
+ status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
}
else if (cmd == USE_AS_STDERR) {
- HYD_PMCD_pmi_proxy_params.upstream.err = fd;
- status = HYD_DMX_deregister_fd(fd);
+ HYD_pmcd_pmi_proxy_params.upstream.err = fd;
+ status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
}
else if (cmd == USE_AS_STDIN) {
- HYD_PMCD_pmi_proxy_params.upstream.in = fd;
- status = HYD_DMX_deregister_fd(fd);
+ HYD_pmcd_pmi_proxy_params.upstream.in = fd;
+ status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
}
else if (cmd == KILL_JOB) {
- HYD_PMCD_pmi_proxy_killjob();
+ HYD_pmcd_pmi_proxy_killjob();
status = HYD_SUCCESS;
}
else if (cmd == PROXY_SHUTDOWN) {
@@ -91,7 +91,7 @@
}
else if (cmd == CKPOINT) {
HYDU_dump(stdout, "requesting checkpoint\n");
- status = HYDU_ckpoint_suspend();
+ status = HYDT_ckpoint_suspend();
HYDU_dump(stdout, "checkpoint completed\n");
}
else {
@@ -104,13 +104,13 @@
* since they can arrive in any order. */
if ((cmd == PROC_INFO) || (cmd == USE_AS_STDOUT) || (cmd == USE_AS_STDERR) ||
(cmd == USE_AS_STDIN))
- if ((HYD_PMCD_pmi_proxy_params.start_pid != -1) &&
- (HYD_PMCD_pmi_proxy_params.upstream.out != -1) &&
- (HYD_PMCD_pmi_proxy_params.upstream.err != -1))
- if ((HYD_PMCD_pmi_proxy_params.start_pid != 0) ||
- (HYD_PMCD_pmi_proxy_params.upstream.in != -1)) {
- status = HYD_PMCD_pmi_proxy_launch_procs();
- HYDU_ERR_POP(status, "HYD_PMCD_pmi_proxy_launch_procs returned error\n");
+ if ((HYD_pmcd_pmi_proxy_params.start_pid != -1) &&
+ (HYD_pmcd_pmi_proxy_params.upstream.out != -1) &&
+ (HYD_pmcd_pmi_proxy_params.upstream.err != -1))
+ if ((HYD_pmcd_pmi_proxy_params.start_pid != 0) ||
+ (HYD_pmcd_pmi_proxy_params.upstream.in != -1)) {
+ status = HYD_pmcd_pmi_proxy_launch_procs();
+ HYDU_ERR_POP(status, "HYD_pmcd_pmi_proxy_launch_procs returned error\n");
}
fn_exit:
@@ -121,24 +121,24 @@
goto fn_exit;
}
-HYD_Status HYD_PMCD_pmi_proxy_stdout_cb(int fd, HYD_Event_t events, void *userp)
+HYD_status HYD_pmcd_pmi_proxy_stdout_cb(int fd, HYD_event_t events, void *userp)
{
int closed, i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYDU_sock_stdout_cb(fd, events, HYD_PMCD_pmi_proxy_params.upstream.out, &closed);
+ status = HYDU_sock_stdout_cb(fd, events, HYD_pmcd_pmi_proxy_params.upstream.out, &closed);
HYDU_ERR_POP(status, "stdout callback error\n");
if (closed) {
/* The connection has closed */
- status = HYD_DMX_deregister_fd(fd);
+ status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.proxy_process_count; i++)
- if (HYD_PMCD_pmi_proxy_params.downstream.out[i] == fd)
- HYD_PMCD_pmi_proxy_params.downstream.out[i] = -1;
+ for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++)
+ if (HYD_pmcd_pmi_proxy_params.downstream.out[i] == fd)
+ HYD_pmcd_pmi_proxy_params.downstream.out[i] = -1;
close(fd);
}
@@ -152,24 +152,24 @@
}
-HYD_Status HYD_PMCD_pmi_proxy_stderr_cb(int fd, HYD_Event_t events, void *userp)
+HYD_status HYD_pmcd_pmi_proxy_stderr_cb(int fd, HYD_event_t events, void *userp)
{
int closed, i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYDU_sock_stdout_cb(fd, events, HYD_PMCD_pmi_proxy_params.upstream.err, &closed);
+ status = HYDU_sock_stdout_cb(fd, events, HYD_pmcd_pmi_proxy_params.upstream.err, &closed);
HYDU_ERR_POP(status, "stdout callback error\n");
if (closed) {
/* The connection has closed */
- status = HYD_DMX_deregister_fd(fd);
+ status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.proxy_process_count; i++)
- if (HYD_PMCD_pmi_proxy_params.downstream.err[i] == fd)
- HYD_PMCD_pmi_proxy_params.downstream.err[i] = -1;
+ for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++)
+ if (HYD_pmcd_pmi_proxy_params.downstream.err[i] == fd)
+ HYD_pmcd_pmi_proxy_params.downstream.err[i] = -1;
close(fd);
}
@@ -183,28 +183,28 @@
}
-HYD_Status HYD_PMCD_pmi_proxy_stdin_cb(int fd, HYD_Event_t events, void *userp)
+HYD_status HYD_pmcd_pmi_proxy_stdin_cb(int fd, HYD_event_t events, void *userp)
{
int closed;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYDU_sock_stdin_cb(HYD_PMCD_pmi_proxy_params.downstream.in, events,
- HYD_PMCD_pmi_proxy_params.upstream.in,
- HYD_PMCD_pmi_proxy_params.local.stdin_tmp_buf,
- &HYD_PMCD_pmi_proxy_params.local.stdin_buf_count,
- &HYD_PMCD_pmi_proxy_params.local.stdin_buf_offset, &closed);
+ status = HYDU_sock_stdin_cb(HYD_pmcd_pmi_proxy_params.downstream.in, events,
+ HYD_pmcd_pmi_proxy_params.upstream.in,
+ HYD_pmcd_pmi_proxy_params.local.stdin_tmp_buf,
+ &HYD_pmcd_pmi_proxy_params.local.stdin_buf_count,
+ &HYD_pmcd_pmi_proxy_params.local.stdin_buf_offset, &closed);
HYDU_ERR_POP(status, "stdin callback error\n");
if (closed) {
/* The connection has closed */
- status = HYD_DMX_deregister_fd(fd);
+ status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
- close(HYD_PMCD_pmi_proxy_params.upstream.in);
- close(HYD_PMCD_pmi_proxy_params.downstream.in);
- HYD_PMCD_pmi_proxy_params.downstream.in = -1;
+ close(HYD_pmcd_pmi_proxy_params.upstream.in);
+ 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-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -10,40 +10,40 @@
#include "hydra_utils.h"
#include "hydra_tools.h"
-struct HYD_PMCD_pmi_proxy_params HYD_PMCD_pmi_proxy_params;
+struct HYD_pmcd_pmi_proxy_params HYD_pmcd_pmi_proxy_params;
-static HYD_Status init_params(void)
+static HYD_status init_params(void)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
- HYDU_init_user_global(&HYD_PMCD_pmi_proxy_params.user_global);
+ HYDU_init_user_global(&HYD_pmcd_pmi_proxy_params.user_global);
- HYD_PMCD_pmi_proxy_params.system_global.global_core_count = 0;
- HYD_PMCD_pmi_proxy_params.system_global.pmi_port_str = NULL;
+ HYD_pmcd_pmi_proxy_params.system_global.global_core_count = 0;
+ HYD_pmcd_pmi_proxy_params.system_global.pmi_port_str = NULL;
- HYD_PMCD_pmi_proxy_params.upstream.server_name = NULL;
- HYD_PMCD_pmi_proxy_params.upstream.server_port = -1;
- HYD_PMCD_pmi_proxy_params.upstream.out = -1;
- HYD_PMCD_pmi_proxy_params.upstream.err = -1;
- HYD_PMCD_pmi_proxy_params.upstream.in = -1;
- HYD_PMCD_pmi_proxy_params.upstream.control = -1;
+ HYD_pmcd_pmi_proxy_params.upstream.server_name = NULL;
+ HYD_pmcd_pmi_proxy_params.upstream.server_port = -1;
+ HYD_pmcd_pmi_proxy_params.upstream.out = -1;
+ HYD_pmcd_pmi_proxy_params.upstream.err = -1;
+ HYD_pmcd_pmi_proxy_params.upstream.in = -1;
+ HYD_pmcd_pmi_proxy_params.upstream.control = -1;
- HYD_PMCD_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.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.local.id = -1;
- HYD_PMCD_pmi_proxy_params.local.proxy_core_count = 0;
- HYD_PMCD_pmi_proxy_params.local.proxy_process_count = 0;
- HYD_PMCD_pmi_proxy_params.local.procs_are_launched = 0;
- HYD_PMCD_pmi_proxy_params.local.stdin_buf_offset = 0;
- HYD_PMCD_pmi_proxy_params.local.stdin_buf_count = 0;
- HYD_PMCD_pmi_proxy_params.local.stdin_tmp_buf[0] = '\0';
+ HYD_pmcd_pmi_proxy_params.local.id = -1;
+ HYD_pmcd_pmi_proxy_params.local.proxy_core_count = 0;
+ HYD_pmcd_pmi_proxy_params.local.proxy_process_count = 0;
+ HYD_pmcd_pmi_proxy_params.local.procs_are_launched = 0;
+ HYD_pmcd_pmi_proxy_params.local.stdin_buf_offset = 0;
+ HYD_pmcd_pmi_proxy_params.local.stdin_buf_count = 0;
+ HYD_pmcd_pmi_proxy_params.local.stdin_tmp_buf[0] = '\0';
- HYD_PMCD_pmi_proxy_params.start_pid = -1;
- HYD_PMCD_pmi_proxy_params.exec_list = NULL;
+ HYD_pmcd_pmi_proxy_params.start_pid = -1;
+ HYD_pmcd_pmi_proxy_params.exec_list = NULL;
return status;
}
@@ -52,13 +52,13 @@
* supposed to be called by the user, but rather by the process
* management server. It will still be helpful for debugging to add
* some error checks. */
-static HYD_Status parse_params(char **t_argv)
+static HYD_status parse_params(char **t_argv)
{
char **argv = t_argv, *str, *argtype;
int arg, i, count;
- HYD_Env_t *env;
- struct HYD_Proxy_exec *exec = NULL;
- HYD_Status status = HYD_SUCCESS;
+ HYD_env_t *env;
+ struct HYD_proxy_exec *exec = NULL;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -66,7 +66,7 @@
/* Working directory */
if (!strcmp(*argv, "--wdir")) {
argv++;
- HYD_PMCD_pmi_proxy_params.user_global.wdir = HYDU_strdup(*argv);
+ HYD_pmcd_pmi_proxy_params.user_global.wdir = HYDU_strdup(*argv);
continue;
}
@@ -74,9 +74,9 @@
if (!strcmp(*argv, "--pmi-port-str")) {
argv++;
if (!strcmp(*argv, "HYDRA_NULL"))
- HYD_PMCD_pmi_proxy_params.system_global.pmi_port_str = NULL;
+ HYD_pmcd_pmi_proxy_params.system_global.pmi_port_str = NULL;
else
- HYD_PMCD_pmi_proxy_params.system_global.pmi_port_str = HYDU_strdup(*argv);
+ HYD_pmcd_pmi_proxy_params.system_global.pmi_port_str = HYDU_strdup(*argv);
continue;
}
@@ -84,9 +84,9 @@
if (!strcmp(*argv, "--binding")) {
argv++;
if (!strcmp(*argv, "HYDRA_NULL"))
- HYD_PMCD_pmi_proxy_params.user_global.binding = NULL;
+ HYD_pmcd_pmi_proxy_params.user_global.binding = NULL;
else
- HYD_PMCD_pmi_proxy_params.user_global.binding = HYDU_strdup(*argv);
+ HYD_pmcd_pmi_proxy_params.user_global.binding = HYDU_strdup(*argv);
continue;
}
@@ -94,28 +94,28 @@
/* Binding library */
if (!strcmp(*argv, "--bindlib")) {
argv++;
- HYD_PMCD_pmi_proxy_params.user_global.bindlib = HYDU_strdup(*argv);
+ HYD_pmcd_pmi_proxy_params.user_global.bindlib = HYDU_strdup(*argv);
continue;
}
/* Checkpointing library */
if (!strcmp(*argv, "--ckpointlib")) {
argv++;
- HYD_PMCD_pmi_proxy_params.user_global.ckpointlib = HYDU_strdup(*argv);
+ HYD_pmcd_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.user_global.ckpoint_prefix = NULL;
+ HYD_pmcd_pmi_proxy_params.user_global.ckpoint_prefix = NULL;
else
- HYD_PMCD_pmi_proxy_params.user_global.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.user_global.ckpoint_restart = 1;
+ HYD_pmcd_pmi_proxy_params.user_global.ckpoint_restart = 1;
continue;
}
@@ -143,16 +143,16 @@
if (!strcmp(argtype, "--global-inherited-env"))
HYDU_append_env_to_list(*env,
- &HYD_PMCD_pmi_proxy_params.user_global.
- 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.user_global.
- 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.user_global.
- global_env.user);
+ &HYD_pmcd_pmi_proxy_params.user_global.global_env.
+ user);
HYDU_FREE(env);
}
@@ -163,41 +163,41 @@
if (!strcmp(*argv, "--genv-prop")) {
argv++;
if (strcmp(*argv, "HYDRA_NULL"))
- HYD_PMCD_pmi_proxy_params.user_global.global_env.prop = HYDU_strdup(*argv);
+ HYD_pmcd_pmi_proxy_params.user_global.global_env.prop = HYDU_strdup(*argv);
else
- HYD_PMCD_pmi_proxy_params.user_global.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.system_global.global_core_count = atoi(*argv);
+ HYD_pmcd_pmi_proxy_params.system_global.global_core_count = atoi(*argv);
continue;
}
/* Process count */
if (!strcmp(*argv, "--proxy-core-count")) {
argv++;
- HYD_PMCD_pmi_proxy_params.local.proxy_core_count = atoi(*argv);
+ HYD_pmcd_pmi_proxy_params.local.proxy_core_count = atoi(*argv);
continue;
}
/* Process count */
if (!strcmp(*argv, "--start-pid")) {
argv++;
- HYD_PMCD_pmi_proxy_params.start_pid = atoi(*argv);
+ HYD_pmcd_pmi_proxy_params.start_pid = atoi(*argv);
continue;
}
/* New executable */
if (!strcmp(*argv, "--exec")) {
- if (HYD_PMCD_pmi_proxy_params.exec_list == NULL) {
- status = HYDU_alloc_proxy_exec(&HYD_PMCD_pmi_proxy_params.exec_list);
+ if (HYD_pmcd_pmi_proxy_params.exec_list == NULL) {
+ status = HYDU_alloc_proxy_exec(&HYD_pmcd_pmi_proxy_params.exec_list);
HYDU_ERR_POP(status, "unable to allocate proxy exec\n");
}
else {
- for (exec = HYD_PMCD_pmi_proxy_params.exec_list; exec->next;
+ for (exec = HYD_pmcd_pmi_proxy_params.exec_list; exec->next;
exec = exec->next);
status = HYDU_alloc_proxy_exec(&exec->next);
HYDU_ERR_POP(status, "unable to allocate proxy exec\n");
@@ -208,7 +208,7 @@
/* Process count */
if (!strcmp(*argv, "--exec-proc-count")) {
argv++;
- for (exec = HYD_PMCD_pmi_proxy_params.exec_list; exec->next; exec = exec->next);
+ for (exec = HYD_pmcd_pmi_proxy_params.exec_list; exec->next; exec = exec->next);
exec->proc_count = atoi(*argv);
continue;
}
@@ -248,7 +248,7 @@
/* Fall through case is application parameters. Load
* everything into the args variable. */
- for (exec = HYD_PMCD_pmi_proxy_params.exec_list; exec->next; exec = exec->next);
+ for (exec = HYD_pmcd_pmi_proxy_params.exec_list; exec->next; exec = exec->next);
for (arg = 0; *argv && strcmp(*argv, "--exec");) {
exec->exec[arg++] = HYDU_strdup(*argv);
++argv;
@@ -272,10 +272,10 @@
}
-HYD_Status HYD_PMCD_pmi_proxy_get_params(char **t_argv)
+HYD_status HYD_pmcd_pmi_proxy_get_params(char **t_argv)
{
char **argv = t_argv;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -285,61 +285,61 @@
while (++argv && *argv) {
if (!strcmp(*argv, "--launch-mode")) {
++argv;
- HYD_PMCD_pmi_proxy_params.user_global.launch_mode =
- (HYD_Launch_mode_t) (unsigned int) atoi(*argv);
+ 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.user_global.launch_mode == HYD_LAUNCH_RUNTIME) {
- HYD_PMCD_pmi_proxy_params.upstream.server_name =
+ 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, ":"));
+ HYD_pmcd_pmi_proxy_params.upstream.server_port = atoi(strtok(NULL, ":"));
}
else {
- HYD_PMCD_pmi_proxy_params.upstream.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.local.id = atoi(*argv);
+ HYD_pmcd_pmi_proxy_params.local.id = atoi(*argv);
continue;
}
if (!strcmp(*argv, "--debug")) {
- HYD_PMCD_pmi_proxy_params.user_global.debug = 1;
+ HYD_pmcd_pmi_proxy_params.user_global.debug = 1;
continue;
}
if (!strcmp(*argv, "--enable-x")) {
- HYD_PMCD_pmi_proxy_params.user_global.enablex = 1;
+ HYD_pmcd_pmi_proxy_params.user_global.enablex = 1;
continue;
}
if (!strcmp(*argv, "--disable-x")) {
- HYD_PMCD_pmi_proxy_params.user_global.enablex = 0;
+ HYD_pmcd_pmi_proxy_params.user_global.enablex = 0;
continue;
}
if (!strcmp(*argv, "--bootstrap")) {
++argv;
- HYD_PMCD_pmi_proxy_params.user_global.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.user_global.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.user_global.bootstrap,
- HYD_PMCD_pmi_proxy_params.user_global.bootstrap_exec,
- HYD_PMCD_pmi_proxy_params.user_global.enablex,
- HYD_PMCD_pmi_proxy_params.user_global.debug);
+ status = HYDT_bsci_init(HYD_pmcd_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.local.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.local.id);
+ status = HYDT_bsci_query_proxy_id(&HYD_pmcd_pmi_proxy_params.local.id);
HYDU_ERR_POP(status, "unable to query bootstrap server for proxy ID\n");
}
@@ -352,51 +352,51 @@
}
-HYD_Status HYD_PMCD_pmi_proxy_cleanup_params(void)
+HYD_status HYD_pmcd_pmi_proxy_cleanup_params(void)
{
- struct HYD_Proxy_exec *exec, *texec;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_proxy_exec *exec, *texec;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- if (HYD_PMCD_pmi_proxy_params.upstream.server_name)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.upstream.server_name);
+ if (HYD_pmcd_pmi_proxy_params.upstream.server_name)
+ HYDU_FREE(HYD_pmcd_pmi_proxy_params.upstream.server_name);
- if (HYD_PMCD_pmi_proxy_params.user_global.bootstrap)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.user_global.bootstrap);
+ if (HYD_pmcd_pmi_proxy_params.user_global.bootstrap)
+ HYDU_FREE(HYD_pmcd_pmi_proxy_params.user_global.bootstrap);
- if (HYD_PMCD_pmi_proxy_params.user_global.bootstrap_exec)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.user_global.bootstrap_exec);
+ if (HYD_pmcd_pmi_proxy_params.user_global.bootstrap_exec)
+ HYDU_FREE(HYD_pmcd_pmi_proxy_params.user_global.bootstrap_exec);
- if (HYD_PMCD_pmi_proxy_params.user_global.wdir)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.user_global.wdir);
+ if (HYD_pmcd_pmi_proxy_params.user_global.wdir)
+ HYDU_FREE(HYD_pmcd_pmi_proxy_params.user_global.wdir);
- if (HYD_PMCD_pmi_proxy_params.system_global.pmi_port_str)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.system_global.pmi_port_str);
+ if (HYD_pmcd_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.user_global.binding)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.user_global.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.user_global.bindlib)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.user_global.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.user_global.ckpointlib)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.user_global.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.user_global.ckpoint_prefix)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.user_global.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.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.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.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.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.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.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.exec_list) {
- exec = HYD_PMCD_pmi_proxy_params.exec_list;
+ if (HYD_pmcd_pmi_proxy_params.exec_list) {
+ exec = HYD_pmcd_pmi_proxy_params.exec_list;
while (exec) {
texec = exec->next;
HYDU_free_strlist(exec->exec);
@@ -407,19 +407,19 @@
}
}
- if (HYD_PMCD_pmi_proxy_params.downstream.pid)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.downstream.pid);
+ if (HYD_pmcd_pmi_proxy_params.downstream.pid)
+ HYDU_FREE(HYD_pmcd_pmi_proxy_params.downstream.pid);
- if (HYD_PMCD_pmi_proxy_params.downstream.out)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.downstream.out);
+ if (HYD_pmcd_pmi_proxy_params.downstream.out)
+ HYDU_FREE(HYD_pmcd_pmi_proxy_params.downstream.out);
- if (HYD_PMCD_pmi_proxy_params.downstream.err)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.downstream.err);
+ if (HYD_pmcd_pmi_proxy_params.downstream.err)
+ HYDU_FREE(HYD_pmcd_pmi_proxy_params.downstream.err);
- if (HYD_PMCD_pmi_proxy_params.downstream.exit_status)
- HYDU_FREE(HYD_PMCD_pmi_proxy_params.downstream.exit_status);
+ if (HYD_pmcd_pmi_proxy_params.downstream.exit_status)
+ HYDU_FREE(HYD_pmcd_pmi_proxy_params.downstream.exit_status);
- HYDU_bind_finalize();
+ HYDT_bind_finalize();
/* Reinitialize all params to set everything to "NULL" or
* equivalent. */
@@ -435,11 +435,11 @@
}
-HYD_Status HYD_PMCD_pmi_proxy_procinfo(int fd)
+HYD_status HYD_pmcd_pmi_proxy_procinfo(int fd)
{
char **arglist;
int num_strings, str_len, recvd, i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -471,7 +471,7 @@
/* Save this fd as we need to send back the exit status on
* this. */
- HYD_PMCD_pmi_proxy_params.upstream.control = fd;
+ HYD_pmcd_pmi_proxy_params.upstream.control = fd;
fn_exit:
HYDU_FUNC_EXIT();
@@ -482,71 +482,71 @@
}
-HYD_Status HYD_PMCD_pmi_proxy_launch_procs(void)
+HYD_status HYD_pmcd_pmi_proxy_launch_procs(void)
{
int i, j, arg, stdin_fd, process_id, core, pmi_id;
char *str, *envstr, *list;
char *client_args[HYD_NUM_TMP_STRINGS];
- HYD_Env_t *env, *prop_env = NULL;
- struct HYD_Proxy_exec *exec;
- HYD_Status status = HYD_SUCCESS;
+ HYD_env_t *env, *prop_env = NULL;
+ struct HYD_proxy_exec *exec;
+ HYD_status status = HYD_SUCCESS;
int *pmi_ids;
HYDU_FUNC_ENTER();
- HYD_PMCD_pmi_proxy_params.local.proxy_process_count = 0;
- for (exec = HYD_PMCD_pmi_proxy_params.exec_list; exec; exec = exec->next)
- HYD_PMCD_pmi_proxy_params.local.proxy_process_count += exec->proc_count;
+ HYD_pmcd_pmi_proxy_params.local.proxy_process_count = 0;
+ for (exec = HYD_pmcd_pmi_proxy_params.exec_list; exec; exec = exec->next)
+ HYD_pmcd_pmi_proxy_params.local.proxy_process_count += exec->proc_count;
- HYDU_MALLOC(pmi_ids, int *, HYD_PMCD_pmi_proxy_params.local.proxy_process_count *
+ HYDU_MALLOC(pmi_ids, int *, HYD_pmcd_pmi_proxy_params.local.proxy_process_count *
sizeof(int), status);
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.proxy_process_count; i++) {
+ for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++) {
pmi_ids[i] =
- HYDU_local_to_global_id(i, HYD_PMCD_pmi_proxy_params.start_pid,
- HYD_PMCD_pmi_proxy_params.local.proxy_core_count,
- HYD_PMCD_pmi_proxy_params.system_global.global_core_count);
+ HYDU_local_to_global_id(i, HYD_pmcd_pmi_proxy_params.start_pid,
+ HYD_pmcd_pmi_proxy_params.local.proxy_core_count,
+ HYD_pmcd_pmi_proxy_params.system_global.global_core_count);
}
- HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.downstream.out, int *,
- HYD_PMCD_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
- HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.downstream.err, int *,
- HYD_PMCD_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
- HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.downstream.pid, int *,
- HYD_PMCD_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
- HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.downstream.exit_status, int *,
- HYD_PMCD_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
+ HYDU_MALLOC(HYD_pmcd_pmi_proxy_params.downstream.out, int *,
+ HYD_pmcd_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
+ HYDU_MALLOC(HYD_pmcd_pmi_proxy_params.downstream.err, int *,
+ HYD_pmcd_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
+ HYDU_MALLOC(HYD_pmcd_pmi_proxy_params.downstream.pid, int *,
+ HYD_pmcd_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
+ HYDU_MALLOC(HYD_pmcd_pmi_proxy_params.downstream.exit_status, int *,
+ HYD_pmcd_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
/* Initialize the exit status */
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.proxy_process_count; i++)
- HYD_PMCD_pmi_proxy_params.downstream.exit_status[i] = -1;
+ for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++)
+ HYD_pmcd_pmi_proxy_params.downstream.exit_status[i] = -1;
- status = HYDU_bind_init(HYD_PMCD_pmi_proxy_params.user_global.binding,
- HYD_PMCD_pmi_proxy_params.user_global.bindlib);
+ status = HYDT_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.user_global.ckpointlib,
- HYD_PMCD_pmi_proxy_params.user_global.ckpoint_prefix);
+ status = HYDT_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.user_global.ckpoint_restart) {
+ 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);
+ 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.local.proxy_process_count,
+ status = HYDT_ckpoint_restart(env, HYD_pmcd_pmi_proxy_params.local.proxy_process_count,
pmi_ids,
pmi_ids[0] ? NULL :
- &HYD_PMCD_pmi_proxy_params.downstream.in,
- HYD_PMCD_pmi_proxy_params.downstream.out,
- HYD_PMCD_pmi_proxy_params.downstream.err);
+ &HYD_pmcd_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;
}
/* Spawn the processes */
process_id = 0;
- for (exec = HYD_PMCD_pmi_proxy_params.exec_list; exec; exec = exec->next) {
+ for (exec = HYD_pmcd_pmi_proxy_params.exec_list; exec; exec = exec->next) {
/*
* Increasing priority order:
@@ -558,9 +558,9 @@
/* Global inherited env */
if ((exec->env_prop && !strcmp(exec->env_prop, "all")) ||
- (!exec->env_prop && !strcmp(HYD_PMCD_pmi_proxy_params.user_global.global_env.prop,
+ (!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;
+ 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");
@@ -568,20 +568,20 @@
}
else if ((exec->env_prop && !strncmp(exec->env_prop, "list", strlen("list"))) ||
(!exec->env_prop &&
- !strncmp(HYD_PMCD_pmi_proxy_params.user_global.global_env.prop, "list",
+ !strncmp(HYD_pmcd_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.user_global.global_env.prop +
+ 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.user_global.
- global_env.inherited);
+ 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");
@@ -591,7 +591,7 @@
}
/* Next priority order is the global user env */
- for (env = HYD_PMCD_pmi_proxy_params.user_global.global_env.user; env; env = env->next) {
+ for (env = HYD_pmcd_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");
}
@@ -603,7 +603,7 @@
}
/* Highest priority is the system env */
- for (env = HYD_PMCD_pmi_proxy_params.user_global.global_env.system; env;
+ 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");
@@ -611,9 +611,9 @@
/* Set the PMI port string to connect to. We currently just
* use the global PMI port. */
- if (HYD_PMCD_pmi_proxy_params.system_global.pmi_port_str) {
+ if (HYD_pmcd_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);
+ 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);
@@ -622,12 +622,12 @@
for (i = 0; i < exec->proc_count; i++) {
pmi_id = HYDU_local_to_global_id(process_id,
- HYD_PMCD_pmi_proxy_params.start_pid,
- HYD_PMCD_pmi_proxy_params.local.proxy_core_count,
- HYD_PMCD_pmi_proxy_params.
- system_global.global_core_count);
+ HYD_pmcd_pmi_proxy_params.start_pid,
+ HYD_pmcd_pmi_proxy_params.local.proxy_core_count,
+ HYD_pmcd_pmi_proxy_params.system_global.
+ global_core_count);
- if (HYD_PMCD_pmi_proxy_params.system_global.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");
@@ -636,7 +636,7 @@
HYDU_ERR_POP(status, "unable to add env to list\n");
}
- if (chdir(HYD_PMCD_pmi_proxy_params.user_global.wdir) < 0)
+ if (chdir(HYD_pmcd_pmi_proxy_params.user_global.wdir) < 0)
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unable to change wdir (%s)\n", HYDU_strerror(errno));
@@ -644,36 +644,36 @@
client_args[arg++] = HYDU_strdup(exec->exec[j]);
client_args[arg++] = NULL;
- core = HYDU_bind_get_core_id(process_id);
+ core = HYDT_bind_get_core_id(process_id);
if (pmi_id == 0) {
status = HYDU_create_process(client_args, prop_env,
- &HYD_PMCD_pmi_proxy_params.downstream.in,
- &HYD_PMCD_pmi_proxy_params.
- downstream.out[process_id],
- &HYD_PMCD_pmi_proxy_params.
- downstream.err[process_id],
- &HYD_PMCD_pmi_proxy_params.
- downstream.pid[process_id], core);
+ &HYD_pmcd_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.local.stdin_buf_offset = 0;
- HYD_PMCD_pmi_proxy_params.local.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);
+ 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.downstream.in;
- status = HYD_DMX_register_fd(1, &stdin_fd, HYD_STDIN, NULL,
- HYD_PMCD_pmi_proxy_stdin_cb);
+ stdin_fd = HYD_pmcd_pmi_proxy_params.downstream.in;
+ status = HYDT_dmx_register_fd(1, &stdin_fd, HYD_STDIN, NULL,
+ HYD_pmcd_pmi_proxy_stdin_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
}
else {
status = HYDU_create_process(client_args, prop_env, NULL,
- &HYD_PMCD_pmi_proxy_params.
- downstream.out[process_id],
- &HYD_PMCD_pmi_proxy_params.
- downstream.err[process_id],
- &HYD_PMCD_pmi_proxy_params.
- downstream.pid[process_id], core);
+ &HYD_pmcd_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");
@@ -686,18 +686,18 @@
fn_spawn_complete:
/* Everything is spawned, register the required FDs */
- status = HYD_DMX_register_fd(HYD_PMCD_pmi_proxy_params.local.proxy_process_count,
- HYD_PMCD_pmi_proxy_params.downstream.out,
- HYD_STDOUT, NULL, HYD_PMCD_pmi_proxy_stdout_cb);
+ status = HYDT_dmx_register_fd(HYD_pmcd_pmi_proxy_params.local.proxy_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.local.proxy_process_count,
- HYD_PMCD_pmi_proxy_params.downstream.err,
- HYD_STDOUT, NULL, HYD_PMCD_pmi_proxy_stderr_cb);
+ status = HYDT_dmx_register_fd(HYD_pmcd_pmi_proxy_params.local.proxy_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.local.procs_are_launched = 1;
+ HYD_pmcd_pmi_proxy_params.local.procs_are_launched = 1;
fn_exit:
if (pmi_ids)
@@ -710,17 +710,17 @@
}
-void HYD_PMCD_pmi_proxy_killjob(void)
+void HYD_pmcd_pmi_proxy_killjob(void)
{
int i;
HYDU_FUNC_ENTER();
/* Send the kill signal to all processes */
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.proxy_process_count; i++) {
- if (HYD_PMCD_pmi_proxy_params.downstream.pid[i] != -1) {
- kill(HYD_PMCD_pmi_proxy_params.downstream.pid[i], SIGTERM);
- kill(HYD_PMCD_pmi_proxy_params.downstream.pid[i], SIGKILL);
+ for (i = 0; i < HYD_pmcd_pmi_proxy_params.local.proxy_process_count; i++) {
+ if (HYD_pmcd_pmi_proxy_params.downstream.pid[i] != -1) {
+ kill(HYD_pmcd_pmi_proxy_params.downstream.pid[i], SIGTERM);
+ kill(HYD_pmcd_pmi_proxy_params.downstream.pid[i], SIGKILL);
}
}
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,14 +9,14 @@
#include "pmi_common.h"
-HYD_Status HYD_PMCD_pmi_connect_cb(int fd, HYD_Event_t events, void *userp);
-HYD_Status HYD_PMCD_pmi_cmd_cb(int fd, HYD_Event_t events, void *userp);
-HYD_Status HYD_PMCD_pmi_serv_control_connect_cb(int fd, HYD_Event_t events, void *userp);
-HYD_Status HYD_PMCD_pmi_serv_control_cb(int fd, HYD_Event_t events, void *userp);
-HYD_Status HYD_PMCD_pmi_serv_cleanup(void);
-HYD_Status HYD_PMCD_pmi_serv_ckpoint(void);
-void HYD_PMCD_pmi_serv_signal_cb(int signal);
+HYD_status HYD_pmcd_pmi_connect_cb(int fd, HYD_event_t events, void *userp);
+HYD_status HYD_pmcd_pmi_cmd_cb(int fd, HYD_event_t events, void *userp);
+HYD_status HYD_pmcd_pmi_serv_control_connect_cb(int fd, HYD_event_t events, void *userp);
+HYD_status HYD_pmcd_pmi_serv_control_cb(int fd, HYD_event_t events, void *userp);
+HYD_status HYD_pmcd_pmi_serv_cleanup(void);
+HYD_status HYD_pmcd_pmi_serv_ckpoint(void);
+void HYD_pmcd_pmi_serv_signal_cb(int signal);
-HYD_Status HYD_PMCD_pmi_send_exec_info(struct HYD_Proxy *proxy);
+HYD_status HYD_pmcd_pmi_send_exec_info(struct HYD_proxy *proxy);
#endif /* PMI_SERV_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_cb.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_cb.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_cb.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -14,10 +14,10 @@
#include "demux.h"
#include "pmi_serv.h"
-HYD_Status HYD_PMCD_pmi_connect_cb(int fd, HYD_Event_t events, void *userp)
+HYD_status HYD_pmcd_pmi_connect_cb(int fd, HYD_event_t events, void *userp)
{
int accept_fd;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -25,7 +25,7 @@
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_cmd_cb);
+ status = HYDT_dmx_register_fd(1, &accept_fd, HYD_STDOUT, NULL, HYD_pmcd_pmi_cmd_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
fn_exit:
@@ -37,13 +37,13 @@
}
-HYD_Status HYD_PMCD_pmi_cmd_cb(int fd, HYD_Event_t events, void *userp)
+HYD_status HYD_pmcd_pmi_cmd_cb(int fd, HYD_event_t events, void *userp)
{
int linelen, i, cmdlen;
char *buf = NULL, *tbuf = NULL, *cmd, *args[HYD_NUM_TMP_STRINGS];
char *str1 = NULL, *str2 = NULL;
- struct HYD_PMCD_pmi_handle_fns *h;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_pmcd_pmi_handle_fns *h;
+ HYD_status status = HYD_SUCCESS;
int buflen = 0;
char *bufptr;
@@ -66,8 +66,8 @@
* vs. PMI-2. But the simple PMI client-side code is so hacked up,
* that commands can arrive out-of-order and this is necessary.
*/
- if (HYD_PMCD_pmi_handle == NULL)
- HYD_PMCD_pmi_handle = HYD_PMCD_pmi_v1;
+ if (HYD_pmcd_pmi_handle == NULL)
+ HYD_pmcd_pmi_handle = HYD_pmcd_pmi_v1;
do {
status = HYDU_sock_read(fd, bufptr, 6, &linelen, HYDU_SOCK_COMM_MSGWAIT);
@@ -100,16 +100,16 @@
* PMI-2 commands interleaved with regular PMI-2
* commands. */
tbuf = HYDU_strdup(buf);
- cmd = strtok(tbuf, HYD_PMCD_pmi_v1->delim);
+ cmd = strtok(tbuf, HYD_pmcd_pmi_v1->delim);
for (i = 0; i < HYD_NUM_TMP_STRINGS; i++) {
- args[i] = strtok(NULL, HYD_PMCD_pmi_v1->delim);
+ args[i] = strtok(NULL, HYD_pmcd_pmi_v1->delim);
if (args[i] == NULL)
break;
}
if (!strcmp("cmd=init", cmd)) {
/* Init is generic to all PMI implementations */
- status = HYD_PMCD_pmi_handle_init(fd, args);
+ status = HYD_pmcd_pmi_handle_init(fd, args);
goto fn_exit;
}
}
@@ -127,16 +127,16 @@
/* This is not a clean close. If a finalize was called, we
* would have deregistered this socket. The application might
* have aborted. Just cleanup all the processes */
- status = HYD_PMCD_pmi_serv_cleanup();
+ status = HYD_pmcd_pmi_serv_cleanup();
if (status != HYD_SUCCESS) {
- HYDU_Warn_printf("bootstrap server returned error cleaning up processes\n");
+ HYDU_warn_printf("bootstrap server returned error cleaning up processes\n");
status = HYD_SUCCESS;
goto fn_fail;
}
- status = HYD_DMX_deregister_fd(fd);
+ status = HYDT_dmx_deregister_fd(fd);
if (status != HYD_SUCCESS) {
- HYDU_Warn_printf("unable to deregister fd %d\n", fd);
+ HYDU_warn_printf("unable to deregister fd %d\n", fd);
status = HYD_SUCCESS;
goto fn_fail;
}
@@ -151,9 +151,9 @@
* PMI-1, so we will use that delimited even for PMI-2 for this
* one command. From the next command onward, we will use the
* PMI-2 specific delimiter. */
- cmd = strtok(buf, HYD_PMCD_pmi_handle->delim);
+ cmd = strtok(buf, HYD_pmcd_pmi_handle->delim);
for (i = 0; i < HYD_NUM_TMP_STRINGS; i++) {
- args[i] = strtok(NULL, HYD_PMCD_pmi_handle->delim);
+ args[i] = strtok(NULL, HYD_pmcd_pmi_handle->delim);
if (args[i] == NULL)
break;
}
@@ -166,7 +166,7 @@
status = HYDU_strsplit(cmd, &str1, &str2, '=');
HYDU_ERR_POP(status, "string split returned error\n");
- h = HYD_PMCD_pmi_handle->handle_fns;
+ h = HYD_pmcd_pmi_handle->handle_fns;
while (h->handler) {
if (!strcmp(str2, h->cmd)) {
status = h->handler(fd, args);
@@ -177,12 +177,12 @@
}
if (!h->handler) {
/* We don't understand the command */
- HYDU_Error_printf("Unrecognized PMI command: %s | cleaning up processes\n", cmd);
+ HYDU_error_printf("Unrecognized PMI command: %s | cleaning up processes\n", cmd);
/* Cleanup all the processes and return. We don't need to
* check the return status since we are anyway returning
* an error */
- HYD_PMCD_pmi_serv_cleanup();
+ HYD_pmcd_pmi_serv_cleanup();
HYDU_ERR_SETANDJUMP(status, HYD_SUCCESS, "");
}
}
@@ -204,11 +204,11 @@
}
-HYD_Status HYD_PMCD_pmi_serv_control_connect_cb(int fd, HYD_Event_t events, void *userp)
+HYD_status HYD_pmcd_pmi_serv_control_connect_cb(int fd, HYD_event_t events, void *userp)
{
int accept_fd, proxy_id, count;
- struct HYD_Proxy *proxy;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_proxy *proxy;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -232,11 +232,11 @@
proxy->control_fd = accept_fd;
/* Send out the executable information */
- status = HYD_PMCD_pmi_send_exec_info(proxy);
+ status = HYD_pmcd_pmi_send_exec_info(proxy);
HYDU_ERR_POP(status, "unable to send exec info to proxy\n");
- status = HYD_DMX_register_fd(1, &accept_fd, HYD_STDOUT, proxy,
- HYD_PMCD_pmi_serv_control_cb);
+ status = HYDT_dmx_register_fd(1, &accept_fd, HYD_STDOUT, proxy,
+ HYD_pmcd_pmi_serv_control_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
fn_exit:
@@ -248,22 +248,22 @@
}
-HYD_Status HYD_PMCD_pmi_serv_control_cb(int fd, HYD_Event_t events, void *userp)
+HYD_status HYD_pmcd_pmi_serv_control_cb(int fd, HYD_event_t events, void *userp)
{
- struct HYD_Proxy *proxy;
+ struct HYD_proxy *proxy;
int count;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- proxy = (struct HYD_Proxy *) userp;
+ proxy = (struct HYD_proxy *) userp;
status = HYDU_sock_read(fd, (void *) proxy->exit_status,
proxy->proxy_process_count * sizeof(int),
&count, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "unable to read status from proxy\n");
- status = HYD_DMX_deregister_fd(fd);
+ status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "error deregistering fd\n");
close(fd);
@@ -277,11 +277,11 @@
}
-HYD_Status HYD_PMCD_pmi_serv_cleanup(void)
+HYD_status HYD_pmcd_pmi_serv_cleanup(void)
{
- struct HYD_Proxy *proxy;
- enum HYD_PMCD_pmi_proxy_cmds cmd;
- HYD_Status status = HYD_SUCCESS, overall_status = HYD_SUCCESS;
+ struct HYD_proxy *proxy;
+ enum HYD_pmcd_pmi_proxy_cmds cmd;
+ HYD_status status = HYD_SUCCESS, overall_status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -291,9 +291,9 @@
FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
cmd = KILL_JOB;
status = HYDU_sock_trywrite(proxy->control_fd, &cmd,
- sizeof(enum HYD_PMCD_pmi_proxy_cmds));
+ sizeof(enum HYD_pmcd_pmi_proxy_cmds));
if (status != HYD_SUCCESS) {
- HYDU_Warn_printf("unable to send data to the proxy on %s\n", proxy->hostname);
+ HYDU_warn_printf("unable to send data to the proxy on %s\n", proxy->hostname);
overall_status = HYD_INTERNAL_ERROR;
continue; /* Move on to the next proxy */
}
@@ -305,11 +305,11 @@
}
-HYD_Status HYD_PMCD_pmi_serv_ckpoint(void)
+HYD_status HYD_pmcd_pmi_serv_ckpoint(void)
{
- struct HYD_Proxy *proxy;
- enum HYD_PMCD_pmi_proxy_cmds cmd;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_proxy *proxy;
+ enum HYD_pmcd_pmi_proxy_cmds cmd;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -319,7 +319,7 @@
FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
cmd = CKPOINT;
status = HYDU_sock_write(proxy->control_fd, &cmd,
- sizeof(enum HYD_PMCD_pmi_proxy_cmds));
+ sizeof(enum HYD_pmcd_pmi_proxy_cmds));
HYDU_ERR_POP(status, "unable to send checkpoint message\n");
}
@@ -333,7 +333,7 @@
}
-void HYD_PMCD_pmi_serv_signal_cb(int sig)
+void HYD_pmcd_pmi_serv_signal_cb(int sig)
{
HYDU_FUNC_ENTER();
@@ -346,11 +346,11 @@
#endif /* SIGSTOP */
) {
/* There's nothing we can do with the return value for now. */
- HYD_PMCD_pmi_serv_cleanup();
+ HYD_pmcd_pmi_serv_cleanup();
}
else {
if (sig == SIGUSR1) {
- HYD_PMCD_pmi_serv_ckpoint();
+ HYD_pmcd_pmi_serv_ckpoint();
}
/* Ignore other signals for now */
}
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-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_finalize.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -11,21 +11,21 @@
#include "demux.h"
#include "pmi_serv.h"
-HYD_Status HYD_PMCI_finalize(void)
+HYD_status HYD_pmci_finalize(void)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_PMCD_pmi_finalize();
+ status = HYD_pmcd_pmi_finalize();
HYDU_ERR_POP(status, "unable to finalize process manager utils\n");
if (HYD_handle.user_global.launch_mode == HYD_LAUNCH_RUNTIME) {
- status = HYD_BSCI_finalize();
+ status = HYDT_bsci_finalize();
HYDU_ERR_POP(status, "unable to finalize bootstrap server\n");
}
- status = HYD_DMX_finalize();
+ status = HYDT_dmx_finalize();
HYDU_ERR_POP(status, "error returned from demux finalize\n");
fn_exit:
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-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -17,9 +17,9 @@
static void *launch_helper(void *args)
{
- struct HYD_Proxy *proxy = (struct HYD_Proxy *) args;
- enum HYD_PMCD_pmi_proxy_cmds cmd;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_proxy *proxy = (struct HYD_proxy *) args;
+ enum HYD_pmcd_pmi_proxy_cmds cmd;
+ HYD_status status = HYD_SUCCESS;
/*
* Here are the steps we will follow:
@@ -55,7 +55,7 @@
status = HYDU_sock_connect(proxy->hostname, HYD_handle.proxy_port, &proxy->control_fd);
HYDU_ERR_POP(status, "unable to connect to proxy\n");
- status = HYD_PMCD_pmi_send_exec_info(proxy);
+ status = HYD_pmcd_pmi_send_exec_info(proxy);
HYDU_ERR_POP(status, "error sending executable info\n");
/* Create an stdout socket */
@@ -63,7 +63,7 @@
HYDU_ERR_POP(status, "unable to connect to proxy\n");
cmd = USE_AS_STDOUT;
- status = HYDU_sock_write(proxy->out, &cmd, sizeof(enum HYD_PMCD_pmi_proxy_cmds));
+ status = HYDU_sock_write(proxy->out, &cmd, sizeof(enum HYD_pmcd_pmi_proxy_cmds));
HYDU_ERR_POP(status, "unable to write data to proxy\n");
/* Create an stderr socket */
@@ -71,7 +71,7 @@
HYDU_ERR_POP(status, "unable to connect to proxy\n");
cmd = USE_AS_STDERR;
- status = HYDU_sock_write(proxy->err, &cmd, sizeof(enum HYD_PMCD_pmi_proxy_cmds));
+ status = HYDU_sock_write(proxy->err, &cmd, sizeof(enum HYD_pmcd_pmi_proxy_cmds));
HYDU_ERR_POP(status, "unable to write data to proxy\n");
/* If rank 0 is here, create an stdin socket */
@@ -80,7 +80,7 @@
HYDU_ERR_POP(status, "unable to connect to proxy\n");
cmd = USE_AS_STDIN;
- status = HYDU_sock_write(proxy->in, &cmd, sizeof(enum HYD_PMCD_pmi_proxy_cmds));
+ status = HYDU_sock_write(proxy->in, &cmd, sizeof(enum HYD_pmcd_pmi_proxy_cmds));
HYDU_ERR_POP(status, "unable to write data to proxy\n");
}
@@ -91,15 +91,15 @@
goto fn_exit;
}
-static HYD_Status
-create_and_listen_portstr(HYD_Status(*callback) (int fd, HYD_Event_t events, void *userp),
+static HYD_status
+create_and_listen_portstr(HYD_status(*callback) (int fd, HYD_event_t events, void *userp),
char **port_str)
{
int listenfd;
char *port_range, *sport;
uint16_t port;
char hostname[MAX_HOSTNAME_LEN];
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
/* Check if the user wants us to use a port within a certain
* range. */
@@ -115,7 +115,7 @@
HYDU_ERR_POP(status, "unable to listen on port\n");
/* Register the listening socket with the demux engine */
- status = HYD_DMX_register_fd(1, &listenfd, HYD_STDOUT, NULL, callback);
+ status = HYDT_dmx_register_fd(1, &listenfd, HYD_STDOUT, NULL, callback);
HYDU_ERR_POP(status, "unable to register fd\n");
/* Create a port string for MPI processes to use to connect to */
@@ -136,11 +136,11 @@
goto fn_exit;
}
-static HYD_Status fill_in_proxy_args(HYD_Launch_mode_t mode, char **proxy_args)
+static HYD_status fill_in_proxy_args(HYD_launch_mode_t mode, char **proxy_args)
{
int i, arg;
char *path_str[HYD_NUM_TMP_STRINGS];
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
if (mode != HYD_LAUNCH_RUNTIME && mode != HYD_LAUNCH_BOOT &&
mode != HYD_LAUNCH_BOOT_FOREGROUND)
@@ -189,16 +189,16 @@
goto fn_exit;
}
-static HYD_Status fill_in_exec_launch_info(void)
+static HYD_status fill_in_exec_launch_info(void)
{
int i, arg, process_id;
int inherited_env_count, user_env_count, system_env_count;
int exec_count, total_args;
static int proxy_count = 0;
- HYD_Env_t *env;
- struct HYD_Proxy *proxy;
- struct HYD_Proxy_exec *exec;
- HYD_Status status = HYD_SUCCESS;
+ HYD_env_t *env;
+ struct HYD_proxy *proxy;
+ struct HYD_proxy_exec *exec;
+ HYD_status status = HYD_SUCCESS;
/* Create the arguments list for each proxy */
process_id = 0;
@@ -350,33 +350,33 @@
goto fn_exit;
}
-HYD_Status HYD_PMCI_launch_procs(void)
+HYD_status HYD_pmci_launch_procs(void)
{
- struct HYD_Proxy *proxy;
- enum HYD_PMCD_pmi_proxy_cmds cmd;
+ struct HYD_proxy *proxy;
+ enum HYD_pmcd_pmi_proxy_cmds cmd;
int fd, len, id;
#if defined HAVE_THREAD_SUPPORT
- struct HYD_Thread_context *thread_context = NULL;
+ struct HYD_thread_context *thread_context = NULL;
#endif /* HAVE_THREAD_SUPPORT */
char *proxy_args[HYD_NUM_TMP_STRINGS] = { NULL };
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYDU_set_common_signals(HYD_PMCD_pmi_serv_signal_cb);
+ status = HYDU_set_common_signals(HYD_pmcd_pmi_serv_signal_cb);
HYDU_ERR_POP(status, "unable to set signal\n");
/* Initialize PMI */
- status = create_and_listen_portstr(HYD_PMCD_pmi_connect_cb, &pmi_port_str);
+ 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.user_global.debug)
HYDU_dump(stdout, "Got a PMI port string of %s\n", pmi_port_str);
- status = HYD_PMCD_pmi_init();
+ status = HYD_pmcd_pmi_init();
HYDU_ERR_POP(status, "unable to create process group\n");
if (HYD_handle.user_global.launch_mode == HYD_LAUNCH_RUNTIME) {
- status = create_and_listen_portstr(HYD_PMCD_pmi_serv_control_connect_cb,
+ 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.user_global.debug)
@@ -388,7 +388,7 @@
status = fill_in_exec_launch_info();
HYDU_ERR_POP(status, "unable to fill in executable arguments\n");
- status = HYD_BSCI_launch_procs(proxy_args, "--proxy-id", HYD_handle.proxy_list);
+ status = HYDT_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.user_global.launch_mode == HYD_LAUNCH_BOOT ||
@@ -396,7 +396,7 @@
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);
+ status = HYDT_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.user_global.launch_mode == HYD_LAUNCH_SHUTDOWN) {
@@ -404,12 +404,12 @@
status = HYDU_sock_connect(proxy->hostname, HYD_handle.proxy_port, &fd);
if (status != HYD_SUCCESS) {
/* Don't abort. Try to shutdown as many proxies as possible */
- HYDU_Error_printf("Unable to connect to proxy at %s\n", proxy->hostname);
+ HYDU_error_printf("Unable to connect to proxy at %s\n", proxy->hostname);
continue;
}
cmd = PROXY_SHUTDOWN;
- status = HYDU_sock_write(fd, &cmd, sizeof(enum HYD_PMCD_pmi_proxy_cmds));
+ status = HYDU_sock_write(fd, &cmd, sizeof(enum HYD_pmcd_pmi_proxy_cmds));
HYDU_ERR_POP(status, "unable to write data to proxy\n");
close(fd);
@@ -424,8 +424,8 @@
len++;
#if defined HAVE_THREAD_SUPPORT
- HYDU_CALLOC(thread_context, struct HYD_Thread_context *, len,
- sizeof(struct HYD_Thread_context), status);
+ HYDU_CALLOC(thread_context, struct HYD_thread_context *, len,
+ sizeof(struct HYD_thread_context), status);
if (!thread_context)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
"Unable to allocate memory for thread context\n");
@@ -447,8 +447,8 @@
HYDU_join_thread(thread_context[id]);
#endif /* HAVE_THREAD_SUPPORT */
- status = HYD_DMX_register_fd(1, &proxy->control_fd, HYD_STDOUT, proxy,
- HYD_PMCD_pmi_serv_control_cb);
+ status = HYDT_dmx_register_fd(1, &proxy->control_fd, HYD_STDOUT, proxy,
+ HYD_pmcd_pmi_serv_control_cb);
HYDU_ERR_POP(status, "unable to register control fd\n");
id++;
@@ -473,11 +473,11 @@
}
-HYD_Status HYD_PMCI_wait_for_completion(void)
+HYD_status HYD_pmci_wait_for_completion(void)
{
- struct HYD_Proxy *proxy;
+ struct HYD_proxy *proxy;
int sockets_open, all_procs_exited;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -489,7 +489,7 @@
while (1) {
/* Wait for some event to occur */
status =
- HYD_DMX_wait_for_event(HYDU_time_left(HYD_handle.start, HYD_handle.timeout));
+ HYDT_dmx_wait_for_event(HYDU_time_left(HYD_handle.start, HYD_handle.timeout));
HYDU_ERR_POP(status, "error waiting for event\n");
/* If the timeout expired, raise a SIGINT and kill all the
@@ -528,12 +528,12 @@
/* If not, wait for some event to occur */
status =
- HYD_DMX_wait_for_event(HYDU_time_left(HYD_handle.start, HYD_handle.timeout));
+ HYDT_dmx_wait_for_event(HYDU_time_left(HYD_handle.start, HYD_handle.timeout));
HYDU_ERR_POP(status, "error waiting for event\n");
} while (1);
}
- status = HYD_BSCI_wait_for_completion(HYD_handle.proxy_list);
+ status = HYDT_bsci_wait_for_completion(HYD_handle.proxy_list);
HYDU_ERR_POP(status, "bootstrap server returned error waiting for completion\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_utils.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_utils.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_utils.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,16 +9,16 @@
#include "pmi_serv.h"
#include "demux.h"
-HYD_Status HYD_PMCD_pmi_send_exec_info(struct HYD_Proxy *proxy)
+HYD_status HYD_pmcd_pmi_send_exec_info(struct HYD_proxy *proxy)
{
- enum HYD_PMCD_pmi_proxy_cmds cmd;
+ enum HYD_pmcd_pmi_proxy_cmds cmd;
int i, list_len, arg_len;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
cmd = PROC_INFO;
- status = HYDU_sock_write(proxy->control_fd, &cmd, sizeof(enum HYD_PMCD_pmi_proxy_cmds));
+ status = HYDU_sock_write(proxy->control_fd, &cmd, sizeof(enum HYD_pmcd_pmi_proxy_cmds));
HYDU_ERR_POP(status, "unable to write data to proxy\n");
/* Check how many arguments we have */
Modified: mpich2/trunk/src/pm/hydra/rmk/dummy/rmk_dummy_init.c
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/dummy/rmk_dummy_init.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/rmk/dummy/rmk_dummy_init.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,9 +8,9 @@
#include "rmki.h"
#include "rmk_dummy.h"
-HYD_Status HYD_RMKI_dummy_init(void)
+HYD_status HYD_rmki_dummy_init(void)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/rmk/include/rmki.h.in
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/include/rmki.h.in 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/rmk/include/rmki.h.in 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,16 +9,16 @@
#include "hydra.h"
-struct HYD_RMKI_fns {
- HYD_Status(*query_node_list) (int *num_nodes, struct HYD_Proxy **proxy_list);
+struct HYD_rmki_fns {
+ HYD_status(*query_node_list) (int *num_nodes, struct HYD_proxy **proxy_list);
};
-extern struct HYD_RMKI_fns HYD_RMKI_fns;
+extern struct HYD_rmki_fns HYD_rmki_fns;
-HYD_Status HYD_RMKI_init(char *rmk);
+HYD_status HYD_rmki_init(char *rmk);
/* Non-zero nodes means that the RMK should allocate the nodes if needed */
-HYD_Status HYD_RMKI_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list);
+HYD_status HYD_rmki_query_node_list(int *num_nodes, struct HYD_proxy **proxy_list);
/* Each resource management kernel has to expose an initialization function */
@hydra_rmk_init_decl@
Modified: mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs.h
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,6 +9,6 @@
#include "hydra_base.h"
-HYD_Status HYD_RMKD_pbs_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list);
+HYD_status HYD_rmkd_pbs_query_node_list(int *num_nodes, struct HYD_proxy **proxy_list);
#endif /* RMK_PBS_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_init.c
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_init.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_init.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,13 +8,13 @@
#include "rmki.h"
#include "rmk_pbs.h"
-HYD_Status HYD_RMKI_pbs_init(void)
+HYD_status HYD_rmki_pbs_init(void)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYD_RMKI_fns.query_node_list = HYD_RMKD_pbs_query_node_list;
+ HYD_rmki_fns.query_node_list = HYD_rmkd_pbs_query_node_list;
HYDU_FUNC_EXIT();
Modified: mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_query_node_list.c
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_query_node_list.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_query_node_list.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,12 +8,12 @@
#include "rmki.h"
#include "rmk_pbs.h"
-HYD_Status HYD_RMKD_pbs_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list)
+HYD_status HYD_rmkd_pbs_query_node_list(int *num_nodes, struct HYD_proxy **proxy_list)
{
char *host_file, *hostname, line[HYD_TMP_STRLEN], **arg_list;
int num_procs;
FILE *fp;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
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-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/rmk/src/rmki_init.c.in 2009-10-16 04:24:58 UTC (rev 5472)
@@ -10,36 +10,36 @@
#include "bsci.h"
/* initialize to avoid common symbols */
-struct HYD_RMKI_fns HYD_RMKI_fns = { 0 };
+struct HYD_rmki_fns HYD_rmki_fns = { 0 };
-const char *HYD_RMKI_comp_array[] = { @hydra_rmk_name_array@ };
-HYD_Status(*HYD_RMKI_comp_init[])(void) = { @hydra_rmk_init_array@ };
+const char *HYD_rmki_comp_array[] = { @hydra_rmk_name_array@ };
+HYD_status(*HYD_rmki_comp_init[])(void) = { @hydra_rmk_init_array@ };
-HYD_Status HYD_RMKI_init(char *rmk)
+HYD_status HYD_rmki_init(char *rmk)
{
int i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYD_RMKI_fns.query_node_list = NULL;
+ HYD_rmki_fns.query_node_list = NULL;
- for (i = 0; HYD_RMKI_comp_array[i]; i++) {
- if (!strcmp(rmk, HYD_RMKI_comp_array[i])) {
- status = (*HYD_RMKI_comp_init[i])();
+ for (i = 0; HYD_rmki_comp_array[i]; i++) {
+ if (!strcmp(rmk, HYD_rmki_comp_array[i])) {
+ status = (*HYD_rmki_comp_init[i])();
HYDU_ERR_POP(status, "RMK device returned error initializing\n");
break;
}
}
- if (HYD_RMKI_comp_array[i] == NULL)
+ if (HYD_rmki_comp_array[i] == NULL)
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unrecognized resource management kernel: %s\n", rmk);
- if (HYD_RMKI_fns.query_node_list == NULL)
- HYD_RMKI_fns.query_node_list = HYD_RMKU_query_node_list;
+ 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.user_global.bootstrap,
+ status = HYDT_bsci_init(HYD_handle.user_global.bootstrap,
HYD_handle.user_global.bootstrap_exec,
HYD_handle.user_global.enablex,
HYD_handle.user_global.debug);
Modified: mpich2/trunk/src/pm/hydra/rmk/src/rmki_query_node_list.c
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/src/rmki_query_node_list.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/rmk/src/rmki_query_node_list.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -7,13 +7,13 @@
#include "hydra_base.h"
#include "rmki.h"
-HYD_Status HYD_RMKI_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list)
+HYD_status HYD_rmki_query_node_list(int *num_nodes, struct HYD_proxy **proxy_list)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_RMKI_fns.query_node_list(num_nodes, proxy_list);
+ status = HYD_rmki_fns.query_node_list(num_nodes, proxy_list);
HYDU_ERR_POP(status, "RMK device returned error while querying node list\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/rmk/utils/rmku.h
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/utils/rmku.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/rmk/utils/rmku.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,6 +9,6 @@
#include "hydra_base.h"
-HYD_Status HYD_RMKU_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list);
+HYD_status HYD_rmku_query_node_list(int *num_nodes, struct HYD_proxy **proxy_list);
#endif /* RMKU_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/rmk/utils/rmku_query_node_list.c
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/utils/rmku_query_node_list.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/rmk/utils/rmku_query_node_list.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,15 +9,15 @@
#include "bsci.h"
#include "rmku.h"
-HYD_Status HYD_RMKU_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list)
+HYD_status HYD_rmku_query_node_list(int *num_nodes, struct HYD_proxy **proxy_list)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
/* We just query the bootstrap server for the node list and return
* it to the upper layer. */
- status = HYD_BSCI_query_node_list(num_nodes, proxy_list);
+ status = HYDT_bsci_query_node_list(num_nodes, proxy_list);
HYDU_ERR_POP(status, "bootstrap device returned error while querying node list\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/tools/bind/bind.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bind/bind.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bind/bind.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -12,25 +12,25 @@
#include "plpa/bind_plpa.h"
#endif /* HAVE_PLPA */
-struct HYDU_bind_info HYDU_bind_info;
+struct HYDT_bind_info HYDT_bind_info;
-HYD_Status HYDU_bind_init(char *binding, char *bindlib)
+HYD_status HYDT_bind_init(char *binding, char *bindlib)
{
char *bindstr, *bindentry;
int sock, core, thread, i, j;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_bind_info.support_level = HYDU_BIND_NONE;
- HYDU_bind_info.topology = NULL;
- HYDU_bind_info.bindlib = HYDU_strdup(bindlib);
+ HYDT_bind_info.support_level = HYDT_BIND_NONE;
+ HYDT_bind_info.topology = NULL;
+ HYDT_bind_info.bindlib = HYDU_strdup(bindlib);
if (!binding || !strcmp(binding, "none")) {
/* If no binding is given, we just set all mappings to -1 */
- HYDU_MALLOC(HYDU_bind_info.bindmap, int *, sizeof(int), status);
- HYDU_bind_info.num_procs = 1;
- HYDU_bind_info.bindmap[0] = -1;
+ HYDU_MALLOC(HYDT_bind_info.bindmap, int *, sizeof(int), status);
+ HYDT_bind_info.num_procs = 1;
+ HYDT_bind_info.bindmap[0] = -1;
goto fn_exit;
}
@@ -41,20 +41,20 @@
bindstr = HYDU_strdup(binding + strlen("user:"));
/* Find the number of processing elements */
- HYDU_bind_info.num_procs = 0;
+ HYDT_bind_info.num_procs = 0;
bindentry = strtok(bindstr, ",");
while (bindentry) {
- HYDU_bind_info.num_procs++;
+ HYDT_bind_info.num_procs++;
bindentry = strtok(NULL, ",");
}
/* Find the actual processing elements */
- HYDU_MALLOC(HYDU_bind_info.bindmap, int *, HYDU_bind_info.num_procs * sizeof(int),
+ HYDU_MALLOC(HYDT_bind_info.bindmap, int *, HYDT_bind_info.num_procs * sizeof(int),
status);
i = 0;
bindentry = strtok(bindstr, ",");
while (bindentry) {
- HYDU_bind_info.bindmap[i++] = atoi(bindentry);
+ HYDT_bind_info.bindmap[i++] = atoi(bindentry);
bindentry = strtok(NULL, ",");
}
@@ -64,55 +64,55 @@
/* If a real binding is required, we initialize the binding
* library requested by the user */
#if defined HAVE_PLPA
- if (!strcmp(HYDU_bind_info.bindlib, "plpa")) {
- status = HYDU_bind_plpa_init(&HYDU_bind_info.support_level);
+ if (!strcmp(HYDT_bind_info.bindlib, "plpa")) {
+ status = HYDT_bind_plpa_init(&HYDT_bind_info.support_level);
HYDU_ERR_POP(status, "unable to initialize plpa\n");
}
#endif /* HAVE_PLPA */
- if (HYDU_bind_info.support_level != HYDU_BIND_NONE) {
- HYDU_MALLOC(HYDU_bind_info.bindmap, int *, HYDU_bind_info.num_procs * sizeof(int),
+ if (HYDT_bind_info.support_level != HYDT_BIND_NONE) {
+ HYDU_MALLOC(HYDT_bind_info.bindmap, int *, HYDT_bind_info.num_procs * sizeof(int),
status);
- for (i = 0; i < HYDU_bind_info.num_procs; i++) {
+ for (i = 0; i < HYDT_bind_info.num_procs; i++) {
/* RR is supported at the basic binding level */
if (!strcmp(binding, "rr")) {
- HYDU_bind_info.bindmap[i] = i;
+ HYDT_bind_info.bindmap[i] = i;
continue;
}
/* If we reached here, the user requested for topology
* aware binding. */
- if (HYDU_bind_info.support_level != HYDU_BIND_TOPO)
+ if (HYDT_bind_info.support_level != HYDT_BIND_TOPO)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
"topology binding not supported on this platform\n");
if (!strcmp(binding, "buddy")) {
- thread = i / (HYDU_bind_info.num_sockets * HYDU_bind_info.num_cores);
+ thread = i / (HYDT_bind_info.num_sockets * HYDT_bind_info.num_cores);
- core = i % (HYDU_bind_info.num_sockets * HYDU_bind_info.num_cores);
- core /= HYDU_bind_info.num_sockets;
+ core = i % (HYDT_bind_info.num_sockets * HYDT_bind_info.num_cores);
+ core /= HYDT_bind_info.num_sockets;
- sock = i % HYDU_bind_info.num_sockets;
+ sock = i % HYDT_bind_info.num_sockets;
}
else if (!strcmp(binding, "pack")) {
- sock = i / (HYDU_bind_info.num_cores * HYDU_bind_info.num_threads);
+ sock = i / (HYDT_bind_info.num_cores * HYDT_bind_info.num_threads);
- core = i % (HYDU_bind_info.num_cores * HYDU_bind_info.num_threads);
- core /= HYDU_bind_info.num_threads;
+ core = i % (HYDT_bind_info.num_cores * HYDT_bind_info.num_threads);
+ core /= HYDT_bind_info.num_threads;
- thread = i % HYDU_bind_info.num_threads;
+ thread = i % HYDT_bind_info.num_threads;
}
else {
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "unknown binding option\n");
}
- for (j = 0; j < HYDU_bind_info.num_procs; j++) {
- if (HYDU_bind_info.topology[j].socket_rank == sock &&
- HYDU_bind_info.topology[j].core_rank == core &&
- HYDU_bind_info.topology[j].thread_rank == thread) {
- HYDU_bind_info.bindmap[i] = HYDU_bind_info.topology[j].processor_id;
+ for (j = 0; j < HYDT_bind_info.num_procs; j++) {
+ if (HYDT_bind_info.topology[j].socket_rank == sock &&
+ HYDT_bind_info.topology[j].core_rank == core &&
+ HYDT_bind_info.topology[j].thread_rank == thread) {
+ HYDT_bind_info.bindmap[i] = HYDT_bind_info.topology[j].processor_id;
break;
}
}
@@ -120,9 +120,9 @@
}
else {
/* If no binding is supported, we just set all mappings to -1 */
- HYDU_MALLOC(HYDU_bind_info.bindmap, int *, sizeof(int), status);
- HYDU_bind_info.num_procs = 1;
- HYDU_bind_info.bindmap[0] = -1;
+ HYDU_MALLOC(HYDT_bind_info.bindmap, int *, sizeof(int), status);
+ HYDT_bind_info.num_procs = 1;
+ HYDT_bind_info.bindmap[0] = -1;
}
fn_exit:
@@ -133,27 +133,27 @@
goto fn_exit;
}
-void HYDU_bind_finalize(void)
+void HYDT_bind_finalize(void)
{
- if (HYDU_bind_info.bindmap)
- HYDU_FREE(HYDU_bind_info.bindmap);
+ if (HYDT_bind_info.bindmap)
+ HYDU_FREE(HYDT_bind_info.bindmap);
- if (HYDU_bind_info.bindlib)
- HYDU_FREE(HYDU_bind_info.bindlib);
+ if (HYDT_bind_info.bindlib)
+ HYDU_FREE(HYDT_bind_info.bindlib);
- if (HYDU_bind_info.topology)
- HYDU_FREE(HYDU_bind_info.topology);
+ if (HYDT_bind_info.topology)
+ HYDU_FREE(HYDT_bind_info.topology);
}
-HYD_Status HYDU_bind_process(int core)
+HYD_status HYDT_bind_process(int core)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
#if defined HAVE_PLPA
- if (!strcmp(HYDU_bind_info.bindlib, "plpa")) {
- status = HYDU_bind_plpa_process(core);
+ if (!strcmp(HYDT_bind_info.bindlib, "plpa")) {
+ status = HYDT_bind_plpa_process(core);
HYDU_ERR_POP(status, "PLPA failure binding process to core\n");
}
#endif /* HAVE_PLPA */
@@ -167,7 +167,7 @@
}
-int HYDU_bind_get_core_id(int id)
+int HYDT_bind_get_core_id(int id)
{
- return HYDU_bind_info.bindmap[id % HYDU_bind_info.num_procs];
+ return HYDT_bind_info.bindmap[id % HYDT_bind_info.num_procs];
}
Modified: mpich2/trunk/src/pm/hydra/tools/bind/bind.h
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bind/bind.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bind/bind.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -10,13 +10,13 @@
#include "hydra_utils.h"
typedef enum {
- HYDU_BIND_NONE = 0,
- HYDU_BIND_BASIC,
- HYDU_BIND_TOPO
-} HYDU_bind_support_level_t;
+ HYDT_BIND_NONE = 0,
+ HYDT_BIND_BASIC,
+ HYDT_BIND_TOPO
+} HYDT_bind_support_level_t;
-struct HYDU_bind_info {
- HYDU_bind_support_level_t support_level;
+struct HYDT_bind_info {
+ HYDT_bind_support_level_t support_level;
int num_procs;
int num_sockets;
@@ -26,7 +26,7 @@
int *bindmap;
char *bindlib;
- struct HYDU_topology {
+ struct HYDT_topology {
int processor_id;
int socket_rank;
@@ -40,6 +40,6 @@
} *topology;
};
-extern struct HYDU_bind_info HYDU_bind_info;
+extern struct HYDT_bind_info HYDT_bind_info;
#endif /* BIND_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/tools/bind/plpa/bind_plpa.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bind/plpa/bind_plpa.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bind/plpa/bind_plpa.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,132 +8,132 @@
#include "bind.h"
#include "bind_plpa.h"
-struct HYDU_bind_info HYDU_bind_info;
+struct HYDT_bind_info HYDT_bind_info;
#include "plpa.h"
#include "plpa_internal.h"
-HYD_Status HYDU_bind_plpa_init(HYDU_bind_support_level_t * support_level)
+HYD_status HYDT_bind_plpa_init(HYDT_bind_support_level_t * support_level)
{
PLPA_NAME(api_type_t) p;
int ret, i, j, max, id;
int processor, sock, core, thread;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
if (!((PLPA_NAME(api_probe) (&p) == 0) && (p == PLPA_NAME_CAPS(PROBE_OK)))) {
/* If this failed, we just return without binding */
- HYDU_Warn_printf("plpa api runtime probe failed\n");
+ HYDU_warn_printf("plpa api runtime probe failed\n");
goto fn_fail;
}
/* Find the maximum number of processing elements */
ret = PLPA_NAME(get_processor_data) (PLPA_NAME_CAPS(COUNT_ONLINE),
- &HYDU_bind_info.num_procs, &max);
+ &HYDT_bind_info.num_procs, &max);
if (ret) {
/* Unable to get number of processors */
- HYDU_Warn_printf("plpa get processor data failed\n");
+ HYDU_warn_printf("plpa get processor data failed\n");
goto fn_fail;
}
- HYDU_MALLOC(HYDU_bind_info.topology, struct HYDU_topology *,
- HYDU_bind_info.num_procs * sizeof(struct HYDU_topology), status);
- for (i = 0; i < HYDU_bind_info.num_procs; i++) {
- HYDU_bind_info.topology[i].processor_id = -1;
- HYDU_bind_info.topology[i].socket_rank = -1;
- HYDU_bind_info.topology[i].socket_id = -1;
- HYDU_bind_info.topology[i].core_rank = -1;
- HYDU_bind_info.topology[i].core_id = -1;
- HYDU_bind_info.topology[i].thread_rank = -1;
- HYDU_bind_info.topology[i].thread_id = -1;
+ HYDU_MALLOC(HYDT_bind_info.topology, struct HYDT_topology *,
+ HYDT_bind_info.num_procs * sizeof(struct HYDT_topology), status);
+ for (i = 0; i < HYDT_bind_info.num_procs; i++) {
+ HYDT_bind_info.topology[i].processor_id = -1;
+ HYDT_bind_info.topology[i].socket_rank = -1;
+ HYDT_bind_info.topology[i].socket_id = -1;
+ HYDT_bind_info.topology[i].core_rank = -1;
+ HYDT_bind_info.topology[i].core_id = -1;
+ HYDT_bind_info.topology[i].thread_rank = -1;
+ HYDT_bind_info.topology[i].thread_id = -1;
}
- for (i = 0; i < HYDU_bind_info.num_procs; i++) {
+ for (i = 0; i < HYDT_bind_info.num_procs; i++) {
ret = PLPA_NAME(get_processor_id) (i, PLPA_NAME_CAPS(COUNT_ALL), &processor);
if (ret) {
/* Unable to get processor ID */
- HYDU_Warn_printf("plpa get processor id failed\n");
- if (HYDU_bind_info.topology)
- HYDU_FREE(HYDU_bind_info.topology);
+ HYDU_warn_printf("plpa get processor id failed\n");
+ if (HYDT_bind_info.topology)
+ HYDU_FREE(HYDT_bind_info.topology);
goto fn_fail;
}
- HYDU_bind_info.topology[i].processor_id = processor;
+ HYDT_bind_info.topology[i].processor_id = processor;
}
/* We have qualified for basic binding support level */
- *support_level = HYDU_BIND_BASIC;
+ *support_level = HYDT_BIND_BASIC;
/* PLPA only gives information about sockets and cores */
- ret = PLPA_NAME(get_socket_info) (&HYDU_bind_info.num_sockets, &max);
+ ret = PLPA_NAME(get_socket_info) (&HYDT_bind_info.num_sockets, &max);
if (ret) {
/* Unable to get number of sockets */
- HYDU_Warn_printf("plpa get socket info failed\n");
+ HYDU_warn_printf("plpa get socket info failed\n");
goto fn_fail;
}
- ret = PLPA_NAME(get_core_info) (0, &HYDU_bind_info.num_cores, &max);
+ ret = PLPA_NAME(get_core_info) (0, &HYDT_bind_info.num_cores, &max);
if (ret) {
/* Unable to get number of cores */
- HYDU_Warn_printf("plpa get core info failed\n");
+ HYDU_warn_printf("plpa get core info failed\n");
goto fn_fail;
}
- HYDU_bind_info.num_threads = HYDU_bind_info.num_procs /
- (HYDU_bind_info.num_sockets * HYDU_bind_info.num_cores);
+ HYDT_bind_info.num_threads = HYDT_bind_info.num_procs /
+ (HYDT_bind_info.num_sockets * HYDT_bind_info.num_cores);
/* Find the socket and core IDs for all processor IDs */
- for (i = 0; i < HYDU_bind_info.num_procs; i++) {
- ret = PLPA_NAME(map_to_socket_core) (HYDU_bind_info.topology[i].processor_id,
+ for (i = 0; i < HYDT_bind_info.num_procs; i++) {
+ ret = PLPA_NAME(map_to_socket_core) (HYDT_bind_info.topology[i].processor_id,
&sock, &core);
if (ret) {
/* Unable to get number of cores */
- HYDU_Warn_printf("plpa unable to map socket to core\n");
+ HYDU_warn_printf("plpa unable to map socket to core\n");
goto fn_fail;
}
- HYDU_bind_info.topology[i].socket_id = sock;
- HYDU_bind_info.topology[i].core_id = core;
+ HYDT_bind_info.topology[i].socket_id = sock;
+ HYDT_bind_info.topology[i].core_id = core;
thread = -1;
for (j = 0; j < i; j++)
- if (HYDU_bind_info.topology[j].socket_id == sock &&
- HYDU_bind_info.topology[j].core_id == core)
- thread = HYDU_bind_info.topology[j].thread_id;
+ if (HYDT_bind_info.topology[j].socket_id == sock &&
+ HYDT_bind_info.topology[j].core_id == core)
+ thread = HYDT_bind_info.topology[j].thread_id;
thread++;
- HYDU_bind_info.topology[i].thread_id = thread;
- HYDU_bind_info.topology[i].thread_rank = thread;
+ HYDT_bind_info.topology[i].thread_id = thread;
+ HYDT_bind_info.topology[i].thread_rank = thread;
}
/* Find the rank of each socket ID */
- for (i = 0; i < HYDU_bind_info.num_sockets; i++) {
+ for (i = 0; i < HYDT_bind_info.num_sockets; i++) {
ret = PLPA_NAME(get_socket_id) (i, &id);
if (ret) {
/* Unable to get socket id */
- HYDU_Warn_printf("plpa unable to get socket id\n");
+ HYDU_warn_printf("plpa unable to get socket id\n");
goto fn_fail;
}
- for (j = 0; j < HYDU_bind_info.num_procs; j++)
- if (HYDU_bind_info.topology[j].socket_id == id)
- HYDU_bind_info.topology[j].socket_rank = i;
+ for (j = 0; j < HYDT_bind_info.num_procs; j++)
+ if (HYDT_bind_info.topology[j].socket_id == id)
+ HYDT_bind_info.topology[j].socket_rank = i;
}
/* Find the rank of each core ID */
- for (i = 0; i < HYDU_bind_info.num_cores; i++) {
- ret = PLPA_NAME(get_core_id) (HYDU_bind_info.topology[0].socket_id, i, &id);
+ for (i = 0; i < HYDT_bind_info.num_cores; i++) {
+ ret = PLPA_NAME(get_core_id) (HYDT_bind_info.topology[0].socket_id, i, &id);
if (ret) {
/* Unable to get socket id */
- HYDU_Warn_printf("plpa unable to get socket id\n");
+ HYDU_warn_printf("plpa unable to get socket id\n");
goto fn_fail;
}
- for (j = 0; j < HYDU_bind_info.num_procs; j++)
- if (HYDU_bind_info.topology[j].core_id == id)
- HYDU_bind_info.topology[j].core_rank = i;
+ for (j = 0; j < HYDT_bind_info.num_procs; j++)
+ if (HYDT_bind_info.topology[j].core_id == id)
+ HYDT_bind_info.topology[j].core_rank = i;
}
/* We have qualified for topology-aware binding support level */
- *support_level = HYDU_BIND_TOPO;
+ *support_level = HYDT_BIND_TOPO;
fn_exit:
HYDU_FUNC_EXIT();
@@ -143,11 +143,11 @@
goto fn_exit;
}
-HYD_Status HYDU_bind_plpa_process(int core)
+HYD_status HYDT_bind_plpa_process(int core)
{
int ret;
PLPA_NAME(cpu_set_t) cpuset;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -156,7 +156,7 @@
goto fn_exit;
PLPA_NAME_CAPS(CPU_ZERO) (&cpuset);
- PLPA_NAME_CAPS(CPU_SET) (core % HYDU_bind_info.num_procs, &cpuset);
+ PLPA_NAME_CAPS(CPU_SET) (core % HYDT_bind_info.num_procs, &cpuset);
ret = PLPA_NAME(sched_setaffinity) (0, 1, &cpuset);
if (ret)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "plpa setaffinity failed\n");
Modified: mpich2/trunk/src/pm/hydra/tools/bind/plpa/bind_plpa.h
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bind/plpa/bind_plpa.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bind/plpa/bind_plpa.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -7,7 +7,7 @@
#ifndef BIND_PLPA_H_INCLUDED
#define BIND_PLPA_H_INCLUDED
-HYD_Status HYDU_bind_plpa_init(HYDU_bind_support_level_t * support_level);
-HYD_Status HYDU_bind_plpa_process(int core);
+HYD_status HYDT_bind_plpa_init(HYDT_bind_support_level_t * support_level);
+HYD_status HYDT_bind_plpa_process(int core);
#endif /* BIND_PLPA_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/fork/fork.h
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/fork/fork.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/fork/fork.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,7 +9,7 @@
#include "hydra_base.h"
-HYD_Status HYD_BSCD_fork_launch_procs(char **global_args, const char *proxy_id_str,
- struct HYD_Proxy *proxy_list);
+HYD_status HYDT_bscd_fork_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_proxy *proxy_list);
#endif /* FORK_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/fork/fork_init.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/fork/fork_init.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/fork/fork_init.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,13 +8,13 @@
#include "bsci.h"
#include "fork.h"
-HYD_Status HYD_BSCI_fork_init(void)
+HYD_status HYDT_bsci_fork_init(void)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYD_BSCI_fns.launch_procs = HYD_BSCD_fork_launch_procs;
+ HYDT_bsci_fns.launch_procs = HYDT_bscd_fork_launch_procs;
HYDU_FUNC_EXIT();
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/fork/fork_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/fork/fork_launch.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/fork/fork_launch.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,13 +9,13 @@
#include "bscu.h"
#include "fork.h"
-HYD_Status HYD_BSCD_fork_launch_procs(char **global_args, const char *proxy_id_str,
- struct HYD_Proxy *proxy_list)
+HYD_status HYDT_bscd_fork_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_proxy *proxy_list)
{
- struct HYD_Proxy *proxy;
+ struct HYD_proxy *proxy;
char *client_arg[HYD_NUM_TMP_STRINGS];
int i, arg, process_id;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -34,7 +34,7 @@
client_arg[arg++] = NULL;
- if (HYD_BSCI_info.debug) {
+ if (HYDT_bsci_info.debug) {
HYDU_dump(stdout, "Launching process: ");
HYDU_print_strlist(client_arg);
}
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/include/bsci.h.in
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/include/bsci.h.in 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/include/bsci.h.in 2009-10-16 04:24:58 UTC (rev 5472)
@@ -7,36 +7,36 @@
#ifndef BSCI_H_INCLUDED
#define BSCI_H_INCLUDED
-struct HYD_BSCI_info {
+struct HYDT_bsci_info {
char *bootstrap_exec;
int enablex;
int debug;
};
-struct HYD_BSCI_fns {
- HYD_Status(*launch_procs) (char **global_args, const char *proxy_id_str,
- struct HYD_Proxy *proxy_list);
- HYD_Status(*finalize) (void);
- HYD_Status(*wait_for_completion) (struct HYD_Proxy *proxy_list);
- HYD_Status(*query_node_list) (int *num_nodes, struct HYD_Proxy **proxy_list);
- HYD_Status(*query_usize) (int *size);
- HYD_Status(*query_proxy_id) (int *proxy_id);
+struct HYDT_bsci_fns {
+ HYD_status(*launch_procs) (char **global_args, const char *proxy_id_str,
+ struct HYD_proxy *proxy_list);
+ HYD_status(*finalize) (void);
+ HYD_status(*wait_for_completion) (struct HYD_proxy *proxy_list);
+ HYD_status(*query_node_list) (int *num_nodes, struct HYD_proxy **proxy_list);
+ HYD_status(*query_usize) (int *size);
+ HYD_status(*query_proxy_id) (int *proxy_id);
};
-extern struct HYD_BSCI_fns HYD_BSCI_fns;
+extern struct HYDT_bsci_fns HYDT_bsci_fns;
-HYD_Status HYD_BSCI_init(char *bootstrap, char *bootstrap_exec, int enablex, int debug);
-HYD_Status HYD_BSCI_launch_procs(char **global_args, const char *proxy_id_str,
- struct HYD_Proxy *proxy_list);
-HYD_Status HYD_BSCI_finalize(void);
-HYD_Status HYD_BSCI_wait_for_completion(struct HYD_Proxy *proxy_list);
-HYD_Status HYD_BSCI_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list);
-HYD_Status HYD_BSCI_query_usize(int *size);
-HYD_Status HYD_BSCI_query_proxy_id(int *proxy_id);
+HYD_status HYDT_bsci_init(char *bootstrap, char *bootstrap_exec, int enablex, int debug);
+HYD_status HYDT_bsci_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_proxy *proxy_list);
+HYD_status HYDT_bsci_finalize(void);
+HYD_status HYDT_bsci_wait_for_completion(struct HYD_proxy *proxy_list);
+HYD_status HYDT_bsci_query_node_list(int *num_nodes, struct HYD_proxy **proxy_list);
+HYD_status HYDT_bsci_query_usize(int *size);
+HYD_status HYDT_bsci_query_proxy_id(int *proxy_id);
/* Each bootstrap server has to expose an initialization function */
@hydra_bss_init_decl@
-extern struct HYD_BSCI_info HYD_BSCI_info;
+extern struct HYDT_bsci_info HYDT_bsci_info;
#endif /* BSCI_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/rsh/rsh.h
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/rsh/rsh.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/rsh/rsh.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,7 +9,7 @@
#include "hydra_base.h"
-HYD_Status HYD_BSCD_rsh_launch_procs(char **global_args, const char *proxy_id_str,
- struct HYD_Proxy *proxy_list);
+HYD_status HYDT_bscd_rsh_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_proxy *proxy_list);
#endif /* RSH_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/rsh/rsh_init.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/rsh/rsh_init.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/rsh/rsh_init.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,13 +8,13 @@
#include "bsci.h"
#include "rsh.h"
-HYD_Status HYD_BSCI_rsh_init(void)
+HYD_status HYDT_bsci_rsh_init(void)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYD_BSCI_fns.launch_procs = HYD_BSCD_rsh_launch_procs;
+ HYDT_bsci_fns.launch_procs = HYDT_bscd_rsh_launch_procs;
HYDU_FUNC_EXIT();
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/rsh/rsh_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/rsh/rsh_launch.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/rsh/rsh_launch.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -10,19 +10,19 @@
#include "rsh.h"
/*
- * HYD_BSCD_rsh_launch_procs: For each process, we create an
+ * HYDT_bscd_rsh_launch_procs: For each process, we create an
* executable which reads like "rsh exec args" and the list of
* environment variables. We fork a worker process that sets the
* environment and execvp's this executable.
*/
-HYD_Status HYD_BSCD_rsh_launch_procs(char **global_args, const char *proxy_id_str,
- struct HYD_Proxy *proxy_list)
+HYD_status HYDT_bscd_rsh_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_proxy *proxy_list)
{
- struct HYD_Proxy *proxy;
+ struct HYD_proxy *proxy;
char *client_arg[HYD_NUM_TMP_STRINGS];
char *tmp[HYD_NUM_TMP_STRINGS], *path = NULL, *test_path = NULL;
int i, arg, process_id;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -32,8 +32,8 @@
* 2. Search in path
* 3. Hard-coded location
*/
- if (HYD_BSCI_info.bootstrap_exec) {
- path = HYDU_strdup(HYD_BSCI_info.bootstrap_exec);
+ if (HYDT_bsci_info.bootstrap_exec) {
+ path = HYDU_strdup(HYDT_bsci_info.bootstrap_exec);
}
else {
status = HYDU_find_in_path("rsh", &test_path);
@@ -71,7 +71,7 @@
client_arg[arg++] = NULL;
- if (HYD_BSCI_info.debug) {
+ if (HYDT_bsci_info.debug) {
HYDU_dump(stdout, "Launching process: ");
HYDU_print_strlist(client_arg);
}
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm.h
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,9 +9,9 @@
#include "hydra_base.h"
-HYD_Status HYD_BSCD_slurm_launch_procs(char **global_args, const char *proxy_id_str,
- struct HYD_Proxy *proxy_list);
-HYD_Status HYD_BSCD_slurm_query_proxy_id(int *proxy_id);
-HYD_Status HYD_BSCD_slurm_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list);
+HYD_status HYDT_bscd_slurm_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_proxy *proxy_list);
+HYD_status HYDT_bscd_slurm_query_proxy_id(int *proxy_id);
+HYD_status HYDT_bscd_slurm_query_node_list(int *num_nodes, struct HYD_proxy **proxy_list);
#endif /* SLURM_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_init.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_init.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_init.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,15 +8,15 @@
#include "bsci.h"
#include "slurm.h"
-HYD_Status HYD_BSCI_slurm_init(void)
+HYD_status HYDT_bsci_slurm_init(void)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYD_BSCI_fns.launch_procs = HYD_BSCD_slurm_launch_procs;
- HYD_BSCI_fns.query_proxy_id = HYD_BSCD_slurm_query_proxy_id;
- HYD_BSCI_fns.query_node_list = HYD_BSCD_slurm_query_node_list;
+ HYDT_bsci_fns.launch_procs = HYDT_bscd_slurm_launch_procs;
+ HYDT_bsci_fns.query_proxy_id = HYDT_bscd_slurm_query_proxy_id;
+ HYDT_bsci_fns.query_node_list = HYDT_bscd_slurm_query_node_list;
HYDU_FUNC_EXIT();
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_launch.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_launch.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,14 +9,14 @@
#include "bscu.h"
#include "slurm.h"
-HYD_Status HYD_BSCD_slurm_launch_procs(char **global_args, const char *proxy_id_str,
- struct HYD_Proxy *proxy_list)
+HYD_status HYDT_bscd_slurm_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_proxy *proxy_list)
{
- struct HYD_Proxy *proxy;
+ struct HYD_proxy *proxy;
char *client_arg[HYD_NUM_TMP_STRINGS];
char *tmp[HYD_NUM_TMP_STRINGS], *path = NULL, *test_path = NULL;
int i, arg, num_nodes;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -26,8 +26,8 @@
* 2. Search in path
* 3. Hard-coded location
*/
- if (HYD_BSCI_info.bootstrap_exec) {
- path = HYDU_strdup(HYD_BSCI_info.bootstrap_exec);
+ if (HYDT_bsci_info.bootstrap_exec) {
+ path = HYDU_strdup(HYDT_bsci_info.bootstrap_exec);
}
else {
status = HYDU_find_in_path("srun", &test_path);
@@ -89,7 +89,7 @@
client_arg[arg++] = NULL;
- if (HYD_BSCI_info.debug) {
+ if (HYDT_bsci_info.debug) {
HYDU_dump(stdout, "Launching process: ");
HYDU_print_strlist(client_arg);
}
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_query_node_list.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_query_node_list.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_query_node_list.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -43,13 +43,13 @@
list[arg++] = NULL;
}
-static HYD_Status group_to_individual_nodes(char *str, char **list)
+static HYD_status group_to_individual_nodes(char *str, char **list)
{
char *pre = NULL, *nodes = NULL, *tmp;
int start_node, end_node;
char new[MAX_HOSTNAME_LEN], *node_str[MAX_HOSTNAME_LEN];
int arg, i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
tmp = str;
i = 0;
@@ -99,12 +99,12 @@
goto fn_exit;
}
-HYD_Status HYD_BSCD_slurm_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list)
+HYD_status HYDT_bscd_slurm_query_node_list(int *num_nodes, struct HYD_proxy **proxy_list)
{
char *str, *num_procs;
char *tmp1[HYD_NUM_TMP_STRINGS], *tmp2[HYD_NUM_TMP_STRINGS];
int i, j;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_query_proxy_id.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_query_proxy_id.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/slurm/slurm_query_proxy_id.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,9 +9,9 @@
#include "bscu.h"
#include "slurm.h"
-HYD_Status HYD_BSCD_slurm_query_proxy_id(int *proxy_id)
+HYD_status HYDT_bscd_slurm_query_proxy_id(int *proxy_id)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_finalize.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_finalize.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_finalize.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,13 +8,13 @@
#include "bsci.h"
#include "bscu.h"
-HYD_Status HYD_BSCI_finalize(void)
+HYD_status HYDT_bsci_finalize(void)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_BSCI_fns.finalize();
+ status = HYDT_bsci_fns.finalize();
HYDU_ERR_POP(status, "bootstrap device returned error while finalizing\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_init.c.in
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_init.c.in 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_init.c.in 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,50 +8,50 @@
#include "bsci.h"
#include "bscu.h"
-struct HYD_BSCI_fns HYD_BSCI_fns = { 0 };
-const char *HYD_BSCI_comp_array[] = { @hydra_bss_name_array@ };
-HYD_Status(*HYD_BSCI_comp_init[])(void) = { @hydra_bss_init_array@ };
-struct HYD_BSCI_info HYD_BSCI_info = { 0 };
+struct HYDT_bsci_fns HYDT_bsci_fns = { 0 };
+const char *HYDT_bsci_comp_array[] = { @hydra_bss_name_array@ };
+HYD_status(*HYDT_bsci_comp_init[])(void) = { @hydra_bss_init_array@ };
+struct HYDT_bsci_info HYDT_bsci_info = { 0 };
-HYD_Status HYD_BSCI_init(char *bootstrap, char *bootstrap_exec, int enablex, int debug)
+HYD_status HYDT_bsci_init(char *bootstrap, char *bootstrap_exec, int enablex, int debug)
{
int i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- for (i = 0; HYD_BSCI_comp_array[i]; i++) {
- if (!strcmp(bootstrap, HYD_BSCI_comp_array[i])) {
- status = (*HYD_BSCI_comp_init[i])();
+ for (i = 0; HYDT_bsci_comp_array[i]; i++) {
+ if (!strcmp(bootstrap, HYDT_bsci_comp_array[i])) {
+ status = (*HYDT_bsci_comp_init[i])();
HYDU_ERR_POP(status, "bootstrap device returned error initializing\n");
break;
}
}
/* Set the appropriate info */
- HYD_BSCI_info.bootstrap_exec = bootstrap_exec;
- HYD_BSCI_info.enablex = enablex;
- HYD_BSCI_info.debug = debug;
+ HYDT_bsci_info.bootstrap_exec = bootstrap_exec;
+ HYDT_bsci_info.enablex = enablex;
+ HYDT_bsci_info.debug = debug;
- if (HYD_BSCI_comp_array[i] == NULL)
+ if (HYDT_bsci_comp_array[i] == NULL)
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
"unrecognized bootstrap server: %s\n", bootstrap);
/* This function is mandatory */
- if (HYD_BSCI_fns.launch_procs == NULL)
+ if (HYDT_bsci_fns.launch_procs == NULL)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
"mandatory bootstrap launch function undefined\n");
- if (HYD_BSCI_fns.finalize == NULL)
- HYD_BSCI_fns.finalize = HYD_BSCU_finalize;
- if (HYD_BSCI_fns.wait_for_completion == NULL)
- HYD_BSCI_fns.wait_for_completion = HYD_BSCU_wait_for_completion;
- if (HYD_BSCI_fns.query_node_list == NULL)
- HYD_BSCI_fns.query_node_list = HYD_BSCU_query_node_list;
- if (HYD_BSCI_fns.query_usize == NULL)
- HYD_BSCI_fns.query_usize = HYD_BSCU_query_usize;
- if (HYD_BSCI_fns.query_proxy_id == NULL)
- HYD_BSCI_fns.query_proxy_id = HYD_BSCU_query_proxy_id;
+ if (HYDT_bsci_fns.finalize == NULL)
+ HYDT_bsci_fns.finalize = HYDT_bscu_finalize;
+ if (HYDT_bsci_fns.wait_for_completion == NULL)
+ HYDT_bsci_fns.wait_for_completion = HYDT_bscu_wait_for_completion;
+ if (HYDT_bsci_fns.query_node_list == NULL)
+ HYDT_bsci_fns.query_node_list = HYDT_bscu_query_node_list;
+ if (HYDT_bsci_fns.query_usize == NULL)
+ HYDT_bsci_fns.query_usize = HYDT_bscu_query_usize;
+ if (HYDT_bsci_fns.query_proxy_id == NULL)
+ HYDT_bsci_fns.query_proxy_id = HYDT_bscu_query_proxy_id;
fn_exit:
HYDU_FUNC_EXIT();
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_launch.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_launch.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -7,14 +7,14 @@
#include "hydra_utils.h"
#include "bsci.h"
-HYD_Status HYD_BSCI_launch_procs(char **global_args, const char *proxy_id_str,
- struct HYD_Proxy *proxy_list)
+HYD_status HYDT_bsci_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_proxy *proxy_list)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_BSCI_fns.launch_procs(global_args, proxy_id_str, proxy_list);
+ status = HYDT_bsci_fns.launch_procs(global_args, proxy_id_str, proxy_list);
HYDU_ERR_POP(status, "bootstrap device returned error while launching processes\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_query_node_list.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_query_node_list.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_query_node_list.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,13 +8,13 @@
#include "bsci.h"
#include "bscu.h"
-HYD_Status HYD_BSCI_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list)
+HYD_status HYDT_bsci_query_node_list(int *num_nodes, struct HYD_proxy **proxy_list)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_BSCI_fns.query_node_list(num_nodes, proxy_list);
+ status = HYDT_bsci_fns.query_node_list(num_nodes, proxy_list);
HYDU_ERR_POP(status, "bootstrap device returned error while querying node list\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_query_proxy_id.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_query_proxy_id.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_query_proxy_id.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,13 +8,13 @@
#include "bsci.h"
#include "bscu.h"
-HYD_Status HYD_BSCI_query_proxy_id(int *proxy_id)
+HYD_status HYDT_bsci_query_proxy_id(int *proxy_id)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_BSCI_fns.query_proxy_id(proxy_id);
+ status = HYDT_bsci_fns.query_proxy_id(proxy_id);
HYDU_ERR_POP(status, "bootstrap device returned error while querying proxy ID\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_usize.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_usize.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_usize.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,13 +8,13 @@
#include "bsci.h"
#include "bscu.h"
-HYD_Status HYD_BSCI_query_usize(int *size)
+HYD_status HYDT_bsci_query_usize(int *size)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_BSCI_fns.query_usize(size);
+ status = HYDT_bsci_fns.query_usize(size);
HYDU_ERR_POP(status, "bootstrap device returned error querying usize\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_wait.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_wait.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/src/bsci_wait.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,13 +8,13 @@
#include "bsci.h"
#include "bscu.h"
-HYD_Status HYD_BSCI_wait_for_completion(struct HYD_Proxy *proxy_list)
+HYD_status HYDT_bsci_wait_for_completion(struct HYD_proxy *proxy_list)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_BSCI_fns.wait_for_completion(proxy_list);
+ status = HYDT_bsci_fns.wait_for_completion(proxy_list);
HYDU_ERR_POP(status, "bootstrap device returned error waiting for completion\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/ssh/ssh.h
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/ssh/ssh.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/ssh/ssh.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,7 +9,7 @@
#include "hydra_base.h"
-HYD_Status HYD_BSCD_ssh_launch_procs(char **global_args, const char *proxy_id_str,
- struct HYD_Proxy *proxy_list);
+HYD_status HYDT_bscd_ssh_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_proxy *proxy_list);
#endif /* SSH_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/ssh/ssh_init.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/ssh/ssh_init.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/ssh/ssh_init.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,13 +8,13 @@
#include "bsci.h"
#include "ssh.h"
-HYD_Status HYD_BSCI_ssh_init(void)
+HYD_status HYDT_bsci_ssh_init(void)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYD_BSCI_fns.launch_procs = HYD_BSCD_ssh_launch_procs;
+ HYDT_bsci_fns.launch_procs = HYDT_bscd_ssh_launch_procs;
HYDU_FUNC_EXIT();
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/ssh/ssh_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/ssh/ssh_launch.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/ssh/ssh_launch.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -10,19 +10,19 @@
#include "ssh.h"
/*
- * HYD_BSCD_ssh_launch_procs: For each process, we create an
+ * HYDT_bscd_ssh_launch_procs: For each process, we create an
* executable which reads like "ssh exec args" and the list of
* environment variables. We fork a worker process that sets the
* environment and execvp's this executable.
*/
-HYD_Status HYD_BSCD_ssh_launch_procs(char **global_args, const char *proxy_id_str,
- struct HYD_Proxy *proxy_list)
+HYD_status HYDT_bscd_ssh_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_proxy *proxy_list)
{
- struct HYD_Proxy *proxy;
+ struct HYD_proxy *proxy;
char *client_arg[HYD_NUM_TMP_STRINGS];
char *tmp[HYD_NUM_TMP_STRINGS], *path = NULL, *test_path = NULL;
int i, arg, process_id;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -32,8 +32,8 @@
* 2. Search in path
* 3. Hard-coded location
*/
- if (HYD_BSCI_info.bootstrap_exec) {
- path = HYDU_strdup(HYD_BSCI_info.bootstrap_exec);
+ if (HYDT_bsci_info.bootstrap_exec) {
+ path = HYDU_strdup(HYDT_bsci_info.bootstrap_exec);
}
else {
status = HYDU_find_in_path("ssh", &test_path);
@@ -60,9 +60,9 @@
client_arg[arg++] = HYDU_strdup(path);
/* Allow X forwarding only if explicitly requested */
- if (HYD_BSCI_info.enablex == 1)
+ if (HYDT_bsci_info.enablex == 1)
client_arg[arg++] = HYDU_strdup("-X");
- else if (HYD_BSCI_info.enablex == 0)
+ else if (HYDT_bsci_info.enablex == 0)
client_arg[arg++] = HYDU_strdup("-x");
else /* default mode is disable X */
client_arg[arg++] = HYDU_strdup("-x");
@@ -79,7 +79,7 @@
client_arg[arg++] = NULL;
- if (HYD_BSCI_info.debug) {
+ if (HYDT_bsci_info.debug) {
HYDU_dump(stdout, "Launching process: ");
HYDU_print_strlist(client_arg);
}
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu.h
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,10 +9,10 @@
#include "hydra_base.h"
-HYD_Status HYD_BSCU_finalize(void);
-HYD_Status HYD_BSCU_wait_for_completion(struct HYD_Proxy *proxy_list);
-HYD_Status HYD_BSCU_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list);
-HYD_Status HYD_BSCU_query_usize(int *size);
-HYD_Status HYD_BSCU_query_proxy_id(int *proxy_id);
+HYD_status HYDT_bscu_finalize(void);
+HYD_status HYDT_bscu_wait_for_completion(struct HYD_proxy *proxy_list);
+HYD_status HYDT_bscu_query_node_list(int *num_nodes, struct HYD_proxy **proxy_list);
+HYD_status HYDT_bscu_query_usize(int *size);
+HYD_status HYDT_bscu_query_proxy_id(int *proxy_id);
#endif /* BSCU_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_finalize.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_finalize.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_finalize.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,9 +8,9 @@
#include "hydra_utils.h"
#include "bscu.h"
-HYD_Status HYD_BSCU_finalize(void)
+HYD_status HYDT_bscu_finalize(void)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_query_node_list.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_query_node_list.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_query_node_list.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,9 +8,9 @@
#include "hydra_utils.h"
#include "bscu.h"
-HYD_Status HYD_BSCU_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list)
+HYD_status HYDT_bscu_query_node_list(int *num_nodes, struct HYD_proxy **proxy_list)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_query_proxy_id.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_query_proxy_id.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_query_proxy_id.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,9 +8,9 @@
#include "hydra_utils.h"
#include "bscu.h"
-HYD_Status HYD_BSCU_query_proxy_id(int *proxy_id)
+HYD_status HYDT_bscu_query_proxy_id(int *proxy_id)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_usize.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_usize.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_usize.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,9 +8,9 @@
#include "hydra_utils.h"
#include "bscu.h"
-HYD_Status HYD_BSCU_query_usize(int *size)
+HYD_status HYDT_bscu_query_usize(int *size)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_wait.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_wait.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/bootstrap/utils/bscu_wait.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -7,12 +7,12 @@
#include "hydra_utils.h"
#include "bscu.h"
-HYD_Status HYD_BSCU_wait_for_completion(struct HYD_Proxy *proxy_list)
+HYD_status HYDT_bscu_wait_for_completion(struct HYD_proxy *proxy_list)
{
int pid, ret_status, not_completed;
- struct HYD_Proxy *proxy;
- struct HYD_Proxy_exec *exec;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_proxy *proxy;
+ struct HYD_proxy_exec *exec;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/tools/ckpoint/blcr/ckpoint_blcr.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/ckpoint/blcr/ckpoint_blcr.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/ckpoint/blcr/ckpoint_blcr.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -36,9 +36,9 @@
return 0;
}
-static HYD_Status create_fifo(const char *fname_template, int rank, int *fd)
+static HYD_status create_fifo(const char *fname_template, int rank, int *fd)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
char filename[256];
int ret;
@@ -61,10 +61,10 @@
}
-static HYD_Status create_stdinouterr_fifos(int num_ranks, int ranks[], int *in, int *out,
+static HYD_status create_stdinouterr_fifos(int num_ranks, int ranks[], int *in, int *out,
int *err)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
int r;
for (r = 0; r < num_ranks; ++r) {
@@ -94,12 +94,12 @@
}
-static HYD_Status create_env_file(const HYD_Env_t * envlist, int num_ranks, int *ranks)
+static HYD_status create_env_file(const HYD_env_t * envlist, int num_ranks, int *ranks)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
char filename[256];
FILE *f;
- const HYD_Env_t *e;
+ const HYD_env_t *e;
int ret;
int r;
@@ -130,9 +130,9 @@
goto fn_exit;
}
-HYD_Status HYDU_ckpoint_blcr_suspend(const char *prefix)
+HYD_status HYDT_ckpoint_blcr_suspend(const char *prefix)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
int ret;
int fd;
cr_checkpoint_args_t my_args;
@@ -201,10 +201,10 @@
goto fn_exit;
}
-HYD_Status HYDU_ckpoint_blcr_restart(const char *prefix, HYD_Env_t * envlist, int num_ranks,
+HYD_status HYDT_ckpoint_blcr_restart(const char *prefix, HYD_env_t * envlist, int num_ranks,
int ranks[], int *in, int *out, int *err)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
pid_t mypid;
int ret;
int context_fd;
@@ -252,9 +252,9 @@
goto fn_exit;
}
-HYD_Status HYDU_ckpoint_blcr_init(void)
+HYD_status HYDT_ckpoint_blcr_init(void)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
int rc;
cr_client_id_t client_id;
cr_callback_id_t callback_id;
Modified: mpich2/trunk/src/pm/hydra/tools/ckpoint/blcr/ckpoint_blcr.h
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/ckpoint/blcr/ckpoint_blcr.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/ckpoint/blcr/ckpoint_blcr.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -7,9 +7,9 @@
#ifndef CKPOINT_BLCR_H_INCLUDED
#define CKPOINT_BLCR_H_INCLUDED
-HYD_Status HYDU_ckpoint_blcr_init(void);
-HYD_Status HYDU_ckpoint_blcr_suspend(const char *prefix);
-HYD_Status HYDU_ckpoint_blcr_restart(const char *prefix, HYD_Env_t * envlist, int num_ranks,
+HYD_status HYDT_ckpoint_blcr_init(void);
+HYD_status HYDT_ckpoint_blcr_suspend(const char *prefix);
+HYD_status HYDT_ckpoint_blcr_restart(const char *prefix, HYD_env_t * envlist, int num_ranks,
int ranks[], int *in, int *out, int *err);
#endif /* CKPOINT_BLCR_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/tools/ckpoint/ckpoint.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/ckpoint/ckpoint.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/ckpoint/ckpoint.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -12,23 +12,23 @@
#include "blcr/ckpoint_blcr.h"
#endif /* HAVE_BLCR */
-struct HYDU_ckpoint_info HYDU_ckpoint_info;
+struct HYDT_ckpoint_info HYDT_ckpoint_info;
-HYD_Status HYDU_ckpoint_init(char *ckpointlib, char *ckpoint_prefix)
+HYD_status HYDT_ckpoint_init(char *ckpointlib, char *ckpoint_prefix)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_ckpoint_info.ckpointlib = ckpointlib;
- HYDU_ckpoint_info.ckpoint_prefix = ckpoint_prefix;
+ HYDT_ckpoint_info.ckpointlib = ckpointlib;
+ HYDT_ckpoint_info.ckpoint_prefix = ckpoint_prefix;
- if (HYDU_ckpoint_info.ckpoint_prefix == NULL)
+ if (HYDT_ckpoint_info.ckpoint_prefix == NULL)
goto fn_exit;
#if defined HAVE_BLCR
- if (!strcmp(HYDU_ckpoint_info.ckpointlib, "blcr")) {
- status = HYDU_ckpoint_blcr_init();
+ if (!strcmp(HYDT_ckpoint_info.ckpointlib, "blcr")) {
+ status = HYDT_ckpoint_blcr_init();
HYDU_ERR_POP(status, "blcr checkpoint returned error\n");
}
#endif /* HAVE_BLCR */
@@ -41,18 +41,18 @@
goto fn_exit;
}
-HYD_Status HYDU_ckpoint_suspend(void)
+HYD_status HYDT_ckpoint_suspend(void)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_ERR_CHKANDJUMP(status, HYDU_ckpoint_info.ckpoint_prefix == NULL, HYD_INTERNAL_ERROR,
+ HYDU_ERR_CHKANDJUMP(status, HYDT_ckpoint_info.ckpoint_prefix == NULL, HYD_INTERNAL_ERROR,
"no checkpoint prefix defined\n");
#if defined HAVE_BLCR
- if (!strcmp(HYDU_ckpoint_info.ckpointlib, "blcr")) {
- status = HYDU_ckpoint_blcr_suspend(HYDU_ckpoint_info.ckpoint_prefix);
+ if (!strcmp(HYDT_ckpoint_info.ckpointlib, "blcr")) {
+ status = HYDT_ckpoint_blcr_suspend(HYDT_ckpoint_info.ckpoint_prefix);
HYDU_ERR_POP(status, "blcr checkpoint returned error\n");
}
#endif /* HAVE_BLCR */
@@ -65,20 +65,20 @@
goto fn_exit;
}
-HYD_Status HYDU_ckpoint_restart(HYD_Env_t * envlist, int num_ranks, int ranks[], int *in,
+HYD_status HYDT_ckpoint_restart(HYD_env_t * envlist, int num_ranks, int ranks[], int *in,
int *out, int *err)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_ERR_CHKANDJUMP(status, HYDU_ckpoint_info.ckpoint_prefix == NULL, HYD_INTERNAL_ERROR,
+ HYDU_ERR_CHKANDJUMP(status, HYDT_ckpoint_info.ckpoint_prefix == NULL, HYD_INTERNAL_ERROR,
"no checkpoint prefix defined\n");
#if defined HAVE_BLCR
- if (!strcmp(HYDU_ckpoint_info.ckpointlib, "blcr")) {
+ if (!strcmp(HYDT_ckpoint_info.ckpointlib, "blcr")) {
status =
- HYDU_ckpoint_blcr_restart(HYDU_ckpoint_info.ckpoint_prefix, envlist, num_ranks,
+ HYDT_ckpoint_blcr_restart(HYDT_ckpoint_info.ckpoint_prefix, envlist, num_ranks,
ranks, in, out, err);
HYDU_ERR_POP(status, "blcr checkpoint returned error\n");
}
Modified: mpich2/trunk/src/pm/hydra/tools/ckpoint/ckpoint.h
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/ckpoint/ckpoint.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/ckpoint/ckpoint.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,11 +9,11 @@
#include "hydra_utils.h"
-struct HYDU_ckpoint_info {
+struct HYDT_ckpoint_info {
char *ckpointlib;
char *ckpoint_prefix;
};
-extern struct HYDU_ckpoint_info HYDU_ckpoint_info;
+extern struct HYDT_ckpoint_info HYDT_ckpoint_info;
#endif /* CKPOINT_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/tools/demux/demux.c
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/demux/demux.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/demux/demux.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -10,24 +10,25 @@
static int num_cb_fds = 0;
-typedef struct HYD_DMXI_callback {
+typedef struct HYDT_dmxi_callback {
int num_fds;
int *fd;
- HYD_Event_t events;
+ 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);
- struct HYD_DMXI_callback *next;
-} HYD_DMXI_callback_t;
+ struct HYDT_dmxi_callback *next;
+} HYDT_dmxi_callback_t;
-static HYD_DMXI_callback_t *cb_list = NULL;
+static HYDT_dmxi_callback_t *cb_list = NULL;
-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 HYDT_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_DMXI_callback_t *cb_element, *run;
+ HYDT_dmxi_callback_t *cb_element, *run;
int i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -35,7 +36,7 @@
if (fd[i] < 0)
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, "registering bad fd %d\n", fd[i]);
- HYDU_MALLOC(cb_element, HYD_DMXI_callback_t *, sizeof(HYD_DMXI_callback_t), status);
+ HYDU_MALLOC(cb_element, HYDT_dmxi_callback_t *, sizeof(HYDT_dmxi_callback_t), status);
cb_element->num_fds = num_fds;
HYDU_MALLOC(cb_element->fd, int *, num_fds * sizeof(int), status);
memcpy(cb_element->fd, fd, num_fds * sizeof(int));
@@ -65,11 +66,11 @@
}
-HYD_Status HYD_DMX_deregister_fd(int fd)
+HYD_status HYDT_dmx_deregister_fd(int fd)
{
int i;
- HYD_DMXI_callback_t *cb_element;
- HYD_Status status = HYD_SUCCESS;
+ HYDT_dmxi_callback_t *cb_element;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -98,12 +99,12 @@
}
-HYD_Status HYD_DMX_wait_for_event(int wtime)
+HYD_status HYDT_dmx_wait_for_event(int wtime)
{
int total_fds, i, j, events, ret;
- HYD_DMXI_callback_t *run;
+ HYDT_dmxi_callback_t *run;
struct pollfd *pollfds = NULL;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -188,10 +189,10 @@
}
-HYD_Status HYD_DMX_finalize(void)
+HYD_status HYDT_dmx_finalize(void)
{
- HYD_DMXI_callback_t *run1, *run2;
- HYD_Status status = HYD_SUCCESS;
+ HYDT_dmxi_callback_t *run1, *run2;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/tools/demux/demux.h
===================================================================
--- mpich2/trunk/src/pm/hydra/tools/demux/demux.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/tools/demux/demux.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,11 +9,11 @@
#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 HYD_DMX_deregister_fd(int fd);
-HYD_Status HYD_DMX_wait_for_event(int time);
-HYD_Status HYD_DMX_finalize(void);
+HYD_status HYDT_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 HYDT_dmx_deregister_fd(int fd);
+HYD_status HYDT_dmx_wait_for_event(int time);
+HYD_status HYDT_dmx_finalize(void);
#endif /* DEMUX_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/ui/mpiexec/callback.c
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/mpiexec/callback.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/ui/mpiexec/callback.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,15 +9,15 @@
#include "mpiexec.h"
#include "demux.h"
-static HYD_Status close_fd(int fd)
+static HYD_status close_fd(int fd)
{
- struct HYD_Proxy *proxy;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_proxy *proxy;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
/* Deregister the FD with the demux engine and close it. */
- status = HYD_DMX_deregister_fd(fd);
+ status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_SETANDJUMP1(status, status, "error deregistering fd %d\n", fd);
close(fd);
@@ -42,10 +42,10 @@
}
-HYD_Status HYD_UII_mpx_stdout_cb(int fd, HYD_Event_t events, void *userp)
+HYD_status HYD_uii_mpx_stdout_cb(int fd, HYD_event_t events, void *userp)
{
int closed;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -69,10 +69,10 @@
goto fn_exit;
}
-HYD_Status HYD_UII_mpx_stderr_cb(int fd, HYD_Event_t events, void *userp)
+HYD_status HYD_uii_mpx_stderr_cb(int fd, HYD_event_t events, void *userp)
{
int closed;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -97,10 +97,10 @@
}
-HYD_Status HYD_UII_mpx_stdin_cb(int fd, HYD_Event_t events, void *userp)
+HYD_status HYD_uii_mpx_stdin_cb(int fd, HYD_event_t events, void *userp)
{
int closed;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.c
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -12,8 +12,7 @@
#include "uiu.h"
#include "demux.h"
-HYD_Handle HYD_handle = { {0}
-};
+struct HYD_handle HYD_handle = { {0} };
static void usage(void)
{
@@ -106,18 +105,18 @@
int main(int argc, char **argv)
{
- struct HYD_Proxy *proxy;
- struct HYD_Proxy_exec *exec;
- struct HYD_Exec_info *exec_info;
+ struct HYD_proxy *proxy;
+ struct HYD_proxy_exec *exec;
+ struct HYD_exec_info *exec_info;
int exit_status = 0, timeout, i, process_id, proc_count, num_nodes = 0;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
status = HYDU_dbg_init("mpiexec");
HYDU_ERR_POP(status, "unable to initialization debugging\n");
- status = HYD_UII_mpx_get_parameters(argv);
+ status = HYD_uii_mpx_get_parameters(argv);
if (status == HYD_GRACEFUL_ABORT) {
exit(0);
}
@@ -126,7 +125,7 @@
goto fn_fail;
}
- status = HYD_RMKI_init(HYD_handle.rmk);
+ status = HYD_rmki_init(HYD_handle.rmk);
HYDU_ERR_POP(status, "unable to initialize RMK\n");
if (HYD_handle.proxy_list == NULL) {
@@ -134,7 +133,7 @@
* provided the host file. Query the RMK. We pass a zero node
* count, so the RMK will give us all the nodes it already has
* and won't try to allocate any more. */
- status = HYD_RMKI_query_node_list(&num_nodes, &HYD_handle.proxy_list);
+ status = HYD_rmki_query_node_list(&num_nodes, &HYD_handle.proxy_list);
HYDU_ERR_POP(status, "unable to query the RMK for a node list\n");
/* We don't have an allocation capability yet, but when we do,
@@ -142,7 +141,7 @@
if (HYD_handle.proxy_list == NULL) {
/* The RMK didn't give us anything back; use localhost */
- status = HYD_UII_mpx_add_to_proxy_list((char *) "localhost", 1);
+ status = HYD_uii_mpx_add_to_proxy_list((char *) "localhost", 1);
HYDU_ERR_POP(status, "unable to initialize proxy\n");
}
}
@@ -174,11 +173,11 @@
proxy->active = 1;
}
- status = HYD_UIU_merge_exec_info_to_proxy();
+ status = HYD_uiu_merge_exec_info_to_proxy();
HYDU_ERR_POP(status, "unable to merge exec info\n");
if (HYD_handle.user_global.debug)
- HYD_UIU_print_params();
+ HYD_uiu_print_params();
HYDU_time_set(&HYD_handle.start, NULL); /* NULL implies right now */
if (getenv("MPIEXEC_TIMEOUT"))
@@ -214,7 +213,7 @@
HYDU_MALLOC(proxy->exit_status, int *, proxy->proxy_process_count * sizeof(int), status);
/* Launch the processes */
- status = HYD_PMCI_launch_procs();
+ status = HYD_pmci_launch_procs();
HYDU_ERR_POP(status, "process manager returned error launching processes\n");
/* During shutdown, no processes are launched, so there is nothing
@@ -227,11 +226,11 @@
* different port and kills the original proxies using them. */
if (HYD_handle.user_global.launch_mode == HYD_LAUNCH_SHUTDOWN) {
/* Call finalize functions for lower layers to cleanup their resources */
- status = HYD_PMCI_finalize();
+ status = HYD_pmci_finalize();
HYDU_ERR_POP(status, "process manager error on finalize\n");
/* Free the mpiexec params */
- HYD_UIU_free_params();
+ HYD_uiu_free_params();
exit_status = 0;
goto fn_exit;
@@ -246,25 +245,26 @@
FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
if (proxy->out != -1) {
- status = HYD_DMX_register_fd(1, &proxy->out, HYD_STDOUT, NULL,
- HYD_UII_mpx_stdout_cb);
+ status = HYDT_dmx_register_fd(1, &proxy->out, HYD_STDOUT, NULL,
+ HYD_uii_mpx_stdout_cb);
HYDU_ERR_POP(status, "demux returned error registering fd\n");
}
if (proxy->err != -1) {
- status = HYD_DMX_register_fd(1, &proxy->err, HYD_STDOUT, NULL,
- HYD_UII_mpx_stderr_cb);
+ status = HYDT_dmx_register_fd(1, &proxy->err, HYD_STDOUT, NULL,
+ HYD_uii_mpx_stderr_cb);
HYDU_ERR_POP(status, "demux returned error registering fd\n");
}
if (proxy->in != -1) {
- status = HYD_DMX_register_fd(1, &proxy->in, HYD_STDIN, NULL, HYD_UII_mpx_stdin_cb);
+ status =
+ HYDT_dmx_register_fd(1, &proxy->in, HYD_STDIN, NULL, HYD_uii_mpx_stdin_cb);
HYDU_ERR_POP(status, "demux returned error registering fd\n");
}
}
/* Wait for their completion */
- status = HYD_PMCI_wait_for_completion();
+ status = HYD_pmci_wait_for_completion();
HYDU_ERR_POP(status, "process manager error waiting for completion\n");
/* Check for the exit status for all the processes */
@@ -292,11 +292,11 @@
HYDU_dump_noprefix(stdout, "\n");
/* Call finalize functions for lower layers to cleanup their resources */
- status = HYD_PMCI_finalize();
+ status = HYD_pmci_finalize();
HYDU_ERR_POP(status, "process manager error on finalize\n");
/* Free the mpiexec params */
- HYD_UIU_free_params();
+ HYD_uiu_free_params();
fn_exit:
HYDU_FUNC_EXIT();
Modified: mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.h
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,10 +9,10 @@
#include "hydra.h"
-HYD_Status HYD_UII_mpx_add_to_proxy_list(char *hostname, int num_procs);
-HYD_Status HYD_UII_mpx_get_parameters(char **t_argv);
-HYD_Status HYD_UII_mpx_stdout_cb(int fd, HYD_Event_t events, void *userp);
-HYD_Status HYD_UII_mpx_stderr_cb(int fd, HYD_Event_t events, void *userp);
-HYD_Status HYD_UII_mpx_stdin_cb(int fd, HYD_Event_t events, void *userp);
+HYD_status HYD_uii_mpx_add_to_proxy_list(char *hostname, int num_procs);
+HYD_status HYD_uii_mpx_get_parameters(char **t_argv);
+HYD_status HYD_uii_mpx_stdout_cb(int fd, HYD_event_t events, void *userp);
+HYD_status HYD_uii_mpx_stderr_cb(int fd, HYD_event_t events, void *userp);
+HYD_status HYD_uii_mpx_stdin_cb(int fd, HYD_event_t events, void *userp);
#endif /* MPIEXEC_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/ui/mpiexec/utils.c
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/mpiexec/utils.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/ui/mpiexec/utils.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -12,7 +12,7 @@
#define IS_HELP(str) \
((!strcmp((str), "-h")) || (!strcmp((str), "-help")) || (!strcmp((str), "--help")))
-HYD_Handle HYD_handle;
+struct HYD_handle HYD_handle;
static void dump_env_notes(void)
{
@@ -29,11 +29,11 @@
printf("\n");
}
-static HYD_Status genv_fn(char *arg, char ***argv)
+static HYD_status genv_fn(char *arg, char ***argv)
{
char *env_name, *env_value, *str[2] = { 0 };
- HYD_Env_t *env;
- HYD_Status status = HYD_SUCCESS;
+ HYD_env_t *env;
+ HYD_status status = HYD_SUCCESS;
if (**argv && IS_HELP(**argv)) {
printf("\n");
@@ -74,10 +74,10 @@
goto fn_exit;
}
-static HYD_Status genvlist_fn(char *arg, char ***argv)
+static HYD_status genvlist_fn(char *arg, char ***argv)
{
int len;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.global_env.prop,
HYD_INTERNAL_ERROR, "duplicate environment setting\n");
@@ -104,9 +104,9 @@
goto fn_exit;
}
-static HYD_Status genvnone_fn(char *arg, char ***argv)
+static HYD_status genvnone_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.global_env.prop,
HYD_INTERNAL_ERROR, "duplicate environment setting\n");
@@ -127,9 +127,9 @@
goto fn_exit;
}
-static HYD_Status genvall_fn(char *arg, char ***argv)
+static HYD_status genvall_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.global_env.prop,
HYD_INTERNAL_ERROR, "duplicate environment setting\n");
@@ -150,11 +150,11 @@
goto fn_exit;
}
-HYD_Status HYD_UII_mpx_add_to_proxy_list(char *hostname, int num_procs)
+HYD_status HYD_uii_mpx_add_to_proxy_list(char *hostname, int num_procs)
{
static int pid = 0;
- struct HYD_Proxy *proxy;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_proxy *proxy;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -197,18 +197,18 @@
}
-static HYD_Status process_mfile_token(char *token, int newline)
+static HYD_status process_mfile_token(char *token, int newline)
{
int num_procs;
char *hostname, *procs;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
if (newline) { /* The first entry gives the hostname and processes */
hostname = strtok(token, ":");
procs = strtok(NULL, ":");
num_procs = procs ? atoi(procs) : 1;
- status = HYD_UII_mpx_add_to_proxy_list(hostname, num_procs);
+ status = HYD_uii_mpx_add_to_proxy_list(hostname, num_procs);
HYDU_ERR_POP(status, "unable to initialize proxy\n");
}
else { /* Not a new line */
@@ -223,9 +223,9 @@
goto fn_exit;
}
-static HYD_Status mfile_fn(char *arg, char ***argv)
+static HYD_status mfile_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.proxy_list, HYD_INTERNAL_ERROR,
"duplicate host file setting\n");
@@ -241,7 +241,7 @@
HYDU_ERR_POP(status, "error parsing hostfile\n");
}
else {
- status = HYD_UII_mpx_add_to_proxy_list((char *) "localhost", 1);
+ status = HYD_uii_mpx_add_to_proxy_list((char *) "localhost", 1);
HYDU_ERR_POP(status, "unable to add proxy\n");
}
@@ -254,9 +254,9 @@
goto fn_exit;
}
-static HYD_Status wdir_fn(char *arg, char ***argv)
+static HYD_status wdir_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.wdir, HYD_INTERNAL_ERROR,
"duplicate wdir setting\n");
@@ -277,12 +277,12 @@
goto fn_exit;
}
-static HYD_Status env_fn(char *arg, char ***argv)
+static HYD_status env_fn(char *arg, char ***argv)
{
char *env_name, *env_value, *str[2] = { 0 };
- HYD_Env_t *env;
- struct HYD_Exec_info *exec_info;
- HYD_Status status = HYD_SUCCESS;
+ HYD_env_t *env;
+ struct HYD_exec_info *exec_info;
+ HYD_status status = HYD_SUCCESS;
if (**argv && IS_HELP(**argv)) {
printf("\n");
@@ -314,7 +314,7 @@
status = HYDU_env_create(&env, env_name, env_value);
HYDU_ERR_POP(status, "unable to create env struct\n");
- status = HYD_UIU_get_current_exec_info(&exec_info);
+ status = HYD_uiu_get_current_exec_info(&exec_info);
HYDU_ERR_POP(status, "get_current_exec_info returned error\n");
HYDU_append_env_to_list(*env, &exec_info->user_env);
@@ -326,13 +326,13 @@
goto fn_exit;
}
-static HYD_Status envlist_fn(char *arg, char ***argv)
+static HYD_status envlist_fn(char *arg, char ***argv)
{
int len;
- struct HYD_Exec_info *exec_info;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_exec_info *exec_info;
+ HYD_status status = HYD_SUCCESS;
- status = HYD_UIU_get_current_exec_info(&exec_info);
+ status = HYD_uiu_get_current_exec_info(&exec_info);
HYDU_ERR_POP(status, "get_current_exec_info returned error\n");
HYDU_ERR_CHKANDJUMP(status, exec_info->env_prop, HYD_INTERNAL_ERROR,
@@ -360,12 +360,12 @@
goto fn_exit;
}
-static HYD_Status envnone_fn(char *arg, char ***argv)
+static HYD_status envnone_fn(char *arg, char ***argv)
{
- struct HYD_Exec_info *exec_info;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_exec_info *exec_info;
+ HYD_status status = HYD_SUCCESS;
- status = HYD_UIU_get_current_exec_info(&exec_info);
+ status = HYD_uiu_get_current_exec_info(&exec_info);
HYDU_ERR_POP(status, "get_current_exec_info returned error\n");
HYDU_ERR_CHKANDJUMP(status, exec_info->env_prop, HYD_INTERNAL_ERROR,
@@ -387,12 +387,12 @@
goto fn_exit;
}
-static HYD_Status envall_fn(char *arg, char ***argv)
+static HYD_status envall_fn(char *arg, char ***argv)
{
- struct HYD_Exec_info *exec_info;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_exec_info *exec_info;
+ HYD_status status = HYD_SUCCESS;
- status = HYD_UIU_get_current_exec_info(&exec_info);
+ status = HYD_uiu_get_current_exec_info(&exec_info);
HYDU_ERR_POP(status, "get_current_exec_info returned error\n");
HYDU_ERR_CHKANDJUMP(status, exec_info->env_prop, HYD_INTERNAL_ERROR,
@@ -414,10 +414,10 @@
goto fn_exit;
}
-static HYD_Status np_fn(char *arg, char ***argv)
+static HYD_status np_fn(char *arg, char ***argv)
{
- struct HYD_Exec_info *exec_info;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_exec_info *exec_info;
+ HYD_status status = HYD_SUCCESS;
if (**argv && IS_HELP(**argv)) {
printf("\n");
@@ -425,7 +425,7 @@
HYDU_ERR_SETANDJUMP(status, HYD_GRACEFUL_ABORT, "");
}
- status = HYD_UIU_get_current_exec_info(&exec_info);
+ status = HYD_uiu_get_current_exec_info(&exec_info);
HYDU_ERR_POP(status, "get_current_exec_info returned error\n");
if (exec_info->process_count != 0)
@@ -442,9 +442,9 @@
goto fn_exit;
}
-static HYD_Status bootstrap_fn(char *arg, char ***argv)
+static HYD_status bootstrap_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.bootstrap, HYD_INTERNAL_ERROR,
"duplicate -bootstrap option\n");
@@ -470,9 +470,9 @@
goto fn_exit;
}
-static HYD_Status bootstrap_exec_fn(char *arg, char ***argv)
+static HYD_status bootstrap_exec_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.bootstrap_exec, HYD_INTERNAL_ERROR,
"duplicate -bootstrap-exec option\n");
@@ -498,9 +498,9 @@
goto fn_exit;
}
-static HYD_Status enablex_fn(char *arg, char ***argv)
+static HYD_status enablex_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.enablex != -1, HYD_INTERNAL_ERROR,
"duplicate -enable-x argument\n");
@@ -524,9 +524,9 @@
goto fn_exit;
}
-static HYD_Status boot_proxies_fn(char *arg, char ***argv)
+static HYD_status boot_proxies_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.launch_mode != HYD_LAUNCH_UNSET,
HYD_INTERNAL_ERROR, "duplicate launch mode\n");
@@ -554,9 +554,9 @@
goto fn_exit;
}
-static HYD_Status proxy_port_fn(char *arg, char ***argv)
+static HYD_status proxy_port_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.proxy_port != -1, HYD_INTERNAL_ERROR,
"duplicate -proxy-port option\n");
@@ -580,9 +580,9 @@
goto fn_exit;
}
-static HYD_Status use_persistent_fn(char *arg, char ***argv)
+static HYD_status use_persistent_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.launch_mode != HYD_LAUNCH_UNSET,
HYD_INTERNAL_ERROR, "duplicate launch mode\n");
@@ -606,9 +606,9 @@
goto fn_exit;
}
-static HYD_Status css_fn(char *arg, char ***argv)
+static HYD_status css_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.css, HYD_INTERNAL_ERROR, "duplicate -css option\n");
@@ -633,9 +633,9 @@
goto fn_exit;
}
-static HYD_Status rmk_fn(char *arg, char ***argv)
+static HYD_status rmk_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.rmk, HYD_INTERNAL_ERROR, "duplicate -rmk option\n");
@@ -660,9 +660,9 @@
goto fn_exit;
}
-static HYD_Status ranks_per_proc_fn(char *arg, char ***argv)
+static HYD_status ranks_per_proc_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.ranks_per_proc != -1, HYD_INTERNAL_ERROR,
"duplicate -ranks-per-proc option\n");
@@ -686,9 +686,9 @@
goto fn_exit;
}
-static HYD_Status enable_pm_env_fn(char *arg, char ***argv)
+static HYD_status enable_pm_env_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.pm_env != -1, HYD_INTERNAL_ERROR,
"duplicate -enable-pm-env argument\n");
@@ -712,9 +712,9 @@
goto fn_exit;
}
-static HYD_Status binding_fn(char *arg, char ***argv)
+static HYD_status binding_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.binding, HYD_INTERNAL_ERROR,
"duplicate binding\n");
@@ -745,9 +745,9 @@
goto fn_exit;
}
-static HYD_Status bindlib_fn(char *arg, char ***argv)
+static HYD_status bindlib_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.bindlib, HYD_INTERNAL_ERROR,
"duplicate -bindlib option\n");
@@ -773,9 +773,9 @@
goto fn_exit;
}
-static HYD_Status ckpoint_interval_fn(char *arg, char ***argv)
+static HYD_status ckpoint_interval_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.ckpoint_int != -1,
HYD_INTERNAL_ERROR, "duplicate -ckpoint-interval option\n");
@@ -799,9 +799,9 @@
goto fn_exit;
}
-static HYD_Status ckpoint_prefix_fn(char *arg, char ***argv)
+static HYD_status ckpoint_prefix_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.ckpoint_prefix, HYD_INTERNAL_ERROR,
"duplicate -ckpoint-prefix option\n");
@@ -825,9 +825,9 @@
goto fn_exit;
}
-static HYD_Status ckpointlib_fn(char *arg, char ***argv)
+static HYD_status ckpointlib_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.ckpointlib, HYD_INTERNAL_ERROR,
"duplicate -ckpointlib option\n");
@@ -853,9 +853,9 @@
goto fn_exit;
}
-static HYD_Status ckpoint_restart_fn(char *arg, char ***argv)
+static HYD_status ckpoint_restart_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.ckpoint_restart,
HYD_INTERNAL_ERROR, "duplicate restart mode\n");
@@ -875,9 +875,9 @@
goto fn_exit;
}
-static HYD_Status verbose_fn(char *arg, char ***argv)
+static HYD_status verbose_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.user_global.debug != -1, HYD_INTERNAL_ERROR,
"duplicate verbose setting\n");
@@ -897,9 +897,9 @@
goto fn_exit;
}
-static HYD_Status info_fn(char *arg, char ***argv)
+static HYD_status info_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
if (**argv && IS_HELP(**argv)) {
printf("\n");
@@ -923,9 +923,9 @@
goto fn_exit;
}
-static HYD_Status print_rank_map_fn(char *arg, char ***argv)
+static HYD_status print_rank_map_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.print_rank_map != -1, HYD_INTERNAL_ERROR,
"duplicate print-rank-map setting\n");
@@ -945,9 +945,9 @@
goto fn_exit;
}
-static HYD_Status print_all_exitcodes_fn(char *arg, char ***argv)
+static HYD_status print_all_exitcodes_fn(char *arg, char ***argv)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_ERR_CHKANDJUMP(status, HYD_handle.print_all_exitcodes != -1, HYD_INTERNAL_ERROR,
"duplicate print-all-exitcodes setting\n");
@@ -969,7 +969,7 @@
struct match_table_fns {
const char *arg;
- HYD_Status(*handler) (char *arg, char ***argv_p);
+ HYD_status(*handler) (char *arg, char ***argv_p);
};
static struct match_table_fns match_table[] = {
@@ -1042,11 +1042,11 @@
{"\0", NULL}
};
-static HYD_Status match_arg(char ***argv_p)
+static HYD_status match_arg(char ***argv_p)
{
struct match_table_fns *m;
char *arg, *tmp;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
arg = **argv_p;
while (*arg == '-') /* Remove leading dashes */
@@ -1086,10 +1086,10 @@
goto fn_exit;
}
-static HYD_Status verify_arguments(void)
+static HYD_status verify_arguments(void)
{
- struct HYD_Exec_info *exec_info;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_exec_info *exec_info;
+ HYD_status status = HYD_SUCCESS;
/* Proxy launch or checkpoint restart */
if ((HYD_handle.user_global.launch_mode == HYD_LAUNCH_BOOT) ||
@@ -1113,7 +1113,7 @@
else { /* Application launch */
/* On a checkpoint restart, we set the prefix as the application */
if (HYD_handle.user_global.ckpoint_restart == 1) {
- status = HYD_UIU_get_current_exec_info(&exec_info);
+ 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.user_global.ckpoint_prefix);
@@ -1137,10 +1137,10 @@
goto fn_exit;
}
-static HYD_Status set_default_values(void)
+static HYD_status set_default_values(void)
{
char *tmp;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
if (HYD_handle.print_rank_map == -1)
HYD_handle.print_rank_map = 0;
@@ -1254,17 +1254,17 @@
goto fn_exit;
}
-HYD_Status HYD_UII_mpx_get_parameters(char **t_argv)
+HYD_status HYD_uii_mpx_get_parameters(char **t_argv)
{
int i;
char **argv = t_argv;
char *progname = *argv;
- struct HYD_Exec_info *exec_info;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_exec_info *exec_info;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYD_UIU_init_params();
+ HYD_uiu_init_params();
status = HYDU_list_inherited_env(&HYD_handle.user_global.global_env.inherited);
HYDU_ERR_POP(status, "unable to get the inherited env list\n");
@@ -1283,7 +1283,7 @@
/* Get the executable information */
/* Read the executable till you hit the end of a ":" */
do {
- status = HYD_UIU_get_current_exec_info(&exec_info);
+ status = HYD_uiu_get_current_exec_info(&exec_info);
HYDU_ERR_POP(status, "get_current_exec_info returned error\n");
if (!strcmp(*argv, ":")) { /* Next executable */
Modified: mpich2/trunk/src/pm/hydra/ui/utils/uiu.c
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/utils/uiu.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/ui/utils/uiu.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,7 +8,7 @@
#include "hydra_utils.h"
#include "uiu.h"
-void HYD_UIU_init_params(void)
+void HYD_uiu_init_params(void)
{
HYDU_init_user_global(&HYD_handle.user_global);
@@ -43,7 +43,7 @@
}
-void HYD_UIU_free_params(void)
+void HYD_uiu_free_params(void)
{
if (HYD_handle.base_path)
HYDU_FREE(HYD_handle.base_path);
@@ -94,13 +94,13 @@
HYDU_free_proxy_list(HYD_handle.proxy_list);
/* Re-initialize everything to default values */
- HYD_UIU_init_params();
+ HYD_uiu_init_params();
}
-HYD_Status HYD_UIU_get_current_exec_info(struct HYD_Exec_info **exec_info)
+HYD_status HYD_uiu_get_current_exec_info(struct HYD_exec_info **exec_info)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -122,12 +122,12 @@
}
-static HYD_Status add_exec_info_to_proxy(struct HYD_Exec_info *exec_info,
- struct HYD_Proxy *proxy, int num_procs)
+static HYD_status add_exec_info_to_proxy(struct HYD_exec_info *exec_info,
+ struct HYD_proxy *proxy, int num_procs)
{
int i;
- struct HYD_Proxy_exec *exec;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_proxy_exec *exec;
+ HYD_status status = HYD_SUCCESS;
if (proxy->exec_list == NULL) {
status = HYDU_alloc_proxy_exec(&proxy->exec_list);
@@ -167,12 +167,12 @@
}
-HYD_Status HYD_UIU_merge_exec_info_to_proxy(void)
+HYD_status HYD_uiu_merge_exec_info_to_proxy(void)
{
int proxy_rem_procs, exec_rem_procs;
- struct HYD_Proxy *proxy;
- struct HYD_Exec_info *exec_info;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_proxy *proxy;
+ struct HYD_exec_info *exec_info;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -218,13 +218,13 @@
}
-void HYD_UIU_print_params(void)
+void HYD_uiu_print_params(void)
{
- HYD_Env_t *env;
+ HYD_env_t *env;
int i;
- struct HYD_Proxy *proxy;
- struct HYD_Proxy_exec *exec;
- struct HYD_Exec_info *exec_info;
+ struct HYD_proxy *proxy;
+ struct HYD_proxy_exec *exec;
+ struct HYD_exec_info *exec_info;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/ui/utils/uiu.h
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/utils/uiu.h 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/ui/utils/uiu.h 2009-10-16 04:24:58 UTC (rev 5472)
@@ -9,10 +9,10 @@
#include "hydra.h"
-void HYD_UIU_init_params(void);
-void HYD_UIU_free_params(void);
-HYD_Status HYD_UIU_merge_exec_info_to_proxy(void);
-HYD_Status HYD_UIU_get_current_exec_info(struct HYD_Exec_info **info);
-void HYD_UIU_print_params(void);
+void HYD_uiu_init_params(void);
+void HYD_uiu_free_params(void);
+HYD_status HYD_uiu_merge_exec_info_to_proxy(void);
+HYD_status HYD_uiu_get_current_exec_info(struct HYD_exec_info **info);
+void HYD_uiu_print_params(void);
#endif /* UIU_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/utils/alloc/alloc.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/alloc/alloc.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/utils/alloc/alloc.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -6,7 +6,7 @@
#include "hydra_utils.h"
-void HYDU_init_user_global(struct HYD_User_global *user_global)
+void HYDU_init_user_global(struct HYD_user_global *user_global)
{
user_global->bootstrap = NULL;
user_global->bootstrap_exec = NULL;
@@ -26,7 +26,7 @@
HYDU_init_global_env(&user_global->global_env);
}
-void HYDU_init_global_env(struct HYD_Env_global *global_env)
+void HYDU_init_global_env(struct HYD_env_global *global_env)
{
global_env->system = NULL;
global_env->user = NULL;
@@ -34,14 +34,14 @@
global_env->prop = NULL;
}
-HYD_Status HYDU_alloc_proxy(struct HYD_Proxy **proxy)
+HYD_status HYDU_alloc_proxy(struct HYD_proxy **proxy)
{
static int proxy_id = 0;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*proxy, struct HYD_Proxy *, sizeof(struct HYD_Proxy), status);
+ HYDU_MALLOC(*proxy, struct HYD_proxy *, sizeof(struct HYD_proxy), status);
(*proxy)->hostname = NULL;
(*proxy)->pid = -1;
@@ -72,13 +72,13 @@
}
-HYD_Status HYDU_alloc_exec_info(struct HYD_Exec_info **exec_info)
+HYD_status HYDU_alloc_exec_info(struct HYD_exec_info **exec_info)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*exec_info, struct HYD_Exec_info *, sizeof(struct HYD_Exec_info), status);
+ HYDU_MALLOC(*exec_info, struct HYD_exec_info *, sizeof(struct HYD_exec_info), status);
(*exec_info)->process_count = 0;
(*exec_info)->exec[0] = NULL;
(*exec_info)->user_env = NULL;
@@ -94,9 +94,9 @@
}
-void HYDU_free_exec_info_list(struct HYD_Exec_info *exec_info_list)
+void HYDU_free_exec_info_list(struct HYD_exec_info *exec_info_list)
{
- struct HYD_Exec_info *exec_info, *run;
+ struct HYD_exec_info *exec_info, *run;
HYDU_FUNC_ENTER();
@@ -119,10 +119,10 @@
}
-void HYDU_free_proxy_list(struct HYD_Proxy *proxy_list)
+void HYDU_free_proxy_list(struct HYD_proxy *proxy_list)
{
- struct HYD_Proxy *proxy, *tproxy;
- struct HYD_Proxy_exec *exec, *texec;
+ struct HYD_proxy *proxy, *tproxy;
+ struct HYD_proxy_exec *exec, *texec;
HYDU_FUNC_ENTER();
@@ -160,13 +160,13 @@
}
-HYD_Status HYDU_alloc_proxy_exec(struct HYD_Proxy_exec **exec)
+HYD_status HYDU_alloc_proxy_exec(struct HYD_proxy_exec **exec)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*exec, struct HYD_Proxy_exec *, sizeof(struct HYD_Proxy_exec), status);
+ HYDU_MALLOC(*exec, struct HYD_proxy_exec *, sizeof(struct HYD_proxy_exec), status);
(*exec)->exec[0] = NULL;
(*exec)->proc_count = 0;
(*exec)->env_prop = NULL;
Modified: mpich2/trunk/src/pm/hydra/utils/args/args.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/args/args.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/utils/args/args.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -17,10 +17,10 @@
return 1;
}
-HYD_Status HYDU_find_in_path(const char *execname, char **path)
+HYD_status HYDU_find_in_path(const char *execname, char **path)
{
char *user_path = NULL, *tmp[HYD_NUM_TMP_STRINGS], *path_loc = NULL, *test_loc;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -72,11 +72,11 @@
goto fn_exit;
}
-HYD_Status HYDU_get_base_path(const char *execname, char *wdir, char **path)
+HYD_status HYDU_get_base_path(const char *execname, char *wdir, char **path)
{
char *loc, *post;
char *tmp[HYD_NUM_TMP_STRINGS];
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -120,7 +120,7 @@
char *HYDU_getcwd(void)
{
char *pwdval, *cwdval, *retval = NULL;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
#if defined HAVE_STAT
struct stat spwd, scwd;
#endif /* HAVE_STAT */
@@ -154,13 +154,13 @@
}
-HYD_Status HYDU_parse_hostfile(char *hostfile,
- HYD_Status(*process_token) (char *token, int newline))
+HYD_status HYDU_parse_hostfile(char *hostfile,
+ HYD_status(*process_token) (char *token, int newline))
{
char line[HYD_TMP_STRLEN], **tokens;
FILE *fp;
int i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/utils/dbg/dbg.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/dbg/dbg.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/utils/dbg/dbg.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -35,10 +35,10 @@
va_end(list);
}
-HYD_Status HYDU_dbg_init(const char *str)
+HYD_status HYDU_dbg_init(const char *str)
{
char hostname[MAX_HOSTNAME_LEN];
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
if (gethostname(hostname, MAX_HOSTNAME_LEN) < 0)
HYDU_ERR_SETANDJUMP2(status, HYD_SOCK_ERROR,
Modified: mpich2/trunk/src/pm/hydra/utils/env/env.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/env/env.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/utils/env/env.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -6,11 +6,11 @@
#include "hydra_utils.h"
-HYD_Status HYDU_env_to_str(HYD_Env_t * env, char **str)
+HYD_status HYDU_env_to_str(HYD_env_t * env, char **str)
{
int i;
char *tmp[HYD_NUM_TMP_STRINGS];
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -37,14 +37,14 @@
}
-HYD_Status HYDU_str_to_env(char *str, HYD_Env_t ** env)
+HYD_status HYDU_str_to_env(char *str, HYD_env_t ** env)
{
char *env_name, *env_value;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_MALLOC((*env), HYD_Env_t *, sizeof(HYD_Env_t), status);
+ HYDU_MALLOC((*env), HYD_env_t *, sizeof(HYD_env_t), status);
env_name = strtok(str, "=");
env_value = strtok(NULL, "=");
(*env)->env_name = HYDU_strdup(env_name);
@@ -63,15 +63,15 @@
}
-static HYD_Env_t *env_dup(HYD_Env_t env)
+static HYD_env_t *env_dup(HYD_env_t env)
{
- HYD_Env_t *tenv;
- HYD_Status status = HYD_SUCCESS;
+ HYD_env_t *tenv;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_MALLOC(tenv, HYD_Env_t *, sizeof(HYD_Env_t), status);
- memcpy(tenv, &env, sizeof(HYD_Env_t));
+ HYDU_MALLOC(tenv, HYD_env_t *, sizeof(HYD_env_t), status);
+ memcpy(tenv, &env, sizeof(HYD_env_t));
tenv->next = NULL;
tenv->env_name = HYDU_strdup(env.env_name);
tenv->env_value = env.env_value ? HYDU_strdup(env.env_value) : NULL;
@@ -88,12 +88,12 @@
}
-HYD_Status HYDU_list_inherited_env(HYD_Env_t ** env_list)
+HYD_status HYDU_list_inherited_env(HYD_env_t ** env_list)
{
- HYD_Env_t *env;
+ HYD_env_t *env;
char *env_str;
int i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -123,10 +123,10 @@
}
-HYD_Env_t *HYDU_env_list_dup(HYD_Env_t * env)
+HYD_env_t *HYDU_env_list_dup(HYD_env_t * env)
{
- HYD_Env_t *tenv, *run;
- HYD_Status status = HYD_SUCCESS;
+ HYD_env_t *tenv, *run;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -148,13 +148,13 @@
}
-HYD_Status HYDU_env_create(HYD_Env_t ** env, const char *env_name, char *env_value)
+HYD_status HYDU_env_create(HYD_env_t ** env, const char *env_name, char *env_value)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*env, HYD_Env_t *, sizeof(HYD_Env_t), status);
+ HYDU_MALLOC(*env, HYD_env_t *, sizeof(HYD_env_t), status);
(*env)->env_name = HYDU_strdup(env_name);
(*env)->env_value = env_value ? HYDU_strdup(env_value) : NULL;
(*env)->next = NULL;
@@ -168,9 +168,9 @@
}
-HYD_Status HYDU_env_free(HYD_Env_t * env)
+HYD_status HYDU_env_free(HYD_env_t * env)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -185,10 +185,10 @@
}
-HYD_Status HYDU_env_free_list(HYD_Env_t * env)
+HYD_status HYDU_env_free_list(HYD_env_t * env)
{
- HYD_Env_t *run, *tmp;
- HYD_Status status = HYD_SUCCESS;
+ HYD_env_t *run, *tmp;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -204,9 +204,9 @@
}
-HYD_Env_t *HYDU_env_lookup(char *env_name, HYD_Env_t * env_list)
+HYD_env_t *HYDU_env_lookup(char *env_name, HYD_env_t * env_list)
{
- HYD_Env_t *run;
+ HYD_env_t *run;
HYDU_FUNC_ENTER();
@@ -224,10 +224,10 @@
}
-HYD_Status HYDU_append_env_to_list(HYD_Env_t env, HYD_Env_t ** env_list)
+HYD_status HYDU_append_env_to_list(HYD_env_t env, HYD_env_t ** env_list)
{
- HYD_Env_t *run, *tenv;
- HYD_Status status = HYD_SUCCESS;
+ HYD_env_t *run, *tenv;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -283,11 +283,11 @@
}
-HYD_Status HYDU_putenv(HYD_Env_t * env, HYD_Env_overwrite_t overwrite)
+HYD_status HYDU_putenv(HYD_env_t * env, HYD_env_overwrite_t overwrite)
{
char *tmp[HYD_NUM_TMP_STRINGS], *str;
int i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -317,10 +317,10 @@
}
-HYD_Status HYDU_putenv_list(HYD_Env_t * env_list, HYD_Env_overwrite_t overwrite)
+HYD_status HYDU_putenv_list(HYD_env_t * env_list, HYD_env_overwrite_t overwrite)
{
- HYD_Env_t *env;
- HYD_Status status = HYD_SUCCESS;
+ HYD_env_t *env;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -338,11 +338,11 @@
}
-HYD_Status HYDU_comma_list_to_env_list(char *str, HYD_Env_t ** env_list)
+HYD_status HYDU_comma_list_to_env_list(char *str, HYD_env_t ** env_list)
{
char *env_name;
- HYD_Env_t *env;
- HYD_Status status = HYD_SUCCESS;
+ HYD_env_t *env;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/utils/launch/launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/launch/launch.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/utils/launch/launch.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -7,11 +7,11 @@
#include "hydra_utils.h"
#include "hydra_tools.h"
-HYD_Status HYDU_create_process(char **client_arg, HYD_Env_t * env_list,
+HYD_status HYDU_create_process(char **client_arg, HYD_env_t * env_list,
int *in, int *out, int *err, int *pid, int core)
{
int inpipe[2], outpipe[2], errpipe[2], tpid;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -60,7 +60,7 @@
}
if (core >= 0) {
- status = HYDU_bind_process(core);
+ status = HYDT_bind_process(core);
HYDU_ERR_POP(status, "bind process failed\n");
}
@@ -68,7 +68,7 @@
/* The child process should never get back to the proxy
* code; if there is an error, just throw it here and
* exit. */
- HYDU_Error_printf("execvp error on file %s (%s)\n", client_arg[0],
+ HYDU_error_printf("execvp error on file %s (%s)\n", client_arg[0],
HYDU_strerror(errno));
exit(-1);
}
@@ -100,10 +100,10 @@
}
-HYD_Status HYDU_fork_and_exit(int core)
+HYD_status HYDU_fork_and_exit(int core)
{
pid_t tpid;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -115,7 +115,7 @@
close(2);
if (core >= 0) {
- status = HYDU_bind_process(core);
+ status = HYDT_bind_process(core);
HYDU_ERR_POP(status, "bind process failed\n");
}
}
@@ -132,11 +132,11 @@
}
#if defined HAVE_THREAD_SUPPORT
-HYD_Status HYDU_create_thread(void *(*func) (void *), void *args,
- struct HYD_Thread_context *ctxt)
+HYD_status HYDU_create_thread(void *(*func) (void *), void *args,
+ struct HYD_thread_context *ctxt)
{
int ret;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -153,10 +153,10 @@
goto fn_exit;
}
-HYD_Status HYDU_join_thread(struct HYD_Thread_context ctxt)
+HYD_status HYDU_join_thread(struct HYD_thread_context ctxt)
{
int ret;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/utils/others/others.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/others/others.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/utils/others/others.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -6,11 +6,11 @@
#include "hydra_utils.h"
-HYD_Status HYDU_merge_proxy_segment(char *hostname, int start_pid, int core_count,
- struct HYD_Proxy **proxy_list)
+HYD_status HYDU_merge_proxy_segment(char *hostname, int start_pid, int core_count,
+ struct HYD_proxy **proxy_list)
{
- struct HYD_Proxy *proxy;
- HYD_Status status = HYD_SUCCESS;
+ struct HYD_proxy *proxy;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/utils/signals/signals.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/signals/signals.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/utils/signals/signals.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -6,9 +6,9 @@
#include "hydra_utils.h"
-HYD_Status HYDU_set_signal(int signum, void (*handler) (int))
+HYD_status HYDU_set_signal(int signum, void (*handler) (int))
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
#if defined HAVE_SIGACTION
struct sigaction act;
#endif
@@ -38,9 +38,9 @@
}
-HYD_Status HYDU_set_common_signals(void (*handler) (int))
+HYD_status HYDU_set_common_signals(void (*handler) (int))
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/utils/sock/sock.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/sock/sock.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/utils/sock/sock.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,14 +8,14 @@
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-HYD_Status HYDU_sock_listen(int *listen_fd, char *port_range, uint16_t * port)
+HYD_status HYDU_sock_listen(int *listen_fd, char *port_range, uint16_t * port)
{
struct sockaddr_in sa;
int one = 1;
uint16_t low_port, high_port;
char *port_str;
uint16_t i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -107,11 +107,11 @@
}
-HYD_Status HYDU_sock_connect(const char *host, uint16_t port, int *fd)
+HYD_status HYDU_sock_connect(const char *host, uint16_t port, int *fd)
{
struct hostent *ht;
struct sockaddr_in sa;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -138,7 +138,7 @@
* return an error, but only print a warning message. The upper
* layer can decide what to do with the return status. */
if (connect(*fd, (struct sockaddr *) &sa, sizeof(sa)) < 0) {
- HYDU_Error_printf("connect error (%s)\n", HYDU_strerror(errno));
+ HYDU_error_printf("connect error (%s)\n", HYDU_strerror(errno));
status = HYD_SOCK_ERROR;
goto fn_fail;
}
@@ -152,9 +152,9 @@
}
-HYD_Status HYDU_sock_accept(int listen_fd, int *fd)
+HYD_status HYDU_sock_accept(int listen_fd, int *fd)
{
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -172,13 +172,13 @@
}
-/* HYD_Sock_readline: Return the next newline-terminated string of
+/* HYD_sock_readline: Return the next newline-terminated string of
* maximum length maxlen. This is a buffered version, and reads from
* fd as necessary. */
-HYD_Status HYDU_sock_readline(int fd, char *buf, int maxlen, int *linelen)
+HYD_status HYDU_sock_readline(int fd, char *buf, int maxlen, int *linelen)
{
int n;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -221,10 +221,10 @@
}
-HYD_Status HYDU_sock_writeline(int fd, const char *buf, int maxsize)
+HYD_status HYDU_sock_writeline(int fd, const char *buf, int maxsize)
{
int n;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -248,11 +248,11 @@
}
-HYD_Status HYDU_sock_read(int fd, void *buf, int maxlen, int *count,
+HYD_status HYDU_sock_read(int fd, void *buf, int maxlen, int *count,
enum HYDU_sock_comm_flag flag)
{
int tmp;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -285,10 +285,10 @@
}
-HYD_Status HYDU_sock_write(int fd, const void *buf, int maxsize)
+HYD_status HYDU_sock_write(int fd, const void *buf, int maxsize)
{
int n;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -309,10 +309,10 @@
}
-HYD_Status HYDU_sock_trywrite(int fd, const void *buf, int maxsize)
+HYD_status HYDU_sock_trywrite(int fd, const void *buf, int maxsize)
{
int n;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -321,7 +321,7 @@
} while (n < 0 && errno == EINTR);
if (n < maxsize) {
- HYDU_Warn_printf("write error (%s)\n", HYDU_strerror(errno));
+ HYDU_warn_printf("write error (%s)\n", HYDU_strerror(errno));
status = HYD_SOCK_ERROR;
goto fn_fail;
}
@@ -335,10 +335,10 @@
}
-HYD_Status HYDU_sock_set_nonblock(int fd)
+HYD_status HYDU_sock_set_nonblock(int fd)
{
int flags;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -357,10 +357,10 @@
}
-HYD_Status HYDU_sock_set_cloexec(int fd)
+HYD_status HYDU_sock_set_cloexec(int fd)
{
int flags;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -376,11 +376,11 @@
}
-HYD_Status HYDU_sock_stdout_cb(int fd, HYD_Event_t events, int stdout_fd, int *closed)
+HYD_status HYDU_sock_stdout_cb(int fd, HYD_event_t events, int stdout_fd, int *closed)
{
int count, written, ret;
char buf[HYD_TMPBUF_SIZE];
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -419,11 +419,11 @@
}
-HYD_Status HYDU_sock_stdin_cb(int fd, HYD_Event_t events, int stdin_fd, char *buf,
+HYD_status HYDU_sock_stdin_cb(int fd, HYD_event_t events, int stdin_fd, char *buf,
int *buf_count, int *buf_offset, int *closed)
{
int count;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/utils/string/string.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/string/string.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/utils/string/string.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -6,10 +6,10 @@
#include "hydra_utils.h"
-HYD_Status HYDU_list_append_strlist(char **src_strlist, char **dest_strlist)
+HYD_status HYDU_list_append_strlist(char **src_strlist, char **dest_strlist)
{
int i, j;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -23,10 +23,10 @@
}
-HYD_Status HYDU_print_strlist(char **strlist)
+HYD_status HYDU_print_strlist(char **strlist)
{
int arg;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -52,10 +52,10 @@
}
-HYD_Status HYDU_str_alloc_and_join(char **strlist, char **strjoin)
+HYD_status HYDU_str_alloc_and_join(char **strlist, char **strjoin)
{
int len = 0, i, count;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -81,10 +81,10 @@
}
-HYD_Status HYDU_strsplit(char *str, char **str1, char **str2, char sep)
+HYD_status HYDU_strsplit(char *str, char **str1, char **str2, char sep)
{
int i;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -110,10 +110,10 @@
}
-HYD_Status HYDU_strdup_list(char *src[], char **dest[])
+HYD_status HYDU_strdup_list(char *src[], char **dest[])
{
int i, count;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -137,7 +137,7 @@
{
int len = 1, max = 10, y;
char *str;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -195,7 +195,7 @@
int argc = 0, i;
char **strlist = NULL;
char *p;
- HYD_Status status = HYD_SUCCESS;
+ HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/utils/timer/timer.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/timer/timer.c 2009-10-15 23:50:22 UTC (rev 5471)
+++ mpich2/trunk/src/pm/hydra/utils/timer/timer.c 2009-10-16 04:24:58 UTC (rev 5472)
@@ -8,7 +8,7 @@
/* FIXME: Here we assume that the timer is gettimeofday. */
-void HYDU_time_set(HYD_Time * time_p, int *val)
+void HYDU_time_set(HYD_time * time_p, int *val)
{
if (val == NULL) {
/* Set time to right now */
@@ -21,9 +21,9 @@
}
-int HYDU_time_left(HYD_Time start, HYD_Time timeout)
+int HYDU_time_left(HYD_time start, HYD_time timeout)
{
- HYD_Time now;
+ HYD_time now;
int time_left;
HYDU_FUNC_ENTER();
More information about the mpich2-commits
mailing list