[mpich2-commits] r5465 - in mpich2/trunk/src/pm/hydra: bootstrap/slurm include pm/pmiserv rmk/pbs ui/mpiexec ui/utils utils/alloc utils/others
balaji at mcs.anl.gov
balaji at mcs.anl.gov
Thu Oct 15 12:10:03 CDT 2009
Author: balaji
Date: 2009-10-15 12:10:02 -0500 (Thu, 15 Oct 2009)
New Revision: 5465
Modified:
mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_node_list.c
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_proxy.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_cb.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_cb.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c
mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_utils.c
mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_query_node_list.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/utils/alloc/alloc.c
mpich2/trunk/src/pm/hydra/utils/others/others.c
Log:
Allow only contiguous segments within each proxy. Multiple contiguous
segments on the same node is still possible, but we use multiple
proxies in that case. This simplifies the code, but might cause minor
performance loss in cases where the user provides weird non-contiguous
segments of ranks on each node.
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-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/bootstrap/slurm/slurm_query_node_list.c 2009-10-15 17:10:02 UTC (rev 5465)
@@ -103,7 +103,6 @@
{
char *str, *num_procs;
char *tmp1[HYD_NUM_TMP_STRINGS], *tmp2[HYD_NUM_TMP_STRINGS];
- struct HYD_Proxy_segment *segment;
int i, j;
HYD_Status status = HYD_SUCCESS;
@@ -125,13 +124,8 @@
HYDU_ERR_POP(status, "unable to parse node list\n");
for (j = 0; tmp2[j]; j++) {
- 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_proxy_segment(tmp2[j], segment, proxy_list);
+ status = HYDU_merge_proxy_segment(tmp2[j], *num_nodes, atoi(num_procs),
+ proxy_list);
HYDU_ERR_POP(status, "merge proxy segment failed\n");
*num_nodes += atoi(num_procs);
Modified: mpich2/trunk/src/pm/hydra/include/hydra_base.h
===================================================================
--- mpich2/trunk/src/pm/hydra/include/hydra_base.h 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/include/hydra_base.h 2009-10-15 17:10:02 UTC (rev 5465)
@@ -162,13 +162,6 @@
char *prop;
};
-/* List of contiguous segments of processes on a proxy */
-struct HYD_Proxy_segment {
- int start_pid;
- int proc_count;
- struct HYD_Proxy_segment *next;
-};
-
/* Executables on a proxy */
struct HYD_Proxy_exec {
char *exec[HYD_NUM_TMP_STRINGS];
@@ -182,7 +175,7 @@
/* Proxy information */
struct HYD_Proxy {
char *hostname;
- char **exec_args;
+ char **exec_launch_info;
int proxy_id;
int active;
@@ -192,10 +185,10 @@
int out;
int err;
+ int start_pid;
int proxy_core_count;
+ int proxy_process_count;
- /* Segment list will contain one-pass of the hosts file */
- struct HYD_Proxy_segment *segment_list;
struct HYD_Proxy_exec *exec_list;
int *exit_status;
Modified: mpich2/trunk/src/pm/hydra/include/hydra_utils.h
===================================================================
--- mpich2/trunk/src/pm/hydra/include/hydra_utils.h 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/include/hydra_utils.h 2009-10-15 17:10:02 UTC (rev 5465)
@@ -128,7 +128,6 @@
HYD_Status HYDU_alloc_exec_info(struct HYD_Exec_info **exec_info);
void HYDU_free_exec_info_list(struct HYD_Exec_info *exec_info_list);
void HYDU_free_proxy_list(struct HYD_Proxy *proxy_list);
-HYD_Status HYDU_alloc_proxy_segment(struct HYD_Proxy_segment **segment);
HYD_Status HYDU_alloc_proxy_exec(struct HYD_Proxy_exec **exec);
/* args */
@@ -181,10 +180,10 @@
#endif /* HAVE_THREAD_SUPPORT */
/* others */
-HYD_Status HYDU_merge_proxy_segment(char *name, struct HYD_Proxy_segment *segment,
+HYD_Status HYDU_merge_proxy_segment(char *name, int start_pid, int core_count,
struct HYD_Proxy **proxy_list);
-int HYDU_local_to_global_id(int local_id, int core_count,
- struct HYD_Proxy_segment *segment_list, int global_core_count);
+int HYDU_local_to_global_id(int local_id, int start_pid, int core_count,
+ int global_core_count);
/* signals */
#ifdef NEEDS_POSIX_FOR_SIGACTION
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.c 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_handle.c 2009-10-15 17:10:02 UTC (rev 5465)
@@ -223,10 +223,8 @@
int i, node_id;
char *tmp[HYD_NUM_TMP_STRINGS];
struct HYD_Proxy *proxy;
- struct HYD_Proxy_segment *segment;
struct segment *seglist_head, *seglist_tail = NULL, *seg, *nseg;
struct block *blocklist_head, *blocklist_tail = NULL, *block, *nblock;
- int done;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -235,46 +233,21 @@
node_id = -1;
FORALL_PROXIES(proxy, HYD_handle.proxy_list) {
node_id++;
- 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;
- seg->node_id = node_id;
- seg->next = NULL;
- if (seglist_head == NULL) {
- seglist_head = seg;
- seglist_tail = seg;
- }
- else {
- seglist_tail->next = seg;
- seglist_tail = seg;
- }
- }
- }
+ HYDU_MALLOC(seg, struct segment *, sizeof(struct segment), status);
+ seg->start_pid = proxy->start_pid;
+ seg->proc_count = proxy->proxy_core_count;
+ seg->node_id = node_id;
+ seg->next = NULL;
- /* Sort the segment list */
- done = 1;
- while (1) {
- for (seg = seglist_head; seg; seg = seg->next) {
- if (seg->next && (seg->start_pid > seg->next->start_pid)) {
- seg->start_pid = seg->start_pid + seg->next->start_pid;
- seg->next->start_pid = seg->start_pid - seg->next->start_pid;
- seg->start_pid = seg->start_pid - seg->next->start_pid;
-
- seg->proc_count = seg->proc_count + seg->next->proc_count;
- seg->next->proc_count = seg->proc_count - seg->next->proc_count;
- seg->proc_count = seg->proc_count - seg->next->proc_count;
-
- seg->node_id = seg->node_id + seg->next->node_id;
- seg->next->node_id = seg->node_id - seg->next->node_id;
- seg->node_id = seg->node_id - seg->next->node_id;
-
- done = 0;
- }
+ if (seglist_head == NULL) {
+ seglist_head = seg;
+ seglist_tail = seg;
}
- if (done)
- break;
+ else {
+ seglist_tail->next = seg;
+ seglist_tail = seg;
+ }
}
/* Create a block list off the segment list */
@@ -350,9 +323,8 @@
static struct HYD_PMCD_pmi_node *find_node(HYD_PMCD_pmi_pg_t * pg, int rank)
{
- int found = 0, node_id, srank;
+ int node_id, srank;
struct HYD_Proxy *proxy;
- struct HYD_Proxy_segment *segment;
struct HYD_PMCD_pmi_node *node, *tmp;
HYD_Status status = HYD_SUCCESS;
@@ -360,15 +332,8 @@
node_id = 0;
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 */
- found = 1;
- break;
- }
- }
- if (found)
+ if ((srank >= proxy->start_pid) &&
+ (srank < (proxy->start_pid + proxy->proxy_core_count)))
break;
node_id++;
}
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.c 2009-10-15 17:10:02 UTC (rev 5465)
@@ -25,7 +25,7 @@
* are, we will just wait for more events. */
out_count = 0;
err_count = 0;
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.process_count; i++) {
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.proxy_process_count; i++) {
if (HYD_PMCD_pmi_proxy_params.downstream.out[i] != -1)
out_count++;
if (HYD_PMCD_pmi_proxy_params.downstream.err[i] != -1)
@@ -56,13 +56,13 @@
/* Find the pid and mark it as complete. */
if (pid > 0)
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.process_count; i++)
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.proxy_process_count; i++)
if (HYD_PMCD_pmi_proxy_params.downstream.pid[i] == pid)
HYD_PMCD_pmi_proxy_params.downstream.exit_status[i] = ret_status;
/* Check how many more processes are pending */
count = 0;
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.process_count; i++) {
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.proxy_process_count; i++) {
if (HYD_PMCD_pmi_proxy_params.downstream.exit_status[i] == -1) {
count++;
break;
@@ -123,7 +123,8 @@
/* Send the exit status upstream */
status = HYDU_sock_write(HYD_PMCD_pmi_proxy_params.upstream.control,
HYD_PMCD_pmi_proxy_params.downstream.exit_status,
- HYD_PMCD_pmi_proxy_params.local.process_count * sizeof(int));
+ HYD_PMCD_pmi_proxy_params.local.proxy_process_count *
+ sizeof(int));
HYDU_ERR_POP(status, "unable to return exit status upstream\n");
status = HYD_DMX_deregister_fd(HYD_PMCD_pmi_proxy_params.upstream.control);
@@ -164,7 +165,7 @@
/* Send the exit status upstream */
status = HYDU_sock_write(HYD_PMCD_pmi_proxy_params.upstream.control,
HYD_PMCD_pmi_proxy_params.downstream.exit_status,
- HYD_PMCD_pmi_proxy_params.local.process_count *
+ HYD_PMCD_pmi_proxy_params.local.proxy_process_count *
sizeof(int));
HYDU_ERR_POP(status, "unable to return exit status upstream\n");
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy.h 2009-10-15 17:10:02 UTC (rev 5465)
@@ -46,8 +46,8 @@
/* Proxy details */
struct {
int id;
- int core_count;
- int process_count;
+ int proxy_core_count;
+ int proxy_process_count;
/* Flag to tell whether the processes are launched */
int procs_are_launched;
@@ -59,7 +59,7 @@
} local;
/* Process segmentation information for this proxy */
- struct HYD_Proxy_segment *segment_list;
+ int start_pid;
struct HYD_Proxy_exec *exec_list;
};
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_cb.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_cb.c 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_cb.c 2009-10-15 17:10:02 UTC (rev 5465)
@@ -103,10 +103,10 @@
* since they can arrive in any order. */
if ((cmd == PROC_INFO) || (cmd == USE_AS_STDOUT) || (cmd == USE_AS_STDERR) ||
(cmd == USE_AS_STDIN))
- if ((HYD_PMCD_pmi_proxy_params.segment_list != NULL) &&
+ if ((HYD_PMCD_pmi_proxy_params.start_pid != -1) &&
(HYD_PMCD_pmi_proxy_params.upstream.out != -1) &&
(HYD_PMCD_pmi_proxy_params.upstream.err != -1))
- if ((HYD_PMCD_pmi_proxy_params.segment_list->start_pid != 0) ||
+ if ((HYD_PMCD_pmi_proxy_params.start_pid != 0) ||
(HYD_PMCD_pmi_proxy_params.upstream.in != -1)) {
status = HYD_PMCD_pmi_proxy_launch_procs();
HYDU_ERR_POP(status, "HYD_PMCD_pmi_proxy_launch_procs returned error\n");
@@ -135,7 +135,7 @@
status = HYD_DMX_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.process_count; i++)
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.proxy_process_count; i++)
if (HYD_PMCD_pmi_proxy_params.downstream.out[i] == fd)
HYD_PMCD_pmi_proxy_params.downstream.out[i] = -1;
@@ -166,7 +166,7 @@
status = HYD_DMX_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.process_count; i++)
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.proxy_process_count; i++)
if (HYD_PMCD_pmi_proxy_params.downstream.err[i] == fd)
HYD_PMCD_pmi_proxy_params.downstream.err[i] = -1;
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_proxy_utils.c 2009-10-15 17:10:02 UTC (rev 5465)
@@ -34,14 +34,14 @@
HYD_PMCD_pmi_proxy_params.downstream.exit_status = NULL;
HYD_PMCD_pmi_proxy_params.local.id = -1;
- HYD_PMCD_pmi_proxy_params.local.core_count = 0;
- HYD_PMCD_pmi_proxy_params.local.process_count = 0;
+ HYD_PMCD_pmi_proxy_params.local.proxy_core_count = 0;
+ HYD_PMCD_pmi_proxy_params.local.proxy_process_count = 0;
HYD_PMCD_pmi_proxy_params.local.procs_are_launched = 0;
HYD_PMCD_pmi_proxy_params.local.stdin_buf_offset = 0;
HYD_PMCD_pmi_proxy_params.local.stdin_buf_count = 0;
HYD_PMCD_pmi_proxy_params.local.stdin_tmp_buf[0] = '\0';
- HYD_PMCD_pmi_proxy_params.segment_list = NULL;
+ HYD_PMCD_pmi_proxy_params.start_pid = -1;
HYD_PMCD_pmi_proxy_params.exec_list = NULL;
return status;
@@ -57,7 +57,6 @@
int arg, i, count;
HYD_Env_t *env;
struct HYD_Proxy_exec *exec = NULL;
- struct HYD_Proxy_segment *segment = NULL;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -176,36 +175,17 @@
continue;
}
- /* New segment */
- if (!strcmp(*argv, "--segment")) {
- if (HYD_PMCD_pmi_proxy_params.segment_list == NULL) {
- 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_proxy_segment(&segment->next);
- HYDU_ERR_POP(status, "unable to allocate proxy segment\n");
- }
- continue;
- }
-
/* Process count */
- if (!strcmp(*argv, "--segment-proc-count")) {
+ if (!strcmp(*argv, "--proxy-core-count")) {
argv++;
- for (segment = HYD_PMCD_pmi_proxy_params.segment_list; segment->next;
- segment = segment->next);
- segment->proc_count = atoi(*argv);
+ HYD_PMCD_pmi_proxy_params.local.proxy_core_count = atoi(*argv);
continue;
}
/* Process count */
- if (!strcmp(*argv, "--segment-start-pid")) {
+ if (!strcmp(*argv, "--start-pid")) {
argv++;
- for (segment = HYD_PMCD_pmi_proxy_params.segment_list; segment->next;
- segment = segment->next);
- segment->start_pid = atoi(*argv);
+ HYD_PMCD_pmi_proxy_params.start_pid = atoi(*argv);
continue;
}
@@ -373,7 +353,6 @@
HYD_Status HYD_PMCD_pmi_proxy_cleanup_params(void)
{
- struct HYD_Proxy_segment *segment, *tsegment;
struct HYD_Proxy_exec *exec, *texec;
HYD_Status status = HYD_SUCCESS;
@@ -415,15 +394,6 @@
if (HYD_PMCD_pmi_proxy_params.user_global.global_env.inherited)
HYDU_env_free_list(HYD_PMCD_pmi_proxy_params.user_global.global_env.inherited);
- if (HYD_PMCD_pmi_proxy_params.segment_list) {
- segment = HYD_PMCD_pmi_proxy_params.segment_list;
- while (segment) {
- tsegment = segment->next;
- HYDU_FREE(segment);
- segment = tsegment;
- }
- }
-
if (HYD_PMCD_pmi_proxy_params.exec_list) {
exec = HYD_PMCD_pmi_proxy_params.exec_list;
while (exec) {
@@ -517,41 +487,36 @@
char *str, *envstr, *list;
char *client_args[HYD_NUM_TMP_STRINGS];
HYD_Env_t *env, *prop_env = NULL;
- 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.local.core_count = 0;
- for (segment = HYD_PMCD_pmi_proxy_params.segment_list; segment; segment = segment->next)
- HYD_PMCD_pmi_proxy_params.local.core_count += segment->proc_count;
-
- HYD_PMCD_pmi_proxy_params.local.process_count = 0;
+ HYD_PMCD_pmi_proxy_params.local.proxy_process_count = 0;
for (exec = HYD_PMCD_pmi_proxy_params.exec_list; exec; exec = exec->next)
- HYD_PMCD_pmi_proxy_params.local.process_count += exec->proc_count;
+ HYD_PMCD_pmi_proxy_params.local.proxy_process_count += exec->proc_count;
- HYDU_MALLOC(pmi_ids, int *, HYD_PMCD_pmi_proxy_params.local.process_count *
+ HYDU_MALLOC(pmi_ids, int *, HYD_PMCD_pmi_proxy_params.local.proxy_process_count *
sizeof(int), status);
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.process_count; i++) {
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.proxy_process_count; i++) {
pmi_ids[i] =
- HYDU_local_to_global_id(i, HYD_PMCD_pmi_proxy_params.local.core_count,
- HYD_PMCD_pmi_proxy_params.segment_list,
+ HYDU_local_to_global_id(i, HYD_PMCD_pmi_proxy_params.start_pid,
+ HYD_PMCD_pmi_proxy_params.local.proxy_core_count,
HYD_PMCD_pmi_proxy_params.system_global.global_core_count);
}
HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.downstream.out, int *,
- HYD_PMCD_pmi_proxy_params.local.process_count * sizeof(int), status);
+ HYD_PMCD_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.downstream.err, int *,
- HYD_PMCD_pmi_proxy_params.local.process_count * sizeof(int), status);
+ HYD_PMCD_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.downstream.pid, int *,
- HYD_PMCD_pmi_proxy_params.local.process_count * sizeof(int), status);
+ HYD_PMCD_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
HYDU_MALLOC(HYD_PMCD_pmi_proxy_params.downstream.exit_status, int *,
- HYD_PMCD_pmi_proxy_params.local.process_count * sizeof(int), status);
+ HYD_PMCD_pmi_proxy_params.local.proxy_process_count * sizeof(int), status);
/* Initialize the exit status */
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.process_count; i++)
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.proxy_process_count; i++)
HYD_PMCD_pmi_proxy_params.downstream.exit_status[i] = -1;
status = HYDU_bind_init(HYD_PMCD_pmi_proxy_params.user_global.binding,
@@ -568,7 +533,7 @@
HYDU_ERR_POP(status, "unable to create env\n");
/* Restart the proxy. Specify stdin fd only if pmi_id 0 is in this proxy. */
- status = HYDU_ckpoint_restart(env, HYD_PMCD_pmi_proxy_params.local.process_count,
+ status = HYDU_ckpoint_restart(env, HYD_PMCD_pmi_proxy_params.local.proxy_process_count,
pmi_ids,
pmi_ids[0] ? NULL :
&HYD_PMCD_pmi_proxy_params.downstream.in,
@@ -656,8 +621,8 @@
for (i = 0; i < exec->proc_count; i++) {
pmi_id = HYDU_local_to_global_id(process_id,
- HYD_PMCD_pmi_proxy_params.local.core_count,
- HYD_PMCD_pmi_proxy_params.segment_list,
+ HYD_PMCD_pmi_proxy_params.start_pid,
+ HYD_PMCD_pmi_proxy_params.local.proxy_core_count,
HYD_PMCD_pmi_proxy_params.system_global.
global_core_count);
@@ -720,12 +685,12 @@
fn_spawn_complete:
/* Everything is spawned, register the required FDs */
- status = HYD_DMX_register_fd(HYD_PMCD_pmi_proxy_params.local.process_count,
+ status = HYD_DMX_register_fd(HYD_PMCD_pmi_proxy_params.local.proxy_process_count,
HYD_PMCD_pmi_proxy_params.downstream.out,
HYD_STDOUT, NULL, HYD_PMCD_pmi_proxy_stdout_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
- status = HYD_DMX_register_fd(HYD_PMCD_pmi_proxy_params.local.process_count,
+ status = HYD_DMX_register_fd(HYD_PMCD_pmi_proxy_params.local.proxy_process_count,
HYD_PMCD_pmi_proxy_params.downstream.err,
HYD_STDOUT, NULL, HYD_PMCD_pmi_proxy_stderr_cb);
HYDU_ERR_POP(status, "unable to register fd\n");
@@ -751,7 +716,7 @@
HYDU_FUNC_ENTER();
/* Send the kill signal to all processes */
- for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.process_count; i++) {
+ for (i = 0; i < HYD_PMCD_pmi_proxy_params.local.proxy_process_count; i++) {
if (HYD_PMCD_pmi_proxy_params.downstream.pid[i] != -1) {
kill(HYD_PMCD_pmi_proxy_params.downstream.pid[i], SIGTERM);
kill(HYD_PMCD_pmi_proxy_params.downstream.pid[i], SIGKILL);
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_cb.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_cb.c 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_cb.c 2009-10-15 17:10:02 UTC (rev 5465)
@@ -251,21 +251,15 @@
HYD_Status HYD_PMCD_pmi_serv_control_cb(int fd, HYD_Event_t events, void *userp)
{
struct HYD_Proxy *proxy;
- struct HYD_Proxy_exec *exec;
- int count, proc_count;
+ int count;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
proxy = (struct HYD_Proxy *) userp;
- proc_count = 0;
- for (exec = proxy->exec_list; exec; exec = exec->next)
- proc_count += exec->proc_count;
-
- HYDU_MALLOC(proxy->exit_status, int *, proc_count * sizeof(int), status);
-
- status = HYDU_sock_read(fd, (void *) proxy->exit_status, proc_count * sizeof(int),
+ status = HYDU_sock_read(fd, (void *) proxy->exit_status,
+ proxy->proxy_process_count * sizeof(int),
&count, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "unable to read status from proxy\n");
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_launch.c 2009-10-15 17:10:02 UTC (rev 5465)
@@ -189,16 +189,15 @@
goto fn_exit;
}
-static HYD_Status fill_in_exec_args(void)
+static HYD_Status fill_in_exec_launch_info(void)
{
int i, arg, process_id;
int inherited_env_count, user_env_count, system_env_count;
- int segment_count, exec_count, total_args;
+ int exec_count, total_args;
static int proxy_count = 0;
HYD_Env_t *env;
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 */
@@ -211,10 +210,6 @@
for (system_env_count = 0, env = HYD_handle.user_global.global_env.system; env;
env = env->next, system_env_count++);
- for (segment_count = 0, segment = proxy->segment_list; segment;
- segment = segment->next)
- segment_count++;
-
for (exec_count = 0, exec = proxy->exec_list; exec; exec = exec->next)
exec_count++;
@@ -225,131 +220,124 @@
total_args += user_env_count;
total_args += system_env_count;
- /* For each segment add a few strings */
- total_args += (segment_count * HYD_NUM_TMP_STRINGS);
-
/* For each exec add a few strings */
total_args += (exec_count * HYD_NUM_TMP_STRINGS);
- HYDU_MALLOC(proxy->exec_args, char **, total_args * sizeof(char *), status);
+ /* Add a few strings for the remaining arguments */
+ total_args += HYD_NUM_TMP_STRINGS;
+ HYDU_MALLOC(proxy->exec_launch_info, char **, total_args * sizeof(char *), status);
+
arg = 0;
- proxy->exec_args[arg++] = HYDU_strdup("--global-core-count");
- proxy->exec_args[arg++] = HYDU_int_to_str(HYD_handle.global_core_count);
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--global-core-count");
+ proxy->exec_launch_info[arg++] = HYDU_int_to_str(HYD_handle.global_core_count);
- proxy->exec_args[arg++] = HYDU_strdup("--wdir");
- proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.user_global.wdir);
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--wdir");
+ proxy->exec_launch_info[arg++] = HYDU_strdup(HYD_handle.user_global.wdir);
- proxy->exec_args[arg++] = HYDU_strdup("--pmi-port-str");
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--pmi-port-str");
if (HYD_handle.pm_env)
- proxy->exec_args[arg++] = HYDU_strdup(pmi_port_str);
+ proxy->exec_launch_info[arg++] = HYDU_strdup(pmi_port_str);
else
- proxy->exec_args[arg++] = HYDU_strdup("HYDRA_NULL");
+ proxy->exec_launch_info[arg++] = HYDU_strdup("HYDRA_NULL");
- proxy->exec_args[arg++] = HYDU_strdup("--binding");
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--binding");
if (HYD_handle.user_global.binding)
- proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.user_global.binding);
+ proxy->exec_launch_info[arg++] = HYDU_strdup(HYD_handle.user_global.binding);
else
- proxy->exec_args[arg++] = HYDU_strdup("HYDRA_NULL");
+ proxy->exec_launch_info[arg++] = HYDU_strdup("HYDRA_NULL");
- proxy->exec_args[arg++] = HYDU_strdup("--bindlib");
- proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.user_global.bindlib);
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--bindlib");
+ proxy->exec_launch_info[arg++] = HYDU_strdup(HYD_handle.user_global.bindlib);
- proxy->exec_args[arg++] = HYDU_strdup("--ckpointlib");
- proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.user_global.ckpointlib);
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--ckpointlib");
+ proxy->exec_launch_info[arg++] = HYDU_strdup(HYD_handle.user_global.ckpointlib);
- proxy->exec_args[arg++] = HYDU_strdup("--ckpoint-prefix");
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--ckpoint-prefix");
if (HYD_handle.user_global.ckpoint_prefix)
- proxy->exec_args[arg++] = HYDU_strdup(HYD_handle.user_global.ckpoint_prefix);
+ proxy->exec_launch_info[arg++] = HYDU_strdup(HYD_handle.user_global.ckpoint_prefix);
else
- proxy->exec_args[arg++] = HYDU_strdup("HYDRA_NULL");
+ proxy->exec_launch_info[arg++] = HYDU_strdup("HYDRA_NULL");
if (HYD_handle.user_global.ckpoint_restart)
- proxy->exec_args[arg++] = HYDU_strdup("--ckpoint-restart");
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--ckpoint-restart");
- proxy->exec_args[arg++] = HYDU_strdup("--global-inherited-env");
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--global-inherited-env");
for (i = 0, env = HYD_handle.user_global.global_env.inherited; env;
env = env->next, i++);
- proxy->exec_args[arg++] = HYDU_int_to_str(i);
+ proxy->exec_launch_info[arg++] = HYDU_int_to_str(i);
for (env = HYD_handle.user_global.global_env.inherited; env; env = env->next) {
- status = HYDU_env_to_str(env, &proxy->exec_args[arg++]);
+ status = HYDU_env_to_str(env, &proxy->exec_launch_info[arg++]);
HYDU_ERR_POP(status, "error converting env to string\n");
}
- proxy->exec_args[arg++] = NULL;
+ proxy->exec_launch_info[arg++] = NULL;
- arg = HYDU_strlist_lastidx(proxy->exec_args);
- proxy->exec_args[arg++] = HYDU_strdup("--global-user-env");
+ arg = HYDU_strlist_lastidx(proxy->exec_launch_info);
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--global-user-env");
for (i = 0, env = HYD_handle.user_global.global_env.user; env; env = env->next, i++);
- proxy->exec_args[arg++] = HYDU_int_to_str(i);
+ proxy->exec_launch_info[arg++] = HYDU_int_to_str(i);
for (env = HYD_handle.user_global.global_env.user; env; env = env->next) {
- status = HYDU_env_to_str(env, &proxy->exec_args[arg++]);
+ status = HYDU_env_to_str(env, &proxy->exec_launch_info[arg++]);
HYDU_ERR_POP(status, "error converting env to string\n");
}
- proxy->exec_args[arg++] = NULL;
+ proxy->exec_launch_info[arg++] = NULL;
- arg = HYDU_strlist_lastidx(proxy->exec_args);
- proxy->exec_args[arg++] = HYDU_strdup("--global-system-env");
+ arg = HYDU_strlist_lastidx(proxy->exec_launch_info);
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--global-system-env");
for (i = 0, env = HYD_handle.user_global.global_env.system; env; env = env->next, i++);
- proxy->exec_args[arg++] = HYDU_int_to_str(i);
+ proxy->exec_launch_info[arg++] = HYDU_int_to_str(i);
for (env = HYD_handle.user_global.global_env.system; env; env = env->next) {
- status = HYDU_env_to_str(env, &proxy->exec_args[arg++]);
+ status = HYDU_env_to_str(env, &proxy->exec_launch_info[arg++]);
HYDU_ERR_POP(status, "error converting env to string\n");
}
- proxy->exec_args[arg++] = NULL;
+ proxy->exec_launch_info[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.user_global.global_env.prop);
- proxy->exec_args[arg++] = NULL;
+ arg = HYDU_strlist_lastidx(proxy->exec_launch_info);
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--genv-prop");
+ proxy->exec_launch_info[arg++] = HYDU_strdup(HYD_handle.user_global.global_env.prop);
- /* Pass the segment information */
- for (segment = proxy->segment_list; segment; segment = segment->next) {
- arg = HYDU_strlist_lastidx(proxy->exec_args);
- proxy->exec_args[arg++] = HYDU_strdup("--segment");
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--start-pid");
+ proxy->exec_launch_info[arg++] = HYDU_int_to_str(proxy->start_pid);
- proxy->exec_args[arg++] = HYDU_strdup("--segment-start-pid");
- proxy->exec_args[arg++] = HYDU_int_to_str(segment->start_pid);
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--proxy-core-count");
+ proxy->exec_launch_info[arg++] = HYDU_int_to_str(proxy->proxy_core_count);
+ proxy->exec_launch_info[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 = proxy->exec_list; exec; exec = exec->next) {
- arg = HYDU_strlist_lastidx(proxy->exec_args);
- proxy->exec_args[arg++] = HYDU_strdup("--exec");
+ arg = HYDU_strlist_lastidx(proxy->exec_launch_info);
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--exec");
- proxy->exec_args[arg++] = HYDU_strdup("--exec-proc-count");
- proxy->exec_args[arg++] = HYDU_int_to_str(exec->proc_count);
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--exec-proc-count");
+ proxy->exec_launch_info[arg++] = HYDU_int_to_str(exec->proc_count);
- proxy->exec_args[arg++] = HYDU_strdup("--exec-local-env");
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--exec-local-env");
for (i = 0, env = exec->user_env; env; env = env->next, i++);
- proxy->exec_args[arg++] = HYDU_int_to_str(i);
+ proxy->exec_launch_info[arg++] = HYDU_int_to_str(i);
for (env = exec->user_env; env; env = env->next) {
- status = HYDU_env_to_str(env, &proxy->exec_args[arg++]);
+ status = HYDU_env_to_str(env, &proxy->exec_launch_info[arg++]);
HYDU_ERR_POP(status, "error converting env to string\n");
}
- proxy->exec_args[arg++] = NULL;
+ proxy->exec_launch_info[arg++] = NULL;
- 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) :
+ arg = HYDU_strlist_lastidx(proxy->exec_launch_info);
+ proxy->exec_launch_info[arg++] = HYDU_strdup("--exec-env-prop");
+ proxy->exec_launch_info[arg++] = exec->env_prop ? HYDU_strdup(exec->env_prop) :
HYDU_strdup("HYDRA_NULL");
- proxy->exec_args[arg++] = NULL;
+ proxy->exec_launch_info[arg++] = NULL;
- HYDU_list_append_strlist(exec->exec, proxy->exec_args);
+ HYDU_list_append_strlist(exec->exec, proxy->exec_launch_info);
process_id += exec->proc_count;
}
if (HYD_handle.user_global.debug) {
printf("Arguments being passed to proxy %d:\n", proxy_count++);
- HYDU_print_strlist(proxy->exec_args);
+ HYDU_print_strlist(proxy->exec_launch_info);
printf("\n");
}
}
@@ -396,7 +384,7 @@
status = fill_in_proxy_args(HYD_handle.user_global.launch_mode, proxy_args);
HYDU_ERR_POP(status, "unable to fill in proxy arguments\n");
- status = fill_in_exec_args();
+ status = fill_in_exec_launch_info();
HYDU_ERR_POP(status, "unable to fill in executable arguments\n");
status = HYD_BSCI_launch_procs(proxy_args, "--proxy-id", HYD_handle.proxy_list);
@@ -427,7 +415,7 @@
}
}
else if (HYD_handle.user_global.launch_mode == HYD_LAUNCH_PERSISTENT) {
- status = fill_in_exec_args();
+ status = fill_in_exec_launch_info();
HYDU_ERR_POP(status, "unable to fill in proxy arguments\n");
len = 0;
Modified: mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_utils.c
===================================================================
--- mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_utils.c 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/pm/pmiserv/pmi_serv_utils.c 2009-10-15 17:10:02 UTC (rev 5465)
@@ -22,18 +22,18 @@
HYDU_ERR_POP(status, "unable to write data to proxy\n");
/* Check how many arguments we have */
- list_len = HYDU_strlist_lastidx(proxy->exec_args);
+ list_len = HYDU_strlist_lastidx(proxy->exec_launch_info);
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; proxy->exec_args[i]; i++) {
- arg_len = strlen(proxy->exec_args[i]) + 1;
+ for (i = 0; proxy->exec_launch_info[i]; i++) {
+ arg_len = strlen(proxy->exec_launch_info[i]) + 1;
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(proxy->control_fd, proxy->exec_args[i], arg_len);
+ status = HYDU_sock_write(proxy->control_fd, proxy->exec_launch_info[i], arg_len);
HYDU_ERR_POP(status, "unable to write data to proxy\n");
}
Modified: mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_query_node_list.c
===================================================================
--- mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_query_node_list.c 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/rmk/pbs/rmk_pbs_query_node_list.c 2009-10-15 17:10:02 UTC (rev 5465)
@@ -13,7 +13,6 @@
char *host_file, *hostname, line[HYD_TMP_STRLEN], **arg_list;
int num_procs;
FILE *fp;
- struct HYD_Proxy_segment *segment;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -55,11 +54,7 @@
/* 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_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_proxy_segment(hostname, segment, proxy_list);
+ status = HYDU_merge_proxy_segment(hostname, *num_nodes, num_procs, proxy_list);
HYDU_ERR_POP(status, "merge proxy segment failed\n");
*num_nodes += num_procs;
Modified: mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.c
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.c 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/ui/mpiexec/mpiexec.c 2009-10-15 17:10:02 UTC (rev 5465)
@@ -165,7 +165,7 @@
if (HYD_handle.user_global.launch_mode == HYD_LAUNCH_RUNTIME ||
HYD_handle.user_global.launch_mode == HYD_LAUNCH_PERSISTENT) {
for (proxy = HYD_handle.proxy_list;
- proxy && (proxy->segment_list->start_pid <= HYD_handle.global_process_count);
+ proxy && (proxy->start_pid <= HYD_handle.global_process_count);
proxy = proxy->next)
proxy->active = 1;
}
@@ -196,11 +196,11 @@
process_id = 0;
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++,
- proxy->proxy_core_count,
- proxy->segment_list,
- HYD_handle.
- global_core_count));
+ HYDU_dump(stdout, "%d",
+ HYDU_local_to_global_id(process_id++,
+ proxy->start_pid,
+ proxy->proxy_core_count,
+ HYD_handle.global_core_count));
if (i < exec->proc_count - 1)
HYDU_dump(stdout, ",");
}
@@ -210,6 +210,10 @@
HYDU_dump(stdout, "\n");
}
+ FORALL_ACTIVE_PROXIES(proxy, HYD_handle.proxy_list)
+ HYDU_MALLOC(proxy->exit_status, int *, proxy->proxy_process_count * sizeof(int),
+ status);
+
/* Launch the processes */
status = HYD_PMCI_launch_procs();
HYDU_ERR_POP(status, "process manager returned error launching processes\n");
@@ -274,19 +278,19 @@
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, proxy->proxy_core_count,
- proxy->segment_list,
- HYD_handle.
- global_core_count));
- HYDU_dump(stdout, "%d", WEXITSTATUS(proxy->exit_status[i]));
+ HYDU_dump_noprefix(stdout, "[%d]",
+ HYDU_local_to_global_id(i, proxy->start_pid,
+ proxy->proxy_core_count,
+ HYD_handle.global_core_count));
+ HYDU_dump_noprefix(stdout, "%d", WEXITSTATUS(proxy->exit_status[i]));
if (i < proc_count - 1)
- HYDU_dump(stdout, ",");
+ HYDU_dump_noprefix(stdout, ",");
}
exit_status |= proxy->exit_status[i];
}
}
if (HYD_handle.print_all_exitcodes)
- HYDU_dump(stdout, "\n");
+ HYDU_dump_noprefix(stdout, "\n");
/* Call finalize functions for lower layers to cleanup their resources */
status = HYD_PMCI_finalize();
Modified: mpich2/trunk/src/pm/hydra/ui/mpiexec/utils.c
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/mpiexec/utils.c 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/ui/mpiexec/utils.c 2009-10-15 17:10:02 UTC (rev 5465)
@@ -154,7 +154,6 @@
{
static int pid = 0;
struct HYD_Proxy *proxy;
- struct HYD_Proxy_segment *segment;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -165,18 +164,12 @@
HYD_handle.proxy_list->hostname = HYDU_strdup(hostname);
- status = HYDU_alloc_proxy_segment(&HYD_handle.proxy_list->segment_list);
- HYDU_ERR_POP(status, "unable to allocate proxy segment\n");
-
- HYD_handle.proxy_list->segment_list->start_pid = 0;
- HYD_handle.proxy_list->segment_list->proc_count = num_procs;
-
- HYD_handle.proxy_list->proxy_core_count += num_procs;
+ HYD_handle.proxy_list->start_pid = 0;
+ HYD_handle.proxy_list->proxy_core_count = num_procs;
HYD_handle.global_core_count += num_procs;
}
else {
- for (proxy = HYD_handle.proxy_list;
- proxy->next && strcmp(proxy->hostname, hostname); proxy = proxy->next);
+ for (proxy = HYD_handle.proxy_list; proxy->next; proxy = proxy->next);
if (strcmp(proxy->hostname, hostname)) {
/* If the hostname does not match, create a new proxy */
@@ -187,28 +180,9 @@
proxy->hostname = HYDU_strdup(hostname);
- status = HYDU_alloc_proxy_segment(&proxy->segment_list);
- HYDU_ERR_POP(status, "unable to allocate proxy segment\n");
-
- proxy->segment_list->start_pid = pid;
- proxy->segment_list->proc_count = num_procs;
+ proxy->start_pid = pid;
}
- else { /* hostname matches */
- for (segment = proxy->segment_list; segment->next; segment = segment->next);
- /* If this segment is a continuation, just increment the
- * size of the previous segment */
- if (segment->start_pid + segment->proc_count == pid)
- segment->proc_count += num_procs;
- else {
- status = HYDU_alloc_proxy_segment(&segment->next);
- HYDU_ERR_POP(status, "unable to allocate proxy segment\n");
-
- segment->next->start_pid = pid;
- segment->next->proc_count = num_procs;
- }
- }
-
proxy->proxy_core_count += num_procs;
HYD_handle.global_core_count += num_procs;
}
Modified: mpich2/trunk/src/pm/hydra/ui/utils/uiu.c
===================================================================
--- mpich2/trunk/src/pm/hydra/ui/utils/uiu.c 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/ui/utils/uiu.c 2009-10-15 17:10:02 UTC (rev 5465)
@@ -157,6 +157,7 @@
exec->env_prop = exec_info->env_prop ? HYDU_strdup(exec_info->env_prop) : NULL;
exec->user_env = HYDU_env_list_dup(exec_info->user_env);
}
+ proxy->proxy_process_count += num_procs;
fn_exit:
return status;
@@ -222,7 +223,6 @@
HYD_Env_t *env;
int i;
struct HYD_Proxy *proxy;
- struct HYD_Proxy_segment *segment;
struct HYD_Proxy_exec *exec;
struct HYD_Exec_info *exec_info;
@@ -293,13 +293,8 @@
HYDU_dump(stdout, " -----------------\n");
HYDU_dump(stdout, " Proxy name: %s\n", proxy->hostname);
HYDU_dump(stdout, " Process count: %d\n", proxy->proxy_core_count);
+ HYDU_dump(stdout, " Start PID: %d\n", proxy->start_pid);
HYDU_dump(stdout, "\n");
- HYDU_dump(stdout, " Proxy segment list:\n");
- HYDU_dump(stdout, " .......................\n");
- 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, " Proxy exec list:\n");
HYDU_dump(stdout, " ....................\n");
for (exec = proxy->exec_list; exec; exec = exec->next)
Modified: mpich2/trunk/src/pm/hydra/utils/alloc/alloc.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/alloc/alloc.c 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/utils/alloc/alloc.c 2009-10-15 17:10:02 UTC (rev 5465)
@@ -51,10 +51,11 @@
(*proxy)->proxy_id = proxy_id++;
(*proxy)->active = 0;
- (*proxy)->exec_args = NULL;
+ (*proxy)->exec_launch_info = NULL;
- (*proxy)->segment_list = NULL;
+ (*proxy)->start_pid = -1;
(*proxy)->proxy_core_count = 0;
+ (*proxy)->proxy_process_count = 0;
(*proxy)->exit_status = NULL;
(*proxy)->control_fd = -1;
@@ -121,7 +122,6 @@
void HYDU_free_proxy_list(struct HYD_Proxy *proxy_list)
{
struct HYD_Proxy *proxy, *tproxy;
- struct HYD_Proxy_segment *segment, *tsegment;
struct HYD_Proxy_exec *exec, *texec;
HYDU_FUNC_ENTER();
@@ -132,18 +132,11 @@
if (proxy->hostname)
HYDU_FREE(proxy->hostname);
- if (proxy->exec_args) {
- HYDU_free_strlist(proxy->exec_args);
- HYDU_FREE(proxy->exec_args);
+ if (proxy->exec_launch_info) {
+ HYDU_free_strlist(proxy->exec_launch_info);
+ HYDU_FREE(proxy->exec_launch_info);
}
- segment = proxy->segment_list;
- while (segment) {
- tsegment = segment->next;
- HYDU_FREE(segment);
- segment = tsegment;
- }
-
if (proxy->exit_status)
HYDU_FREE(proxy->exit_status);
@@ -167,27 +160,6 @@
}
-HYD_Status HYDU_alloc_proxy_segment(struct HYD_Proxy_segment **segment)
-{
- HYD_Status status = HYD_SUCCESS;
-
- HYDU_FUNC_ENTER();
-
- HYDU_MALLOC(*segment, struct HYD_Proxy_segment *,
- sizeof(struct HYD_Proxy_segment), status);
- (*segment)->start_pid = -1;
- (*segment)->proc_count = 0;
- (*segment)->next = NULL;
-
- fn_exit:
- HYDU_FUNC_EXIT();
- return status;
-
- fn_fail:
- goto fn_exit;
-}
-
-
HYD_Status HYDU_alloc_proxy_exec(struct HYD_Proxy_exec **exec)
{
HYD_Status status = HYD_SUCCESS;
Modified: mpich2/trunk/src/pm/hydra/utils/others/others.c
===================================================================
--- mpich2/trunk/src/pm/hydra/utils/others/others.c 2009-10-15 16:36:40 UTC (rev 5464)
+++ mpich2/trunk/src/pm/hydra/utils/others/others.c 2009-10-15 17:10:02 UTC (rev 5465)
@@ -6,11 +6,10 @@
#include "hydra_utils.h"
-HYD_Status HYDU_merge_proxy_segment(char *hostname, struct HYD_Proxy_segment *segment,
+HYD_Status HYDU_merge_proxy_segment(char *hostname, int start_pid, int core_count,
struct HYD_Proxy **proxy_list)
{
struct HYD_Proxy *proxy;
- struct HYD_Proxy_segment *s;
HYD_Status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -18,37 +17,22 @@
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;
+ (*proxy_list)->start_pid = start_pid;
+ (*proxy_list)->proxy_core_count = core_count;
}
else {
- proxy = *proxy_list;
- while (proxy) {
- if (strcmp(proxy->hostname, hostname) == 0) {
- if (proxy->segment_list == NULL)
- proxy->segment_list = segment;
- else {
- s = proxy->segment_list;
- while (s->next)
- s = s->next;
- s->next = segment;
- }
- proxy->proxy_core_count += segment->proc_count;
- break;
- }
- 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 {
- proxy = proxy->next;
- }
+ /* Run to the last proxy */
+ for (proxy = *proxy_list; proxy->next; proxy = proxy->next);
+
+ if (strcmp(proxy->hostname, hostname)) { /* hostname doesn't match */
+ status = HYDU_alloc_proxy(&proxy->next);
+ HYDU_ERR_POP(status, "unable to alloc proxy\n");
+ proxy->next->hostname = HYDU_strdup(hostname);
+ proxy->next->start_pid = start_pid;
+ proxy = proxy->next;
}
+ proxy->proxy_core_count += core_count;
}
fn_exit:
@@ -58,23 +42,9 @@
goto fn_exit;
}
-int HYDU_local_to_global_id(int local_id, int core_count,
- struct HYD_Proxy_segment *segment_list, int global_core_count)
+int HYDU_local_to_global_id(int local_id, int start_pid, int core_count,
+ int global_core_count)
{
- int global_id, rem;
- struct HYD_Proxy_segment *segment;
-
- global_id = ((local_id / core_count) * global_core_count);
- rem = (local_id % core_count);
-
- for (segment = segment_list; segment; segment = segment->next) {
- if (rem >= segment->proc_count)
- rem -= segment->proc_count;
- else {
- global_id += segment->start_pid + rem;
- break;
- }
- }
-
- return global_id;
+ return ((local_id / core_count) * global_core_count) + (local_id % core_count) +
+ start_pid;
}
More information about the mpich2-commits
mailing list