[mpich2-commits] r5444 - in mpich2/trunk/src/pm/hydra: bootstrap/fork bootstrap/include bootstrap/rsh bootstrap/slurm bootstrap/src bootstrap/ssh bootstrap/utils include pm/pmiserv rmk/include rmk/pbs rmk/src rmk/utils ui/mpiexec ui/utils utils/launch
balaji at mcs.anl.gov
balaji at mcs.anl.gov
Sun Oct 11 00:44:30 CDT 2009
Author: balaji
Date: 2009-10-11 00:44:30 -0500 (Sun, 11 Oct 2009)
New Revision: 5444
Added:
mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_proxy_id.c
mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_query_proxy_id.c
mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_query_proxy_id.c
Removed:
mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_partition_id.c
mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_query_partition_id.c
mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_query_partition_id.c
Modified:
mpich2/trunk/src/pm/hydra/bootstrap/fork/fork.h
mpich2/trunk/src/pm/hydra/bootstrap/fork/fork_launch.c
mpich2/trunk/src/pm/hydra/bootstrap/include/bsci.h.in
mpich2/trunk/src/pm/hydra/bootstrap/rsh/rsh.h
mpich2/trunk/src/pm/hydra/bootstrap/rsh/rsh_launch.c
mpich2/trunk/src/pm/hydra/bootstrap/slurm/Makefile.mk
mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm.h
mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_init.c
mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_launch.c
mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_node_list.c
mpich2/trunk/src/pm/hydra/bootstrap/src/Makefile.mk
mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_init.c.in
mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_launch.c
mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_query_node_list.c
mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_wait.c
mpich2/trunk/src/pm/hydra/bootstrap/ssh/ssh.h
mpich2/trunk/src/pm/hydra/bootstrap/ssh/ssh_launch.c
mpich2/trunk/src/pm/hydra/bootstrap/utils/Makefile.mk
mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu.h
mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_query_node_list.c
mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_wait.c
mpich2/trunk/src/pm/hydra/include/hydra.h
mpich2/trunk/src/pm/hydra/include/hydra_base.h
mpich2/trunk/src/pm/hydra/include/hydra_utils.h
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.h
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv.h
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_cb.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_utils.c
mpich2/trunk/src/pm/hydra/rmk/include/rmki.h.in
mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs.h
mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_query_node_list.c
mpich2/trunk/src/pm/hydra/rmk/src/rmki_query_node_list.c
mpich2/trunk/src/pm/hydra/rmk/utils/rmku.h
mpich2/trunk/src/pm/hydra/rmk/utils/rmku_query_node_list.c
mpich2/trunk/src/pm/hydra/ui/mpiexec/callback.c
mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.c
mpich2/trunk/src/pm/hydra/ui/mpiexec/utils.c
mpich2/trunk/src/pm/hydra/ui/utils/uiu.c
mpich2/trunk/src/pm/hydra/ui/utils/uiu.h
mpich2/trunk/src/pm/hydra/utils/launch/allocate.c
mpich2/trunk/src/pm/hydra/utils/launch/launch.c
Log:
This is the first part of the cleanup to decouple the proxy/host
information (e.g., hostfile related information) from the executable
information. This issue has been the source of many bugs including
ticket #893. This commit alone is not the entire fix, but an
intermediate step to reduce the working copy state that I have to
maintain.
Modified: mpich2/trunk/src/pm/hydra/bootstrap/fork/fork.h
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/fork/fork.h 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/fork/fork.h 2009-10-11 05:44:30 UTC (rev 5444)
@@ -9,7 +9,7 @@
#include "hydra_base.h"
-HYD_Status HYD_BSCD_fork_launch_procs(char **global_args, const char *partition_id_str,
- struct HYD_Partition *partition_list);
+HYD_Status HYD_BSCD_fork_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_Proxy *proxy_list);
#endif /* FORK_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/bootstrap/fork/fork_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/fork/fork_launch.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/fork/fork_launch.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -9,10 +9,10 @@
#include "bscu.h"
#include "fork.h"
-HYD_Status HYD_BSCD_fork_launch_procs(char **global_args, const char *partition_id_str,
- struct HYD_Partition *partition_list)
+HYD_Status HYD_BSCD_fork_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_Proxy *proxy_list)
{
- struct HYD_Partition *partition;
+ struct HYD_Proxy *proxy;
char *client_arg[HYD_NUM_TMP_STRINGS];
int i, arg, process_id;
HYD_Status status = HYD_SUCCESS;
@@ -20,16 +20,16 @@
HYDU_FUNC_ENTER();
process_id = 0;
- FORALL_ACTIVE_PARTITIONS(partition, partition_list) {
+ FORALL_ACTIVE_PROXIES(proxy, proxy_list) {
/* Setup the executable arguments */
arg = 0;
for (i = 0; global_args[i]; i++)
client_arg[arg++] = HYDU_strdup(global_args[i]);
- if (partition_id_str) {
- client_arg[arg++] = HYDU_strdup(partition_id_str);
- client_arg[arg++] = HYDU_int_to_str(partition->base->partition_id);
+ if (proxy_id_str) {
+ client_arg[arg++] = HYDU_strdup(proxy_id_str);
+ client_arg[arg++] = HYDU_int_to_str(proxy->proxy_id);
}
client_arg[arg++] = NULL;
@@ -42,9 +42,9 @@
/* The stdin pointer will be some value for process_id 0; for
* everyone else, it's NULL. */
status = HYDU_create_process(client_arg, NULL,
- (process_id == 0 ? &partition->base->in : NULL),
- &partition->base->out, &partition->base->err,
- &partition->base->pid, -1);
+ (process_id == 0 ? &proxy->in : NULL),
+ &proxy->out, &proxy->err,
+ &proxy->pid, -1);
HYDU_ERR_POP(status, "create process returned error\n");
HYDU_free_strlist(client_arg);
Modified: mpich2/trunk/src/pm/hydra/bootstrap/include/bsci.h.in
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/include/bsci.h.in 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/include/bsci.h.in 2009-10-11 05:44:30 UTC (rev 5444)
@@ -14,25 +14,25 @@
};
struct HYD_BSCI_fns {
- HYD_Status(*launch_procs) (char **global_args, const char *partition_id_str,
- struct HYD_Partition *partition_list);
+ HYD_Status(*launch_procs) (char **global_args, const char *proxy_id_str,
+ struct HYD_Proxy *proxy_list);
HYD_Status(*finalize) (void);
- HYD_Status(*wait_for_completion) (struct HYD_Partition *partition_list);
- HYD_Status(*query_node_list) (int *num_nodes, struct HYD_Partition **partition_list);
+ HYD_Status(*wait_for_completion) (struct HYD_Proxy *proxy_list);
+ HYD_Status(*query_node_list) (int *num_nodes, struct HYD_Proxy **proxy_list);
HYD_Status(*query_usize) (int *size);
- HYD_Status(*query_partition_id) (int *partition_id);
+ HYD_Status(*query_proxy_id) (int *proxy_id);
};
extern struct HYD_BSCI_fns HYD_BSCI_fns;
HYD_Status HYD_BSCI_init(char *bootstrap, char *bootstrap_exec, int enablex, int debug);
-HYD_Status HYD_BSCI_launch_procs(char **global_args, const char *partition_id_str,
- struct HYD_Partition *partition_list);
+HYD_Status HYD_BSCI_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_Proxy *proxy_list);
HYD_Status HYD_BSCI_finalize(void);
-HYD_Status HYD_BSCI_wait_for_completion(struct HYD_Partition *partition_list);
-HYD_Status HYD_BSCI_query_node_list(int *num_nodes, struct HYD_Partition **partition_list);
+HYD_Status HYD_BSCI_wait_for_completion(struct HYD_Proxy *proxy_list);
+HYD_Status HYD_BSCI_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list);
HYD_Status HYD_BSCI_query_usize(int *size);
-HYD_Status HYD_BSCI_query_partition_id(int *partition_id);
+HYD_Status HYD_BSCI_query_proxy_id(int *proxy_id);
/* Each bootstrap server has to expose an initialization function */
@hydra_bss_init_decl@
Modified: mpich2/trunk/src/pm/hydra/bootstrap/rsh/rsh.h
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/rsh/rsh.h 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/rsh/rsh.h 2009-10-11 05:44:30 UTC (rev 5444)
@@ -9,7 +9,7 @@
#include "hydra_base.h"
-HYD_Status HYD_BSCD_rsh_launch_procs(char **global_args, const char *partition_id_str,
- struct HYD_Partition *partition_list);
+HYD_Status HYD_BSCD_rsh_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_Proxy *proxy_list);
#endif /* RSH_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/bootstrap/rsh/rsh_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/rsh/rsh_launch.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/rsh/rsh_launch.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -15,10 +15,10 @@
* environment variables. We fork a worker process that sets the
* environment and execvp's this executable.
*/
-HYD_Status HYD_BSCD_rsh_launch_procs(char **global_args, const char *partition_id_str,
- struct HYD_Partition *partition_list)
+HYD_Status HYD_BSCD_rsh_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_Proxy *proxy_list)
{
- struct HYD_Partition *partition;
+ struct HYD_Proxy *proxy;
char *client_arg[HYD_NUM_TMP_STRINGS];
char *tmp[HYD_NUM_TMP_STRINGS], *path = NULL, *test_path = NULL;
int i, arg, process_id;
@@ -54,20 +54,19 @@
}
process_id = 0;
- FORALL_ACTIVE_PARTITIONS(partition, partition_list) {
+ FORALL_ACTIVE_PROXIES(proxy, proxy_list) {
/* Setup the executable arguments */
arg = 0;
client_arg[arg++] = HYDU_strdup(path);
- /* rsh does not support any partition names other than host names */
- client_arg[arg++] = HYDU_strdup(partition->base->name);
+ client_arg[arg++] = HYDU_strdup(proxy->hostname);
for (i = 0; global_args[i]; i++)
client_arg[arg++] = HYDU_strdup(global_args[i]);
- if (partition_id_str) {
- client_arg[arg++] = HYDU_strdup(partition_id_str);
- client_arg[arg++] = HYDU_int_to_str(partition->base->partition_id);
+ if (proxy_id_str) {
+ client_arg[arg++] = HYDU_strdup(proxy_id_str);
+ client_arg[arg++] = HYDU_int_to_str(proxy->proxy_id);
}
client_arg[arg++] = NULL;
@@ -80,9 +79,9 @@
/* The stdin pointer will be some value for process_id 0; for
* everyone else, it's NULL. */
status = HYDU_create_process(client_arg, NULL,
- (process_id == 0 ? &partition->base->in : NULL),
- &partition->base->out, &partition->base->err,
- &partition->base->pid, -1);
+ (process_id == 0 ? &proxy->in : NULL),
+ &proxy->out, &proxy->err,
+ &proxy->pid, -1);
HYDU_ERR_POP(status, "create process returned error\n");
HYDU_free_strlist(client_arg);
Modified: mpich2/trunk/src/pm/hydra/bootstrap/slurm/Makefile.mk
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/slurm/Makefile.mk 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/slurm/Makefile.mk 2009-10-11 05:44:30 UTC (rev 5444)
@@ -7,4 +7,4 @@
libhydra_a_SOURCES += $(top_srcdir)/bootstrap/slurm/slurm_init.c \
$(top_srcdir)/bootstrap/slurm/slurm_launch.c \
$(top_srcdir)/bootstrap/slurm/slurm_query_node_list.c \
- $(top_srcdir)/bootstrap/slurm/slurm_query_partition_id.c
+ $(top_srcdir)/bootstrap/slurm/slurm_query_proxy_id.c
Modified: mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm.h
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm.h 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm.h 2009-10-11 05:44:30 UTC (rev 5444)
@@ -9,10 +9,10 @@
#include "hydra_base.h"
-HYD_Status HYD_BSCD_slurm_launch_procs(char **global_args, const char *partition_id_str,
- struct HYD_Partition *partition_list);
-HYD_Status HYD_BSCD_slurm_query_partition_id(int *partition_id);
+HYD_Status HYD_BSCD_slurm_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_Proxy *proxy_list);
+HYD_Status HYD_BSCD_slurm_query_proxy_id(int *proxy_id);
HYD_Status HYD_BSCD_slurm_query_node_list(int *num_nodes,
- struct HYD_Partition **partition_list);
+ struct HYD_Proxy **proxy_list);
#endif /* SLURM_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_init.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_init.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_init.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -15,7 +15,7 @@
HYDU_FUNC_ENTER();
HYD_BSCI_fns.launch_procs = HYD_BSCD_slurm_launch_procs;
- HYD_BSCI_fns.query_partition_id = HYD_BSCD_slurm_query_partition_id;
+ HYD_BSCI_fns.query_proxy_id = HYD_BSCD_slurm_query_proxy_id;
HYD_BSCI_fns.query_node_list = HYD_BSCD_slurm_query_node_list;
HYDU_FUNC_EXIT();
Modified: mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_launch.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_launch.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -9,10 +9,10 @@
#include "bscu.h"
#include "slurm.h"
-HYD_Status HYD_BSCD_slurm_launch_procs(char **global_args, const char *partition_id_str,
- struct HYD_Partition *partition_list)
+HYD_Status HYD_BSCD_slurm_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_Proxy *proxy_list)
{
- struct HYD_Partition *partition;
+ struct HYD_Proxy *proxy;
char *client_arg[HYD_NUM_TMP_STRINGS];
char *tmp[HYD_NUM_TMP_STRINGS], *path = NULL, *test_path = NULL;
int i, arg, num_nodes;
@@ -53,9 +53,9 @@
i = 0;
num_nodes = 0;
- FORALL_ACTIVE_PARTITIONS(partition, partition_list) {
- tmp[i++] = HYDU_strdup(partition->base->name);
- if (partition->next && partition->next->base->active)
+ FORALL_ACTIVE_PROXIES(proxy, proxy_list) {
+ tmp[i++] = HYDU_strdup(proxy->hostname);
+ if (proxy->next && proxy->next->active)
tmp[i++] = HYDU_strdup(",");
num_nodes++;
@@ -95,10 +95,10 @@
}
status = HYDU_create_process(client_arg, NULL,
- &partition_list->base->in,
- &partition_list->base->out,
- &partition_list->base->err,
- &partition_list->base->pid, -1);
+ &proxy_list->in,
+ &proxy_list->out,
+ &proxy_list->err,
+ &proxy_list->pid, -1);
HYDU_ERR_POP(status, "bootstrap spawn process returned error\n");
HYDU_free_strlist(client_arg);
Modified: mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_node_list.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_node_list.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_node_list.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -100,11 +100,11 @@
}
HYD_Status HYD_BSCD_slurm_query_node_list(int *num_nodes,
- struct HYD_Partition **partition_list)
+ struct HYD_Proxy **proxy_list)
{
char *str, *num_procs;
char *tmp1[HYD_NUM_TMP_STRINGS], *tmp2[HYD_NUM_TMP_STRINGS];
- struct HYD_Partition_segment *segment;
+ struct HYD_Proxy_segment *segment;
int i, j;
HYD_Status status = HYD_SUCCESS;
@@ -114,7 +114,7 @@
num_procs = getenv("SLURM_JOB_CPUS_PER_NODE");
if (str == NULL || num_procs == NULL) {
- *partition_list = NULL;
+ *proxy_list = NULL;
}
else {
full_str_to_groups(str, tmp1);
@@ -126,14 +126,14 @@
HYDU_ERR_POP(status, "unable to parse node list\n");
for (j = 0; tmp2[j]; j++) {
- status = HYDU_alloc_partition_segment(&segment);
- HYDU_ERR_POP(status, "Unable to allocate partition segment\n");
+ status = HYDU_alloc_proxy_segment(&segment);
+ HYDU_ERR_POP(status, "Unable to allocate proxy segment\n");
segment->start_pid = *num_nodes;
segment->proc_count = atoi(num_procs);
- status = HYDU_merge_partition_segment(tmp2[j], segment, partition_list);
- HYDU_ERR_POP(status, "merge partition segment failed\n");
+ status = HYDU_merge_proxy_segment(tmp2[j], segment, proxy_list);
+ HYDU_ERR_POP(status, "merge proxy segment failed\n");
*num_nodes += atoi(num_procs);
}
Deleted: mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_partition_id.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_partition_id.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_partition_id.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -1,32 +0,0 @@
-/* -*- Mode: C; c-basic-offset:4 ; -*- */
-/*
- * (C) 2008 by Argonne National Laboratory.
- * See COPYRIGHT in top-level directory.
- */
-
-#include "hydra_utils.h"
-#include "bsci.h"
-#include "bscu.h"
-#include "slurm.h"
-
-HYD_Status HYD_BSCD_slurm_query_partition_id(int *partition_id)
-{
- HYD_Status status = HYD_SUCCESS;
-
- HYDU_FUNC_ENTER();
-
- if (getenv("SLURM_NODEID")) {
- *partition_id = atoi(getenv("SLURM_NODEID"));
- }
- else {
- *partition_id = -1;
- HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "cannot find slurm partition ID\n");
- }
-
- fn_exit:
- HYDU_FUNC_EXIT();
- return status;
-
- fn_fail:
- goto fn_exit;
-}
Copied: mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_proxy_id.c (from rev 5443, mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_partition_id.c)
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_proxy_id.c (rev 0)
+++ mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_proxy_id.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -0,0 +1,32 @@
+/* -*- Mode: C; c-basic-offset:4 ; -*- */
+/*
+ * (C) 2008 by Argonne National Laboratory.
+ * See COPYRIGHT in top-level directory.
+ */
+
+#include "hydra_utils.h"
+#include "bsci.h"
+#include "bscu.h"
+#include "slurm.h"
+
+HYD_Status HYD_BSCD_slurm_query_proxy_id(int *proxy_id)
+{
+ HYD_Status status = HYD_SUCCESS;
+
+ HYDU_FUNC_ENTER();
+
+ if (getenv("SLURM_NODEID")) {
+ *proxy_id = atoi(getenv("SLURM_NODEID"));
+ }
+ else {
+ *proxy_id = -1;
+ HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "cannot find slurm proxy ID\n");
+ }
+
+ fn_exit:
+ HYDU_FUNC_EXIT();
+ return status;
+
+ fn_fail:
+ goto fn_exit;
+}
Property changes on: mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_proxy_id.c
___________________________________________________________________
Added: svn:mergeinfo
+
Modified: mpich2/trunk/src/pm/hydra/bootstrap/src/Makefile.mk
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/src/Makefile.mk 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/src/Makefile.mk 2009-10-11 05:44:30 UTC (rev 5444)
@@ -8,6 +8,6 @@
$(top_srcdir)/bootstrap/src/bsci_finalize.c \
$(top_srcdir)/bootstrap/src/bsci_launch.c \
$(top_srcdir)/bootstrap/src/bsci_query_node_list.c \
- $(top_srcdir)/bootstrap/src/bsci_query_partition_id.c \
+ $(top_srcdir)/bootstrap/src/bsci_query_proxy_id.c \
$(top_srcdir)/bootstrap/src/bsci_usize.c \
$(top_srcdir)/bootstrap/src/bsci_wait.c
Modified: mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_init.c.in
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_init.c.in 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_init.c.in 2009-10-11 05:44:30 UTC (rev 5444)
@@ -50,8 +50,8 @@
HYD_BSCI_fns.query_node_list = HYD_BSCU_query_node_list;
if (HYD_BSCI_fns.query_usize == NULL)
HYD_BSCI_fns.query_usize = HYD_BSCU_query_usize;
- if (HYD_BSCI_fns.query_partition_id == NULL)
- HYD_BSCI_fns.query_partition_id = HYD_BSCU_query_partition_id;
+ if (HYD_BSCI_fns.query_proxy_id == NULL)
+ HYD_BSCI_fns.query_proxy_id = HYD_BSCU_query_proxy_id;
fn_exit:
HYDU_FUNC_EXIT();
Modified: mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_launch.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_launch.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -7,14 +7,14 @@
#include "hydra_utils.h"
#include "bsci.h"
-HYD_Status HYD_BSCI_launch_procs(char **global_args, const char *partition_id_str,
- struct HYD_Partition *partition_list)
+HYD_Status HYD_BSCI_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_Proxy *proxy_list)
{
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_BSCI_fns.launch_procs(global_args, partition_id_str, partition_list);
+ status = HYD_BSCI_fns.launch_procs(global_args, proxy_id_str, proxy_list);
HYDU_ERR_POP(status, "bootstrap device returned error while launching processes\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_query_node_list.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_query_node_list.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_query_node_list.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -8,13 +8,13 @@
#include "bsci.h"
#include "bscu.h"
-HYD_Status HYD_BSCI_query_node_list(int *num_nodes, struct HYD_Partition **partition_list)
+HYD_Status HYD_BSCI_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list)
{
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_BSCI_fns.query_node_list(num_nodes, partition_list);
+ status = HYD_BSCI_fns.query_node_list(num_nodes, proxy_list);
HYDU_ERR_POP(status, "bootstrap device returned error while querying node list\n");
fn_exit:
Deleted: mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_query_partition_id.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_query_partition_id.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_query_partition_id.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -1,26 +0,0 @@
-/* -*- Mode: C; c-basic-offset:4 ; -*- */
-/*
- * (C) 2008 by Argonne National Laboratory.
- * See COPYRIGHT in top-level directory.
- */
-
-#include "hydra_utils.h"
-#include "bsci.h"
-#include "bscu.h"
-
-HYD_Status HYD_BSCI_query_partition_id(int *partition_id)
-{
- HYD_Status status = HYD_SUCCESS;
-
- HYDU_FUNC_ENTER();
-
- status = HYD_BSCI_fns.query_partition_id(partition_id);
- HYDU_ERR_POP(status, "bootstrap device returned error while querying partition ID\n");
-
- fn_exit:
- HYDU_FUNC_EXIT();
- return status;
-
- fn_fail:
- goto fn_exit;
-}
Copied: mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_query_proxy_id.c (from rev 5443, mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_query_partition_id.c)
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_query_proxy_id.c (rev 0)
+++ mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_query_proxy_id.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -0,0 +1,26 @@
+/* -*- Mode: C; c-basic-offset:4 ; -*- */
+/*
+ * (C) 2008 by Argonne National Laboratory.
+ * See COPYRIGHT in top-level directory.
+ */
+
+#include "hydra_utils.h"
+#include "bsci.h"
+#include "bscu.h"
+
+HYD_Status HYD_BSCI_query_proxy_id(int *proxy_id)
+{
+ HYD_Status status = HYD_SUCCESS;
+
+ HYDU_FUNC_ENTER();
+
+ status = HYD_BSCI_fns.query_proxy_id(proxy_id);
+ HYDU_ERR_POP(status, "bootstrap device returned error while querying proxy ID\n");
+
+ fn_exit:
+ HYDU_FUNC_EXIT();
+ return status;
+
+ fn_fail:
+ goto fn_exit;
+}
Property changes on: mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_query_proxy_id.c
___________________________________________________________________
Added: svn:mergeinfo
+
Modified: mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_wait.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_wait.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/src/bsci_wait.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -8,13 +8,13 @@
#include "bsci.h"
#include "bscu.h"
-HYD_Status HYD_BSCI_wait_for_completion(struct HYD_Partition *partition_list)
+HYD_Status HYD_BSCI_wait_for_completion(struct HYD_Proxy *proxy_list)
{
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_BSCI_fns.wait_for_completion(partition_list);
+ status = HYD_BSCI_fns.wait_for_completion(proxy_list);
HYDU_ERR_POP(status, "bootstrap device returned error waiting for completion\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/bootstrap/ssh/ssh.h
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/ssh/ssh.h 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/ssh/ssh.h 2009-10-11 05:44:30 UTC (rev 5444)
@@ -9,7 +9,7 @@
#include "hydra_base.h"
-HYD_Status HYD_BSCD_ssh_launch_procs(char **global_args, const char *partition_id_str,
- struct HYD_Partition *partition_list);
+HYD_Status HYD_BSCD_ssh_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_Proxy *proxy_list);
#endif /* SSH_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/bootstrap/ssh/ssh_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/ssh/ssh_launch.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/ssh/ssh_launch.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -15,10 +15,10 @@
* environment variables. We fork a worker process that sets the
* environment and execvp's this executable.
*/
-HYD_Status HYD_BSCD_ssh_launch_procs(char **global_args, const char *partition_id_str,
- struct HYD_Partition *partition_list)
+HYD_Status HYD_BSCD_ssh_launch_procs(char **global_args, const char *proxy_id_str,
+ struct HYD_Proxy *proxy_list)
{
- struct HYD_Partition *partition;
+ struct HYD_Proxy *proxy;
char *client_arg[HYD_NUM_TMP_STRINGS];
char *tmp[HYD_NUM_TMP_STRINGS], *path = NULL, *test_path = NULL;
int i, arg, process_id;
@@ -54,7 +54,7 @@
}
process_id = 0;
- FORALL_ACTIVE_PARTITIONS(partition, partition_list) {
+ FORALL_ACTIVE_PROXIES(proxy, proxy_list) {
/* Setup the executable arguments */
arg = 0;
client_arg[arg++] = HYDU_strdup(path);
@@ -67,15 +67,14 @@
else /* default mode is disable X */
client_arg[arg++] = HYDU_strdup("-x");
- /* ssh does not support any partition names other than host names */
- client_arg[arg++] = HYDU_strdup(partition->base->name);
+ client_arg[arg++] = HYDU_strdup(proxy->hostname);
for (i = 0; global_args[i]; i++)
client_arg[arg++] = HYDU_strdup(global_args[i]);
- if (partition_id_str) {
- client_arg[arg++] = HYDU_strdup(partition_id_str);
- client_arg[arg++] = HYDU_int_to_str(partition->base->partition_id);
+ if (proxy_id_str) {
+ client_arg[arg++] = HYDU_strdup(proxy_id_str);
+ client_arg[arg++] = HYDU_int_to_str(proxy->proxy_id);
}
client_arg[arg++] = NULL;
@@ -88,9 +87,9 @@
/* The stdin pointer will be some value for process_id 0; for
* everyone else, it's NULL. */
status = HYDU_create_process(client_arg, NULL,
- (process_id == 0 ? &partition->base->in : NULL),
- &partition->base->out, &partition->base->err,
- &partition->base->pid, -1);
+ (process_id == 0 ? &proxy->in : NULL),
+ &proxy->out, &proxy->err,
+ &proxy->pid, -1);
HYDU_ERR_POP(status, "create process returned error\n");
HYDU_free_strlist(client_arg);
Modified: mpich2/trunk/src/pm/hydra/bootstrap/utils/Makefile.mk
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/utils/Makefile.mk 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/utils/Makefile.mk 2009-10-11 05:44:30 UTC (rev 5444)
@@ -8,6 +8,6 @@
libhydra_a_SOURCES += $(top_srcdir)/bootstrap/utils/bscu_finalize.c \
$(top_srcdir)/bootstrap/utils/bscu_query_node_list.c \
- $(top_srcdir)/bootstrap/utils/bscu_query_partition_id.c \
+ $(top_srcdir)/bootstrap/utils/bscu_query_proxy_id.c \
$(top_srcdir)/bootstrap/utils/bscu_usize.c \
$(top_srcdir)/bootstrap/utils/bscu_wait.c
Modified: mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu.h
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu.h 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu.h 2009-10-11 05:44:30 UTC (rev 5444)
@@ -10,9 +10,9 @@
#include "hydra_base.h"
HYD_Status HYD_BSCU_finalize(void);
-HYD_Status HYD_BSCU_wait_for_completion(struct HYD_Partition *partition_list);
-HYD_Status HYD_BSCU_query_node_list(int *num_nodes, struct HYD_Partition **partition_list);
+HYD_Status HYD_BSCU_wait_for_completion(struct HYD_Proxy *proxy_list);
+HYD_Status HYD_BSCU_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list);
HYD_Status HYD_BSCU_query_usize(int *size);
-HYD_Status HYD_BSCU_query_partition_id(int *partition_id);
+HYD_Status HYD_BSCU_query_proxy_id(int *proxy_id);
#endif /* BSCU_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_query_node_list.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_query_node_list.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_query_node_list.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -8,7 +8,7 @@
#include "hydra_utils.h"
#include "bscu.h"
-HYD_Status HYD_BSCU_query_node_list(int *num_nodes, struct HYD_Partition **partition_list)
+HYD_Status HYD_BSCU_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list)
{
HYD_Status status = HYD_SUCCESS;
@@ -17,7 +17,7 @@
/* We don't know anything about nodes or resources. Just return
* NULL. */
*num_nodes = 0;
- *partition_list = NULL;
+ *proxy_list = NULL;
HYDU_FUNC_EXIT();
Deleted: mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_query_partition_id.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_query_partition_id.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_query_partition_id.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -1,23 +0,0 @@
-/* -*- Mode: C; c-basic-offset:4 ; -*- */
-/*
- * (C) 2008 by Argonne National Laboratory.
- * See COPYRIGHT in top-level directory.
- */
-
-#include "hydra_base.h"
-#include "hydra_utils.h"
-#include "bscu.h"
-
-HYD_Status HYD_BSCU_query_partition_id(int *partition_id)
-{
- HYD_Status status = HYD_SUCCESS;
-
- HYDU_FUNC_ENTER();
-
- /* We don't know anything about partition IDs by default. */
- *partition_id = -1;
-
- HYDU_FUNC_EXIT();
-
- return status;
-}
Copied: mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_query_proxy_id.c (from rev 5443, mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_query_partition_id.c)
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_query_proxy_id.c (rev 0)
+++ mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_query_proxy_id.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -0,0 +1,23 @@
+/* -*- Mode: C; c-basic-offset:4 ; -*- */
+/*
+ * (C) 2008 by Argonne National Laboratory.
+ * See COPYRIGHT in top-level directory.
+ */
+
+#include "hydra_base.h"
+#include "hydra_utils.h"
+#include "bscu.h"
+
+HYD_Status HYD_BSCU_query_proxy_id(int *proxy_id)
+{
+ HYD_Status status = HYD_SUCCESS;
+
+ HYDU_FUNC_ENTER();
+
+ /* We don't know anything about proxy IDs by default. */
+ *proxy_id = -1;
+
+ HYDU_FUNC_EXIT();
+
+ return status;
+}
Property changes on: mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_query_proxy_id.c
___________________________________________________________________
Added: svn:mergeinfo
+
Modified: mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_wait.c
===================================================================
--- mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_wait.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/bootstrap/utils/bscu_wait.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -7,19 +7,19 @@
#include "hydra_utils.h"
#include "bscu.h"
-HYD_Status HYD_BSCU_wait_for_completion(struct HYD_Partition *partition_list)
+HYD_Status HYD_BSCU_wait_for_completion(struct HYD_Proxy *proxy_list)
{
int pid, ret_status, not_completed;
- struct HYD_Partition *partition;
- struct HYD_Partition_exec *exec;
+ struct HYD_Proxy *proxy;
+ struct HYD_Proxy_exec *exec;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
not_completed = 0;
- FORALL_ACTIVE_PARTITIONS(partition, partition_list) {
- if (partition->exit_status == NULL) {
- for (exec = partition->exec_list; exec; exec = exec->next)
+ FORALL_ACTIVE_PROXIES(proxy, proxy_list) {
+ if (proxy->exit_status == NULL) {
+ for (exec = proxy->exec_list; exec; exec = exec->next)
not_completed += exec->proc_count;
}
}
@@ -33,8 +33,8 @@
pid = waitpid(-1, &ret_status, WNOHANG);
if (pid > 0) {
/* Find the pid and mark it as complete. */
- FORALL_ACTIVE_PARTITIONS(partition, partition_list) {
- if (partition->base->pid == pid)
+ FORALL_ACTIVE_PROXIES(proxy, proxy_list) {
+ if (proxy->pid == pid)
not_completed--;
}
}
Modified: mpich2/trunk/src/pm/hydra/include/hydra.h
===================================================================
--- mpich2/trunk/src/pm/hydra/include/hydra.h 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/include/hydra.h 2009-10-11 05:44:30 UTC (rev 5444)
@@ -55,7 +55,7 @@
int global_core_count;
struct HYD_Exec_info *exec_info_list;
- struct HYD_Partition *partition_list;
+ struct HYD_Proxy *proxy_list;
/* Random parameters used for internal code */
int func_depth;
Modified: mpich2/trunk/src/pm/hydra/include/hydra_base.h
===================================================================
--- mpich2/trunk/src/pm/hydra/include/hydra_base.h 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/include/hydra_base.h 2009-10-11 05:44:30 UTC (rev 5444)
@@ -141,27 +141,6 @@
char *prop;
};
-/* List of contiguous segments of processes on a partition */
-struct HYD_Partition_segment {
- int start_pid;
- int proc_count;
- char **mapping;
- struct HYD_Partition_segment *next;
-};
-
-/* Executables on a partition */
-struct HYD_Partition_exec {
- char *exec[HYD_NUM_TMP_STRINGS];
- int proc_count;
- HYD_Env_t *user_env;
- char *env_prop;
-
- int pgid; /* All executables with the same PGID belong to the same
- * job. */
-
- struct HYD_Partition_exec *next;
-};
-
#if !defined HAVE_PTHREAD_H
#error "pthread.h needed"
#else
@@ -178,52 +157,62 @@
#endif
#endif
-#define FORALL_ACTIVE_PARTITIONS(partition, partition_list) \
- for ((partition) = (partition_list); (partition) && (partition)->base->active; \
- (partition) = (partition)->next)
+#define FORALL_ACTIVE_PROXIES(proxy, proxy_list) \
+ for ((proxy) = (proxy_list); (proxy) && (proxy)->active; \
+ (proxy) = (proxy)->next)
-#define FORALL_PARTITIONS(partition, partition_list) \
- for ((partition) = (partition_list); (partition); (partition) = (partition)->next)
+#define FORALL_PROXIES(proxy, proxy_list) \
+ for ((proxy) = (proxy_list); (proxy); (proxy) = (proxy)->next)
-struct HYD_Partition_base {
- char *name;
- char **exec_args; /* Full argument list */
+/* List of contiguous segments of processes on a proxy */
+struct HYD_Proxy_segment {
+ int start_pid;
+ int proc_count;
+ char **mapping;
+ struct HYD_Proxy_segment *next;
+};
- int partition_id;
- int active;
+/* Executables on a proxy */
+struct HYD_Proxy_exec {
+ char *exec[HYD_NUM_TMP_STRINGS];
+ int proc_count;
+ HYD_Env_t *user_env;
+ char *env_prop;
- int pid;
- int in; /* stdin is only valid for partition_id 0 */
- int out;
- int err;
+ int pgid; /* All executables with the same PGID belong to the same
+ * job. */
- struct HYD_Partition_base *next; /* Unused */
+ struct HYD_Proxy_exec *next;
};
-/* Partition information */
-struct HYD_Partition {
- struct HYD_Partition_base *base;
+/* Proxy information */
+struct HYD_Proxy {
+ char *hostname;
+ char **exec_args;
+ int proxy_id;
+ int active;
+
+ int pid;
+ int in; /* stdin is only valid for proxy_id 0 */
+ int out;
+ int err;
+
char *user_bind_map;
- int partition_core_count;
+ int proxy_core_count;
/* Segment list will contain one-pass of the hosts file */
- struct HYD_Partition_segment *segment_list;
- struct HYD_Partition_exec *exec_list;
+ struct HYD_Proxy_segment *segment_list;
+ struct HYD_Proxy_exec *exec_list;
- /* Spawn information: each partition can have one or more
- * proxies. For the time being, we only support one proxy per
- * partition, but this can be easily extended later. We will also
- * need to give different ports for the proxies to listen on in
- * that case. */
int *exit_status;
int control_fd;
- struct HYD_Partition *next;
+ struct HYD_Proxy *next;
};
struct HYD_Exec_info {
- int exec_proc_count;
+ int process_count;
char *exec[HYD_NUM_TMP_STRINGS];
/* Local environment */
Modified: mpich2/trunk/src/pm/hydra/include/hydra_utils.h
===================================================================
--- mpich2/trunk/src/pm/hydra/include/hydra_utils.h 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/include/hydra_utils.h 2009-10-11 05:44:30 UTC (rev 5444)
@@ -162,18 +162,18 @@
};
#endif /* HAVE_THREAD_SUPPORT */
-HYD_Status HYDU_alloc_partition(struct HYD_Partition **partition);
-void HYDU_free_partition_list(struct HYD_Partition *partition);
+HYD_Status HYDU_alloc_proxy(struct HYD_Proxy **proxy);
+void HYDU_free_proxy_list(struct HYD_Proxy *proxy);
HYD_Status HYDU_alloc_exec_info(struct HYD_Exec_info **exec_info);
void HYDU_free_exec_info_list(struct HYD_Exec_info *exec_info_list);
-HYD_Status HYDU_alloc_partition_segment(struct HYD_Partition_segment **segment);
-HYD_Status HYDU_merge_partition_segment(char *name, struct HYD_Partition_segment *segment,
- struct HYD_Partition **partition_list);
-HYD_Status HYDU_merge_partition_mapping(char *name, char *map, int num_procs,
- struct HYD_Partition **partition_list);
-HYD_Status HYDU_alloc_partition_exec(struct HYD_Partition_exec **exec);
+HYD_Status HYDU_alloc_proxy_segment(struct HYD_Proxy_segment **segment);
+HYD_Status HYDU_merge_proxy_segment(char *name, struct HYD_Proxy_segment *segment,
+ struct HYD_Proxy **proxy_list);
+HYD_Status HYDU_merge_proxy_mapping(char *name, char *map, int num_procs,
+ struct HYD_Proxy **proxy_list);
+HYD_Status HYDU_alloc_proxy_exec(struct HYD_Proxy_exec **exec);
HYD_Status HYDU_create_node_list_from_file(char *host_file,
- struct HYD_Partition **partition_list);
+ struct HYD_Proxy **proxy_list);
HYD_Status HYDU_create_process(char **client_arg, HYD_Env_t * env_list,
int *in, int *out, int *err, int *pid, int core);
HYD_Status HYDU_fork_and_exit(int core);
@@ -182,8 +182,8 @@
struct HYD_Thread_context *ctxt);
HYD_Status HYDU_join_thread(struct HYD_Thread_context ctxt);
#endif /* HAVE_THREAD_SUPPORT */
-int HYDU_local_to_global_id(int local_id, int partition_core_count,
- struct HYD_Partition_segment *segment_list, int global_core_count);
+int HYDU_local_to_global_id(int local_id, int proxy_core_count,
+ struct HYD_Proxy_segment *segment_list, int global_core_count);
/* signals */
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -223,8 +223,8 @@
{
int i, node_id;
char *tmp[HYD_NUM_TMP_STRINGS];
- struct HYD_Partition *partition;
- struct HYD_Partition_segment *segment;
+ struct HYD_Proxy *proxy;
+ struct HYD_Proxy_segment *segment;
struct segment *seglist_head, *seglist_tail = NULL, *seg;
struct block *blocklist_head, *blocklist_tail = NULL, *block;
int done;
@@ -234,9 +234,9 @@
seglist_head = NULL;
node_id = -1;
- FORALL_PARTITIONS(partition, HYD_handle.partition_list) {
+ FORALL_PROXIES(proxy, HYD_handle.proxy_list) {
node_id++;
- for (segment = partition->segment_list; segment; segment = segment->next) {
+ for (segment = proxy->segment_list; segment; segment = segment->next) {
HYDU_MALLOC(seg, struct segment *, sizeof(struct segment), status);
seg->start_pid = segment->start_pid;
seg->proc_count = segment->proc_count;
@@ -343,16 +343,16 @@
static struct HYD_PMCD_pmi_node *find_node(HYD_PMCD_pmi_pg_t * pg, int rank)
{
int found = 0, node_id, srank;
- struct HYD_Partition *partition;
- struct HYD_Partition_segment *segment;
+ struct HYD_Proxy *proxy;
+ struct HYD_Proxy_segment *segment;
struct HYD_PMCD_pmi_node *node, *tmp;
HYD_Status status = HYD_SUCCESS;
srank = rank % HYD_handle.global_core_count;
node_id = 0;
- FORALL_PARTITIONS(partition, HYD_handle.partition_list) {
- for (segment = partition->segment_list; segment; segment = segment->next) {
+ FORALL_PROXIES(proxy, HYD_handle.proxy_list) {
+ for (segment = proxy->segment_list; segment; segment = segment->next) {
if ((srank >= segment->start_pid) &&
(srank < (segment->start_pid + segment->proc_count))) {
/* We found our rank */
@@ -450,8 +450,8 @@
HYD_Status HYD_PMCD_pmi_init(void)
{
- struct HYD_Partition *partition;
- struct HYD_Partition_exec *exec;
+ struct HYD_Proxy *proxy;
+ struct HYD_Proxy_exec *exec;
int i;
HYD_Status status = HYD_SUCCESS;
@@ -462,8 +462,8 @@
/* Find the number of processes in the PG */
HYD_pg_list->num_subgroups = 0;
- FORALL_ACTIVE_PARTITIONS(partition, HYD_handle.partition_list) {
- for (exec = partition->exec_list; exec; exec = exec->next)
+ FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
+ for (exec = proxy->exec_list; exec; exec = exec->next)
HYD_pg_list->num_subgroups += exec->proc_count;
}
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.h 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.h 2009-10-11 05:44:30 UTC (rev 5444)
@@ -42,7 +42,7 @@
};
struct HYD_PMCD_pmi_node {
- int node_id; /* This corresponds to the partition ID of the
+ int node_id; /* This corresponds to the proxy ID of the
* launched processes */
struct HYD_PMCD_pmi_pg *pg; /* Back pointer to the group */
struct HYD_PMCD_pmi_process *process_list;
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -108,9 +108,9 @@
HYDU_ERR_POP(status, "unable to connect to the main server\n");
status = HYDU_sock_write(HYD_PMCD_pmi_proxy_params.upstream.control,
- &HYD_PMCD_pmi_proxy_params.proxy.partition_id,
- sizeof(HYD_PMCD_pmi_proxy_params.proxy.partition_id));
- HYDU_ERR_POP(status, "unable to send the partition ID to the server\n");
+ &HYD_PMCD_pmi_proxy_params.proxy.proxy_id,
+ sizeof(HYD_PMCD_pmi_proxy_params.proxy.proxy_id));
+ HYDU_ERR_POP(status, "unable to send the proxy ID to the server\n");
status = HYD_DMX_register_fd(1, &HYD_PMCD_pmi_proxy_params.upstream.control,
HYD_STDOUT, NULL, HYD_PMCD_pmi_proxy_control_cmd_cb);
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h 2009-10-11 05:44:30 UTC (rev 5444)
@@ -17,7 +17,7 @@
char *server_name;
int server_port;
HYD_Launch_mode_t launch_mode;
- int partition_id;
+ int proxy_id;
char *bootstrap;
char *bootstrap_exec;
int enablex;
@@ -38,14 +38,14 @@
struct HYD_Env_global global_env;
int global_core_count;
- int partition_core_count;
+ int proxy_core_count;
int exec_proc_count;
int procs_are_launched;
- /* Process segmentation information for this partition */
- struct HYD_Partition_segment *segment_list;
- struct HYD_Partition_exec *exec_list;
+ /* Process segmentation information for this proxy */
+ struct HYD_Proxy_segment *segment_list;
+ struct HYD_Proxy_exec *exec_list;
struct {
int out;
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -18,7 +18,7 @@
HYD_PMCD_pmi_proxy_params.proxy.server_name = NULL;
HYD_PMCD_pmi_proxy_params.proxy.server_port = -1;
HYD_PMCD_pmi_proxy_params.proxy.launch_mode = HYD_LAUNCH_UNSET;
- HYD_PMCD_pmi_proxy_params.proxy.partition_id = -1;
+ HYD_PMCD_pmi_proxy_params.proxy.proxy_id = -1;
HYD_PMCD_pmi_proxy_params.proxy.bootstrap = NULL;
HYD_PMCD_pmi_proxy_params.proxy.bootstrap_exec = NULL;
HYD_PMCD_pmi_proxy_params.proxy.debug = 0;
@@ -39,7 +39,7 @@
HYD_PMCD_pmi_proxy_params.global_env.inherited = NULL;
HYD_PMCD_pmi_proxy_params.global_core_count = 0;
- HYD_PMCD_pmi_proxy_params.partition_core_count = 0;
+ HYD_PMCD_pmi_proxy_params.proxy_core_count = 0;
HYD_PMCD_pmi_proxy_params.exec_proc_count = 0;
HYD_PMCD_pmi_proxy_params.procs_are_launched = 0;
@@ -74,8 +74,8 @@
char **argv = t_argv, *str, *argtype;
int arg, i, count;
HYD_Env_t *env;
- struct HYD_Partition_exec *exec = NULL;
- struct HYD_Partition_segment *segment = NULL;
+ struct HYD_Proxy_exec *exec = NULL;
+ struct HYD_Proxy_segment *segment = NULL;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -200,14 +200,14 @@
/* New segment */
if (!strcmp(*argv, "--segment")) {
if (HYD_PMCD_pmi_proxy_params.segment_list == NULL) {
- status = HYDU_alloc_partition_segment(&HYD_PMCD_pmi_proxy_params.segment_list);
- HYDU_ERR_POP(status, "unable to allocate partition segment\n");
+ status = HYDU_alloc_proxy_segment(&HYD_PMCD_pmi_proxy_params.segment_list);
+ HYDU_ERR_POP(status, "unable to allocate proxy segment\n");
}
else {
for (segment = HYD_PMCD_pmi_proxy_params.segment_list; segment->next;
segment = segment->next);
- status = HYDU_alloc_partition_segment(&segment->next);
- HYDU_ERR_POP(status, "unable to allocate partition segment\n");
+ status = HYDU_alloc_proxy_segment(&segment->next);
+ HYDU_ERR_POP(status, "unable to allocate proxy segment\n");
}
continue;
}
@@ -233,14 +233,14 @@
/* New executable */
if (!strcmp(*argv, "--exec")) {
if (HYD_PMCD_pmi_proxy_params.exec_list == NULL) {
- status = HYDU_alloc_partition_exec(&HYD_PMCD_pmi_proxy_params.exec_list);
- HYDU_ERR_POP(status, "unable to allocate partition exec\n");
+ status = HYDU_alloc_proxy_exec(&HYD_PMCD_pmi_proxy_params.exec_list);
+ HYDU_ERR_POP(status, "unable to allocate proxy exec\n");
}
else {
for (exec = HYD_PMCD_pmi_proxy_params.exec_list; exec->next;
exec = exec->next);
- status = HYDU_alloc_partition_exec(&exec->next);
- HYDU_ERR_POP(status, "unable to allocate partition exec\n");
+ status = HYDU_alloc_proxy_exec(&exec->next);
+ HYDU_ERR_POP(status, "unable to allocate proxy exec\n");
}
continue;
}
@@ -340,9 +340,9 @@
}
continue;
}
- if (!strcmp(*argv, "--partition-id")) {
+ if (!strcmp(*argv, "--proxy-id")) {
++argv;
- HYD_PMCD_pmi_proxy_params.proxy.partition_id = atoi(*argv);
+ HYD_PMCD_pmi_proxy_params.proxy.proxy_id = atoi(*argv);
continue;
}
if (!strcmp(*argv, "--debug")) {
@@ -375,11 +375,11 @@
HYD_PMCD_pmi_proxy_params.proxy.debug);
HYDU_ERR_POP(status, "proxy unable to initialize bootstrap\n");
- if (HYD_PMCD_pmi_proxy_params.proxy.partition_id == -1) {
- /* We didn't get a partition ID during launch; query the
+ if (HYD_PMCD_pmi_proxy_params.proxy.proxy_id == -1) {
+ /* We didn't get a proxy ID during launch; query the
* bootstrap server for it. */
- status = HYD_BSCI_query_partition_id(&HYD_PMCD_pmi_proxy_params.proxy.partition_id);
- HYDU_ERR_POP(status, "unable to query bootstrap server for partition ID\n");
+ status = HYD_BSCI_query_proxy_id(&HYD_PMCD_pmi_proxy_params.proxy.proxy_id);
+ HYDU_ERR_POP(status, "unable to query bootstrap server for proxy ID\n");
}
fn_exit:
@@ -393,8 +393,8 @@
HYD_Status HYD_PMCD_pmi_proxy_cleanup_params(void)
{
- struct HYD_Partition_segment *segment, *tsegment;
- struct HYD_Partition_exec *exec, *texec;
+ struct HYD_Proxy_segment *segment, *tsegment;
+ struct HYD_Proxy_exec *exec, *texec;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -542,16 +542,16 @@
char *str, *envstr, *list;
char *client_args[HYD_NUM_TMP_STRINGS];
HYD_Env_t *env, *prop_env = NULL;
- struct HYD_Partition_segment *segment;
- struct HYD_Partition_exec *exec;
+ struct HYD_Proxy_segment *segment;
+ struct HYD_Proxy_exec *exec;
HYD_Status status = HYD_SUCCESS;
int *pmi_ids;
HYDU_FUNC_ENTER();
- HYD_PMCD_pmi_proxy_params.partition_core_count = 0;
+ HYD_PMCD_pmi_proxy_params.proxy_core_count = 0;
for (segment = HYD_PMCD_pmi_proxy_params.segment_list; segment; segment = segment->next)
- HYD_PMCD_pmi_proxy_params.partition_core_count += segment->proc_count;
+ HYD_PMCD_pmi_proxy_params.proxy_core_count += segment->proc_count;
HYD_PMCD_pmi_proxy_params.exec_proc_count = 0;
for (exec = HYD_PMCD_pmi_proxy_params.exec_list; exec; exec = exec->next)
@@ -560,7 +560,7 @@
HYDU_MALLOC(pmi_ids, int *, HYD_PMCD_pmi_proxy_params.exec_proc_count * sizeof(int), status);
for (i = 0; i < HYD_PMCD_pmi_proxy_params.exec_proc_count; i++) {
pmi_ids[i] = HYDU_local_to_global_id(i,
- HYD_PMCD_pmi_proxy_params.partition_core_count,
+ HYD_PMCD_pmi_proxy_params.proxy_core_count,
HYD_PMCD_pmi_proxy_params.segment_list,
HYD_PMCD_pmi_proxy_params.global_core_count);
}
@@ -591,7 +591,7 @@
status = HYDU_env_create(&env, "PMI_PORT", HYD_PMCD_pmi_proxy_params.pmi_port_str);
HYDU_ERR_POP(status, "unable to create env\n");
- /* Restart the partition. Specify stdin fd only if pmi_id 0 is in this partition. */
+ /* Restart the proxy. Specify stdin fd only if pmi_id 0 is in this proxy. */
status = HYDU_ckpoint_restart(env, HYD_PMCD_pmi_proxy_params.exec_proc_count,
pmi_ids,
pmi_ids[0] ? NULL : &HYD_PMCD_pmi_proxy_params.in,
@@ -671,7 +671,7 @@
for (i = 0; i < exec->proc_count; i++) {
pmi_id = HYDU_local_to_global_id(process_id,
- HYD_PMCD_pmi_proxy_params.partition_core_count,
+ HYD_PMCD_pmi_proxy_params.proxy_core_count,
HYD_PMCD_pmi_proxy_params.segment_list,
HYD_PMCD_pmi_proxy_params.global_core_count);
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv.h 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv.h 2009-10-11 05:44:30 UTC (rev 5444)
@@ -17,6 +17,6 @@
HYD_Status HYD_PMCD_pmi_serv_ckpoint(void);
void HYD_PMCD_pmi_serv_signal_cb(int signal);
-HYD_Status HYD_PMCD_pmi_send_exec_info(struct HYD_Partition *partition);
+HYD_Status HYD_PMCD_pmi_send_exec_info(struct HYD_Proxy *proxy);
#endif /* PMI_SERV_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_cb.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_cb.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_cb.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -206,8 +206,8 @@
HYD_Status HYD_PMCD_pmi_serv_control_connect_cb(int fd, HYD_Event_t events, void *userp)
{
- int accept_fd, partition_id, count;
- struct HYD_Partition *partition;
+ int accept_fd, proxy_id, count;
+ struct HYD_Proxy *proxy;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -216,27 +216,27 @@
status = HYDU_sock_accept(fd, &accept_fd);
HYDU_ERR_POP(status, "accept error\n");
- /* Read the partition ID */
- status = HYDU_sock_read(accept_fd, &partition_id, sizeof(int), &count,
+ /* Read the proxy ID */
+ status = HYDU_sock_read(accept_fd, &proxy_id, sizeof(int), &count,
HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "sock read returned error\n");
- /* Find the partition */
- FORALL_PARTITIONS(partition, HYD_handle.partition_list) {
- if (partition->base->partition_id == partition_id)
+ /* Find the proxy */
+ FORALL_PROXIES(proxy, HYD_handle.proxy_list) {
+ if (proxy->proxy_id == proxy_id)
break;
}
- HYDU_ERR_CHKANDJUMP1(status, partition == NULL, HYD_INTERNAL_ERROR,
- "cannot find partition with ID %d\n", partition_id);
+ HYDU_ERR_CHKANDJUMP1(status, proxy == NULL, HYD_INTERNAL_ERROR,
+ "cannot find proxy with ID %d\n", proxy_id);
- /* This will be the control socket for this partition */
- partition->control_fd = accept_fd;
+ /* This will be the control socket for this proxy */
+ proxy->control_fd = accept_fd;
/* Send out the executable information */
- status = HYD_PMCD_pmi_send_exec_info(partition);
+ status = HYD_PMCD_pmi_send_exec_info(proxy);
HYDU_ERR_POP(status, "unable to send exec info to proxy\n");
- status = HYD_DMX_register_fd(1, &accept_fd, HYD_STDOUT, partition,
+ status = HYD_DMX_register_fd(1, &accept_fd, HYD_STDOUT, proxy,
HYD_PMCD_pmi_serv_control_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
@@ -251,22 +251,22 @@
HYD_Status HYD_PMCD_pmi_serv_control_cb(int fd, HYD_Event_t events, void *userp)
{
- struct HYD_Partition *partition;
- struct HYD_Partition_exec *exec;
+ struct HYD_Proxy *proxy;
+ struct HYD_Proxy_exec *exec;
int count, proc_count;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- partition = (struct HYD_Partition *) userp;
+ proxy = (struct HYD_Proxy *) userp;
proc_count = 0;
- for (exec = partition->exec_list; exec; exec = exec->next)
+ for (exec = proxy->exec_list; exec; exec = exec->next)
proc_count += exec->proc_count;
- HYDU_MALLOC(partition->exit_status, int *, proc_count * sizeof(int), status);
+ HYDU_MALLOC(proxy->exit_status, int *, proc_count * sizeof(int), status);
- status = HYDU_sock_read(fd, (void *) partition->exit_status, proc_count * sizeof(int),
+ status = HYDU_sock_read(fd, (void *) proxy->exit_status, proc_count * sizeof(int),
&count, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "unable to read status from proxy\n");
@@ -286,7 +286,7 @@
HYD_Status HYD_PMCD_pmi_serv_cleanup(void)
{
- struct HYD_Partition *partition;
+ struct HYD_Proxy *proxy;
enum HYD_PMCD_pmi_proxy_cmds cmd;
HYD_Status status = HYD_SUCCESS, overall_status = HYD_SUCCESS;
@@ -295,13 +295,13 @@
/* FIXME: Instead of doing this from this process itself, fork a
* bunch of processes to do this. */
/* Connect to all proxies and send a KILL command */
- FORALL_ACTIVE_PARTITIONS(partition, HYD_handle.partition_list) {
+ FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
cmd = KILL_JOB;
- status = HYDU_sock_trywrite(partition->control_fd, &cmd,
+ status = HYDU_sock_trywrite(proxy->control_fd, &cmd,
sizeof(enum HYD_PMCD_pmi_proxy_cmds));
if (status != HYD_SUCCESS) {
HYDU_Warn_printf("unable to send data to the proxy on %s\n",
- partition->base->name);
+ proxy->hostname);
overall_status = HYD_INTERNAL_ERROR;
continue; /* Move on to the next proxy */
}
@@ -315,7 +315,7 @@
HYD_Status HYD_PMCD_pmi_serv_ckpoint(void)
{
- struct HYD_Partition *partition;
+ struct HYD_Proxy *proxy;
enum HYD_PMCD_pmi_proxy_cmds cmd;
HYD_Status status = HYD_SUCCESS;
@@ -324,9 +324,9 @@
/* FIXME: Instead of doing this from this process itself, fork a
* bunch of processes to do this. */
/* Connect to all proxies and send the checkpoint command */
- FORALL_ACTIVE_PARTITIONS(partition, HYD_handle.partition_list) {
+ FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
cmd = CKPOINT;
- status = HYDU_sock_write(partition->control_fd, &cmd,
+ status = HYDU_sock_write(proxy->control_fd, &cmd,
sizeof(enum HYD_PMCD_pmi_proxy_cmds));
HYDU_ERR_POP(status, "unable to send checkpoint message\n");
}
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -17,7 +17,7 @@
static void *launch_helper(void *args)
{
- struct HYD_Partition *partition = (struct HYD_Partition *) args;
+ struct HYD_Proxy *proxy = (struct HYD_Proxy *) args;
enum HYD_PMCD_pmi_proxy_cmds cmd;
HYD_Status status = HYD_SUCCESS;
@@ -52,39 +52,39 @@
* work.
*/
- status = HYDU_sock_connect(partition->base->name, HYD_handle.proxy_port,
- &partition->control_fd);
+ status = HYDU_sock_connect(proxy->hostname, HYD_handle.proxy_port,
+ &proxy->control_fd);
HYDU_ERR_POP(status, "unable to connect to proxy\n");
- status = HYD_PMCD_pmi_send_exec_info(partition);
+ status = HYD_PMCD_pmi_send_exec_info(proxy);
HYDU_ERR_POP(status, "error sending executable info\n");
/* Create an stdout socket */
- status = HYDU_sock_connect(partition->base->name, HYD_handle.proxy_port,
- &partition->base->out);
+ status = HYDU_sock_connect(proxy->hostname, HYD_handle.proxy_port,
+ &proxy->out);
HYDU_ERR_POP(status, "unable to connect to proxy\n");
cmd = USE_AS_STDOUT;
- status = HYDU_sock_write(partition->base->out, &cmd, sizeof(enum HYD_PMCD_pmi_proxy_cmds));
+ status = HYDU_sock_write(proxy->out, &cmd, sizeof(enum HYD_PMCD_pmi_proxy_cmds));
HYDU_ERR_POP(status, "unable to write data to proxy\n");
/* Create an stderr socket */
- status = HYDU_sock_connect(partition->base->name, HYD_handle.proxy_port,
- &partition->base->err);
+ status = HYDU_sock_connect(proxy->hostname, HYD_handle.proxy_port,
+ &proxy->err);
HYDU_ERR_POP(status, "unable to connect to proxy\n");
cmd = USE_AS_STDERR;
- status = HYDU_sock_write(partition->base->err, &cmd, sizeof(enum HYD_PMCD_pmi_proxy_cmds));
+ status = HYDU_sock_write(proxy->err, &cmd, sizeof(enum HYD_PMCD_pmi_proxy_cmds));
HYDU_ERR_POP(status, "unable to write data to proxy\n");
/* If rank 0 is here, create an stdin socket */
- if (partition->base->partition_id == 0) {
- status = HYDU_sock_connect(partition->base->name, HYD_handle.proxy_port,
- &partition->base->in);
+ if (proxy->proxy_id == 0) {
+ status = HYDU_sock_connect(proxy->hostname, HYD_handle.proxy_port,
+ &proxy->in);
HYDU_ERR_POP(status, "unable to connect to proxy\n");
cmd = USE_AS_STDIN;
- status = HYDU_sock_write(partition->base->in, &cmd,
+ status = HYDU_sock_write(proxy->in, &cmd,
sizeof(enum HYD_PMCD_pmi_proxy_cmds));
HYDU_ERR_POP(status, "unable to write data to proxy\n");
}
@@ -201,14 +201,14 @@
int segment_count, exec_count, total_args;
static int proxy_count = 0;
HYD_Env_t *env;
- struct HYD_Partition *partition;
- struct HYD_Partition_exec *exec;
- struct HYD_Partition_segment *segment;
+ struct HYD_Proxy *proxy;
+ struct HYD_Proxy_exec *exec;
+ struct HYD_Proxy_segment *segment;
HYD_Status status = HYD_SUCCESS;
/* Create the arguments list for each proxy */
process_id = 0;
- FORALL_ACTIVE_PARTITIONS(partition, HYD_handle.partition_list) {
+ FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
for (inherited_env_count = 0, env = HYD_handle.global_env.inherited; env;
env = env->next, inherited_env_count++);
for (user_env_count = 0, env = HYD_handle.global_env.user; env;
@@ -216,11 +216,11 @@
for (system_env_count = 0, env = HYD_handle.global_env.system; env;
env = env->next, system_env_count++);
- for (segment_count = 0, segment = partition->segment_list; segment;
+ for (segment_count = 0, segment = proxy->segment_list; segment;
segment = segment->next)
segment_count++;
- for (exec_count = 0, exec = partition->exec_list; exec; exec = exec->next)
+ for (exec_count = 0, exec = proxy->exec_list; exec; exec = exec->next)
exec_count++;
total_args = HYD_NUM_TMP_STRINGS; /* For the basic arguments */
@@ -236,131 +236,131 @@
/* For each exec add a few strings */
total_args += (exec_count * HYD_NUM_TMP_STRINGS);
- HYDU_MALLOC(partition->base->exec_args, char **, total_args * sizeof(char *),
+ HYDU_MALLOC(proxy->exec_args, char **, total_args * sizeof(char *),
status);
arg = 0;
- partition->base->exec_args[arg++] = HYDU_strdup("--global-core-count");
- partition->base->exec_args[arg++] = HYDU_int_to_str(HYD_handle.global_core_count);
+ proxy->exec_args[arg++] = HYDU_strdup("--global-core-count");
+ proxy->exec_args[arg++] = HYDU_int_to_str(HYD_handle.global_core_count);
- partition->base->exec_args[arg++] = HYDU_strdup("--wdir");
- partition->base->exec_args[arg++] = HYDU_strdup(HYD_handle.wdir);
+ proxy->exec_args[arg++] = HYDU_strdup("--wdir");
+ proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.wdir);
- partition->base->exec_args[arg++] = HYDU_strdup("--pmi-port-str");
+ proxy->exec_args[arg++] = HYDU_strdup("--pmi-port-str");
if (HYD_handle.pm_env)
- partition->base->exec_args[arg++] = HYDU_strdup(pmi_port_str);
+ proxy->exec_args[arg++] = HYDU_strdup(pmi_port_str);
else
- partition->base->exec_args[arg++] = HYDU_strdup("HYDRA_NULL");
+ proxy->exec_args[arg++] = HYDU_strdup("HYDRA_NULL");
- partition->base->exec_args[arg++] = HYDU_strdup("--binding");
+ proxy->exec_args[arg++] = HYDU_strdup("--binding");
if (HYD_handle.binding)
- partition->base->exec_args[arg++] = HYDU_strdup(HYD_handle.binding);
+ proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.binding);
else
- partition->base->exec_args[arg++] = HYDU_strdup("HYDRA_NULL");
+ proxy->exec_args[arg++] = HYDU_strdup("HYDRA_NULL");
if (HYD_handle.user_bind_map)
- partition->base->exec_args[arg++] = HYDU_strdup(HYD_handle.user_bind_map);
- else if (partition->user_bind_map)
- partition->base->exec_args[arg++] = HYDU_strdup(partition->user_bind_map);
+ proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.user_bind_map);
+ else if (proxy->user_bind_map)
+ proxy->exec_args[arg++] = HYDU_strdup(proxy->user_bind_map);
else
- partition->base->exec_args[arg++] = HYDU_strdup("HYDRA_NULL");
+ proxy->exec_args[arg++] = HYDU_strdup("HYDRA_NULL");
- partition->base->exec_args[arg++] = HYDU_strdup("--bindlib");
- partition->base->exec_args[arg++] = HYDU_strdup(HYD_handle.bindlib);
+ proxy->exec_args[arg++] = HYDU_strdup("--bindlib");
+ proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.bindlib);
- partition->base->exec_args[arg++] = HYDU_strdup("--ckpointlib");
- partition->base->exec_args[arg++] = HYDU_strdup(HYD_handle.ckpointlib);
+ proxy->exec_args[arg++] = HYDU_strdup("--ckpointlib");
+ proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.ckpointlib);
- partition->base->exec_args[arg++] = HYDU_strdup("--ckpoint-prefix");
+ proxy->exec_args[arg++] = HYDU_strdup("--ckpoint-prefix");
if (HYD_handle.ckpoint_prefix)
- partition->base->exec_args[arg++] = HYDU_strdup(HYD_handle.ckpoint_prefix);
+ proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.ckpoint_prefix);
else
- partition->base->exec_args[arg++] = HYDU_strdup("HYDRA_NULL");
+ proxy->exec_args[arg++] = HYDU_strdup("HYDRA_NULL");
if (HYD_handle.ckpoint_restart)
- partition->base->exec_args[arg++] = HYDU_strdup("--ckpoint-restart");
+ proxy->exec_args[arg++] = HYDU_strdup("--ckpoint-restart");
- partition->base->exec_args[arg++] = HYDU_strdup("--global-inherited-env");
+ proxy->exec_args[arg++] = HYDU_strdup("--global-inherited-env");
for (i = 0, env = HYD_handle.global_env.inherited; env; env = env->next, i++);
- partition->base->exec_args[arg++] = HYDU_int_to_str(i);
+ proxy->exec_args[arg++] = HYDU_int_to_str(i);
for (env = HYD_handle.global_env.inherited; env; env = env->next) {
- status = HYDU_env_to_str(env, &partition->base->exec_args[arg++]);
+ status = HYDU_env_to_str(env, &proxy->exec_args[arg++]);
HYDU_ERR_POP(status, "error converting env to string\n");
}
- partition->base->exec_args[arg++] = NULL;
+ proxy->exec_args[arg++] = NULL;
- arg = HYDU_strlist_lastidx(partition->base->exec_args);
- partition->base->exec_args[arg++] = HYDU_strdup("--global-user-env");
+ arg = HYDU_strlist_lastidx(proxy->exec_args);
+ proxy->exec_args[arg++] = HYDU_strdup("--global-user-env");
for (i = 0, env = HYD_handle.global_env.user; env; env = env->next, i++);
- partition->base->exec_args[arg++] = HYDU_int_to_str(i);
+ proxy->exec_args[arg++] = HYDU_int_to_str(i);
for (env = HYD_handle.global_env.user; env; env = env->next) {
- status = HYDU_env_to_str(env, &partition->base->exec_args[arg++]);
+ status = HYDU_env_to_str(env, &proxy->exec_args[arg++]);
HYDU_ERR_POP(status, "error converting env to string\n");
}
- partition->base->exec_args[arg++] = NULL;
+ proxy->exec_args[arg++] = NULL;
- arg = HYDU_strlist_lastidx(partition->base->exec_args);
- partition->base->exec_args[arg++] = HYDU_strdup("--global-system-env");
+ arg = HYDU_strlist_lastidx(proxy->exec_args);
+ proxy->exec_args[arg++] = HYDU_strdup("--global-system-env");
for (i = 0, env = HYD_handle.global_env.system; env; env = env->next, i++);
- partition->base->exec_args[arg++] = HYDU_int_to_str(i);
+ proxy->exec_args[arg++] = HYDU_int_to_str(i);
for (env = HYD_handle.global_env.system; env; env = env->next) {
- status = HYDU_env_to_str(env, &partition->base->exec_args[arg++]);
+ status = HYDU_env_to_str(env, &proxy->exec_args[arg++]);
HYDU_ERR_POP(status, "error converting env to string\n");
}
- partition->base->exec_args[arg++] = NULL;
+ proxy->exec_args[arg++] = NULL;
- arg = HYDU_strlist_lastidx(partition->base->exec_args);
- partition->base->exec_args[arg++] = HYDU_strdup("--genv-prop");
- partition->base->exec_args[arg++] = HYDU_strdup(HYD_handle.global_env.prop);
- partition->base->exec_args[arg++] = NULL;
+ arg = HYDU_strlist_lastidx(proxy->exec_args);
+ proxy->exec_args[arg++] = HYDU_strdup("--genv-prop");
+ proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.global_env.prop);
+ proxy->exec_args[arg++] = NULL;
/* Pass the segment information */
- for (segment = partition->segment_list; segment; segment = segment->next) {
- arg = HYDU_strlist_lastidx(partition->base->exec_args);
- partition->base->exec_args[arg++] = HYDU_strdup("--segment");
+ for (segment = proxy->segment_list; segment; segment = segment->next) {
+ arg = HYDU_strlist_lastidx(proxy->exec_args);
+ proxy->exec_args[arg++] = HYDU_strdup("--segment");
- partition->base->exec_args[arg++] = HYDU_strdup("--segment-start-pid");
- partition->base->exec_args[arg++] = HYDU_int_to_str(segment->start_pid);
+ proxy->exec_args[arg++] = HYDU_strdup("--segment-start-pid");
+ proxy->exec_args[arg++] = HYDU_int_to_str(segment->start_pid);
- partition->base->exec_args[arg++] = HYDU_strdup("--segment-proc-count");
- partition->base->exec_args[arg++] = HYDU_int_to_str(segment->proc_count);
- partition->base->exec_args[arg++] = NULL;
+ proxy->exec_args[arg++] = HYDU_strdup("--segment-proc-count");
+ proxy->exec_args[arg++] = HYDU_int_to_str(segment->proc_count);
+ proxy->exec_args[arg++] = NULL;
}
/* Now pass the local executable information */
- for (exec = partition->exec_list; exec; exec = exec->next) {
- arg = HYDU_strlist_lastidx(partition->base->exec_args);
- partition->base->exec_args[arg++] = HYDU_strdup("--exec");
+ for (exec = proxy->exec_list; exec; exec = exec->next) {
+ arg = HYDU_strlist_lastidx(proxy->exec_args);
+ proxy->exec_args[arg++] = HYDU_strdup("--exec");
- partition->base->exec_args[arg++] = HYDU_strdup("--exec-proc-count");
- partition->base->exec_args[arg++] = HYDU_int_to_str(exec->proc_count);
+ proxy->exec_args[arg++] = HYDU_strdup("--exec-proc-count");
+ proxy->exec_args[arg++] = HYDU_int_to_str(exec->proc_count);
- partition->base->exec_args[arg++] = HYDU_strdup("--exec-local-env");
+ proxy->exec_args[arg++] = HYDU_strdup("--exec-local-env");
for (i = 0, env = exec->user_env; env; env = env->next, i++);
- partition->base->exec_args[arg++] = HYDU_int_to_str(i);
+ proxy->exec_args[arg++] = HYDU_int_to_str(i);
for (env = exec->user_env; env; env = env->next) {
- status = HYDU_env_to_str(env, &partition->base->exec_args[arg++]);
+ status = HYDU_env_to_str(env, &proxy->exec_args[arg++]);
HYDU_ERR_POP(status, "error converting env to string\n");
}
- partition->base->exec_args[arg++] = NULL;
+ proxy->exec_args[arg++] = NULL;
- arg = HYDU_strlist_lastidx(partition->base->exec_args);
- partition->base->exec_args[arg++] = HYDU_strdup("--exec-env-prop");
- partition->base->exec_args[arg++] = exec->env_prop ? HYDU_strdup(exec->env_prop) :
+ arg = HYDU_strlist_lastidx(proxy->exec_args);
+ proxy->exec_args[arg++] = HYDU_strdup("--exec-env-prop");
+ proxy->exec_args[arg++] = exec->env_prop ? HYDU_strdup(exec->env_prop) :
HYDU_strdup("HYDRA_NULL");
- partition->base->exec_args[arg++] = NULL;
+ proxy->exec_args[arg++] = NULL;
- HYDU_list_append_strlist(exec->exec, partition->base->exec_args);
+ HYDU_list_append_strlist(exec->exec, proxy->exec_args);
process_id += exec->proc_count;
}
if (HYD_handle.debug) {
printf("Arguments being passed to proxy %d:\n", proxy_count++);
- HYDU_print_strlist(partition->base->exec_args);
+ HYDU_print_strlist(proxy->exec_args);
printf("\n");
}
}
@@ -374,7 +374,7 @@
HYD_Status HYD_PMCI_launch_procs(void)
{
- struct HYD_Partition *partition;
+ struct HYD_Proxy *proxy;
enum HYD_PMCD_pmi_proxy_cmds cmd;
int fd, len, id;
#if defined HAVE_THREAD_SUPPORT
@@ -410,7 +410,7 @@
status = fill_in_exec_args();
HYDU_ERR_POP(status, "unable to fill in executable arguments\n");
- status = HYD_BSCI_launch_procs(proxy_args, "--partition-id", HYD_handle.partition_list);
+ status = HYD_BSCI_launch_procs(proxy_args, "--proxy-id", HYD_handle.proxy_list);
HYDU_ERR_POP(status, "bootstrap server cannot launch processes\n");
}
else if (HYD_handle.launch_mode == HYD_LAUNCH_BOOT ||
@@ -418,15 +418,15 @@
status = fill_in_proxy_args(HYD_handle.launch_mode, proxy_args);
HYDU_ERR_POP(status, "unable to fill in proxy arguments\n");
- status = HYD_BSCI_launch_procs(proxy_args, "--partition-id", HYD_handle.partition_list);
+ status = HYD_BSCI_launch_procs(proxy_args, "--proxy-id", HYD_handle.proxy_list);
HYDU_ERR_POP(status, "bootstrap server cannot launch processes\n");
}
else if (HYD_handle.launch_mode == HYD_LAUNCH_SHUTDOWN) {
- FORALL_ACTIVE_PARTITIONS(partition, HYD_handle.partition_list) {
- status = HYDU_sock_connect(partition->base->name, HYD_handle.proxy_port, &fd);
+ FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
+ status = HYDU_sock_connect(proxy->hostname, HYD_handle.proxy_port, &fd);
if (status != HYD_SUCCESS) {
/* Don't abort. Try to shutdown as many proxies as possible */
- HYDU_Error_printf("Unable to connect to proxy at %s\n", partition->base->name);
+ HYDU_Error_printf("Unable to connect to proxy at %s\n", proxy->hostname);
continue;
}
@@ -442,7 +442,7 @@
HYDU_ERR_POP(status, "unable to fill in proxy arguments\n");
len = 0;
- FORALL_ACTIVE_PARTITIONS(partition, HYD_handle.partition_list)
+ FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list)
len++;
#if defined HAVE_THREAD_SUPPORT
@@ -454,22 +454,22 @@
#endif /* HAVE_THREAD_SUPPORT */
id = 0;
- FORALL_ACTIVE_PARTITIONS(partition, HYD_handle.partition_list) {
+ FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
#if defined HAVE_THREAD_SUPPORT
- HYDU_create_thread(launch_helper, (void *) partition, &thread_context[id]);
+ HYDU_create_thread(launch_helper, (void *) proxy, &thread_context[id]);
#else
- launch_helper(partition);
+ launch_helper(proxy);
#endif /* HAVE_THREAD_SUPPORT */
id++;
}
id = 0;
- FORALL_ACTIVE_PARTITIONS(partition, HYD_handle.partition_list) {
+ FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
#if defined HAVE_THREAD_SUPPORT
HYDU_join_thread(thread_context[id]);
#endif /* HAVE_THREAD_SUPPORT */
- status = HYD_DMX_register_fd(1, &partition->control_fd, HYD_STDOUT, partition,
+ status = HYD_DMX_register_fd(1, &proxy->control_fd, HYD_STDOUT, proxy,
HYD_PMCD_pmi_serv_control_cb);
HYDU_ERR_POP(status, "unable to register control fd\n");
@@ -497,7 +497,7 @@
HYD_Status HYD_PMCI_wait_for_completion(void)
{
- struct HYD_Partition *partition;
+ struct HYD_Proxy *proxy;
int sockets_open, all_procs_exited;
HYD_Status status = HYD_SUCCESS;
@@ -521,8 +521,8 @@
/* Check to see if there's any open read socket left; if
* there are, we will just wait for more events. */
sockets_open = 0;
- FORALL_ACTIVE_PARTITIONS(partition, HYD_handle.partition_list) {
- if (partition->base->out != -1 || partition->base->err != -1) {
+ FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
+ if (proxy->out != -1 || proxy->err != -1) {
sockets_open++;
break;
}
@@ -537,8 +537,8 @@
do {
/* Check if the exit status has already arrived */
all_procs_exited = 1;
- FORALL_ACTIVE_PARTITIONS(partition, HYD_handle.partition_list) {
- if (partition->exit_status == NULL) {
+ FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
+ if (proxy->exit_status == NULL) {
all_procs_exited = 0;
break;
}
@@ -553,7 +553,7 @@
} while (1);
}
- status = HYD_BSCI_wait_for_completion(HYD_handle.partition_list);
+ status = HYD_BSCI_wait_for_completion(HYD_handle.proxy_list);
HYDU_ERR_POP(status, "bootstrap server returned error waiting for completion\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_utils.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_utils.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_utils.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -9,7 +9,7 @@
#include "pmi_serv.h"
#include "demux.h"
-HYD_Status HYD_PMCD_pmi_send_exec_info(struct HYD_Partition *partition)
+HYD_Status HYD_PMCD_pmi_send_exec_info(struct HYD_Proxy *proxy)
{
enum HYD_PMCD_pmi_proxy_cmds cmd;
int i, list_len, arg_len;
@@ -18,23 +18,23 @@
HYDU_FUNC_ENTER();
cmd = PROC_INFO;
- status = HYDU_sock_write(partition->control_fd, &cmd,
+ status = HYDU_sock_write(proxy->control_fd, &cmd,
sizeof(enum HYD_PMCD_pmi_proxy_cmds));
HYDU_ERR_POP(status, "unable to write data to proxy\n");
/* Check how many arguments we have */
- list_len = HYDU_strlist_lastidx(partition->base->exec_args);
- status = HYDU_sock_write(partition->control_fd, &list_len, sizeof(int));
+ list_len = HYDU_strlist_lastidx(proxy->exec_args);
+ status = HYDU_sock_write(proxy->control_fd, &list_len, sizeof(int));
HYDU_ERR_POP(status, "unable to write data to proxy\n");
/* Convert the string list to parseable data and send */
- for (i = 0; partition->base->exec_args[i]; i++) {
- arg_len = strlen(partition->base->exec_args[i]) + 1;
+ for (i = 0; proxy->exec_args[i]; i++) {
+ arg_len = strlen(proxy->exec_args[i]) + 1;
- status = HYDU_sock_write(partition->control_fd, &arg_len, sizeof(int));
+ status = HYDU_sock_write(proxy->control_fd, &arg_len, sizeof(int));
HYDU_ERR_POP(status, "unable to write data to proxy\n");
- status = HYDU_sock_write(partition->control_fd, partition->base->exec_args[i],
+ status = HYDU_sock_write(proxy->control_fd, proxy->exec_args[i],
arg_len);
HYDU_ERR_POP(status, "unable to write data to proxy\n");
}
Modified: mpich2/trunk/src/pm/hydra/rmk/include/rmki.h.in
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/include/rmki.h.in 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/rmk/include/rmki.h.in 2009-10-11 05:44:30 UTC (rev 5444)
@@ -10,7 +10,7 @@
#include "hydra.h"
struct HYD_RMKI_fns {
- HYD_Status(*query_node_list) (int *num_nodes, struct HYD_Partition **partition_list);
+ HYD_Status(*query_node_list) (int *num_nodes, struct HYD_Proxy **proxy_list);
};
extern struct HYD_RMKI_fns HYD_RMKI_fns;
@@ -18,7 +18,7 @@
HYD_Status HYD_RMKI_init(char *rmk);
/* Non-zero nodes means that the RMK should allocate the nodes if needed */
-HYD_Status HYD_RMKI_query_node_list(int *num_nodes, struct HYD_Partition **partition_list);
+HYD_Status HYD_RMKI_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list);
/* Each resource management kernel has to expose an initialization function */
@hydra_rmk_init_decl@
Modified: mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs.h
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs.h 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs.h 2009-10-11 05:44:30 UTC (rev 5444)
@@ -9,6 +9,6 @@
#include "hydra_base.h"
-HYD_Status HYD_RMKD_pbs_query_node_list(int *num_nodes, struct HYD_Partition **partition_list);
+HYD_Status HYD_RMKD_pbs_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list);
#endif /* RMK_PBS_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_query_node_list.c
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_query_node_list.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_query_node_list.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -8,12 +8,12 @@
#include "rmki.h"
#include "rmk_pbs.h"
-HYD_Status HYD_RMKD_pbs_query_node_list(int *num_nodes, struct HYD_Partition **partition_list)
+HYD_Status HYD_RMKD_pbs_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list)
{
char *host_file, *hostname, line[HYD_TMP_STRLEN], **arg_list;
int num_procs;
FILE *fp;
- struct HYD_Partition_segment *segment;
+ struct HYD_Proxy_segment *segment;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -21,7 +21,7 @@
host_file = getenv("PBS_NODEFILE");
if (host_file == NULL || host_file == NULL) {
- *partition_list = NULL;
+ *proxy_list = NULL;
}
else {
fp = fopen(host_file, "r");
@@ -52,15 +52,15 @@
hostname = arg_list[0];
num_procs = 1;
- /* Try to find an existing partition with this name and
- * add this segment in. If there is no existing partition
+ /* Try to find an existing proxy with this name and
+ * add this segment in. If there is no existing proxy
* with this name, we create a new one. */
- status = HYDU_alloc_partition_segment(&segment);
- HYDU_ERR_POP(status, "Unable to allocate partition segment\n");
+ status = HYDU_alloc_proxy_segment(&segment);
+ HYDU_ERR_POP(status, "Unable to allocate proxy segment\n");
segment->start_pid = *num_nodes;
segment->proc_count = num_procs;
- status = HYDU_merge_partition_segment(hostname, segment, partition_list);
- HYDU_ERR_POP(status, "merge partition segment failed\n");
+ status = HYDU_merge_proxy_segment(hostname, segment, proxy_list);
+ HYDU_ERR_POP(status, "merge proxy segment failed\n");
*num_nodes += num_procs;
Modified: mpich2/trunk/src/pm/hydra/rmk/src/rmki_query_node_list.c
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/src/rmki_query_node_list.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/rmk/src/rmki_query_node_list.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -7,13 +7,13 @@
#include "hydra_base.h"
#include "rmki.h"
-HYD_Status HYD_RMKI_query_node_list(int *num_nodes, struct HYD_Partition **partition_list)
+HYD_Status HYD_RMKI_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list)
{
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- status = HYD_RMKI_fns.query_node_list(num_nodes, partition_list);
+ status = HYD_RMKI_fns.query_node_list(num_nodes, proxy_list);
HYDU_ERR_POP(status, "RMK device returned error while querying node list\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/rmk/utils/rmku.h
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/utils/rmku.h 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/rmk/utils/rmku.h 2009-10-11 05:44:30 UTC (rev 5444)
@@ -9,6 +9,6 @@
#include "hydra_base.h"
-HYD_Status HYD_RMKU_query_node_list(int *num_nodes, struct HYD_Partition **partition_list);
+HYD_Status HYD_RMKU_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list);
#endif /* RMKU_H_INCLUDED */
Modified: mpich2/trunk/src/pm/hydra/rmk/utils/rmku_query_node_list.c
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/utils/rmku_query_node_list.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/rmk/utils/rmku_query_node_list.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -9,7 +9,7 @@
#include "bsci.h"
#include "rmku.h"
-HYD_Status HYD_RMKU_query_node_list(int *num_nodes, struct HYD_Partition **partition_list)
+HYD_Status HYD_RMKU_query_node_list(int *num_nodes, struct HYD_Proxy **proxy_list)
{
HYD_Status status = HYD_SUCCESS;
@@ -17,7 +17,7 @@
/* We just query the bootstrap server for the node list and return
* it to the upper layer. */
- status = HYD_BSCI_query_node_list(num_nodes, partition_list);
+ status = HYD_BSCI_query_node_list(num_nodes, proxy_list);
HYDU_ERR_POP(status, "bootstrap device returned error while querying node list\n");
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/ui/mpiexec/callback.c
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/mpiexec/callback.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/ui/mpiexec/callback.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -11,7 +11,7 @@
static HYD_Status close_fd(int fd)
{
- struct HYD_Partition *partition;
+ struct HYD_Proxy *proxy;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -22,13 +22,13 @@
close(fd);
/* Find the FD in the HYD_handle and remove it. */
- FORALL_ACTIVE_PARTITIONS(partition, HYD_handle.partition_list) {
- if (partition->base->out == fd) {
- partition->base->out = -1;
+ FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
+ if (proxy->out == fd) {
+ proxy->out = -1;
goto fn_exit;
}
- if (partition->base->err == fd) {
- partition->base->err = -1;
+ if (proxy->err == fd) {
+ proxy->err = -1;
goto fn_exit;
}
}
Modified: mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.c
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -105,8 +105,8 @@
int main(int argc, char **argv)
{
- struct HYD_Partition *partition;
- struct HYD_Partition_exec *exec;
+ struct HYD_Proxy *proxy;
+ struct HYD_Proxy_exec *exec;
struct HYD_Exec_info *exec_info;
int exit_status = 0, timeout, i, process_id, proc_count, num_nodes = 0;
HYD_Status status = HYD_SUCCESS;
@@ -132,13 +132,13 @@
/* User did not provide any host file. Query the RMK. We pass
* a zero node count, so the RMK will give us all the nodes it
* already has and won't try to allocate any more. */
- status = HYD_RMKI_query_node_list(&num_nodes, &HYD_handle.partition_list);
+ status = HYD_RMKI_query_node_list(&num_nodes, &HYD_handle.proxy_list);
HYDU_ERR_POP(status, "unable to query the RMK for a node list\n");
/* We don't have an allocation capability yet, but when we do,
* we should try it here. */
- if (HYD_handle.partition_list == NULL) {
+ if (HYD_handle.proxy_list == NULL) {
/* The RMK didn't give us anything back; use localhost */
HYD_handle.host_file = HYDU_strdup("HYDRA_USE_LOCALHOST");
}
@@ -146,40 +146,40 @@
if (HYD_handle.host_file) {
/* Use the user specified host file */
- status = HYDU_create_node_list_from_file(HYD_handle.host_file, &HYD_handle.partition_list);
+ status = HYDU_create_node_list_from_file(HYD_handle.host_file, &HYD_handle.proxy_list);
HYDU_ERR_POP(status, "unable to create host list\n");
}
/* If the number of processes is not given, we allocate all the
* available nodes to each executable */
for (exec_info = HYD_handle.exec_info_list; exec_info; exec_info = exec_info->next) {
- if (exec_info->exec_proc_count == 0) {
+ if (exec_info->process_count == 0) {
if (num_nodes == 0)
- exec_info->exec_proc_count = 1;
+ exec_info->process_count = 1;
else
- exec_info->exec_proc_count = num_nodes;
+ exec_info->process_count = num_nodes;
}
}
- status = HYD_UIU_merge_exec_info_to_partition();
+ status = HYD_UIU_merge_exec_info_to_proxy();
HYDU_ERR_POP(status, "unable to merge exec info\n");
if (HYD_handle.debug)
HYD_UIU_print_params();
- /* Figure out what the active partitions are: in RUNTIME and
- * PERSISTENT modes, only partitions which have an executable are
+ /* Figure out what the active proxys are: in RUNTIME and
+ * PERSISTENT modes, only proxys which have an executable are
* active. In BOOT, BOOT_FOREGROUND and SHUTDOWN modes, all
- * partitions are active. */
+ * proxys are active. */
if (HYD_handle.launch_mode == HYD_LAUNCH_RUNTIME ||
HYD_handle.launch_mode == HYD_LAUNCH_PERSISTENT) {
- for (partition = HYD_handle.partition_list; partition && partition->exec_list;
- partition = partition->next)
- partition->base->active = 1;
+ for (proxy = HYD_handle.proxy_list; proxy && proxy->exec_list;
+ proxy = proxy->next)
+ proxy->active = 1;
}
else {
- for (partition = HYD_handle.partition_list; partition; partition = partition->next)
- partition->base->active = 1;
+ for (proxy = HYD_handle.proxy_list; proxy; proxy = proxy->next)
+ proxy->active = 1;
}
HYDU_time_set(&HYD_handle.start, NULL); /* NULL implies right now */
@@ -192,15 +192,15 @@
HYDU_dump(stdout, "Timeout set to %d (-1 means infinite)\n", timeout);
if (HYD_handle.print_rank_map) {
- FORALL_ACTIVE_PARTITIONS(partition, HYD_handle.partition_list) {
- HYDU_dump(stdout, "[%s] ", partition->base->name);
+ FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
+ HYDU_dump(stdout, "[%s] ", proxy->hostname);
process_id = 0;
- for (exec = partition->exec_list; exec; exec = exec->next) {
+ for (exec = proxy->exec_list; exec; exec = exec->next) {
for (i = 0; i < exec->proc_count; i++) {
HYDU_dump(stdout, "%d", HYDU_local_to_global_id(process_id++,
- partition->partition_core_count,
- partition->segment_list,
+ proxy->proxy_core_count,
+ proxy->segment_list,
HYD_handle.global_core_count));
if (i < exec->proc_count - 1)
HYDU_dump(stdout, ",");
@@ -242,21 +242,21 @@
HYD_handle.stdin_buf_count = 0;
HYD_handle.stdin_buf_offset = 0;
- FORALL_ACTIVE_PARTITIONS(partition, HYD_handle.partition_list) {
- if (partition->base->out != -1) {
- status = HYD_DMX_register_fd(1, &partition->base->out, HYD_STDOUT, NULL,
+ FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
+ if (proxy->out != -1) {
+ status = HYD_DMX_register_fd(1, &proxy->out, HYD_STDOUT, NULL,
HYD_UII_mpx_stdout_cb);
HYDU_ERR_POP(status, "demux returned error registering fd\n");
}
- if (partition->base->err != -1) {
- status = HYD_DMX_register_fd(1, &partition->base->err, HYD_STDOUT, NULL,
+ if (proxy->err != -1) {
+ status = HYD_DMX_register_fd(1, &proxy->err, HYD_STDOUT, NULL,
HYD_UII_mpx_stderr_cb);
HYDU_ERR_POP(status, "demux returned error registering fd\n");
}
- if (partition->base->in != -1) {
- status = HYD_DMX_register_fd(1, &partition->base->in, HYD_STDIN, NULL,
+ if (proxy->in != -1) {
+ status = HYD_DMX_register_fd(1, &proxy->in, HYD_STDIN, NULL,
HYD_UII_mpx_stdin_cb);
HYDU_ERR_POP(status, "demux returned error registering fd\n");
}
@@ -270,20 +270,20 @@
if (HYD_handle.print_all_exitcodes)
HYDU_dump(stdout, "Exit codes: ");
exit_status = 0;
- FORALL_ACTIVE_PARTITIONS(partition, HYD_handle.partition_list) {
+ FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list) {
proc_count = 0;
- for (exec = partition->exec_list; exec; exec = exec->next)
+ for (exec = proxy->exec_list; exec; exec = exec->next)
proc_count += exec->proc_count;
for (i = 0; i < proc_count; i++) {
if (HYD_handle.print_all_exitcodes) {
- HYDU_dump(stdout, "[%d]", HYDU_local_to_global_id(i, partition->partition_core_count,
- partition->segment_list,
+ HYDU_dump(stdout, "[%d]", HYDU_local_to_global_id(i, proxy->proxy_core_count,
+ proxy->segment_list,
HYD_handle.global_core_count));
- HYDU_dump(stdout, "%d", WEXITSTATUS(partition->exit_status[i]));
+ HYDU_dump(stdout, "%d", WEXITSTATUS(proxy->exit_status[i]));
if (i < proc_count - 1)
HYDU_dump(stdout, ",");
}
- exit_status |= partition->exit_status[i];
+ exit_status |= proxy->exit_status[i];
}
}
if (HYD_handle.print_all_exitcodes)
Modified: mpich2/trunk/src/pm/hydra/ui/mpiexec/utils.c
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/mpiexec/utils.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/ui/mpiexec/utils.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -345,10 +345,10 @@
status = HYD_UIU_get_current_exec_info(&exec_info);
HYDU_ERR_POP(status, "get_current_exec_info returned error\n");
- if (exec_info->exec_proc_count != 0)
+ if (exec_info->process_count != 0)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "duplicate process count\n");
- exec_info->exec_proc_count = atoi(**argv);
+ exec_info->process_count = atoi(**argv);
(*argv)++;
fn_exit:
Modified: mpich2/trunk/src/pm/hydra/ui/utils/uiu.c
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/utils/uiu.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/ui/utils/uiu.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -50,7 +50,7 @@
HYD_handle.global_core_count = 0;
HYD_handle.exec_info_list = NULL;
- HYD_handle.partition_list = NULL;
+ HYD_handle.proxy_list = NULL;
HYD_handle.func_depth = 0;
HYD_handle.stdin_buf_offset = 0;
@@ -111,17 +111,16 @@
if (HYD_handle.exec_info_list)
HYDU_free_exec_info_list(HYD_handle.exec_info_list);
- if (HYD_handle.partition_list)
- HYDU_free_partition_list(HYD_handle.partition_list);
+ if (HYD_handle.proxy_list)
+ HYDU_free_proxy_list(HYD_handle.proxy_list);
/* Re-initialize everything to default values */
HYD_UIU_init_params();
}
-HYD_Status HYD_UIU_get_current_exec_info(struct HYD_Exec_info **info)
+HYD_Status HYD_UIU_get_current_exec_info(struct HYD_Exec_info **exec_info)
{
- struct HYD_Exec_info *exec_info;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -131,12 +130,10 @@
HYDU_ERR_POP(status, "unable to allocate exec_info\n");
}
- exec_info = HYD_handle.exec_info_list;
- while (exec_info->next)
- exec_info = exec_info->next;
+ *exec_info = HYD_handle.exec_info_list;
+ while ((*exec_info)->next)
+ *exec_info = (*exec_info)->next;
- *info = exec_info;
-
fn_exit:
HYDU_FUNC_EXIT();
return status;
@@ -146,33 +143,33 @@
}
-static HYD_Status add_exec_info_to_partition(struct HYD_Exec_info *exec_info,
- struct HYD_Partition *partition,
- int num_procs)
+static HYD_Status add_exec_info_to_proxy(struct HYD_Exec_info *exec_info,
+ struct HYD_Proxy *proxy,
+ int num_procs)
{
int i;
- struct HYD_Partition_exec *exec;
+ struct HYD_Proxy_exec *exec;
HYD_Status status = HYD_SUCCESS;
- if (partition->exec_list == NULL) {
- status = HYDU_alloc_partition_exec(&partition->exec_list);
- HYDU_ERR_POP(status, "unable to allocate partition exec\n");
+ if (proxy->exec_list == NULL) {
+ status = HYDU_alloc_proxy_exec(&proxy->exec_list);
+ HYDU_ERR_POP(status, "unable to allocate proxy exec\n");
- partition->exec_list->pgid = 0; /* This is the COMM_WORLD exec */
+ proxy->exec_list->pgid = 0; /* This is the COMM_WORLD exec */
for (i = 0; exec_info->exec[i]; i++)
- partition->exec_list->exec[i] = HYDU_strdup(exec_info->exec[i]);
- partition->exec_list->exec[i] = NULL;
+ proxy->exec_list->exec[i] = HYDU_strdup(exec_info->exec[i]);
+ proxy->exec_list->exec[i] = NULL;
- partition->exec_list->proc_count = num_procs;
- partition->exec_list->env_prop = exec_info->env_prop ?
+ proxy->exec_list->proc_count = num_procs;
+ proxy->exec_list->env_prop = exec_info->env_prop ?
HYDU_strdup(exec_info->env_prop) : NULL;
- partition->exec_list->user_env = HYDU_env_list_dup(exec_info->user_env);
+ proxy->exec_list->user_env = HYDU_env_list_dup(exec_info->user_env);
}
else {
- for (exec = partition->exec_list; exec->next; exec = exec->next);
- status = HYDU_alloc_partition_exec(&exec->next);
- HYDU_ERR_POP(status, "unable to allocate partition exec\n");
+ for (exec = proxy->exec_list; exec->next; exec = exec->next);
+ status = HYDU_alloc_proxy_exec(&exec->next);
+ HYDU_ERR_POP(status, "unable to allocate proxy exec\n");
exec = exec->next;
exec->pgid = 0; /* This is the COMM_WORLD exec */
@@ -194,48 +191,48 @@
}
-HYD_Status HYD_UIU_merge_exec_info_to_partition(void)
+HYD_Status HYD_UIU_merge_exec_info_to_proxy(void)
{
- int partition_rem_procs, exec_rem_procs;
- struct HYD_Partition *partition;
+ int proxy_rem_procs, exec_rem_procs;
+ struct HYD_Proxy *proxy;
struct HYD_Exec_info *exec_info;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- for (partition = HYD_handle.partition_list; partition; partition = partition->next)
- HYD_handle.global_core_count += partition->partition_core_count;
+ for (proxy = HYD_handle.proxy_list; proxy; proxy = proxy->next)
+ HYD_handle.global_core_count += proxy->proxy_core_count;
- partition = HYD_handle.partition_list;
+ proxy = HYD_handle.proxy_list;
exec_info = HYD_handle.exec_info_list;
- partition_rem_procs = partition->partition_core_count;
- exec_rem_procs = exec_info ? exec_info->exec_proc_count : 0;
+ proxy_rem_procs = proxy->proxy_core_count;
+ exec_rem_procs = exec_info ? exec_info->process_count : 0;
while (exec_info) {
- if (exec_rem_procs <= partition_rem_procs) {
- status = add_exec_info_to_partition(exec_info, partition, exec_rem_procs);
- HYDU_ERR_POP(status, "unable to add executable to partition\n");
+ if (exec_rem_procs <= proxy_rem_procs) {
+ status = add_exec_info_to_proxy(exec_info, proxy, exec_rem_procs);
+ HYDU_ERR_POP(status, "unable to add executable to proxy\n");
- partition_rem_procs -= exec_rem_procs;
- if (partition_rem_procs == 0) {
- partition = partition->next;
- if (partition == NULL)
- partition = HYD_handle.partition_list;
- partition_rem_procs = partition->partition_core_count;
+ proxy_rem_procs -= exec_rem_procs;
+ if (proxy_rem_procs == 0) {
+ proxy = proxy->next;
+ if (proxy == NULL)
+ proxy = HYD_handle.proxy_list;
+ proxy_rem_procs = proxy->proxy_core_count;
}
exec_info = exec_info->next;
- exec_rem_procs = exec_info ? exec_info->exec_proc_count : 0;
+ exec_rem_procs = exec_info ? exec_info->process_count : 0;
}
else {
- status = add_exec_info_to_partition(exec_info, partition, partition_rem_procs);
- HYDU_ERR_POP(status, "unable to add executable to partition\n");
+ status = add_exec_info_to_proxy(exec_info, proxy, proxy_rem_procs);
+ HYDU_ERR_POP(status, "unable to add executable to proxy\n");
- exec_rem_procs -= partition_rem_procs;
+ exec_rem_procs -= proxy_rem_procs;
- partition = partition->next;
- if (partition == NULL)
- partition = HYD_handle.partition_list;
- partition_rem_procs = partition->partition_core_count;
+ proxy = proxy->next;
+ if (proxy == NULL)
+ proxy = HYD_handle.proxy_list;
+ proxy_rem_procs = proxy->proxy_core_count;
}
}
@@ -252,9 +249,9 @@
{
HYD_Env_t *env;
int i;
- struct HYD_Partition *partition;
- struct HYD_Partition_segment *segment;
- struct HYD_Partition_exec *exec;
+ struct HYD_Proxy *proxy;
+ struct HYD_Proxy_segment *segment;
+ struct HYD_Proxy_exec *exec;
struct HYD_Exec_info *exec_info;
HYDU_FUNC_ENTER();
@@ -303,7 +300,7 @@
for (exec_info = HYD_handle.exec_info_list; exec_info; exec_info = exec_info->next) {
HYDU_dump(stdout, " Executable ID: %2d\n", i++);
HYDU_dump(stdout, " -----------------\n");
- HYDU_dump(stdout, " Process count: %d\n", exec_info->exec_proc_count);
+ HYDU_dump(stdout, " Process count: %d\n", exec_info->process_count);
HYDU_dump(stdout, " Executable: ");
HYDU_print_strlist(exec_info->exec);
HYDU_dump(stdout, "\n");
@@ -317,24 +314,24 @@
}
}
- HYDU_dump(stdout, " Partition information:\n");
+ HYDU_dump(stdout, " Proxy information:\n");
HYDU_dump(stdout, " *********************\n");
i = 1;
- for (partition = HYD_handle.partition_list; partition; partition = partition->next) {
- HYDU_dump(stdout, " Partition ID: %2d\n", i++);
+ for (proxy = HYD_handle.proxy_list; proxy; proxy = proxy->next) {
+ HYDU_dump(stdout, " Proxy ID: %2d\n", i++);
HYDU_dump(stdout, " -----------------\n");
- HYDU_dump(stdout, " Partition name: %s\n", partition->base->name);
- HYDU_dump(stdout, " Process count: %d\n", partition->partition_core_count);
+ HYDU_dump(stdout, " Proxy name: %s\n", proxy->hostname);
+ HYDU_dump(stdout, " Process count: %d\n", proxy->proxy_core_count);
HYDU_dump(stdout, "\n");
- HYDU_dump(stdout, " Partition segment list:\n");
+ HYDU_dump(stdout, " Proxy segment list:\n");
HYDU_dump(stdout, " .......................\n");
- for (segment = partition->segment_list; segment; segment = segment->next)
+ for (segment = proxy->segment_list; segment; segment = segment->next)
HYDU_dump(stdout, " Start PID: %d; Process count: %d\n",
segment->start_pid, segment->proc_count);
HYDU_dump(stdout, "\n");
- HYDU_dump(stdout, " Partition exec list:\n");
+ HYDU_dump(stdout, " Proxy exec list:\n");
HYDU_dump(stdout, " ....................\n");
- for (exec = partition->exec_list; exec; exec = exec->next)
+ for (exec = proxy->exec_list; exec; exec = exec->next)
HYDU_dump(stdout, " Exec: %s; Process count: %d\n", exec->exec[0],
exec->proc_count);
}
Modified: mpich2/trunk/src/pm/hydra/ui/utils/uiu.h
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/utils/uiu.h 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/ui/utils/uiu.h 2009-10-11 05:44:30 UTC (rev 5444)
@@ -11,7 +11,7 @@
void HYD_UIU_init_params(void);
void HYD_UIU_free_params(void);
-HYD_Status HYD_UIU_merge_exec_info_to_partition(void);
+HYD_Status HYD_UIU_merge_exec_info_to_proxy(void);
HYD_Status HYD_UIU_get_current_exec_info(struct HYD_Exec_info **info);
void HYD_UIU_print_params(void);
Modified: mpich2/trunk/src/pm/hydra/utils/launch/allocate.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/launch/allocate.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/utils/launch/allocate.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -6,64 +6,35 @@
#include "hydra_utils.h"
-static HYD_Status alloc_partition_base(struct HYD_Partition_base **base)
+HYD_Status HYDU_alloc_proxy(struct HYD_Proxy **proxy)
{
- static int partition_id = 0;
+ static int proxy_id = 0;
HYD_Status status = HYD_SUCCESS;
- HYDU_MALLOC(*base, struct HYD_Partition_base *, sizeof(struct HYD_Partition_base), status);
-
- (*base)->name = NULL;
- (*base)->pid = -1;
- (*base)->in = -1;
- (*base)->out = -1;
- (*base)->err = -1;
-
- (*base)->partition_id = partition_id++;
- (*base)->active = 0;
- (*base)->exec_args = NULL;
-
- (*base)->next = NULL;
-
- fn_exit:
- return status;
-
- fn_fail:
- goto fn_exit;
-}
-
-static void free_partition_base(struct HYD_Partition_base *base)
-{
- if (base->name)
- HYDU_FREE(base->name);
- if (base->exec_args) {
- HYDU_free_strlist(base->exec_args);
- HYDU_FREE(base->exec_args);
- }
-
- HYDU_FREE(base);
-}
-
-HYD_Status HYDU_alloc_partition(struct HYD_Partition **partition)
-{
- HYD_Status status = HYD_SUCCESS;
-
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*partition, struct HYD_Partition *, sizeof(struct HYD_Partition), status);
+ HYDU_MALLOC(*proxy, struct HYD_Proxy *, sizeof(struct HYD_Proxy), status);
- alloc_partition_base(&((*partition)->base));
+ (*proxy)->hostname = NULL;
+ (*proxy)->pid = -1;
+ (*proxy)->in = -1;
+ (*proxy)->out = -1;
+ (*proxy)->err = -1;
- (*partition)->user_bind_map = NULL;
- (*partition)->segment_list = NULL;
- (*partition)->partition_core_count = 0;
+ (*proxy)->proxy_id = proxy_id++;
+ (*proxy)->active = 0;
+ (*proxy)->exec_args = NULL;
- (*partition)->exit_status = NULL;
- (*partition)->control_fd = -1;
+ (*proxy)->user_bind_map = NULL;
+ (*proxy)->segment_list = NULL;
+ (*proxy)->proxy_core_count = 0;
- (*partition)->exec_list = NULL;
- (*partition)->next = NULL;
+ (*proxy)->exit_status = NULL;
+ (*proxy)->control_fd = -1;
+ (*proxy)->exec_list = NULL;
+ (*proxy)->next = NULL;
+
fn_exit:
HYDU_FUNC_EXIT();
return status;
@@ -80,7 +51,7 @@
HYDU_FUNC_ENTER();
HYDU_MALLOC(*exec_info, struct HYD_Exec_info *, sizeof(struct HYD_Exec_info), status);
- (*exec_info)->exec_proc_count = 0;
+ (*exec_info)->process_count = 0;
(*exec_info)->exec[0] = NULL;
(*exec_info)->user_env = NULL;
(*exec_info)->env_prop = NULL;
@@ -120,24 +91,29 @@
}
-void HYDU_free_partition_list(struct HYD_Partition *partition_list)
+void HYDU_free_proxy_list(struct HYD_Proxy *proxy_list)
{
- struct HYD_Partition *partition, *tpartition;
- struct HYD_Partition_segment *segment, *tsegment;
- struct HYD_Partition_exec *exec, *texec;
+ struct HYD_Proxy *proxy, *tproxy;
+ struct HYD_Proxy_segment *segment, *tsegment;
+ struct HYD_Proxy_exec *exec, *texec;
HYDU_FUNC_ENTER();
- partition = partition_list;
- while (partition) {
- tpartition = partition->next;
+ proxy = proxy_list;
+ while (proxy) {
+ tproxy = proxy->next;
- free_partition_base(partition->base);
+ if (proxy->hostname)
+ HYDU_FREE(proxy->hostname);
+ if (proxy->exec_args) {
+ HYDU_free_strlist(proxy->exec_args);
+ HYDU_FREE(proxy->exec_args);
+ }
- if (partition->user_bind_map)
- HYDU_FREE(partition->user_bind_map);
+ if (proxy->user_bind_map)
+ HYDU_FREE(proxy->user_bind_map);
- segment = partition->segment_list;
+ segment = proxy->segment_list;
while (segment) {
tsegment = segment->next;
if (segment->mapping) {
@@ -148,10 +124,10 @@
segment = tsegment;
}
- if (partition->exit_status)
- HYDU_FREE(partition->exit_status);
+ if (proxy->exit_status)
+ HYDU_FREE(proxy->exit_status);
- exec = partition->exec_list;
+ exec = proxy->exec_list;
while (exec) {
texec = exec->next;
HYDU_free_strlist(exec->exec);
@@ -163,22 +139,22 @@
exec = texec;
}
- HYDU_FREE(partition);
- partition = tpartition;
+ HYDU_FREE(proxy);
+ proxy = tproxy;
}
HYDU_FUNC_EXIT();
}
-HYD_Status HYDU_alloc_partition_segment(struct HYD_Partition_segment **segment)
+HYD_Status HYDU_alloc_proxy_segment(struct HYD_Proxy_segment **segment)
{
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*segment, struct HYD_Partition_segment *,
- sizeof(struct HYD_Partition_segment), status);
+ HYDU_MALLOC(*segment, struct HYD_Proxy_segment *,
+ sizeof(struct HYD_Proxy_segment), status);
(*segment)->start_pid = -1;
(*segment)->proc_count = 0;
(*segment)->mapping = NULL;
@@ -193,48 +169,47 @@
}
-HYD_Status HYDU_merge_partition_segment(char *name, struct HYD_Partition_segment *segment,
- struct HYD_Partition **partition_list)
+HYD_Status HYDU_merge_proxy_segment(char *hostname, struct HYD_Proxy_segment *segment,
+ struct HYD_Proxy **proxy_list)
{
- struct HYD_Partition *partition;
- struct HYD_Partition_segment *s;
+ struct HYD_Proxy *proxy;
+ struct HYD_Proxy_segment *s;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- if (*partition_list == NULL) {
- status = HYDU_alloc_partition(partition_list);
- HYDU_ERR_POP(status, "Unable to alloc partition\n");
- (*partition_list)->segment_list = segment;
- (*partition_list)->base->name = HYDU_strdup(name);
- (*partition_list)->partition_core_count += segment->proc_count;
+ if (*proxy_list == NULL) {
+ status = HYDU_alloc_proxy(proxy_list);
+ HYDU_ERR_POP(status, "Unable to alloc proxy\n");
+ (*proxy_list)->segment_list = segment;
+ (*proxy_list)->hostname = HYDU_strdup(hostname);
+ (*proxy_list)->proxy_core_count += segment->proc_count;
}
else {
- partition = *partition_list;
- while (partition) {
- if (strcmp(partition->base->name, name) == 0) {
- if (partition->segment_list == NULL)
- partition->segment_list = segment;
+ proxy = *proxy_list;
+ while (proxy) {
+ if (strcmp(proxy->hostname, hostname) == 0) {
+ if (proxy->segment_list == NULL)
+ proxy->segment_list = segment;
else {
- s = partition->segment_list;
+ s = proxy->segment_list;
while (s->next)
s = s->next;
s->next = segment;
}
- partition->partition_core_count += segment->proc_count;
+ proxy->proxy_core_count += segment->proc_count;
break;
}
- else if (partition->next == NULL) {
- status = HYDU_alloc_partition(&partition->next);
- HYDU_ERR_POP(status, "Unable to alloc partition\n");
- partition->next->segment_list = segment;
- partition->next->base->name = HYDU_strdup(name);
- partition->next->partition_core_count += segment->proc_count;
- partition->base->next = partition->next->base;
+ else if (proxy->next == NULL) {
+ status = HYDU_alloc_proxy(&proxy->next);
+ HYDU_ERR_POP(status, "Unable to alloc proxy\n");
+ proxy->next->segment_list = segment;
+ proxy->next->hostname = HYDU_strdup(hostname);
+ proxy->next->proxy_core_count += segment->proc_count;
break;
}
else {
- partition = partition->next;
+ proxy = proxy->next;
}
}
}
@@ -292,37 +267,37 @@
}
-HYD_Status HYDU_merge_partition_mapping(char *name, char *map, int num_procs,
- struct HYD_Partition **partition_list)
+HYD_Status HYDU_merge_proxy_mapping(char *hostname, char *map, int num_procs,
+ struct HYD_Proxy **proxy_list)
{
- struct HYD_Partition *partition;
+ struct HYD_Proxy *proxy;
char *tmp[HYD_NUM_TMP_STRINGS], *x;
int i, count;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- if (*partition_list == NULL) {
- HYDU_alloc_partition(partition_list);
- (*partition_list)->base->name = HYDU_strdup(name);
+ if (*proxy_list == NULL) {
+ HYDU_alloc_proxy(proxy_list);
+ (*proxy_list)->hostname = HYDU_strdup(hostname);
x = HYDU_strdup(map);
count = num_procs - count_elements(x, ",");
HYDU_FREE(x);
- (*partition_list)->user_bind_map = pad_string(map, ",-1", count);
+ (*proxy_list)->user_bind_map = pad_string(map, ",-1", count);
}
else {
- partition = *partition_list;
- while (partition) {
- if (strcmp(partition->base->name, name) == 0) {
- /* Found a partition with the same name; append */
- if (partition->user_bind_map == NULL) {
+ proxy = *proxy_list;
+ while (proxy) {
+ if (strcmp(proxy->hostname, hostname) == 0) {
+ /* Found a proxy with the same hostname; append */
+ if (proxy->user_bind_map == NULL) {
x = HYDU_strdup(map);
count = num_procs - count_elements(x, ",");
HYDU_FREE(x);
- partition->user_bind_map = pad_string(map, ",-1", count);
+ proxy->user_bind_map = pad_string(map, ",-1", count);
}
else {
x = HYDU_strdup(map);
@@ -330,28 +305,27 @@
HYDU_FREE(x);
i = 0;
- tmp[i++] = HYDU_strdup(partition->user_bind_map);
+ tmp[i++] = HYDU_strdup(proxy->user_bind_map);
tmp[i++] = HYDU_strdup(",");
tmp[i++] = pad_string(map, ",-1", count);
tmp[i++] = NULL;
- HYDU_FREE(partition->user_bind_map);
- status = HYDU_str_alloc_and_join(tmp, &partition->user_bind_map);
+ HYDU_FREE(proxy->user_bind_map);
+ status = HYDU_str_alloc_and_join(tmp, &proxy->user_bind_map);
HYDU_ERR_POP(status, "unable to join strings\n");
HYDU_free_strlist(tmp);
}
break;
}
- else if (partition->next == NULL) {
- HYDU_alloc_partition(&partition->next);
- partition->base->next = partition->next->base;
- partition->next->base->name = HYDU_strdup(name);
- partition->next->user_bind_map = HYDU_strdup(map);
+ else if (proxy->next == NULL) {
+ HYDU_alloc_proxy(&proxy->next);
+ proxy->next->hostname = HYDU_strdup(hostname);
+ proxy->next->user_bind_map = HYDU_strdup(map);
break;
}
else {
- partition = partition->next;
+ proxy = proxy->next;
}
}
}
@@ -365,13 +339,13 @@
}
-HYD_Status HYDU_alloc_partition_exec(struct HYD_Partition_exec **exec)
+HYD_Status HYDU_alloc_proxy_exec(struct HYD_Proxy_exec **exec)
{
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*exec, struct HYD_Partition_exec *, sizeof(struct HYD_Partition_exec), status);
+ HYDU_MALLOC(*exec, struct HYD_Proxy_exec *, sizeof(struct HYD_Proxy_exec), status);
(*exec)->exec[0] = NULL;
(*exec)->proc_count = 0;
(*exec)->env_prop = NULL;
@@ -388,25 +362,25 @@
HYD_Status HYDU_create_node_list_from_file(char *host_file,
- struct HYD_Partition **partition_list)
+ struct HYD_Proxy **proxy_list)
{
FILE *fp = NULL;
char line[HYD_TMP_STRLEN], *hostname, *procs, **arg_list;
char *str[2] = { NULL };
int num_procs, total_count, arg, i;
- struct HYD_Partition_segment *segment;
+ struct HYD_Proxy_segment *segment;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
if (!strcmp(host_file, "HYDRA_USE_LOCALHOST")) {
- HYDU_alloc_partition(&(*partition_list));
- (*partition_list)->base->name = HYDU_strdup("localhost");
- (*partition_list)->partition_core_count = 1;
+ HYDU_alloc_proxy(&(*proxy_list));
+ (*proxy_list)->hostname = HYDU_strdup("localhost");
+ (*proxy_list)->proxy_core_count = 1;
- HYDU_alloc_partition_segment(&((*partition_list)->segment_list));
- (*partition_list)->segment_list->start_pid = 0;
- (*partition_list)->segment_list->proc_count = 1;
+ HYDU_alloc_proxy_segment(&((*proxy_list)->segment_list));
+ (*proxy_list)->segment_list->start_pid = 0;
+ (*proxy_list)->segment_list->proc_count = 1;
}
else {
fp = fopen(host_file, "r");
@@ -438,15 +412,15 @@
procs = strtok(NULL, ":");
num_procs = procs ? atoi(procs) : 1;
- /* Try to find an existing partition with this name and
- * add this segment in. If there is no existing partition
+ /* Try to find an existing proxy with this name and
+ * add this segment in. If there is no existing proxy
* with this name, we create a new one. */
- status = HYDU_alloc_partition_segment(&segment);
- HYDU_ERR_POP(status, "Unable to allocate partition segment\n");
+ status = HYDU_alloc_proxy_segment(&segment);
+ HYDU_ERR_POP(status, "Unable to allocate proxy segment\n");
segment->start_pid = total_count;
segment->proc_count = num_procs;
- status = HYDU_merge_partition_segment(hostname, segment, partition_list);
- HYDU_ERR_POP(status, "merge partition segment failed\n");
+ status = HYDU_merge_proxy_segment(hostname, segment, proxy_list);
+ HYDU_ERR_POP(status, "merge proxy segment failed\n");
total_count += num_procs;
@@ -458,9 +432,9 @@
HYDU_ERR_POP(status, "unable to split string\n");
if (!strcmp(str[0], "map")) {
- status = HYDU_merge_partition_mapping(hostname, str[1], num_procs,
- partition_list);
- HYDU_ERR_POP(status, "merge partition mapping failed\n");
+ status = HYDU_merge_proxy_mapping(hostname, str[1], num_procs,
+ proxy_list);
+ HYDU_ERR_POP(status, "merge proxy mapping failed\n");
}
if (str[0])
HYDU_FREE(str[0]);
Modified: mpich2/trunk/src/pm/hydra/utils/launch/launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/launch/launch.c 2009-10-11 04:19:18 UTC (rev 5443)
+++ mpich2/trunk/src/pm/hydra/utils/launch/launch.c 2009-10-11 05:44:30 UTC (rev 5444)
@@ -173,14 +173,14 @@
}
#endif /* HAVE_THREAD_SUPPORT */
-int HYDU_local_to_global_id(int local_id, int partition_core_count,
- struct HYD_Partition_segment *segment_list, int global_core_count)
+int HYDU_local_to_global_id(int local_id, int proxy_core_count,
+ struct HYD_Proxy_segment *segment_list, int global_core_count)
{
int global_id, rem;
- struct HYD_Partition_segment *segment;
+ struct HYD_Proxy_segment *segment;
- global_id = ((local_id / partition_core_count) * global_core_count);
- rem = (local_id % partition_core_count);
+ global_id = ((local_id / proxy_core_count) * global_core_count);
+ rem = (local_id % proxy_core_count);
for (segment = segment_list; segment; segment = segment->next) {
if (rem >= segment->proc_count)
More information about the mpich2-commits
mailing list