[mpich2-commits] r4140 - in mpich2/trunk/src/pm/hydra: bootstrap/fork bootstrap/slurm bootstrap/ssh bootstrap/utils control/consys control/include demux include launcher/mpiexec launcher/utils pm/central pm/include pm/utils utils utils/args utils/env utils/launch utils/signals utils/sock utils/string utils/timer
balaji at mcs.anl.gov
balaji at mcs.anl.gov
Fri Mar 20 01:00:17 CDT 2009
Author: balaji
Date: 2009-03-20 01:00:15 -0500 (Fri, 20 Mar 2009)
New Revision: 4140
Removed:
mpich2/trunk/src/pm/hydra/utils/dbg/
Modified:
mpich2/trunk/src/pm/hydra/bootstrap/fork/fork_launch.c
mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_launch.c
mpich2/trunk/src/pm/hydra/bootstrap/ssh/ssh_launch.c
mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_wait.c
mpich2/trunk/src/pm/hydra/control/consys/consys_close.c
mpich2/trunk/src/pm/hydra/control/consys/consys_finalize.c
mpich2/trunk/src/pm/hydra/control/consys/consys_launch.c
mpich2/trunk/src/pm/hydra/control/consys/consys_wait.c
mpich2/trunk/src/pm/hydra/control/include/csi.h
mpich2/trunk/src/pm/hydra/demux/demux.c
mpich2/trunk/src/pm/hydra/demux/demux.h
mpich2/trunk/src/pm/hydra/include/hydra.h
mpich2/trunk/src/pm/hydra/include/hydra_utils.h
mpich2/trunk/src/pm/hydra/launcher/mpiexec/callback.c
mpich2/trunk/src/pm/hydra/launcher/mpiexec/mpiexec.c
mpich2/trunk/src/pm/hydra/launcher/mpiexec/mpiexec.h
mpich2/trunk/src/pm/hydra/launcher/mpiexec/utils.c
mpich2/trunk/src/pm/hydra/launcher/utils/lchu.c
mpich2/trunk/src/pm/hydra/launcher/utils/lchu.h
mpich2/trunk/src/pm/hydra/pm/central/central_cb.c
mpich2/trunk/src/pm/hydra/pm/central/central_finalize.c
mpich2/trunk/src/pm/hydra/pm/central/central_launch.c
mpich2/trunk/src/pm/hydra/pm/central/proxy.c
mpich2/trunk/src/pm/hydra/pm/central/proxy_cb.c
mpich2/trunk/src/pm/hydra/pm/central/proxy_utils.c
mpich2/trunk/src/pm/hydra/pm/include/pmci.h
mpich2/trunk/src/pm/hydra/pm/utils/pmcu_pmi.h
mpich2/trunk/src/pm/hydra/pm/utils/pmi.c
mpich2/trunk/src/pm/hydra/utils/Makefile.sm
mpich2/trunk/src/pm/hydra/utils/args/args.c
mpich2/trunk/src/pm/hydra/utils/env/env.c
mpich2/trunk/src/pm/hydra/utils/launch/allocate.c
mpich2/trunk/src/pm/hydra/utils/launch/launch.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:
Several cleanups to the overall Hydra code. We now use a consistent
naming convention everywhere. Utility functions are more general. And
several hacks in the code have been removed and handled in a cleaner
manner.
Modified: mpich2/trunk/src/pm/hydra/bootstrap/fork/fork_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/fork/fork_launch.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/bootstrap/fork/fork_launch.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -39,7 +39,7 @@
/* The stdin pointer will be some value for process_id 0;
* for everyone else, it's NULL. */
- status = HYDU_Create_process(client_arg, (process_id == 0 ? &handle.in : NULL),
+ status = HYDU_create_process(client_arg, (process_id == 0 ? &handle.in : NULL),
&partition->out, &partition->err, &partition->pid,
-1);
HYDU_ERR_POP(status, "create process returned error\n");
Modified: mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_launch.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_launch.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -55,7 +55,7 @@
/* The stdin pointer will be some value for process_id 0;
* for everyone else, it's NULL. */
- status = HYDU_Create_process(client_arg, (process_id == 0 ? &handle.in : NULL),
+ status = HYDU_create_process(client_arg, (process_id == 0 ? &handle.in : NULL),
&partition->out, &partition->err, &partition->pid,
-1);
if (status != HYD_SUCCESS) {
Modified: mpich2/trunk/src/pm/hydra/bootstrap/ssh/ssh_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/ssh/ssh_launch.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/bootstrap/ssh/ssh_launch.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -59,7 +59,7 @@
/* The stdin pointer will be some value for process_id 0;
* for everyone else, it's NULL. */
- status = HYDU_Create_process(client_arg, (process_id == 0 ? &handle.in : NULL),
+ status = HYDU_create_process(client_arg, (process_id == 0 ? &handle.in : NULL),
&partition->out, &partition->err, &partition->pid,
-1);
HYDU_ERR_POP(status, "create process returned error\n");
Modified: mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_wait.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_wait.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_wait.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -51,7 +51,7 @@
}
}
}
- if (HYDU_Time_left(handle.start, handle.timeout) == 0)
+ if (HYDU_time_left(handle.start, handle.timeout) == 0)
break;
/* FIXME: If we did not break out yet, add a small usleep to
Modified: mpich2/trunk/src/pm/hydra/control/consys/consys_close.c
===================================================================
--- mpich2/trunk/src/pm/hydra/control/consys/consys_close.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/control/consys/consys_close.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -12,7 +12,7 @@
HYD_Handle handle;
-HYD_Status HYD_CSI_Close_fd(int fd)
+HYD_Status HYD_CSI_close_fd(int fd)
{
struct HYD_Proc_params *proc_params;
struct HYD_Partition_list *partition;
@@ -21,7 +21,7 @@
HYDU_FUNC_ENTER();
/* Deregister the FD with the demux engine and close it. */
- status = HYD_DMX_Deregister_fd(fd);
+ status = HYD_DMX_deregister_fd(fd);
HYDU_ERR_SETANDJUMP1(status, status, "error deregistering fd %d\n", fd);
close(fd);
Modified: mpich2/trunk/src/pm/hydra/control/consys/consys_finalize.c
===================================================================
--- mpich2/trunk/src/pm/hydra/control/consys/consys_finalize.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/control/consys/consys_finalize.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -9,16 +9,16 @@
#include "pmci.h"
#include "demux.h"
-HYD_Status HYD_CSI_Finalize(void)
+HYD_Status HYD_CSI_finalize(void)
{
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_PMCI_Finalize();
+ status = HYD_PMCI_finalize();
HYDU_ERR_POP(status, "error returned from PM finalize\n");
- status = HYD_DMX_Finalize();
+ status = HYD_DMX_finalize();
HYDU_ERR_POP(status, "error returned from demux finalize\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/control/consys/consys_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/control/consys/consys_launch.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/control/consys/consys_launch.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -12,7 +12,7 @@
HYD_Handle handle;
-HYD_Status HYD_CSI_Launch_procs(void)
+HYD_Status HYD_CSI_launch_procs(void)
{
struct HYD_Proc_params *proc_params;
struct HYD_Partition_list *partition;
@@ -21,33 +21,33 @@
HYDU_FUNC_ENTER();
- status = HYD_PMCI_Launch_procs();
+ status = HYD_PMCI_launch_procs();
HYDU_ERR_POP(status, "PM returned error while launching processes\n");
for (proc_params = handle.proc_params; proc_params; proc_params = proc_params->next) {
for (partition = proc_params->partition; partition; partition = partition->next) {
status =
- HYD_DMX_Register_fd(1, &partition->out, HYD_STDOUT, proc_params->stdout_cb);
+ HYD_DMX_register_fd(1, &partition->out, HYD_STDOUT, proc_params->stdout_cb);
HYDU_ERR_POP(status, "demux returned error registering fd\n");
status =
- HYD_DMX_Register_fd(1, &partition->err, HYD_STDOUT, proc_params->stderr_cb);
+ HYD_DMX_register_fd(1, &partition->err, HYD_STDOUT, proc_params->stderr_cb);
HYDU_ERR_POP(status, "demux returned error registering fd\n");
}
}
if (handle.in != -1) { /* Only process_id 0 */
- status = HYDU_Sock_set_nonblock(handle.in);
+ status = HYDU_sock_set_nonblock(handle.in);
HYDU_ERR_POP(status, "unable to set socket as non-blocking\n");
stdin_fd = 0;
- status = HYDU_Sock_set_nonblock(stdin_fd);
+ status = HYDU_sock_set_nonblock(stdin_fd);
HYDU_ERR_POP(status, "unable to set socket as non-blocking\n");
handle.stdin_buf_count = 0;
handle.stdin_buf_offset = 0;
- status = HYD_DMX_Register_fd(1, &stdin_fd, HYD_STDIN, handle.stdin_cb);
+ status = HYD_DMX_register_fd(1, &stdin_fd, HYD_STDIN, handle.stdin_cb);
HYDU_ERR_POP(status, "demux returned error registering fd\n");
}
Modified: mpich2/trunk/src/pm/hydra/control/consys/consys_wait.c
===================================================================
--- mpich2/trunk/src/pm/hydra/control/consys/consys_wait.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/control/consys/consys_wait.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -12,7 +12,7 @@
HYD_Handle handle;
-HYD_Status HYD_CSI_Wait_for_completion(void)
+HYD_Status HYD_CSI_wait_for_completion(void)
{
int sockets_open;
struct HYD_Proc_params *proc_params;
@@ -23,7 +23,7 @@
while (1) {
/* Wait for some event to occur */
- status = HYD_DMX_Wait_for_event(HYDU_Time_left(handle.start, handle.timeout));
+ status = HYD_DMX_wait_for_event(HYDU_time_left(handle.start, handle.timeout));
HYDU_ERR_POP(status, "error waiting for event\n");
/* Check to see if there's any open read socket left; if there
@@ -40,12 +40,12 @@
break;
}
- if (sockets_open && HYDU_Time_left(handle.start, handle.timeout))
+ if (sockets_open && HYDU_time_left(handle.start, handle.timeout))
continue;
/* Make sure all the processes have terminated. The process
* manager control device will take care of that. */
- status = HYD_PMCI_Wait_for_completion();
+ status = HYD_PMCI_wait_for_completion();
HYDU_ERR_POP(status, "error waiting for completion\n");
/* We are done */
Modified: mpich2/trunk/src/pm/hydra/control/include/csi.h
===================================================================
--- mpich2/trunk/src/pm/hydra/control/include/csi.h 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/control/include/csi.h 2009-03-20 06:00:15 UTC (rev 4140)
@@ -9,9 +9,9 @@
#include "hydra.h"
-HYD_Status HYD_CSI_Launch_procs(void);
-HYD_Status HYD_CSI_Wait_for_completion(void);
-HYD_Status HYD_CSI_Close_fd(int fd);
-HYD_Status HYD_CSI_Finalize(void);
+HYD_Status HYD_CSI_launch_procs(void);
+HYD_Status HYD_CSI_wait_for_completion(void);
+HYD_Status HYD_CSI_close_fd(int fd);
+HYD_Status HYD_CSI_finalize(void);
#endif /* CSI_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/demux/demux.c
===================================================================
--- mpich2/trunk/src/pm/hydra/demux/demux.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/demux/demux.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -10,21 +10,21 @@
static int num_cb_fds = 0;
-typedef struct HYD_DMXI_Callback {
+typedef struct HYD_DMXI_callback {
int num_fds;
int *fd;
HYD_Event_t events;
HYD_Status(*callback) (int fd, HYD_Event_t events);
- struct HYD_DMXI_Callback *next;
-} HYD_DMXI_Callback_t;
+ struct HYD_DMXI_callback *next;
+} HYD_DMXI_callback_t;
-static HYD_DMXI_Callback_t *cb_list = NULL;
+static HYD_DMXI_callback_t *cb_list = NULL;
-HYD_Status HYD_DMX_Register_fd(int num_fds, int *fd, HYD_Event_t events,
+HYD_Status HYD_DMX_register_fd(int num_fds, int *fd, HYD_Event_t events,
HYD_Status(*callback) (int fd, HYD_Event_t events))
{
- HYD_DMXI_Callback_t *cb_element, *run;
+ HYD_DMXI_callback_t *cb_element, *run;
int i;
HYD_Status status = HYD_SUCCESS;
@@ -35,7 +35,7 @@
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, HYD_DMXI_callback_t *, sizeof(HYD_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));
@@ -64,10 +64,10 @@
}
-HYD_Status HYD_DMX_Deregister_fd(int fd)
+HYD_Status HYD_DMX_deregister_fd(int fd)
{
int i;
- HYD_DMXI_Callback_t *cb_element;
+ HYD_DMXI_callback_t *cb_element;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -97,10 +97,10 @@
}
-HYD_Status HYD_DMX_Wait_for_event(int time)
+HYD_Status HYD_DMX_wait_for_event(int time)
{
int total_fds, i, j, events, ret;
- HYD_DMXI_Callback_t *run;
+ HYD_DMXI_callback_t *run;
struct pollfd *pollfds = NULL;
HYD_Status status = HYD_SUCCESS;
@@ -140,7 +140,7 @@
goto fn_exit;
}
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "poll error (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
}
break;
}
@@ -184,9 +184,9 @@
}
-HYD_Status HYD_DMX_Finalize(void)
+HYD_Status HYD_DMX_finalize(void)
{
- HYD_DMXI_Callback_t *run1, *run2;
+ HYD_DMXI_callback_t *run1, *run2;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
Modified: mpich2/trunk/src/pm/hydra/demux/demux.h
===================================================================
--- mpich2/trunk/src/pm/hydra/demux/demux.h 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/demux/demux.h 2009-03-20 06:00:15 UTC (rev 4140)
@@ -9,10 +9,10 @@
#include "hydra.h"
-HYD_Status HYD_DMX_Register_fd(int num_fds, int *fd, HYD_Event_t events,
+HYD_Status HYD_DMX_register_fd(int num_fds, int *fd, HYD_Event_t events,
HYD_Status(*callback) (int fd, HYD_Event_t events));
-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 HYD_DMX_deregister_fd(int fd);
+HYD_Status HYD_DMX_wait_for_event(int time);
+HYD_Status HYD_DMX_finalize(void);
#endif /* DEMUX_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/include/hydra.h
===================================================================
--- mpich2/trunk/src/pm/hydra/include/hydra.h 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/include/hydra.h 2009-03-20 06:00:15 UTC (rev 4140)
@@ -69,16 +69,16 @@
/* We'll use this as the central handle that has most of the
* information needed by everyone. All data to be written has to be
- * done before the HYD_CSI_Wait_for_completion() function is called,
+ * done before the HYD_CSI_wait_for_completion() function is called,
* except for two exceptions:
*
* 1. The timeout value is initially added by the launcher before the
- * HYD_CSI_Wait_for_completion() function is called, but can be edited
+ * HYD_CSI_wait_for_completion() function is called, but can be edited
* by the control system within this call. There's no guarantee on
* what value it will contain for the other layers.
*
* 2. There is no guarantee on what the exit status will contain till
- * the HYD_CSI_Wait_for_completion() function returns (where the
+ * the HYD_CSI_wait_for_completion() function returns (where the
* bootstrap server can fill out these values).
*/
extern HYD_Handle handle;
Modified: mpich2/trunk/src/pm/hydra/include/hydra_utils.h
===================================================================
--- mpich2/trunk/src/pm/hydra/include/hydra_utils.h 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/include/hydra_utils.h 2009-03-20 06:00:15 UTC (rev 4140)
@@ -9,45 +9,38 @@
#include "hydra_base.h"
-/* Environment utilities */
-HYD_Status HYDU_Env_global_list(HYD_Env_t ** env_list);
-HYD_Env_t *HYDU_Env_dup(HYD_Env_t env);
-HYD_Env_t *HYDU_Env_listdup(HYD_Env_t * env);
-HYD_Status HYDU_Env_create(HYD_Env_t ** env, 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_found_in_list(HYD_Env_t * env_list, HYD_Env_t env);
-HYD_Status HYDU_Env_add_to_list(HYD_Env_t ** env_list, HYD_Env_t env);
-HYD_Status HYDU_Env_assign_form(HYD_Env_t env, char **env_str);
-void HYDU_Env_putenv(char *env_str);
+/* args */
+HYD_Status HYDU_get_base_path(char *execname, char *wdir, char **path);
-/* Launch utilities */
+/* bind */
+#if defined PROC_BINDING
+#include "plpa.h"
+#include "plpa_internal.h"
+HYD_Status HYDU_bind_process(int core);
+#else
+#define HYDU_bind_process(...) HYD_SUCCESS
+#endif /* PROC_BINDING */
+
+
+/* env */
+HYD_Status HYDU_list_append_env_to_str(HYD_Env_t * env_list, char **str_list);
+HYD_Status HYDU_list_global_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, 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(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);
+void HYDU_putenv(char *env_str);
+
+
+/* launch */
struct HYD_Partition_list {
char *name;
int proc_count;
char **mapping; /* Can be core IDs or something else */
- /*
- * The boot-strap server is expected to start a single executable
- * on the first possible node and return a single PID. This
- * executable could be a PM proxy that will launch the actual
- * application on the rest of the partition list.
- *
- * Possible hacks:
- *
- * 1. If the process manager needs more proxies within this same
- * list, it can use different group IDs. Each group ID will
- * have its own proxy.
- *
- * 2. If no proxy is needed, the PM can split this list into one
- * element per process. The boot-strap server itself does not
- * distinguish a proxy from the application executable, so it
- * will not require any changes.
- *
- * 3. One proxy per physical node means that each partition will
- * have a different group ID.
- */
int group_id; /* Assumed to be in ascending order */
int group_rank; /* Rank within the group */
int pid;
@@ -59,35 +52,60 @@
struct HYD_Partition_list *next;
};
-HYD_Status HYDU_Allocate_Partition(struct HYD_Partition_list **partition);
-void HYDU_Free_partition_list(struct HYD_Partition_list *partition);
+HYD_Status HYDU_alloc_partition(struct HYD_Partition_list **partition);
+void HYDU_free_partition_list(struct HYD_Partition_list *partition);
+HYD_Status HYDU_create_process(char **client_arg, int *in, int *out, int *err,
+ int *pid, int core);
-HYD_Status HYDU_Append_env(HYD_Env_t * env_list, char **client_arg);
-HYD_Status HYDU_Append_exec(char **exec, char **client_arg);
-HYD_Status HYDU_Append_wdir(char **client_arg, char *wdir);
-HYD_Status HYDU_Dump_args(char **args);
-void HYDU_Free_args(char **args);
-HYD_Status HYDU_Create_process(char **client_arg, int *in, int *out, int *err, int *pid,
- int core);
-HYD_Status HYDU_Get_base_path(char *execname, char **path);
-HYD_Status HYDU_Chdir(const char *dir);
+/* signals */
+#ifdef NEEDS_POSIX_FOR_SIGACTION
+#define _POSIX_SOURCE
+#endif
-/* Process binding */
-#if defined PROC_BINDING
+#include <sys/wait.h>
+#if defined(USE_SIGNAL) || defined(USE_SIGACTION)
+#include <signal.h>
+#else
+#error no signal choice
+#endif
+#ifdef NEEDS_STRSIGNAL_DECL
+extern char *strsignal(int);
+#endif
-#include "plpa.h"
-#include "plpa_internal.h"
+HYD_Status HYDU_set_signal(int signum, void (*handler) (int));
+HYD_Status HYDU_set_common_signals(void (*handler) (int));
-HYD_Status HYDU_bind_process(int core);
-#else
+/* Sock utilities */
+#include <poll.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
-#define HYDU_bind_process(...) HYD_SUCCESS
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
-#endif /* PROC_BINDING */
+#if !defined size_t
+#define size_t unsigned int
+#endif /* size_t */
+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_read(int fd, void *buf, int maxlen, int *count);
+HYD_Status HYDU_sock_writeline(int fd, char *buf, int maxsize);
+HYD_Status HYDU_sock_write(int fd, 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, char *buf, int *buf_count,
+ int *buf_offset, int *closed);
+
/* Memory utilities */
#define HYDU_NUM_JOIN_STR 100
@@ -113,67 +131,22 @@
"failed duping string %s\n", (src)); \
}
-HYD_Status HYDU_String_alloc_and_join(char **strlist, char **strjoin);
-HYD_Status HYDU_String_break(char *str, char **str1, char **str2);
-HYD_Status HYDU_String_int_to_str(int x, char **str);
-char *HYDU_String_error(int error);
+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_int_to_str(int x, char **str);
+char *HYDU_strerror(int error);
-/* Signal utilities */
-#ifdef NEEDS_POSIX_FOR_SIGACTION
-#define _POSIX_SOURCE
-#endif
-
-#include <sys/wait.h>
-#if defined(USE_SIGNAL) || defined(USE_SIGACTION)
-#include <signal.h>
-#else
-#error no signal choice
-#endif
-#ifdef NEEDS_STRSIGNAL_DECL
-extern char *strsignal(int);
-#endif
-
-HYD_Status HYDU_Set_signal(int signum, void (*handler) (int));
-HYD_Status HYDU_Set_common_signals(void (*handler) (int));
-
-
/* Timer utilities */
/* 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);
+void HYDU_time_set(HYD_Time * time, int *val);
+int HYDU_time_left(HYD_Time start, HYD_Time timeout);
-
-/* Sock utilities */
-#include <poll.h>
-#include <fcntl.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-
-#ifdef HAVE_SYS_SOCKET_H
-#include <sys/socket.h>
-#endif
-
-#if !defined size_t
-#define size_t unsigned int
-#endif /* size_t */
-
-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_read(int fd, void *buf, int maxlen, int *count);
-HYD_Status HYDU_Sock_writeline(int fd, char *buf, int maxsize);
-HYD_Status HYDU_Sock_write(int fd, 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, char *buf, int *buf_count,
- int *buf_offset, int *closed);
-
#endif /* HYDRA_UTILS_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/launcher/mpiexec/callback.c
===================================================================
--- mpich2/trunk/src/pm/hydra/launcher/mpiexec/callback.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/launcher/mpiexec/callback.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -19,14 +19,14 @@
HYDU_FUNC_ENTER();
/* Write output to fd 1 */
- status = HYDU_Sock_stdout_cb(fd, events, 1, &closed);
+ status = HYDU_sock_stdout_cb(fd, events, 1, &closed);
HYDU_ERR_SETANDJUMP2(status, status, "stdout callback error on fd %d: %s\n",
- fd, HYDU_String_error(errno));
+ fd, HYDU_strerror(errno));
if (closed) {
- status = HYD_CSI_Close_fd(fd);
+ status = HYD_CSI_close_fd(fd);
HYDU_ERR_SETANDJUMP2(status, status, "socket close error on fd %d: %s\n",
- fd, HYDU_String_error(errno));
+ fd, HYDU_strerror(errno));
goto fn_exit;
}
@@ -47,14 +47,14 @@
HYDU_FUNC_ENTER();
/* Write output to fd 2 */
- status = HYDU_Sock_stdout_cb(fd, events, 2, &closed);
+ status = HYDU_sock_stdout_cb(fd, events, 2, &closed);
HYDU_ERR_SETANDJUMP2(status, status, "stdout callback error on %d (%s)\n",
- fd, HYDU_String_error(errno))
+ fd, HYDU_strerror(errno))
if (closed) {
- status = HYD_CSI_Close_fd(fd);
+ status = HYD_CSI_close_fd(fd);
HYDU_ERR_SETANDJUMP2(status, status, "socket close error on fd %d (%s)\n",
- fd, HYDU_String_error(errno));
+ fd, HYDU_strerror(errno));
goto fn_exit;
}
@@ -74,12 +74,12 @@
HYDU_FUNC_ENTER();
- status = HYDU_Sock_stdin_cb(handle.in, events, handle.stdin_tmp_buf,
+ status = HYDU_sock_stdin_cb(handle.in, events, handle.stdin_tmp_buf,
&handle.stdin_buf_count, &handle.stdin_buf_offset, &closed);
HYDU_ERR_POP(status, "stdin callback error\n");
if (closed) {
- status = HYD_CSI_Close_fd(fd);
+ status = HYD_CSI_close_fd(fd);
HYDU_ERR_SETANDJUMP2(status, status, "socket close error on fd %d (errno: %d)\n",
fd, errno);
Modified: mpich2/trunk/src/pm/hydra/launcher/mpiexec/mpiexec.c
===================================================================
--- mpich2/trunk/src/pm/hydra/launcher/mpiexec/mpiexec.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/launcher/mpiexec/mpiexec.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -55,7 +55,7 @@
HYDU_FUNC_ENTER();
- status = HYD_LCHI_Get_parameters(argc, argv);
+ status = HYD_LCHI_get_parameters(argc, argv);
if (status == HYD_GRACEFUL_ABORT) {
exit(0);
}
@@ -64,17 +64,15 @@
goto fn_fail;
}
- if (handle.debug) {
- status = HYD_LCHI_Print_parameters();
- HYDU_ERR_POP(status, "");
- }
+ if (handle.debug)
+ HYD_LCHI_print_parameters();
/* Convert the host file to a host list */
- status = HYD_LCHU_Create_host_list();
+ status = HYD_LCHU_create_host_list();
HYDU_ERR_POP(status, "unable to create host list\n");
/* Consolidate the environment list that we need to propagate */
- status = HYD_LCHU_Create_env_list();
+ status = HYD_LCHU_create_env_list();
HYDU_ERR_POP(status, "unable to create env list\n");
proc_params = handle.proc_params;
@@ -85,20 +83,20 @@
}
handle.stdin_cb = HYD_LCHI_stdin_cb;
- HYDU_Time_set(&handle.start, NULL); /* NULL implies right now */
+ HYDU_time_set(&handle.start, NULL); /* NULL implies right now */
if (getenv("MPIEXEC_TIMEOUT"))
timeout = atoi(getenv("MPIEXEC_TIMEOUT"));
else
timeout = -1; /* Set a negative timeout */
HYDU_Debug("Timeout set to %d seconds (negative means infinite)\n", timeout);
- HYDU_Time_set(&handle.timeout, &timeout);
+ HYDU_time_set(&handle.timeout, &timeout);
/* Launch the processes */
- status = HYD_CSI_Launch_procs();
+ status = HYD_CSI_launch_procs();
HYDU_ERR_POP(status, "control system error launching processes\n");
/* Wait for their completion */
- status = HYD_CSI_Wait_for_completion();
+ status = HYD_CSI_wait_for_completion();
HYDU_ERR_POP(status, "control system error waiting for completion\n");
/* Check for the exit status for all the processes */
@@ -108,11 +106,11 @@
exit_status |= partition->exit_status;
/* Call finalize functions for lower layers to cleanup their resources */
- status = HYD_CSI_Finalize();
+ status = HYD_CSI_finalize();
HYDU_ERR_POP(status, "control system error on finalize\n");
/* Free the mpiexec params */
- HYD_LCHU_Free_params();
+ HYD_LCHU_free_params();
fn_exit:
HYDU_FUNC_EXIT();
Modified: mpich2/trunk/src/pm/hydra/launcher/mpiexec/mpiexec.h
===================================================================
--- mpich2/trunk/src/pm/hydra/launcher/mpiexec/mpiexec.h 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/launcher/mpiexec/mpiexec.h 2009-03-20 06:00:15 UTC (rev 4140)
@@ -9,8 +9,8 @@
#include "hydra.h"
-HYD_Status HYD_LCHI_Get_parameters(int t_argc, char **t_argv);
-HYD_Status HYD_LCHI_Print_parameters(void);
+HYD_Status HYD_LCHI_get_parameters(int t_argc, char **t_argv);
+void HYD_LCHI_print_parameters(void);
HYD_Status HYD_LCHI_stdout_cb(int fd, HYD_Event_t events);
HYD_Status HYD_LCHI_stderr_cb(int fd, HYD_Event_t events);
HYD_Status HYD_LCHI_stdin_cb(int fd, HYD_Event_t events);
Modified: mpich2/trunk/src/pm/hydra/launcher/mpiexec/utils.c
===================================================================
--- mpich2/trunk/src/pm/hydra/launcher/mpiexec/utils.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/launcher/mpiexec/utils.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -89,28 +89,25 @@
}
-HYD_Status HYD_LCHI_Get_parameters(int t_argc, char **t_argv)
+HYD_Status HYD_LCHI_get_parameters(int t_argc, char **t_argv)
{
int argc = t_argc, i;
char **argv = t_argv;
- char *env_name, *env_value, *str1, *str2;
+ char *env_name, *env_value, *str1, *str2, *progname = *argv;
HYD_Env_t *env;
struct HYD_Proc_params *proc_params;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYD_LCHU_Init_params();
+ HYD_LCHU_init_params();
- status = HYDU_Get_base_path(argv[0], &handle.base_path);
- HYDU_ERR_POP(status, "unable to get base path\n");
-
- status = HYDU_Env_global_list(&handle.global_env);
+ status = HYDU_list_global_env(&handle.global_env);
HYDU_ERR_POP(status, "unable to get the global env list\n");
while (--argc && ++argv) {
- status = HYDU_String_break(*argv, &str1, &str2);
+ status = HYDU_strsplit(*argv, &str1, &str2, '=');
HYDU_ERR_POP(status, "string break returned error\n");
if (!strcmp(str1, "-h") || !strcmp(str1, "--help") || !strcmp(str1, "-help"))
@@ -176,10 +173,10 @@
env_name = strtok(str2, ",");
do {
- status = HYDU_Env_create(&env, env_name, NULL);
+ status = HYDU_env_create(&env, env_name, NULL);
HYDU_ERR_POP(status, "unable to create env struct\n");
- status = HYDU_Env_add_to_list(&handle.user_env, *env);
+ status = HYDU_append_env_to_list(*env, &handle.user_env);
HYDU_ERR_POP(status, "unable to add env to list\n");
} while ((env_name = strtok(NULL, ",")));
}
@@ -211,10 +208,10 @@
if (env_name == NULL)
break;
- status = HYDU_Env_create(&env, env_name, NULL);
+ status = HYDU_env_create(&env, env_name, NULL);
HYDU_ERR_POP(status, "unable to create env struct\n");
- status = HYDU_Env_add_to_list(&proc_params->prop_env, *env);
+ status = HYDU_append_env_to_list(*env, &proc_params->prop_env);
HYDU_ERR_POP(status, "unable to add env to list\n");
} while (env_name);
}
@@ -232,16 +229,16 @@
CHECK_NEXT_ARG_VALID(status);
env_value = MPIU_Strdup(*argv);
- status = HYDU_Env_create(&env, env_name, env_value);
+ status = HYDU_env_create(&env, env_name, env_value);
HYDU_ERR_POP(status, "unable to create env struct\n");
if (!strcmp(str1, "-genv"))
- HYDU_Env_add_to_list(&handle.user_env, *env);
+ HYDU_append_env_to_list(*env, &handle.user_env);
else {
status = get_current_proc_params(&proc_params);
HYDU_ERR_POP(status, "get_current_proc_params returned error\n");
- HYDU_Env_add_to_list(&proc_params->user_env, *env);
+ HYDU_append_env_to_list(*env, &proc_params->user_env);
}
HYDU_FREE(env);
@@ -344,6 +341,9 @@
if (handle.host_file == NULL)
handle.host_file = MPIU_Strdup("HYDRA_USE_LOCALHOST");
+ status = HYDU_get_base_path(progname, handle.wdir, &handle.base_path);
+ HYDU_ERR_POP(status, "unable to get base path\n");
+
proc_params = handle.proc_params;
while (proc_params) {
if (proc_params->exec[0] == NULL)
@@ -370,13 +370,12 @@
}
-HYD_Status HYD_LCHI_Print_parameters(void)
+void HYD_LCHI_print_parameters(void)
{
HYD_Env_t *env;
int i, j;
struct HYD_Proc_params *proc_params;
struct HYD_Partition_list *partition;
- HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -455,5 +454,6 @@
HYDU_Debug("\n\n");
HYDU_FUNC_EXIT();
- return status;
+
+ return;
}
Modified: mpich2/trunk/src/pm/hydra/launcher/utils/lchu.c
===================================================================
--- mpich2/trunk/src/pm/hydra/launcher/utils/lchu.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/launcher/utils/lchu.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -10,7 +10,7 @@
HYD_Handle handle;
-void HYD_LCHU_Init_params()
+void HYD_LCHU_init_params(void)
{
handle.base_path = NULL;
handle.proxy_port = -1;
@@ -39,7 +39,7 @@
}
-void HYD_LCHU_Free_params()
+void HYD_LCHU_free_params(void)
{
if (handle.base_path) {
HYDU_FREE(handle.base_path);
@@ -60,33 +60,33 @@
}
if (handle.global_env) {
- HYDU_Env_free_list(handle.global_env);
+ HYDU_env_free_list(handle.global_env);
handle.global_env = NULL;
}
if (handle.system_env) {
- HYDU_Env_free_list(handle.system_env);
+ HYDU_env_free_list(handle.system_env);
handle.system_env = NULL;
}
if (handle.user_env) {
- HYDU_Env_free_list(handle.user_env);
+ HYDU_env_free_list(handle.user_env);
handle.user_env = NULL;
}
if (handle.prop_env) {
- HYDU_Env_free_list(handle.prop_env);
+ HYDU_env_free_list(handle.prop_env);
handle.prop_env = NULL;
}
if (handle.proc_params) {
- HYD_LCHU_Free_proc_params();
+ HYD_LCHU_free_proc_params();
handle.proc_params = NULL;
}
}
-void HYD_LCHU_Free_proc_params()
+void HYD_LCHU_free_proc_params(void)
{
struct HYD_Proc_params *proc_params, *run;
@@ -95,13 +95,13 @@
proc_params = handle.proc_params;
while (proc_params) {
run = proc_params->next;
- HYDU_Free_args(proc_params->exec);
- HYDU_Free_partition_list(proc_params->partition);
+ HYDU_free_strlist(proc_params->exec);
+ HYDU_free_partition_list(proc_params->partition);
proc_params->partition = NULL;
- HYDU_Env_free_list(proc_params->user_env);
+ HYDU_env_free_list(proc_params->user_env);
proc_params->user_env = NULL;
- HYDU_Env_free_list(proc_params->prop_env);
+ HYDU_env_free_list(proc_params->prop_env);
proc_params->prop_env = NULL;
HYDU_FREE(proc_params);
@@ -112,7 +112,7 @@
}
-HYD_Status HYD_LCHU_Create_host_list(void)
+HYD_Status HYD_LCHU_create_host_list(void)
{
FILE *fp = NULL;
char line[2 * MAX_HOSTNAME_LEN], *hostname, *procs;
@@ -134,7 +134,7 @@
proc_params = handle.proc_params;
while (proc_params) {
if (!strcmp(handle.host_file, "HYDRA_USE_LOCALHOST")) {
- HYDU_Allocate_Partition(&proc_params->partition);
+ HYDU_alloc_partition(&proc_params->partition);
proc_params->partition->name = MPIU_Strdup("localhost");
proc_params->partition->proc_count = proc_params->exec_proc_count;
total_procs = proc_params->exec_proc_count;
@@ -157,13 +157,13 @@
num_procs = (proc_params->exec_proc_count - total_procs);
if (!proc_params->partition) {
- HYDU_Allocate_Partition(&proc_params->partition);
+ HYDU_alloc_partition(&proc_params->partition);
partition = proc_params->partition;
}
else {
for (partition = proc_params->partition;
partition->next; partition = partition->next);
- HYDU_Allocate_Partition(&partition->next);
+ HYDU_alloc_partition(&partition->next);
partition = partition->next;
}
partition->name = MPIU_Strdup(hostname);
@@ -191,7 +191,7 @@
}
else {
while (total_procs != proc_params->exec_proc_count) {
- HYDU_Allocate_Partition(&partition->next);
+ HYDU_alloc_partition(&partition->next);
partition = partition->next;
partition->name = MPIU_Strdup(run->name);
partition->proc_count = run->proc_count;
@@ -219,7 +219,7 @@
}
-HYD_Status HYD_LCHU_Free_host_list(void)
+HYD_Status HYD_LCHU_free_host_list(void)
{
struct HYD_Proc_params *proc_params;
struct HYD_Partition_list *partition, *next;
@@ -251,7 +251,7 @@
}
-HYD_Status HYD_LCHU_Create_env_list(void)
+HYD_Status HYD_LCHU_create_env_list(void)
{
struct HYD_Proc_params *proc_params;
HYD_Env_t *env, *run;
@@ -260,17 +260,17 @@
HYDU_FUNC_ENTER();
if (handle.prop == HYD_ENV_PROP_ALL) {
- handle.prop_env = HYDU_Env_listdup(handle.global_env);
+ handle.prop_env = HYDU_env_list_dup(handle.global_env);
for (env = handle.user_env; env; env = env->next) {
- status = HYDU_Env_add_to_list(&handle.prop_env, *env);
+ status = HYDU_append_env_to_list(*env, &handle.prop_env);
HYDU_ERR_POP(status, "unable to add env to list\n");
}
}
else if (handle.prop == HYD_ENV_PROP_LIST) {
for (env = handle.user_env; env; env = env->next) {
- run = HYDU_Env_found_in_list(handle.global_env, *env);
+ run = HYDU_env_lookup(*env, handle.global_env);
if (run) {
- status = HYDU_Env_add_to_list(&handle.prop_env, *run);
+ status = HYDU_append_env_to_list(*run, &handle.prop_env);
HYDU_ERR_POP(status, "unable to add env to list\n");
}
}
@@ -279,17 +279,17 @@
proc_params = handle.proc_params;
while (proc_params) {
if (proc_params->prop == HYD_ENV_PROP_ALL) {
- proc_params->prop_env = HYDU_Env_listdup(handle.global_env);
+ proc_params->prop_env = HYDU_env_list_dup(handle.global_env);
for (env = proc_params->user_env; env; env = env->next) {
- status = HYDU_Env_add_to_list(&proc_params->prop_env, *env);
+ status = HYDU_append_env_to_list(*env, &proc_params->prop_env);
HYDU_ERR_POP(status, "unable to add env to list\n");
}
}
else if (proc_params->prop == HYD_ENV_PROP_LIST) {
for (env = proc_params->user_env; env; env = env->next) {
- run = HYDU_Env_found_in_list(handle.global_env, *env);
+ run = HYDU_env_lookup(*env, handle.global_env);
if (run) {
- status = HYDU_Env_add_to_list(&proc_params->prop_env, *run);
+ status = HYDU_append_env_to_list(*run, &proc_params->prop_env);
HYDU_ERR_POP(status, "unable to add env to list\n");
}
}
Modified: mpich2/trunk/src/pm/hydra/launcher/utils/lchu.h
===================================================================
--- mpich2/trunk/src/pm/hydra/launcher/utils/lchu.h 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/launcher/utils/lchu.h 2009-03-20 06:00:15 UTC (rev 4140)
@@ -9,10 +9,10 @@
#include "hydra.h"
-void HYD_LCHU_Init_params(void);
-void HYD_LCHU_Free_params(void);
-void HYD_LCHU_Free_proc_params(void);
-HYD_Status HYD_LCHU_Create_host_list(void);
-HYD_Status HYD_LCHU_Create_env_list(void);
+void HYD_LCHU_init_params(void);
+void HYD_LCHU_free_params(void);
+void HYD_LCHU_free_proc_params(void);
+HYD_Status HYD_LCHU_create_host_list(void);
+HYD_Status HYD_LCHU_create_env_list(void);
#endif /* LCHU_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/pm/central/central_cb.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/central/central_cb.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/pm/central/central_cb.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -53,14 +53,14 @@
HYDU_MALLOC(buf, char *, HYD_TMPBUF_SIZE, status);
if (fd == HYD_PMCD_Central_listenfd) { /* Someone is trying to connect to us */
- status = HYDU_Sock_accept(fd, &accept_fd);
+ status = HYDU_sock_accept(fd, &accept_fd);
HYDU_ERR_POP(status, "accept error\n");
- status = HYD_DMX_Register_fd(1, &accept_fd, HYD_STDOUT, HYD_PMCD_Central_cb);
+ status = HYD_DMX_register_fd(1, &accept_fd, HYD_STDOUT, HYD_PMCD_Central_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
}
else {
- status = HYDU_Sock_readline(fd, buf, HYD_TMPBUF_SIZE, &linelen);
+ status = HYDU_sock_readline(fd, buf, HYD_TMPBUF_SIZE, &linelen);
HYDU_ERR_POP(status, "PMI read line error\n");
if (linelen == 0) {
@@ -74,7 +74,7 @@
goto fn_fail;
}
- status = HYD_DMX_Deregister_fd(fd);
+ status = HYD_DMX_deregister_fd(fd);
if (status != HYD_SUCCESS) {
HYDU_Warn_printf("unable to deregister fd %d\n", fd);
status = HYD_SUCCESS;
@@ -127,7 +127,7 @@
status = HYD_PMCU_pmi_finalize(fd, args);
if (status == HYD_SUCCESS) {
- status = HYD_DMX_Deregister_fd(fd);
+ status = HYD_DMX_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to register fd\n");
close(fd);
}
@@ -176,14 +176,14 @@
cmd = KILLALL_PROCS;
for (proc_params = handle.proc_params; proc_params; proc_params = proc_params->next) {
for (partition = proc_params->partition; partition; partition = partition->next) {
- status = HYDU_Sock_connect(partition->name, handle.proxy_port, &fd);
+ status = HYDU_sock_connect(partition->name, handle.proxy_port, &fd);
if (status != HYD_SUCCESS) {
HYDU_Warn_printf("unable to connect to the proxy on %s\n", partition->name);
overall_status = HYD_INTERNAL_ERROR;
continue; /* Move on to the next proxy */
}
- status = HYDU_Sock_write(fd, &cmd, sizeof(cmd));
+ status = HYDU_sock_write(fd, &cmd, sizeof(cmd));
if (status != HYD_SUCCESS) {
HYDU_Warn_printf("unable to send data to the proxy on %s\n", partition->name);
overall_status = HYD_INTERNAL_ERROR;
Modified: mpich2/trunk/src/pm/hydra/pm/central/central_finalize.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/central/central_finalize.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/pm/central/central_finalize.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -13,7 +13,7 @@
int HYD_PMCD_Central_listenfd;
-HYD_Status HYD_PMCI_Finalize(void)
+HYD_Status HYD_PMCI_finalize(void)
{
HYD_Status status = HYD_SUCCESS;
@@ -21,13 +21,13 @@
/* Deregister the listen socket from the demux engine and close
* it. */
- status = HYD_DMX_Deregister_fd(HYD_PMCD_Central_listenfd);
+ status = HYD_DMX_deregister_fd(HYD_PMCD_Central_listenfd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
close(HYD_PMCD_Central_listenfd);
HYD_PMCD_Central_listenfd = -1;
- status = HYD_PMCU_Finalize();
+ status = HYD_PMCU_finalize();
HYDU_ERR_POP(status, "unable to finalize process manager utils\n");
status = HYD_BSCI_finalize();
Modified: mpich2/trunk/src/pm/hydra/pm/central/central_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/central/central_launch.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/pm/central/central_launch.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -16,7 +16,7 @@
HYD_Handle handle;
/*
- * HYD_PMCI_Launch_procs: Here are the steps we follow:
+ * HYD_PMCI_launch_procs: Here are the steps we follow:
*
* 1. Find what all ports the user wants to allow and listen on one of
* those ports.
@@ -34,7 +34,7 @@
* 5. Create a process info setup and ask the bootstrap server to
* launch the processes.
*/
-HYD_Status HYD_PMCI_Launch_procs(void)
+HYD_Status HYD_PMCI_launch_procs(void)
{
char *port_range, *port_str, *sport, *str;
uint16_t port;
@@ -49,7 +49,7 @@
HYDU_FUNC_ENTER();
- status = HYDU_Set_common_signals(HYD_PMCD_Central_signal_cb);
+ status = HYDU_set_common_signals(HYD_PMCD_Central_signal_cb);
HYDU_ERR_POP(status, "unable to set signal\n");
/* Check if the user wants us to use a port within a certain
@@ -62,11 +62,11 @@
/* Listen on a port in the port range */
port = 0;
- status = HYDU_Sock_listen(&HYD_PMCD_Central_listenfd, port_range, &port);
+ status = HYDU_sock_listen(&HYD_PMCD_Central_listenfd, port_range, &port);
HYDU_ERR_POP(status, "unable to listen on port\n");
/* Register the listening socket with the demux engine */
- status = HYD_DMX_Register_fd(1, &HYD_PMCD_Central_listenfd, HYD_STDOUT,
+ status = HYD_DMX_register_fd(1, &HYD_PMCD_Central_listenfd, HYD_STDOUT,
HYD_PMCD_Central_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
@@ -76,7 +76,7 @@
"gethostname error (hostname: %s; errno: %d)\n", hostname,
errno);
- status = HYDU_String_int_to_str(port, &sport);
+ status = HYDU_int_to_str(port, &sport);
HYDU_ERR_POP(status, "cannot convert int to string\n");
HYDU_MALLOC(port_str, char *, strlen(hostname) + 1 + strlen(sport) + 1, status);
@@ -85,18 +85,18 @@
HYDU_FREE(sport);
HYDU_Debug("Process manager listening on PMI port %s\n", port_str);
- status = HYDU_Env_create(&env, "PMI_PORT", port_str);
+ status = HYDU_env_create(&env, "PMI_PORT", port_str);
HYDU_ERR_POP(status, "unable to create env\n");
- status = HYDU_Env_add_to_list(&handle.system_env, *env);
+ status = HYDU_append_env_to_list(*env, &handle.system_env);
HYDU_ERR_POP(status, "unable to add env to list\n");
- HYDU_Env_free(env);
+ HYDU_env_free(env);
HYDU_FREE(port_str);
/* Create a process group for the MPI processes in this
* comm_world */
- status = HYD_PMCU_Create_pg();
+ status = HYD_PMCU_create_pg();
HYDU_ERR_POP(status, "unable to create process group\n");
/* Create the arguments list for each proxy */
@@ -110,21 +110,15 @@
for (arg = 0; partition->args[arg]; arg++);
i = 0;
- if (handle.base_path[0] && (handle.base_path[0] != '/')) {
- /* This should be a relative path; add the wdir as well */
- path_str[i++] = MPIU_Strdup(handle.wdir);
- path_str[i++] = MPIU_Strdup("/");
- }
path_str[i++] = MPIU_Strdup(handle.base_path);
path_str[i++] = MPIU_Strdup("hydproxy");
path_str[i] = NULL;
- status = HYDU_String_alloc_and_join(path_str, &partition->args[arg]);
+ status = HYDU_str_alloc_and_join(path_str, &partition->args[arg++]);
HYDU_ERR_POP(status, "unable to join strings\n");
- arg++;
- HYDU_Free_args(path_str);
+ HYDU_free_strlist(path_str);
- status = HYDU_String_int_to_str(partition->proc_count, &str);
+ status = HYDU_int_to_str(partition->proc_count, &str);
HYDU_ERR_POP(status, "unable to convert int to string\n");
partition->args[arg++] = MPIU_Strdup("--proc-count");
@@ -135,14 +129,14 @@
partition->args[arg++] = MPIU_Strdup(str);
HYDU_FREE(str);
- status = HYDU_String_int_to_str(process_id, &str);
+ status = HYDU_int_to_str(process_id, &str);
HYDU_ERR_POP(status, "unable to convert int to string\n");
partition->args[arg++] = MPIU_Strdup("--pmi-id");
partition->args[arg++] = MPIU_Strdup(str);
HYDU_FREE(str);
- status = HYDU_String_int_to_str(handle.proxy_port, &str);
+ status = HYDU_int_to_str(handle.proxy_port, &str);
HYDU_ERR_POP(status, "unable to convert in to string\n");
partition->args[arg++] = MPIU_Strdup("--proxy-port");
@@ -160,23 +154,23 @@
i++;
for (env = proc_params->prop_env; env; env = env->next)
i++;
- status = HYDU_String_int_to_str(i, &str);
+ status = HYDU_int_to_str(i, &str);
HYDU_ERR_POP(status, "unable to convert in to string\n");
partition->args[arg++] = MPIU_Strdup(str);
partition->args[arg++] = NULL;
- HYDU_Append_env(handle.system_env, partition->args);
- HYDU_Append_env(handle.prop_env, partition->args);
- HYDU_Append_env(proc_params->prop_env, partition->args);
+ HYDU_list_append_env_to_str(handle.system_env, partition->args);
+ HYDU_list_append_env_to_str(handle.prop_env, partition->args);
+ HYDU_list_append_env_to_str(proc_params->prop_env, partition->args);
for (arg = 0; partition->args[arg]; arg++);
partition->args[arg] = NULL;
- HYDU_Append_exec(proc_params->exec, partition->args);
+ HYDU_list_append_strlist(proc_params->exec, partition->args);
if (handle.debug) {
HYDU_Debug("Executable passed to the bootstrap: ");
- HYDU_Dump_args(partition->args);
+ HYDU_print_strlist(partition->args);
}
process_id += partition->proc_count;
@@ -200,7 +194,7 @@
}
-HYD_Status HYD_PMCI_Wait_for_completion(void)
+HYD_Status HYD_PMCI_wait_for_completion(void)
{
HYD_Status status = HYD_SUCCESS;
Modified: mpich2/trunk/src/pm/hydra/pm/central/proxy.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/central/proxy.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/pm/central/proxy.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -24,12 +24,12 @@
status = HYD_Proxy_get_params(argc, argv);
HYDU_ERR_POP(status, "bad parameters passed to the proxy\n");
- status = HYDU_Sock_listen(&HYD_Proxy_listenfd, NULL,
+ status = HYDU_sock_listen(&HYD_Proxy_listenfd, NULL,
(uint16_t *) & HYD_Proxy_params.proxy_port);
HYDU_ERR_POP(status, "unable to listen on socket\n");
/* Register the listening socket with the demux engine */
- status = HYD_DMX_Register_fd(1, &HYD_Proxy_listenfd, HYD_STDOUT, HYD_Proxy_listen_cb);
+ status = HYD_DMX_register_fd(1, &HYD_Proxy_listenfd, HYD_STDOUT, HYD_Proxy_listen_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
/* FIXME: We do not use the bootstrap server right now, as the
@@ -58,21 +58,22 @@
j = 0;
tmp[j++] = MPIU_Strdup("PMI_ID=");
- status = HYDU_String_int_to_str(HYD_Proxy_params.pmi_id + i, &str);
+ status = HYDU_int_to_str(HYD_Proxy_params.pmi_id + i, &str);
HYDU_ERR_POP(status, "unable to convert int to string\n");
tmp[j++] = MPIU_Strdup(str);
HYDU_FREE(str);
tmp[j++] = NULL;
- status = HYDU_String_alloc_and_join(tmp, &str);
+ status = HYDU_str_alloc_and_join(tmp, &str);
HYDU_ERR_POP(status, "unable to join strings\n");
- HYDU_Env_putenv(str);
+ HYDU_putenv(str);
for (j = 0; tmp[j]; j++)
HYDU_FREE(tmp[j]);
- status = HYDU_Chdir(HYD_Proxy_params.wdir);
- HYDU_ERR_POP(status, "unable to change wdir\n");
+ if (chdir(HYD_Proxy_params.wdir) < 0)
+ HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR,
+ "unable to change wdir (%s)\n", HYDU_strerror(errno));
for (j = 0, arg = 0; HYD_Proxy_params.args[j]; j++)
client_args[arg++] = MPIU_Strdup(HYD_Proxy_params.args[j]);
@@ -82,12 +83,12 @@
* processes are there on this partition, and appropriately
* bind them. */
if ((i + HYD_Proxy_params.pmi_id) == 0) {
- status = HYDU_Create_process(client_args, &HYD_Proxy_params.in,
+ status = HYDU_create_process(client_args, &HYD_Proxy_params.in,
&HYD_Proxy_params.out[i], &HYD_Proxy_params.err[i],
&HYD_Proxy_params.pid[i], i);
}
else {
- status = HYDU_Create_process(client_args, NULL,
+ status = HYDU_create_process(client_args, NULL,
&HYD_Proxy_params.out[i],
&HYD_Proxy_params.err[i], &HYD_Proxy_params.pid[i],
i);
@@ -98,25 +99,25 @@
}
/* Everything is spawned, now wait for I/O */
- status = HYD_DMX_Register_fd(HYD_Proxy_params.proc_count, HYD_Proxy_params.out,
+ status = HYD_DMX_register_fd(HYD_Proxy_params.proc_count, HYD_Proxy_params.out,
HYD_STDOUT, HYD_Proxy_stdout_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
- status = HYD_DMX_Register_fd(HYD_Proxy_params.proc_count, HYD_Proxy_params.err,
+ status = HYD_DMX_register_fd(HYD_Proxy_params.proc_count, HYD_Proxy_params.err,
HYD_STDOUT, HYD_Proxy_stderr_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
if (HYD_Proxy_params.pmi_id == 0) {
- status = HYDU_Sock_set_nonblock(HYD_Proxy_params.in);
+ status = HYDU_sock_set_nonblock(HYD_Proxy_params.in);
HYDU_ERR_POP(status, "unable to set socket as non-blocking\n");
stdin_fd = 0;
- status = HYDU_Sock_set_nonblock(stdin_fd);
+ status = HYDU_sock_set_nonblock(stdin_fd);
HYDU_ERR_POP(status, "unable to set socket as non-blocking\n");
HYD_Proxy_params.stdin_buf_offset = 0;
HYD_Proxy_params.stdin_buf_count = 0;
- status = HYD_DMX_Register_fd(1, &stdin_fd, HYD_STDIN, HYD_Proxy_stdin_cb);
+ status = HYD_DMX_register_fd(1, &stdin_fd, HYD_STDIN, HYD_Proxy_stdin_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
}
@@ -128,7 +129,7 @@
while (1) {
/* Wait for some event to occur */
- status = HYD_DMX_Wait_for_event(timeout);
+ status = HYD_DMX_wait_for_event(timeout);
HYDU_ERR_POP(status, "demux engine error waiting for event\n");
/* Check to see if there's any open read socket left; if there
@@ -175,7 +176,7 @@
break;
/* Check if there are any messages from the launcher */
- status = HYD_DMX_Wait_for_event(0);
+ status = HYD_DMX_wait_for_event(0);
HYDU_ERR_POP(status, "demux engine error waiting for event\n");
} while (1);
Modified: mpich2/trunk/src/pm/hydra/pm/central/proxy_cb.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/central/proxy_cb.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/pm/central/proxy_cb.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -25,21 +25,21 @@
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "stdout handler got stdin event\n");
if (fd == HYD_Proxy_listenfd) { /* mpiexec is trying to connect */
- status = HYDU_Sock_accept(fd, &accept_fd);
+ status = HYDU_sock_accept(fd, &accept_fd);
HYDU_ERR_POP(status, "accept error\n");
- status = HYD_DMX_Register_fd(1, &accept_fd, HYD_STDOUT, HYD_Proxy_listen_cb);
+ status = HYD_DMX_register_fd(1, &accept_fd, HYD_STDOUT, HYD_Proxy_listen_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
}
else { /* We got a command from mpiexec */
count = read(fd, &cmd, sizeof(enum HYD_Proxy_cmds));
if (count < 0) {
HYDU_ERR_SETANDJUMP2(status, HYD_SOCK_ERROR, "read error on %d (%s)\n",
- fd, HYDU_String_error(errno));
+ fd, HYDU_strerror(errno));
}
else if (count == 0) {
/* The connection has closed */
- status = HYD_DMX_Deregister_fd(fd);
+ status = HYD_DMX_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
close(fd);
goto fn_exit;
@@ -50,7 +50,7 @@
if (HYD_Proxy_params.pid[i] != -1)
kill(HYD_Proxy_params.pid[i], SIGKILL);
- status = HYD_DMX_Deregister_fd(fd);
+ status = HYD_DMX_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to register fd\n");
close(fd);
}
@@ -76,12 +76,12 @@
HYDU_FUNC_ENTER();
- status = HYDU_Sock_stdout_cb(fd, events, 1, &closed);
+ status = HYDU_sock_stdout_cb(fd, events, 1, &closed);
HYDU_ERR_POP(status, "stdout callback error\n");
if (closed) {
/* The connection has closed */
- status = HYD_DMX_Deregister_fd(fd);
+ status = HYD_DMX_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
for (i = 0; i < HYD_Proxy_params.proc_count; i++)
@@ -105,12 +105,12 @@
HYDU_FUNC_ENTER();
- status = HYDU_Sock_stdout_cb(fd, events, 2, &closed);
+ status = HYDU_sock_stdout_cb(fd, events, 2, &closed);
HYDU_ERR_POP(status, "stdout callback error\n");
if (closed) {
/* The connection has closed */
- status = HYD_DMX_Deregister_fd(fd);
+ status = HYD_DMX_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
for (i = 0; i < HYD_Proxy_params.proc_count; i++)
@@ -134,14 +134,14 @@
HYDU_FUNC_ENTER();
- status = HYDU_Sock_stdin_cb(HYD_Proxy_params.in, events, HYD_Proxy_params.stdin_tmp_buf,
+ status = HYDU_sock_stdin_cb(HYD_Proxy_params.in, events, HYD_Proxy_params.stdin_tmp_buf,
&HYD_Proxy_params.stdin_buf_count,
&HYD_Proxy_params.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 = HYD_DMX_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
close(HYD_Proxy_params.in);
Modified: mpich2/trunk/src/pm/hydra/pm/central/proxy_utils.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/central/proxy_utils.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/pm/central/proxy_utils.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -23,7 +23,7 @@
HYD_Proxy_params.env_list = NULL;
HYD_Proxy_params.partition = NULL;
- status = HYDU_Env_global_list(&HYD_Proxy_params.global_env);
+ status = HYDU_list_global_env(&HYD_Proxy_params.global_env);
HYDU_ERR_POP(status, "unable to get the global env list\n");
while (--argc && ++argv) {
@@ -55,7 +55,7 @@
* as multiple parameters. */
if (!strcmp(*argv, "--partition")) {
argv++;
- HYDU_Allocate_Partition(&partition);
+ HYDU_alloc_partition(&partition);
partition->name = MPIU_Strdup(*argv);
argv++;
partition->proc_count = atoi(*argv);
@@ -92,7 +92,7 @@
str++;
str[strlen(str) - 1] = 0;
}
- HYDU_Env_putenv(str);
+ HYDU_putenv(str);
}
continue;
}
Modified: mpich2/trunk/src/pm/hydra/pm/include/pmci.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/include/pmci.h 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/pm/include/pmci.h 2009-03-20 06:00:15 UTC (rev 4140)
@@ -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/utils/pmcu_pmi.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/utils/pmcu_pmi.h 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/pm/utils/pmcu_pmi.h 2009-03-20 06:00:15 UTC (rev 4140)
@@ -53,7 +53,7 @@
struct HYD_PMCU_pmi_pg *next;
};
-HYD_Status HYD_PMCU_Create_pg(void);
+HYD_Status HYD_PMCU_create_pg(void);
HYD_Status HYD_PMCU_pmi_initack(int fd, char *args[]);
HYD_Status HYD_PMCU_pmi_init(int fd, char *args[]);
HYD_Status HYD_PMCU_pmi_get_maxes(int fd, char *args[]);
@@ -64,6 +64,6 @@
HYD_Status HYD_PMCU_pmi_get(int fd, char *args[]);
HYD_Status HYD_PMCU_pmi_finalize(int fd, char *args[]);
HYD_Status HYD_PMCU_pmi_get_usize(int fd, char *args[]);
-HYD_Status HYD_PMCU_Finalize(void);
+HYD_Status HYD_PMCU_finalize(void);
#endif /* PMCU_PMI_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/pm/utils/pmi.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/utils/pmi.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/pm/utils/pmi.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -86,7 +86,7 @@
}
-HYD_Status HYD_PMCU_Create_pg(void)
+HYD_Status HYD_PMCU_create_pg(void)
{
struct HYD_Proc_params *proc_params;
int num_procs;
@@ -136,13 +136,13 @@
}
debug = handle.debug;
- status = HYDU_String_int_to_str(size, &ssize);
+ status = HYDU_int_to_str(size, &ssize);
HYDU_ERR_POP(status, "unable to convert int to string\n");
- status = HYDU_String_int_to_str(id, &srank);
+ status = HYDU_int_to_str(id, &srank);
HYDU_ERR_POP(status, "unable to convert int to string\n");
- status = HYDU_String_int_to_str(debug, &sdebug);
+ status = HYDU_int_to_str(debug, &sdebug);
HYDU_ERR_POP(status, "unable to convert int to string\n");
i = 0;
@@ -155,10 +155,10 @@
tmp[i++] = "\n";
tmp[i++] = NULL;
- status = HYDU_String_alloc_and_join(tmp, &cmd);
+ status = HYDU_str_alloc_and_join(tmp, &cmd);
HYDU_ERR_POP(status, "error while joining strings\n");
- status = HYDU_Sock_writeline(fd, cmd, strlen(cmd));
+ status = HYDU_sock_writeline(fd, cmd, strlen(cmd));
HYDU_ERR_POP(status, "error writing PMI line\n");
HYDU_FREE(ssize);
@@ -199,7 +199,7 @@
if (pmi_version == 1 && pmi_subversion <= 1) {
/* We support PMI v1.0 and 1.1 */
tmp[0] = "cmd=response_to_init pmi_version=1 pmi_subversion=1 rc=0\n";
- status = HYDU_Sock_writeline(fd, tmp[0], strlen(tmp[0]));
+ status = HYDU_sock_writeline(fd, tmp[0], strlen(tmp[0]));
HYDU_ERR_POP(status, "error writing PMI line\n");
}
else {
@@ -226,13 +226,13 @@
HYDU_FUNC_ENTER();
- status = HYDU_String_int_to_str(MAXKVSNAME, &maxkvsname);
+ status = HYDU_int_to_str(MAXKVSNAME, &maxkvsname);
HYDU_ERR_POP(status, "unable to convert int to string\n");
- status = HYDU_String_int_to_str(MAXKEYLEN, &maxkeylen);
+ status = HYDU_int_to_str(MAXKEYLEN, &maxkeylen);
HYDU_ERR_POP(status, "unable to convert int to string\n");
- status = HYDU_String_int_to_str(MAXVALLEN, &maxvallen);
+ status = HYDU_int_to_str(MAXVALLEN, &maxvallen);
HYDU_ERR_POP(status, "unable to convert int to string\n");
i = 0;
@@ -245,10 +245,10 @@
tmp[i++] = "\n";
tmp[i++] = NULL;
- status = HYDU_String_alloc_and_join(tmp, &cmd);
+ status = HYDU_str_alloc_and_join(tmp, &cmd);
HYDU_ERR_POP(status, "unable to join strings\n");
- status = HYDU_Sock_writeline(fd, cmd, strlen(cmd));
+ status = HYDU_sock_writeline(fd, cmd, strlen(cmd));
HYDU_ERR_POP(status, "error writing PMI line\n");
HYDU_FREE(cmd);
@@ -301,7 +301,7 @@
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
"unable to find process structure\n");
- status = HYDU_String_int_to_str(process->pg->id, &sapp_num);
+ status = HYDU_int_to_str(process->pg->id, &sapp_num);
HYDU_ERR_POP(status, "unable to convert int to string\n");
i = 0;
@@ -310,10 +310,10 @@
tmp[i++] = "\n";
tmp[i++] = NULL;
- status = HYDU_String_alloc_and_join(tmp, &cmd);
+ status = HYDU_str_alloc_and_join(tmp, &cmd);
HYDU_ERR_POP(status, "unable to join strings\n");
- status = HYDU_Sock_writeline(fd, cmd, strlen(cmd));
+ status = HYDU_sock_writeline(fd, cmd, strlen(cmd));
HYDU_ERR_POP(status, "error writing PMI line\n");
HYDU_FREE(cmd);
@@ -349,10 +349,10 @@
tmp[i++] = "\n";
tmp[i++] = NULL;
- status = HYDU_String_alloc_and_join(tmp, &cmd);
+ status = HYDU_str_alloc_and_join(tmp, &cmd);
HYDU_ERR_POP(status, "unable to join strings\n");
- status = HYDU_Sock_writeline(fd, cmd, strlen(cmd));
+ status = HYDU_sock_writeline(fd, cmd, strlen(cmd));
HYDU_ERR_POP(status, "error writing PMI line\n");
HYDU_FREE(cmd);
@@ -387,7 +387,7 @@
cmd = "cmd=barrier_out\n";
run = process->pg->process; /* The first process in the list */
while (run) {
- status = HYDU_Sock_writeline(run->fd, cmd, strlen(cmd));
+ status = HYDU_sock_writeline(run->fd, cmd, strlen(cmd));
HYDU_ERR_POP(status, "error writing PMI line\n");
run = run->next;
}
@@ -461,10 +461,10 @@
tmp[i++] = "\n";
tmp[i++] = NULL;
- status = HYDU_String_alloc_and_join(tmp, &cmd);
+ status = HYDU_str_alloc_and_join(tmp, &cmd);
HYDU_ERR_POP(status, "unable to join strings\n");
- status = HYDU_Sock_writeline(fd, cmd, strlen(cmd));
+ status = HYDU_sock_writeline(fd, cmd, strlen(cmd));
HYDU_ERR_POP(status, "error writing PMI line\n");
HYDU_FREE(cmd);
HYDU_FREE(key_pair_str);
@@ -532,10 +532,10 @@
tmp[i++] = "\n";
tmp[i++] = NULL;
- status = HYDU_String_alloc_and_join(tmp, &cmd);
+ status = HYDU_str_alloc_and_join(tmp, &cmd);
HYDU_ERR_POP(status, "unable to join strings\n");
- status = HYDU_Sock_writeline(fd, cmd, strlen(cmd));
+ status = HYDU_sock_writeline(fd, cmd, strlen(cmd));
HYDU_ERR_POP(status, "error writing PMI line\n");
HYDU_FREE(cmd);
HYDU_FREE(key_val_str);
@@ -557,7 +557,7 @@
HYDU_FUNC_ENTER();
cmd = "cmd=finalize_ack\n";
- status = HYDU_Sock_writeline(fd, cmd, strlen(cmd));
+ status = HYDU_sock_writeline(fd, cmd, strlen(cmd));
HYDU_ERR_POP(status, "error writing PMI line\n");
fn_exit:
@@ -580,7 +580,7 @@
status = HYD_BSCI_get_usize(&usize);
HYDU_ERR_POP(status, "unable to get bootstrap universe size\n");
- status = HYDU_String_int_to_str(usize, &usize_str);
+ status = HYDU_int_to_str(usize, &usize_str);
HYDU_ERR_POP(status, "unable to convert int to string\n");
i = 0;
@@ -589,10 +589,10 @@
tmp[i++] = "\n";
tmp[i++] = NULL;
- status = HYDU_String_alloc_and_join(tmp, &cmd);
+ status = HYDU_str_alloc_and_join(tmp, &cmd);
HYDU_ERR_POP(status, "unable to join strings\n");
- status = HYDU_Sock_writeline(fd, cmd, strlen(cmd));
+ status = HYDU_sock_writeline(fd, cmd, strlen(cmd));
HYDU_ERR_POP(status, "error writing PMI line\n");
HYDU_FREE(cmd);
@@ -644,7 +644,7 @@
}
-HYD_Status HYD_PMCU_Finalize(void)
+HYD_Status HYD_PMCU_finalize(void)
{
HYD_PMCU_pmi_pg_t *pg, *tmp;
HYD_Status status = HYD_SUCCESS;
Modified: mpich2/trunk/src/pm/hydra/utils/Makefile.sm
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/Makefile.sm 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/utils/Makefile.sm 2009-03-20 06:00:15 UTC (rev 4140)
@@ -5,4 +5,4 @@
#
SUBDIRS_opt_utils = plpa bind .
-SUBDIRS = args dbg env launch signals sock string timer @opt_utils@
+SUBDIRS = args env launch signals sock string timer @opt_utils@
Modified: mpich2/trunk/src/pm/hydra/utils/args/args.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/args/args.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/utils/args/args.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -6,148 +6,44 @@
#include "hydra_utils.h"
-HYD_Status HYDU_Append_env(HYD_Env_t * env_list, char **client_arg)
+HYD_Status HYDU_get_base_path(char *execname, char *wdir, char **path)
{
- int i, j;
- HYD_Env_t *env;
- char *envstr, *tmp[HYDU_NUM_JOIN_STR];
+ char *loc, *pre, *post;
+ char *path_str[HYDU_NUM_JOIN_STR];
+ int i;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- for (i = 0; client_arg[i]; i++);
- env = env_list;
- while (env) {
- j = 0;
-
- tmp[j++] = MPIU_Strdup("'");
- tmp[j++] = MPIU_Strdup(env->env_name);
- tmp[j++] = MPIU_Strdup("=");
- tmp[j++] = env->env_value ? MPIU_Strdup(env->env_value) : MPIU_Strdup("");
- tmp[j++] = MPIU_Strdup("'");
- tmp[j++] = NULL;
-
- status = HYDU_String_alloc_and_join(tmp, &envstr);
- HYDU_ERR_POP(status, "unable to join strings\n");
-
- client_arg[i++] = MPIU_Strdup(envstr);
- HYDU_FREE(envstr);
- for (j = 0; tmp[j]; j++)
- HYDU_FREE(tmp[j]);
-
- env = env->next;
+ /* Find the last '/' in the executable name */
+ post = MPIU_Strdup(execname);
+ loc = strrchr(post, '/');
+ if (!loc) { /* If there is no path */
+ *path = MPIU_Strdup("");
}
- client_arg[i++] = NULL;
+ else { /* There is a path */
+ *(++loc) = 0;
- fn_exit:
- HYDU_FUNC_EXIT();
- return status;
-
- fn_fail:
- goto fn_exit;
-}
-
-
-HYD_Status HYDU_Append_exec(char **exec, char **client_arg)
-{
- int i, j;
- HYD_Status status = HYD_SUCCESS;
-
- HYDU_FUNC_ENTER();
-
- for (i = 0; client_arg[i]; i++);
- for (j = 0; exec[j]; j++)
- client_arg[i++] = MPIU_Strdup(exec[j]);
- client_arg[i++] = NULL;
-
- HYDU_FUNC_EXIT();
- return status;
-}
-
-
-HYD_Status HYDU_Append_wdir(char **client_arg, char *wdir)
-{
- int arg;
- HYD_Status status = HYD_SUCCESS;
-
- HYDU_FUNC_ENTER();
-
- for (arg = 0; client_arg[arg]; arg++);
- client_arg[arg++] = MPIU_Strdup("cd");
- client_arg[arg++] = MPIU_Strdup(wdir);
- client_arg[arg++] = MPIU_Strdup(";");
- client_arg[arg++] = NULL;
-
- HYDU_FUNC_EXIT();
- return status;
-}
-
-
-HYD_Status HYDU_Dump_args(char **args)
-{
- int arg;
- HYD_Status status = HYD_SUCCESS;
-
- HYDU_FUNC_ENTER();
-
- for (arg = 0; args[arg]; arg++)
- printf("%s ", args[arg]);
- printf("\n");
-
- HYDU_FUNC_EXIT();
- return status;
-}
-
-
-void HYDU_Free_args(char **args)
-{
- int arg;
-
- HYDU_FUNC_ENTER();
-
- for (arg = 0; args[arg]; arg++)
- HYDU_FREE(args[arg]);
-
- HYDU_FUNC_EXIT();
-}
-
-
-HYD_Status HYDU_Get_base_path(char *execname, char **path)
-{
- char *loc;
- HYD_Status status = HYD_SUCCESS;
-
- HYDU_FUNC_ENTER();
-
- *path = MPIU_Strdup(execname);
- loc = strrchr(*path, '/');
- if (loc) {
- loc++;
- *loc = 0;
+ /* Check if its absolute or relative */
+ if (post[0] != '/') { /* relative */
+ path_str[0] = wdir;
+ path_str[1] = "/";
+ path_str[2] = post;
+ path_str[3] = NULL;
+ status = HYDU_str_alloc_and_join(path_str, path);
+ HYDU_ERR_POP(status, "unable to join strings\n");
+ }
+ else { /* absolute */
+ *path = MPIU_Strdup(post);
+ }
}
- else {
- HYDU_FREE(*path);
- *path = MPIU_Strdup("");
- }
+fn_exit:
+ if (post)
+ HYDU_FREE(post);
HYDU_FUNC_EXIT();
return status;
-}
-
-HYD_Status HYDU_Chdir(const char *dir)
-{
- HYD_Status status = HYD_SUCCESS;
-
- HYDU_FUNC_ENTER();
-
- if (chdir(dir) < 0)
- HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "chdir failed\n");
-
- fn_exit:
- HYDU_FUNC_EXIT();
- return status;
-
- fn_fail:
+fn_fail:
goto fn_exit;
}
Modified: mpich2/trunk/src/pm/hydra/utils/env/env.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/env/env.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/utils/env/env.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -6,45 +6,38 @@
#include "hydra_utils.h"
-HYD_Status HYDU_Env_global_list(HYD_Env_t ** env_list)
+static HYD_Status env_to_str(HYD_Env_t * env, char **str)
{
- HYD_Env_t *env;
- char *env_name, *env_value, *env_str;
int i;
+ char *tmp[HYDU_NUM_JOIN_STR];
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- *env_list = NULL;
i = 0;
- while (environ[i]) {
- HYDU_MALLOC(env, HYD_Env_t *, sizeof(HYD_Env_t), status);
+ tmp[i++] = MPIU_Strdup("'");
+ tmp[i++] = MPIU_Strdup(env->env_name);
+ tmp[i++] = MPIU_Strdup("=");
+ tmp[i++] = env->env_value ? MPIU_Strdup(env->env_value) : MPIU_Strdup("");
+ tmp[i++] = MPIU_Strdup("'");
+ tmp[i++] = NULL;
- env_str = MPIU_Strdup(environ[i]);
- env_name = strtok(env_str, "=");
- env_value = strtok(NULL, "=");
- env->env_name = MPIU_Strdup(env_name);
- env->env_value = env_value ? MPIU_Strdup(env_value) : NULL;
- HYDU_FREE(env_str);
+ status = HYDU_str_alloc_and_join(tmp, str);
+ HYDU_ERR_POP(status, "unable to join strings\n");
- status = HYDU_Env_add_to_list(env_list, *env);
- HYDU_ERR_POP(status, "unable to add env to list\n");
+ for (i = 0; tmp[i]; i++)
+ HYDU_FREE(tmp[i]);
- HYDU_Env_free(env);
-
- i++;
- }
-
- fn_exit:
+fn_exit:
HYDU_FUNC_EXIT();
return status;
- fn_fail:
+fn_fail:
goto fn_exit;
}
-HYD_Env_t *HYDU_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;
@@ -69,8 +62,73 @@
}
-HYD_Env_t *HYDU_Env_listdup(HYD_Env_t * env)
+HYD_Status HYDU_list_append_env_to_str(HYD_Env_t * env_list, char **str_list)
{
+ int i;
+ HYD_Env_t *env;
+ HYD_Status status = HYD_SUCCESS;
+
+ HYDU_FUNC_ENTER();
+
+ for (i = 0; str_list[i]; i++);
+ env = env_list;
+ while (env) {
+ status = env_to_str(env, &str_list[i++]);
+ HYDU_ERR_POP(status, "env_to_str returned error\n");
+
+ env = env->next;
+ }
+ str_list[i++] = NULL;
+
+fn_exit:
+ HYDU_FUNC_EXIT();
+ return status;
+
+fn_fail:
+ goto fn_exit;
+}
+
+
+HYD_Status HYDU_list_global_env(HYD_Env_t ** env_list)
+{
+ HYD_Env_t *env;
+ char *env_name, *env_value, *env_str;
+ int i;
+ HYD_Status status = HYD_SUCCESS;
+
+ HYDU_FUNC_ENTER();
+
+ *env_list = NULL;
+ i = 0;
+ while (environ[i]) {
+ HYDU_MALLOC(env, HYD_Env_t *, sizeof(HYD_Env_t), status);
+
+ env_str = MPIU_Strdup(environ[i]);
+ env_name = strtok(env_str, "=");
+ env_value = strtok(NULL, "=");
+ env->env_name = MPIU_Strdup(env_name);
+ env->env_value = env_value ? MPIU_Strdup(env_value) : NULL;
+ HYDU_FREE(env_str);
+
+ status = HYDU_append_env_to_list(*env, env_list);
+ HYDU_ERR_POP(status, "unable to add env to list\n");
+
+ HYDU_env_free(env);
+
+ i++;
+ }
+
+ fn_exit:
+ HYDU_FUNC_EXIT();
+ return status;
+
+ fn_fail:
+ goto fn_exit;
+}
+
+
+HYD_Env_t *HYDU_env_list_dup(HYD_Env_t * env)
+{
HYD_Env_t *tenv, *run;
HYD_Status status = HYD_SUCCESS;
@@ -79,7 +137,7 @@
run = env;
tenv = NULL;
while (run) {
- status = HYDU_Env_add_to_list(&tenv, *run);
+ status = HYDU_append_env_to_list(*run, &tenv);
HYDU_ERR_POP(status, "unable to add env to list\n");
run = run->next;
}
@@ -94,7 +152,7 @@
}
-HYD_Status HYDU_Env_create(HYD_Env_t ** env, char *env_name, char *env_value)
+HYD_Status HYDU_env_create(HYD_Env_t ** env, char *env_name, char *env_value)
{
HYD_Status status = HYD_SUCCESS;
@@ -114,7 +172,7 @@
}
-HYD_Status HYDU_Env_free(HYD_Env_t * env)
+HYD_Status HYDU_env_free(HYD_Env_t * env)
{
HYD_Status status = HYD_SUCCESS;
@@ -131,7 +189,7 @@
}
-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;
@@ -141,7 +199,7 @@
run = env;
while (run) {
tmp = run->next;
- HYDU_Env_free(run);
+ HYDU_env_free(run);
run = tmp;
}
@@ -150,7 +208,7 @@
}
-HYD_Env_t *HYDU_Env_found_in_list(HYD_Env_t * env_list, HYD_Env_t env)
+HYD_Env_t *HYDU_env_lookup(HYD_Env_t env, HYD_Env_t * env_list)
{
HYD_Env_t *run;
@@ -170,14 +228,14 @@
}
-HYD_Status HYDU_Env_add_to_list(HYD_Env_t ** env_list, HYD_Env_t env)
+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;
HYDU_FUNC_ENTER();
- tenv = HYDU_Env_dup(env);
+ tenv = env_dup(env);
if (tenv == NULL)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "unable to dup env\n");
@@ -229,36 +287,10 @@
}
-HYD_Status HYDU_Env_assign_form(HYD_Env_t env, char **env_str)
+void HYDU_putenv(char *env_str)
{
- int i;
- char *tmp[HYDU_NUM_JOIN_STR];
- HYD_Status status = HYD_SUCCESS;
-
HYDU_FUNC_ENTER();
- i = 0;
- tmp[i++] = MPIU_Strdup(env.env_name);
- tmp[i++] = MPIU_Strdup("=");
- tmp[i++] = env.env_value ? MPIU_Strdup(env.env_value) : MPIU_Strdup("");
- tmp[i++] = NULL;
-
- status = HYDU_String_alloc_and_join(tmp, env_str);
- HYDU_ERR_POP(status, "unable to join strings\n");
-
- fn_exit:
- HYDU_FUNC_EXIT();
- return status;
-
- fn_fail:
- goto fn_exit;
-}
-
-
-void HYDU_Env_putenv(char *env_str)
-{
- HYDU_FUNC_ENTER();
-
MPIU_PutEnv(env_str);
HYDU_FUNC_EXIT();
Modified: mpich2/trunk/src/pm/hydra/utils/launch/allocate.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/launch/allocate.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/utils/launch/allocate.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -6,7 +6,7 @@
#include "hydra_utils.h"
-HYD_Status HYDU_Allocate_Partition(struct HYD_Partition_list **partition)
+HYD_Status HYDU_alloc_partition(struct HYD_Partition_list **partition)
{
HYD_Status status = HYD_SUCCESS;
@@ -36,7 +36,7 @@
}
-void HYDU_Free_partition_list(struct HYD_Partition_list *partition)
+void HYDU_free_partition_list(struct HYD_Partition_list *partition)
{
struct HYD_Partition_list *run, *p;
int arg;
@@ -62,7 +62,7 @@
p->mapping = NULL;
}
- HYDU_Free_args(p->args);
+ HYDU_free_strlist(p->args);
HYDU_FREE(p);
p = run;
Modified: mpich2/trunk/src/pm/hydra/utils/launch/launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/launch/launch.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/utils/launch/launch.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -6,7 +6,7 @@
#include "hydra_utils.h"
-HYD_Status HYDU_Create_process(char **client_arg, int *in, int *out, int *err,
+HYD_Status HYDU_create_process(char **client_arg, int *in, int *out, int *err,
int *pid, int core)
{
int inpipe[2], outpipe[2], errpipe[2], tpid, my_pid;
@@ -16,15 +16,15 @@
if (in && (pipe(inpipe) < 0))
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "pipe error (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
if (out && (pipe(outpipe) < 0))
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "pipe error (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
if (err && (pipe(errpipe) < 0))
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "pipe error (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
/* Fork off the process */
tpid = fork();
@@ -33,13 +33,13 @@
close(1);
if (dup2(outpipe[1], 1) < 0)
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "dup2 error (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
close(errpipe[0]);
close(2);
if (dup2(errpipe[1], 2) < 0)
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "dup2 error (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
if (core >= 0) {
status = HYDU_bind_process(core);
@@ -50,11 +50,11 @@
close(0);
if (in && (dup2(inpipe[0], 0) < 0))
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "dup2 error (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
if (execvp(client_arg[0], client_arg) < 0) {
HYDU_ERR_SETANDJUMP1(status, HYD_INTERNAL_ERROR, "execvp error (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
}
}
else { /* Parent process */
Modified: mpich2/trunk/src/pm/hydra/utils/signals/signals.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/signals/signals.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/utils/signals/signals.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -6,7 +6,7 @@
#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;
#if defined HAVE_SIGACTION
@@ -38,28 +38,28 @@
}
-HYD_Status HYDU_Set_common_signals(void (*handler) (int))
+HYD_Status HYDU_set_common_signals(void (*handler) (int))
{
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYDU_Set_signal(SIGINT, handler);
+ status = HYDU_set_signal(SIGINT, handler);
HYDU_ERR_POP(status, "unable to set SIGINT\n");
- status = HYDU_Set_signal(SIGQUIT, handler);
+ status = HYDU_set_signal(SIGQUIT, handler);
HYDU_ERR_POP(status, "unable to set SIGQUIT\n");
- status = HYDU_Set_signal(SIGTERM, handler);
+ status = HYDU_set_signal(SIGTERM, handler);
HYDU_ERR_POP(status, "unable to set SIGTERM\n");
#if defined SIGSTOP
- status = HYDU_Set_signal(SIGSTOP, handler);
+ status = HYDU_set_signal(SIGSTOP, handler);
HYDU_ERR_POP(status, "unable to set SIGSTOP\n");
#endif /* SIGSTOP */
#if defined SIGCONT
- status = HYDU_Set_signal(SIGCONT, handler);
+ status = HYDU_set_signal(SIGCONT, handler);
HYDU_ERR_POP(status, "unable to set SIGCONT\n");
#endif /* SIGCONT */
Modified: mpich2/trunk/src/pm/hydra/utils/sock/sock.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/sock/sock.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/utils/sock/sock.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -6,7 +6,7 @@
#include "hydra_utils.h"
-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;
@@ -46,7 +46,7 @@
*listen_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (*listen_fd < 0)
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "cannot open socket (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
if (setsockopt(*listen_fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(int)) < 0)
HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "cannot set TCP_NODELAY\n");
@@ -71,7 +71,7 @@
* port. Otherwise, it's an error. */
if (errno != EADDRINUSE)
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "bind error (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
}
else /* We got a port */
break;
@@ -83,7 +83,7 @@
if (listen(*listen_fd, -1) < 0)
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "listen error (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
/* We asked for any port, so we need to find out which port we
* actually got. */
@@ -92,7 +92,7 @@
if (getsockname(*listen_fd, (struct sockaddr *) &sa, &sinlen) < 0)
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "getsockname error (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
*port = ntohs(sa.sin_port);
}
@@ -105,7 +105,7 @@
}
-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 sockaddr_in sa;
struct hostent *ht;
@@ -121,20 +121,20 @@
ht = gethostbyname(host);
if (ht == NULL)
HYDU_ERR_SETANDJUMP1(status, HYD_INVALID_PARAM,
- "unable to get host address (%s)\n", HYDU_String_error(errno));
+ "unable to get host address (%s)\n", HYDU_strerror(errno));
memcpy(&sa.sin_addr, ht->h_addr_list[0], ht->h_length);
/* Create a socket and set the required options */
*fd = socket(AF_INET, SOCK_STREAM, 0);
if (*fd < 0)
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "cannot open socket (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
/* Not being able to connect is not an error in all cases. So we
* 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_Warn_printf("connect error (%s)\n", HYDU_String_error(errno));
+ HYDU_Warn_printf("connect error (%s)\n", HYDU_strerror(errno));
status = HYD_SOCK_ERROR;
goto fn_fail;
}
@@ -148,7 +148,7 @@
}
-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;
@@ -157,7 +157,7 @@
*fd = accept(listen_fd, 0, 0);
if (*fd < 0)
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "accept error (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
fn_exit:
HYDU_FUNC_EXIT();
@@ -168,12 +168,10 @@
}
-/*
- * 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)
+ * fd as necessary. */
+HYD_Status HYDU_sock_readline(int fd, char *buf, int maxlen, int *linelen)
{
int n;
HYD_Status status = HYD_SUCCESS;
@@ -190,7 +188,7 @@
if (errno == EINTR)
continue;
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "read error (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
}
*linelen += n;
@@ -219,10 +217,7 @@
}
-/*
- * HYD_Sock_read: perform a blocking read on a non-blocking socket.
- */
-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)
{
HYD_Status status = HYD_SUCCESS;
@@ -234,7 +229,7 @@
if (*count < 0)
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "read errno (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
fn_exit:
HYDU_FUNC_EXIT();
@@ -245,7 +240,7 @@
}
-HYD_Status HYDU_Sock_writeline(int fd, char *buf, int maxsize)
+HYD_Status HYDU_sock_writeline(int fd, char *buf, int maxsize)
{
int n;
HYD_Status status = HYD_SUCCESS;
@@ -261,7 +256,7 @@
if (n < maxsize)
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "write error (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
fn_exit:
HYDU_FUNC_EXIT();
@@ -272,7 +267,7 @@
}
-HYD_Status HYDU_Sock_write(int fd, void *buf, int maxsize)
+HYD_Status HYDU_sock_write(int fd, void *buf, int maxsize)
{
int n;
HYD_Status status = HYD_SUCCESS;
@@ -285,7 +280,7 @@
if (n < maxsize)
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "write error (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
fn_exit:
HYDU_FUNC_EXIT();
@@ -296,7 +291,7 @@
}
-HYD_Status HYDU_Sock_set_nonblock(int fd)
+HYD_Status HYDU_sock_set_nonblock(int fd)
{
int flags;
HYD_Status status = HYD_SUCCESS;
@@ -318,7 +313,7 @@
}
-HYD_Status HYDU_Sock_set_cloexec(int fd)
+HYD_Status HYDU_sock_set_cloexec(int fd)
{
int flags;
HYD_Status status = HYD_SUCCESS;
@@ -337,7 +332,7 @@
}
-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];
@@ -353,7 +348,7 @@
count = read(fd, buf, HYD_TMPBUF_SIZE);
if (count < 0) {
HYDU_ERR_SETANDJUMP2(status, HYD_SOCK_ERROR, "read error on %d (%s)\n",
- fd, HYDU_String_error(errno));
+ fd, HYDU_strerror(errno));
}
else if (count == 0) {
/* The connection has closed */
@@ -366,7 +361,7 @@
ret = write(stdout_fd, buf + written, count - written);
if (ret < 0 && errno != EAGAIN)
HYDU_ERR_SETANDJUMP2(status, HYD_SOCK_ERROR, "write error on %d (%s)\n",
- stdout_fd, HYDU_String_error(errno));
+ stdout_fd, HYDU_strerror(errno));
if (ret > 0)
written += ret;
}
@@ -380,7 +375,7 @@
}
-HYD_Status HYDU_Sock_stdin_cb(int fd, HYD_Event_t events, char *buf, int *buf_count,
+HYD_Status HYDU_sock_stdin_cb(int fd, HYD_Event_t events, char *buf, int *buf_count,
int *buf_offset, int *closed)
{
int count;
@@ -399,7 +394,7 @@
count = write(fd, buf + *buf_offset, *buf_count);
if (count < 0)
HYDU_ERR_SETANDJUMP2(status, HYD_SOCK_ERROR, "write error on %d (%s)\n",
- fd, HYDU_String_error(errno))
+ fd, HYDU_strerror(errno))
*buf_offset += count;
*buf_count -= count;
break;
@@ -415,7 +410,7 @@
}
HYDU_ERR_SETANDJUMP1(status, HYD_SOCK_ERROR, "read error on 0 (%s)\n",
- HYDU_String_error(errno));
+ HYDU_strerror(errno));
}
else if (count == 0) {
/* The connection has closed */
Modified: mpich2/trunk/src/pm/hydra/utils/string/string.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/string/string.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/utils/string/string.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -6,8 +6,54 @@
#include "hydra_utils.h"
-HYD_Status HYDU_String_alloc_and_join(char **strlist, char **strjoin)
+HYD_Status HYDU_list_append_strlist(char **src_strlist, char **dest_strlist)
{
+ int i, j;
+ HYD_Status status = HYD_SUCCESS;
+
+ HYDU_FUNC_ENTER();
+
+ for (i = 0; dest_strlist[i]; i++);
+ for (j = 0; src_strlist[j]; j++)
+ dest_strlist[i++] = MPIU_Strdup(src_strlist[j]);
+ dest_strlist[i++] = NULL;
+
+ HYDU_FUNC_EXIT();
+ return status;
+}
+
+
+HYD_Status HYDU_print_strlist(char **strlist)
+{
+ int arg;
+ HYD_Status status = HYD_SUCCESS;
+
+ HYDU_FUNC_ENTER();
+
+ for (arg = 0; strlist[arg]; arg++)
+ printf("%s ", strlist[arg]);
+ printf("\n");
+
+ HYDU_FUNC_EXIT();
+ return status;
+}
+
+
+void HYDU_free_strlist(char **strlist)
+{
+ int arg;
+
+ HYDU_FUNC_ENTER();
+
+ for (arg = 0; strlist[arg]; arg++)
+ HYDU_FREE(strlist[arg]);
+
+ HYDU_FUNC_EXIT();
+}
+
+
+HYD_Status HYDU_str_alloc_and_join(char **strlist, char **strjoin)
+{
int len = 0, i, count;
HYD_Status status = HYD_SUCCESS;
@@ -34,7 +80,7 @@
}
-HYD_Status HYDU_String_break(char *str, char **str1, char **str2)
+HYD_Status HYDU_strsplit(char *str, char **str1, char **str2, char sep)
{
int i;
HYD_Status status = HYD_SUCCESS;
@@ -45,7 +91,7 @@
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "");
*str1 = MPIU_Strdup(str);
- for (i = 0; (*str1)[i] && ((*str1)[i] != '='); i++);
+ for (i = 0; (*str1)[i] && ((*str1)[i] != sep); i++);
if ((*str1)[i] == 0) /* End of the string */
*str2 = NULL;
@@ -63,7 +109,7 @@
}
-HYD_Status HYDU_String_int_to_str(int x, char **str)
+HYD_Status HYDU_int_to_str(int x, char **str)
{
int len = 1, max = 10, y;
HYD_Status status = HYD_SUCCESS;
@@ -97,7 +143,7 @@
}
-char *HYDU_String_error(int error)
+char *HYDU_strerror(int error)
{
char *str;
Modified: mpich2/trunk/src/pm/hydra/utils/timer/timer.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/timer/timer.c 2009-03-20 02:53:02 UTC (rev 4139)
+++ mpich2/trunk/src/pm/hydra/utils/timer/timer.c 2009-03-20 06:00:15 UTC (rev 4140)
@@ -8,7 +8,7 @@
/* FIXME: Here we assume that the timer is gettimeofday. */
-void HYDU_Time_set(HYD_Time * time, int *val)
+void HYDU_time_set(HYD_Time * time, int *val)
{
if (val == NULL) {
/* Set time to right now */
@@ -20,7 +20,8 @@
}
}
-int HYDU_Time_left(HYD_Time start, HYD_Time timeout)
+
+int HYDU_time_left(HYD_Time start, HYD_Time timeout)
{
HYD_Time now;
int time_left;
More information about the mpich2-commits
mailing list