Commit 1e9e9ec9 authored by Pavan Balaji's avatar Pavan Balaji
Browse files

[svn-r4140] 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.
parent c8ae4d11
......@@ -39,7 +39,7 @@ HYD_Status HYD_BSCD_fork_launch_procs(void)
/* 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");
......
......@@ -55,7 +55,7 @@ HYD_Status HYD_BSCD_slurm_launch_procs(void)
/* 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) {
......
......@@ -59,7 +59,7 @@ HYD_Status HYD_BSCD_ssh_launch_procs(void)
/* 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");
......
......@@ -51,7 +51,7 @@ HYD_Status HYD_BSCU_wait_for_completion(void)
}
}
}
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
......
......@@ -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 @@ HYD_Status HYD_CSI_Close_fd(int fd)
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);
......
......@@ -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:
......
......@@ -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 @@ HYD_Status HYD_CSI_Launch_procs(void)
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");
}
......
......@@ -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 @@ HYD_Status HYD_CSI_Wait_for_completion(void)
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 @@ HYD_Status HYD_CSI_Wait_for_completion(void)
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 */
......
......@@ -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 */
......@@ -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 @@ HYD_Status HYD_DMX_Register_fd(int num_fds, int *fd, HYD_Event_t events,
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_Register_fd(int num_fds, int *fd, HYD_Event_t events,
}
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_Deregister_fd(int fd)
}
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 @@ HYD_Status HYD_DMX_Wait_for_event(int time)
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_Wait_for_event(int time)
}
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();
......
......@@ -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 */
......@@ -69,16 +69,16 @@ typedef struct HYD_Handle_ HYD_Handle;
/* 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;
......
......@@ -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);
/* Launch utilities */
/* args */
HYD_Status HYDU_get_base_path(char *execname, char *wdir, char **path);
/* 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,33 +52,58 @@ struct HYD_Partition_list {
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 */
......@@ -113,29 +131,13 @@ HYD_Status HYDU_bind_process(int core);
"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);
/* 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));
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);
/* Timer utilities */
......@@ -144,36 +146,7 @@ HYD_Status HYDU_Set_common_signals(void (*handler) (int));
#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);
/* 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);
void HYDU_time_set(HYD_Time * time, int *val);
int HYDU_time_left(HYD_Time start, HYD_Time timeout);
#endif /* HYDRA_UTILS_H_INCLUDED */
......@@ -19,14 +19,14 @@ HYD_Status HYD_LCHI_stdout_cb(int fd, HYD_Event_t events)
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 @@ HYD_Status HYD_LCHI_stderr_cb(int fd, HYD_Event_t events)
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 @@ HYD_Status HYD_LCHI_stdin_cb(int fd, HYD_Event_t events)
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);
......
......@@ -55,7 +55,7 @@ int main(int argc, char **argv)
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 @@ int main(int argc, char **argv)
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 @@ int main(int argc, char **argv)