[mpich-commits] [mpich] MPICH primary repository branch, master, updated. v3.2-219-g778679c
Service Account
noreply at mpich.org
Fri Feb 19 21:16:27 CST 2016
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "MPICH primary repository".
The branch, master has been updated
via 778679c0fbea3ffc017d7f1178f35d5b64d74665 (commit)
via 09f7baeb7886aac7a1fb8840437a994751292271 (commit)
via 743ff1e52d7f5cba8891cad03635bc9d43bb106e (commit)
via 7951766d3f3a37f54e73a8f1abc3d3783914039f (commit)
from 658531a076a1586bf1b49c4809162c693a714e14 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
http://git.mpich.org/mpich.git/commitdiff/778679c0fbea3ffc017d7f1178f35d5b64d74665
commit 778679c0fbea3ffc017d7f1178f35d5b64d74665
Author: Pavan Balaji <balaji at anl.gov>
Date: Thu Feb 18 12:36:34 2016 -0600
hydra: white space cleanup
No reviewer.
diff --git a/src/pm/hydra/include/hydra.h b/src/pm/hydra/include/hydra.h
index 6af5fa6..1124519 100644
--- a/src/pm/hydra/include/hydra.h
+++ b/src/pm/hydra/include/hydra.h
@@ -141,14 +141,14 @@ extern char *HYD_dbg_prefix;
printf("\n"); \
}
-#define HYD_CONVERT_FALSE_TO_NULL(x) \
+#define HYD_CONVERT_FALSE_TO_NULL(x) \
{ \
if (!(x)) { \
} \
else if (!strcasecmp((x), "none") || !strcasecmp((x), "no") || \
!strcasecmp((x), "dummy") || !strcasecmp((x), "null") || \
!strcasecmp((x), "nil") || !strcasecmp((x), "false")) { \
- MPL_free((x)); \
+ MPL_free((x)); \
(x) = NULL; \
} \
}
@@ -158,7 +158,7 @@ extern char **environ;
#endif /* MANUAL_EXTERN_ENVIRON */
#if defined NEEDS_HSTRERROR_DECL
-const char * hstrerror(int err);
+const char *hstrerror(int err);
#endif /* NEEDS_HSTRERROR_DECL */
#if defined NEEDS_GETTIMEOFDAY_DECL
@@ -193,9 +193,9 @@ struct HYD_string_stash {
#define HYD_STRING_STASH(stash, str, status) \
do { \
if ((stash).cur_count >= (stash).max_count - 1) { \
- HYDU_REALLOC_OR_JUMP((stash).strlist, char **, \
- ((stash).max_count + HYD_NUM_TMP_STRINGS) * sizeof(char *), \
- (status)); \
+ HYDU_REALLOC_OR_JUMP((stash).strlist, char **, \
+ ((stash).max_count + HYD_NUM_TMP_STRINGS) * sizeof(char *), \
+ (status)); \
(stash).max_count += HYD_NUM_TMP_STRINGS; \
} \
(stash).strlist[(stash).cur_count++] = (str); \
@@ -211,7 +211,7 @@ struct HYD_string_stash {
(status) = HYDU_str_alloc_and_join((stash).strlist, &(str)); \
HYDU_ERR_POP((status), "unable to join strings\n"); \
HYDU_free_strlist((stash).strlist); \
- MPL_free((stash).strlist); \
+ MPL_free((stash).strlist); \
HYD_STRING_STASH_INIT((stash)); \
} \
} while (0)
@@ -221,7 +221,7 @@ struct HYD_string_stash {
if ((stash).strlist == NULL) \
break; \
HYDU_free_strlist((stash).strlist); \
- MPL_free((stash).strlist); \
+ MPL_free((stash).strlist); \
(stash).max_count = 0; \
(stash).cur_count = 0; \
} while (0)
@@ -441,26 +441,26 @@ struct HYD_user_global {
HYDU_dump_noprefix(stderr, __VA_ARGS__); \
}
#elif defined __FILE__
-#define HYDU_error_printf(...) \
- { \
+#define HYDU_error_printf(...) \
+ { \
HYDU_dump_prefix(stderr); \
HYDU_dump_noprefix(stderr, "%s (%d): ", __FILE__, __LINE__); \
HYDU_dump_noprefix(stderr, __VA_ARGS__); \
}
#else
-#define HYDU_error_printf(...) \
- { \
- HYDU_dump_prefix(stderr); \
- HYDU_dump_noprefix(stderr, __VA_ARGS__); \
+#define HYDU_error_printf(...) \
+ { \
+ HYDU_dump_prefix(stderr); \
+ HYDU_dump_noprefix(stderr, __VA_ARGS__); \
}
#endif
-#define HYDU_ASSERT(x, status) \
- { \
- if (!(x)) { \
- HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, \
- "assert (%s) failed\n", #x); \
- } \
+#define HYDU_ASSERT(x, status) \
+ { \
+ if (!(x)) { \
+ HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, \
+ "assert (%s) failed\n", #x); \
+ } \
}
#define HYDU_IGNORE_TIMEOUT(status) \
@@ -469,27 +469,27 @@ struct HYD_user_global {
(status) = HYD_SUCCESS; \
}
-#define HYDU_ERR_POP(status, ...) \
- { \
- if (status && !HYD_SILENT_ERROR(status)) { \
- HYDU_error_printf(__VA_ARGS__); \
- goto fn_fail; \
- } \
- else if (HYD_SILENT_ERROR(status)) { \
- goto fn_exit; \
- } \
+#define HYDU_ERR_POP(status, ...) \
+ { \
+ if (status && !HYD_SILENT_ERROR(status)) { \
+ HYDU_error_printf(__VA_ARGS__); \
+ goto fn_fail; \
+ } \
+ else if (HYD_SILENT_ERROR(status)) { \
+ goto fn_exit; \
+ } \
}
-#define HYDU_ERR_SETANDJUMP(status, error, ...) \
- { \
- status = error; \
- HYDU_ERR_POP(status, __VA_ARGS__); \
+#define HYDU_ERR_SETANDJUMP(status, error, ...) \
+ { \
+ status = error; \
+ HYDU_ERR_POP(status, __VA_ARGS__); \
}
-#define HYDU_ERR_CHKANDJUMP(status, chk, error, ...) \
- { \
- if ((chk)) \
- HYDU_ERR_SETANDJUMP(status, error, __VA_ARGS__); \
+#define HYDU_ERR_CHKANDJUMP(status, chk, error, ...) \
+ { \
+ if ((chk)) \
+ HYDU_ERR_SETANDJUMP(status, error, __VA_ARGS__); \
}
#if defined ENABLE_WARNINGS
@@ -612,7 +612,7 @@ HYD_status HYDU_sock_cloexec(int fd);
/* Memory utilities */
#include <ctype.h>
-#define HYDU_MALLOC_OR_JUMP(p, type, size, status) \
+#define HYDU_MALLOC_OR_JUMP(p, type, size, status) \
{ \
(p) = NULL; /* initialize p in case assert fails */ \
HYDU_ASSERT(size, status); \
@@ -623,7 +623,7 @@ HYD_status HYDU_sock_cloexec(int fd);
(int) (size)); \
}
-#define HYDU_REALLOC_OR_JUMP(p, type, size, status) \
+#define HYDU_REALLOC_OR_JUMP(p, type, size, status) \
{ \
HYDU_ASSERT(size, status); \
(p) = (type) MPL_realloc((p),(size)); \
diff --git a/src/pm/hydra/pm/pmiserv/common.c b/src/pm/hydra/pm/pmiserv/common.c
index fceb081..7ec397a 100644
--- a/src/pm/hydra/pm/pmiserv/common.c
+++ b/src/pm/hydra/pm/pmiserv/common.c
@@ -75,7 +75,8 @@ HYD_status HYD_pmcd_pmi_args_to_tokens(char *args[], struct HYD_pmcd_token **tok
for (i = 0; args[i]; i++);
*count = i;
- HYDU_MALLOC_OR_JUMP(*tokens, struct HYD_pmcd_token *, *count * sizeof(struct HYD_pmcd_token), status);
+ HYDU_MALLOC_OR_JUMP(*tokens, struct HYD_pmcd_token *, *count * sizeof(struct HYD_pmcd_token),
+ status);
for (i = 0; args[i]; i++) {
arg = MPL_strdup(args[i]);
@@ -160,8 +161,8 @@ HYD_status HYD_pmcd_pmi_add_kvs(const char *key, char *val, struct HYD_pmcd_pmi_
HYDU_FUNC_ENTER();
- HYDU_MALLOC_OR_JUMP(key_pair, struct HYD_pmcd_pmi_kvs_pair *, sizeof(struct HYD_pmcd_pmi_kvs_pair),
- status);
+ HYDU_MALLOC_OR_JUMP(key_pair, struct HYD_pmcd_pmi_kvs_pair *,
+ sizeof(struct HYD_pmcd_pmi_kvs_pair), status);
MPL_snprintf(key_pair->key, PMI_MAXKEYLEN, "%s", key);
MPL_snprintf(key_pair->val, PMI_MAXVALLEN, "%s", val);
key_pair->next = NULL;
diff --git a/src/pm/hydra/pm/pmiserv/common.h b/src/pm/hydra/pm/pmiserv/common.h
index d0c249e..5423fb9 100644
--- a/src/pm/hydra/pm/pmiserv/common.h
+++ b/src/pm/hydra/pm/pmiserv/common.h
@@ -14,7 +14,7 @@
#define PMI_MAXVALLEN (1024) /* max length of value in keyval space */
#define PMI_MAXKVSLEN (256) /* max length of various names */
-#define MAX_PMI_ARGS (65536) /* number of arguments in a PMI command */
+#define MAX_PMI_ARGS (65536) /* number of arguments in a PMI command */
#define MAX_PMI_INTERNAL_ARGS (65536) /* number of arguments in internal communication */
struct HYD_pmcd_pmi_kvs_pair {
diff --git a/src/pm/hydra/pm/pmiserv/pmi_v2_common.c b/src/pm/hydra/pm/pmiserv/pmi_v2_common.c
index 9a545ab..f5ef263 100644
--- a/src/pm/hydra/pm/pmiserv/pmi_v2_common.c
+++ b/src/pm/hydra/pm/pmiserv/pmi_v2_common.c
@@ -15,7 +15,8 @@ HYD_status HYD_pmcd_pmi_v2_queue_req(int fd, int pid, int pgid, char *args[], ch
struct HYD_pmcd_pmi_v2_reqs *req, *tmp;
HYD_status status = HYD_SUCCESS;
- HYDU_MALLOC_OR_JUMP(req, struct HYD_pmcd_pmi_v2_reqs *, sizeof(struct HYD_pmcd_pmi_v2_reqs), status);
+ HYDU_MALLOC_OR_JUMP(req, struct HYD_pmcd_pmi_v2_reqs *, sizeof(struct HYD_pmcd_pmi_v2_reqs),
+ status);
req->fd = fd;
req->pid = pid;
req->pgid = pgid;
diff --git a/src/pm/hydra/pm/pmiserv/pmip_cb.c b/src/pm/hydra/pm/pmiserv/pmip_cb.c
index b47f204..a66916b 100644
--- a/src/pm/hydra/pm/pmiserv/pmip_cb.c
+++ b/src/pm/hydra/pm/pmiserv/pmip_cb.c
@@ -222,7 +222,7 @@ static HYD_status pmi_cb(int fd, HYD_event_t events, void *userp)
}
}
- read_cmd:
+ read_cmd:
/* PMI-1 does not tell us how much to read. We read how much ever
* we can, parse out full PMI commands from it, and process
* them. When we don't have a full PMI command, we go back and
@@ -284,7 +284,7 @@ static HYD_status pmi_cb(int fd, HYD_event_t events, void *userp)
pmi_storage[pmi_storage_len] = 0;
}
- check_cmd:
+ check_cmd:
status = check_pmi_cmd(&buf, &hdr.pmi_version, &repeat);
HYDU_ERR_POP(status, "error checking the PMI command\n");
@@ -305,8 +305,8 @@ static HYD_status pmi_cb(int fd, HYD_event_t events, void *userp)
HYD_pmcd_pmip_pmi_handle = HYD_pmcd_pmip_pmi_v2;
HYDU_MALLOC_OR_JUMP(args, char **, MAX_PMI_ARGS * sizeof(char *), status);
- for(i = 0;i < MAX_PMI_ARGS; i++)
- args[i]= NULL;
+ for (i = 0; i < MAX_PMI_ARGS; i++)
+ args[i] = NULL;
status = HYD_pmcd_pmi_parse_pmi_cmd(buf, hdr.pmi_version, &pmi_cmd, args);
HYDU_ERR_POP(status, "unable to parse PMI command\n");
@@ -327,8 +327,7 @@ static HYD_status pmi_cb(int fd, HYD_event_t events, void *userp)
}
if (HYD_pmcd_pmip.user_global.debug) {
- HYDU_dump(stdout, "we don't understand this command %s; forwarding upstream\n",
- pmi_cmd);
+ HYDU_dump(stdout, "we don't understand this command %s; forwarding upstream\n", pmi_cmd);
}
/* We don't understand the command; forward it upstream */
@@ -489,19 +488,19 @@ static HYD_status launch_procs(void)
HYD_pmcd_pmip.local.proxy_process_count += exec->proc_count;
HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.downstream.out, int *,
- HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
+ HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.downstream.err, int *,
- HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
+ HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.downstream.pid, int *,
- HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
+ HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.downstream.exit_status, int *,
- HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
+ HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.downstream.pmi_rank, int *,
- HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
+ HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.downstream.pmi_fd, int *,
- HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
+ HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.downstream.pmi_fd_active, int *,
- HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
+ HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
/* Initialize the PMI_FD and PMI FD active state, and exit status */
for (i = 0; i < HYD_pmcd_pmip.local.proxy_process_count; i++) {
diff --git a/src/pm/hydra/pm/pmiserv/pmip_pmi_v1.c b/src/pm/hydra/pm/pmiserv/pmip_pmi_v1.c
index 452ec02..5bd5f3d 100644
--- a/src/pm/hydra/pm/pmiserv/pmip_pmi_v1.c
+++ b/src/pm/hydra/pm/pmiserv/pmip_pmi_v1.c
@@ -502,10 +502,10 @@ static HYD_status fn_keyval_cache(int fd, char *args[])
/* allocate a larger space for the cached keyvals, copy over the
* older keyvals and add the new ones in */
- HYDU_REALLOC_OR_JUMP(cache_get.key, char **, (cache_get.keyval_len + token_count) * sizeof(char *),
- status);
- HYDU_REALLOC_OR_JUMP(cache_get.val, char **, (cache_get.keyval_len + token_count) * sizeof(char *),
- status);
+ HYDU_REALLOC_OR_JUMP(cache_get.key, char **,
+ (cache_get.keyval_len + token_count) * sizeof(char *), status);
+ HYDU_REALLOC_OR_JUMP(cache_get.val, char **,
+ (cache_get.keyval_len + token_count) * sizeof(char *), status);
for (i = 0; i < token_count; i++) {
cache_get.key[cache_get.keyval_len + i] = MPL_strdup(tokens[i].key);
diff --git a/src/pm/hydra/pm/pmiserv/pmip_utils.c b/src/pm/hydra/pm/pmiserv/pmip_utils.c
index e101702..ca4a0c1 100644
--- a/src/pm/hydra/pm/pmiserv/pmip_utils.c
+++ b/src/pm/hydra/pm/pmiserv/pmip_utils.c
@@ -288,7 +288,7 @@ static HYD_status parse_ckpoint_prefix(char *pathlist)
prefixes++;
HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.local.ckpoint_prefix_list, char **, prefixes * sizeof(char *),
- status);
+ status);
dummy = strtok(pathlist, ":");
i = 0;
@@ -733,7 +733,7 @@ HYD_status HYD_pmcd_pmip_get_params(char **t_argv)
HYDU_dbg_finalize();
MPL_snprintf(dbg_prefix, 2 * MAX_HOSTNAME_LEN, "proxy:%d:%d",
- HYD_pmcd_pmip.local.pgid, HYD_pmcd_pmip.local.id);
+ HYD_pmcd_pmip.local.pgid, HYD_pmcd_pmip.local.id);
status = HYDU_dbg_init((const char *) dbg_prefix);
HYDU_ERR_POP(status, "unable to initialization debugging\n");
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_cb.c b/src/pm/hydra/pm/pmiserv/pmiserv_cb.c
index c33dca1..acc8007 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_cb.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_cb.c
@@ -232,7 +232,8 @@ static HYD_status control_cb(int fd, HYD_event_t events, void *userp)
HYDU_ERR_POP(status, "debugger setup failed\n");
}
else if (hdr.cmd == EXIT_STATUS) {
- HYDU_MALLOC_OR_JUMP(proxy->exit_status, int *, proxy->proxy_process_count * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(proxy->exit_status, int *, proxy->proxy_process_count * sizeof(int),
+ status);
status =
HYDU_sock_read(fd, (void *) proxy->exit_status,
proxy->proxy_process_count * sizeof(int), &count, &closed,
@@ -376,7 +377,8 @@ static HYD_status control_cb(int fd, HYD_event_t events, void *userp)
HYDU_MALLOC_OR_JUMP(str, char *, PMI_MAXVALLEN, status);
MPL_snprintf(str, PMI_MAXVALLEN, "%s,%d", pg_scratch->dead_processes, hdr.pid);
- } else {
+ }
+ else {
str = current_list;
}
pg_scratch->dead_processes = str;
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_pmi.c b/src/pm/hydra/pm/pmiserv/pmiserv_pmi.c
index 69e1f96..ee96942 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_pmi.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_pmi.c
@@ -82,7 +82,7 @@ HYD_status HYD_pmcd_pmi_publish(char *name, char *port, int *success)
*success = 1;
HYDU_MALLOC_OR_JUMP(publish, struct HYD_pmcd_pmi_publish *,
- sizeof(struct HYD_pmcd_pmi_publish), status);
+ sizeof(struct HYD_pmcd_pmi_publish), status);
publish->name = MPL_strdup(name);
publish->port = MPL_strdup(port);
publish->infokeycount = 0;
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v1.c b/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v1.c
index 1f170b9..4c41999 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v1.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v1.c
@@ -366,7 +366,7 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
total_spawns = atoi(val);
HYDU_MALLOC_OR_JUMP(segment_list, struct HYD_pmcd_token_segment *,
- total_spawns * sizeof(struct HYD_pmcd_token_segment), status);
+ total_spawns * sizeof(struct HYD_pmcd_token_segment), status);
segment_tokens(tokens, token_count, segment_list, &num_segments);
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v2.c b/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v2.c
index ea277b0..0bb6be1 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v2.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v2.c
@@ -492,7 +492,7 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
ncmds = atoi(val);
HYDU_MALLOC_OR_JUMP(segment_list, struct HYD_pmcd_token_segment *,
- (ncmds + 1) * sizeof(struct HYD_pmcd_token_segment), status);
+ (ncmds + 1) * sizeof(struct HYD_pmcd_token_segment), status);
segment_tokens(tokens, token_count, segment_list, &num_segments);
HYDU_ASSERT((ncmds + 1) == num_segments, status);
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_utils.c b/src/pm/hydra/pm/pmiserv/pmiserv_utils.c
index 07f4f2c..12260db 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_utils.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_utils.c
@@ -524,7 +524,7 @@ HYD_status HYD_pmcd_pmi_alloc_pg_scratch(struct HYD_pg *pg)
pg_scratch->barrier_count = 0;
HYDU_MALLOC_OR_JUMP(pg_scratch->ecount, struct HYD_pmcd_pmi_ecount *,
- pg->pg_process_count * sizeof(struct HYD_pmcd_pmi_ecount), status);
+ pg->pg_process_count * sizeof(struct HYD_pmcd_pmi_ecount), status);
for (i = 0; i < pg->pg_process_count; i++) {
pg_scratch->ecount[i].fd = HYD_FD_UNSET;
pg_scratch->ecount[i].pid = -1;
diff --git a/src/pm/hydra/tools/bootstrap/external/external_common_launch.c b/src/pm/hydra/tools/bootstrap/external/external_common_launch.c
index f0e110e..6da75b6 100644
--- a/src/pm/hydra/tools/bootstrap/external/external_common_launch.c
+++ b/src/pm/hydra/tools/bootstrap/external/external_common_launch.c
@@ -198,7 +198,8 @@ HYD_status HYDT_bscd_common_launch_procs(char **args, struct HYD_proxy *proxy_li
HYD_bscu_pid_list = pid;
/* Increase fd list to accommodate these new fds */
- HYDU_MALLOC_OR_JUMP(fd_list, int *, (HYD_bscu_fd_count + (2 * num_hosts) + 1) * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(fd_list, int *, (HYD_bscu_fd_count + (2 * num_hosts) + 1) * sizeof(int),
+ status);
for (i = 0; i < HYD_bscu_fd_count; i++)
fd_list[i] = HYD_bscu_fd_list[i];
MPL_free(HYD_bscu_fd_list);
diff --git a/src/pm/hydra/tools/bootstrap/external/pbs_init.c b/src/pm/hydra/tools/bootstrap/external/pbs_init.c
index 394f172..4e0780a 100644
--- a/src/pm/hydra/tools/bootstrap/external/pbs_init.c
+++ b/src/pm/hydra/tools/bootstrap/external/pbs_init.c
@@ -25,7 +25,7 @@ HYD_status HYDT_bsci_launcher_pbs_init(void)
HYDT_bsci_fns.launcher_finalize = HYDT_bscd_pbs_launcher_finalize;
HYDU_MALLOC_OR_JUMP(HYDT_bscd_pbs_sys, struct HYDT_bscd_pbs_sys_s *,
- sizeof(struct HYDT_bscd_pbs_sys_s), status);
+ sizeof(struct HYDT_bscd_pbs_sys_s), status);
/* Initialize TM and Hydra's PBS data structure */
err = tm_init(NULL, &tm_root);
diff --git a/src/pm/hydra/tools/bootstrap/external/pbs_launch.c b/src/pm/hydra/tools/bootstrap/external/pbs_launch.c
index e4deafe..f1eae39 100644
--- a/src/pm/hydra/tools/bootstrap/external/pbs_launch.c
+++ b/src/pm/hydra/tools/bootstrap/external/pbs_launch.c
@@ -60,9 +60,10 @@ HYD_status HYDT_bscd_pbs_launch_procs(char **args, struct HYD_proxy *proxy_list,
for (args_count = 0; args[args_count]; args_count++)
targs[args_count] = MPL_strdup(args[args_count]);
- HYDU_MALLOC_OR_JUMP(HYDT_bscd_pbs_sys->task_id, tm_task_id *, proxy_count * sizeof(tm_task_id), status);
+ HYDU_MALLOC_OR_JUMP(HYDT_bscd_pbs_sys->task_id, tm_task_id *, proxy_count * sizeof(tm_task_id),
+ status);
HYDU_MALLOC_OR_JUMP(HYDT_bscd_pbs_sys->spawn_events, tm_event_t *,
- proxy_count * sizeof(tm_event_t), status);
+ proxy_count * sizeof(tm_event_t), status);
/* Spawn a process on each allocated node through tm_spawn() which
* returns a taskID for the process + a eventID for the
diff --git a/src/pm/hydra/tools/bootstrap/external/pbs_wait.c b/src/pm/hydra/tools/bootstrap/external/pbs_wait.c
index 087554a..c3d712e 100644
--- a/src/pm/hydra/tools/bootstrap/external/pbs_wait.c
+++ b/src/pm/hydra/tools/bootstrap/external/pbs_wait.c
@@ -19,8 +19,8 @@ HYD_status HYDT_bscd_pbs_wait_for_completion(int timeout)
HYDU_FUNC_ENTER();
HYDU_MALLOC_OR_JUMP(taskobits, int *, HYDT_bscd_pbs_sys->spawn_count * sizeof(int), status);
- HYDU_MALLOC_OR_JUMP(obit_events, tm_event_t *, HYDT_bscd_pbs_sys->spawn_count * sizeof(tm_event_t),
- status);
+ HYDU_MALLOC_OR_JUMP(obit_events, tm_event_t *,
+ HYDT_bscd_pbs_sys->spawn_count * sizeof(tm_event_t), status);
for (idx = 0; idx < HYDT_bscd_pbs_sys->spawn_count; idx++)
obit_events[idx] = TM_NULL_EVENT;
diff --git a/src/pm/hydra/tools/bootstrap/external/ssh.c b/src/pm/hydra/tools/bootstrap/external/ssh.c
index 251b904..d26a172 100644
--- a/src/pm/hydra/tools/bootstrap/external/ssh.c
+++ b/src/pm/hydra/tools/bootstrap/external/ssh.c
@@ -18,9 +18,10 @@ static HYD_status create_element(char *hostname, struct HYDT_bscd_ssh_time **e)
HYD_status status = HYD_SUCCESS;
/* FIXME: These are never getting freed */
- HYDU_MALLOC_OR_JUMP((*e), struct HYDT_bscd_ssh_time *, sizeof(struct HYDT_bscd_ssh_time), status);
+ HYDU_MALLOC_OR_JUMP((*e), struct HYDT_bscd_ssh_time *, sizeof(struct HYDT_bscd_ssh_time),
+ status);
HYDU_MALLOC_OR_JUMP((*e)->init_time, struct timeval *,
- HYDT_bscd_ssh_limit_time * sizeof(struct timeval), status);
+ HYDT_bscd_ssh_limit_time * sizeof(struct timeval), status);
(*e)->hostname = MPL_strdup(hostname);
for (i = 0; i < HYDT_bscd_ssh_limit; i++) {
diff --git a/src/pm/hydra/tools/bootstrap/persist/persist_launch.c b/src/pm/hydra/tools/bootstrap/persist/persist_launch.c
index 9d06fdd..6d471cc 100644
--- a/src/pm/hydra/tools/bootstrap/persist/persist_launch.c
+++ b/src/pm/hydra/tools/bootstrap/persist/persist_launch.c
@@ -75,7 +75,7 @@ HYD_status HYDT_bscd_persist_launch_procs(char **args, struct HYD_proxy *proxy_l
args[idx + 1] = NULL;
HYDU_MALLOC_OR_JUMP(HYDT_bscd_persist_control_fd, int *,
- HYDT_bscd_persist_node_count * sizeof(int), status);
+ HYDT_bscd_persist_node_count * sizeof(int), status);
for (proxy = proxy_list, i = 0; proxy; proxy = proxy->next, i++) {
args[idx] = HYDU_int_to_str(i);
diff --git a/src/pm/hydra/tools/debugger/debugger.c b/src/pm/hydra/tools/debugger/debugger.c
index 357943c..dd125f0 100644
--- a/src/pm/hydra/tools/debugger/debugger.c
+++ b/src/pm/hydra/tools/debugger/debugger.c
@@ -34,7 +34,7 @@ HYD_status HYDT_dbg_setup_procdesc(struct HYD_pg * pg)
HYDU_FUNC_ENTER();
HYDU_MALLOC_OR_JUMP(MPIR_proctable, struct MPIR_PROCDESC *,
- pg->pg_process_count * sizeof(struct MPIR_PROCDESC), status);
+ pg->pg_process_count * sizeof(struct MPIR_PROCDESC), status);
round = 0;
/* We need to allocate the MPIR_proctable in COMM_WORLD rank
diff --git a/src/pm/hydra/tools/demux/demux.c b/src/pm/hydra/tools/demux/demux.c
index 3206742..fb5339d 100644
--- a/src/pm/hydra/tools/demux/demux.c
+++ b/src/pm/hydra/tools/demux/demux.c
@@ -106,7 +106,8 @@ HYD_status HYDT_dmx_register_fd(int num_fds, int *fd, HYD_event_t events, void *
}
#endif /* HAVE_ERROR_CHECKING */
- HYDU_MALLOC_OR_JUMP(cb_element, struct HYDT_dmxu_callback *, sizeof(struct HYDT_dmxu_callback), status);
+ HYDU_MALLOC_OR_JUMP(cb_element, struct HYDT_dmxu_callback *, sizeof(struct HYDT_dmxu_callback),
+ status);
cb_element->num_fds = num_fds;
HYDU_MALLOC_OR_JUMP(cb_element->fd, int *, num_fds * sizeof(int), status);
memcpy(cb_element->fd, fd, num_fds * sizeof(int));
diff --git a/src/pm/hydra/tools/demux/demux_poll.c b/src/pm/hydra/tools/demux/demux_poll.c
index 1f15ce5..b0e4fe1 100644
--- a/src/pm/hydra/tools/demux/demux_poll.c
+++ b/src/pm/hydra/tools/demux/demux_poll.c
@@ -15,7 +15,8 @@ HYD_status HYDT_dmxu_poll_wait_for_event(int wtime)
HYDU_FUNC_ENTER();
- HYDU_MALLOC_OR_JUMP(pollfds, struct pollfd *, HYDT_dmxu_num_cb_fds * sizeof(struct pollfd), status);
+ HYDU_MALLOC_OR_JUMP(pollfds, struct pollfd *, HYDT_dmxu_num_cb_fds * sizeof(struct pollfd),
+ status);
for (i = 0, run = HYDT_dmxu_cb_list; run; run = run->next) {
for (j = 0; j < run->num_fds; j++) {
diff --git a/src/pm/hydra/tools/nameserver/hydra_nameserver.c b/src/pm/hydra/tools/nameserver/hydra_nameserver.c
index 5179483..487929d 100644
--- a/src/pm/hydra/tools/nameserver/hydra_nameserver.c
+++ b/src/pm/hydra/tools/nameserver/hydra_nameserver.c
@@ -148,7 +148,8 @@ static HYD_status request_cb(int fd, HYD_event_t events, void *userp)
HYDU_ASSERT(!closed, status);
if (!strcmp(cmd, "PUBLISH")) {
- HYDU_MALLOC_OR_JUMP(publish, struct HYDT_ns_publish *, sizeof(struct HYDT_ns_publish), status);
+ HYDU_MALLOC_OR_JUMP(publish, struct HYDT_ns_publish *, sizeof(struct HYDT_ns_publish),
+ status);
status = HYDU_sock_read(fd, &len, sizeof(int), &recvd, &closed, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "error reading data\n");
diff --git a/src/pm/hydra/tools/topo/hwloc/topo_hwloc.c b/src/pm/hydra/tools/topo/hwloc/topo_hwloc.c
index 4ba91b2..013f1e7 100644
--- a/src/pm/hydra/tools/topo/hwloc/topo_hwloc.c
+++ b/src/pm/hydra/tools/topo/hwloc/topo_hwloc.c
@@ -63,7 +63,7 @@ static HYD_status handle_user_binding(const char *binding)
/* initialize bitmaps */
HYDU_MALLOC_OR_JUMP(HYDT_topo_hwloc_info.bitmap, hwloc_bitmap_t *,
- num_bind_entries * sizeof(hwloc_bitmap_t), status);
+ num_bind_entries * sizeof(hwloc_bitmap_t), status);
for (i = 0; i < num_bind_entries; i++) {
HYDT_topo_hwloc_info.bitmap[i] = hwloc_bitmap_alloc();
@@ -106,7 +106,7 @@ static HYD_status handle_rr_binding(void)
HYDT_topo_hwloc_info.num_bitmaps = hwloc_get_nbobjs_by_type(topology, HWLOC_OBJ_PU);
HYDU_MALLOC_OR_JUMP(HYDT_topo_hwloc_info.bitmap, hwloc_bitmap_t *,
- HYDT_topo_hwloc_info.num_bitmaps * sizeof(hwloc_bitmap_t), status);
+ HYDT_topo_hwloc_info.num_bitmaps * sizeof(hwloc_bitmap_t), status);
for (i = 0; i < HYDT_topo_hwloc_info.num_bitmaps; i++) {
HYDT_topo_hwloc_info.bitmap[i] = hwloc_bitmap_alloc();
@@ -271,7 +271,8 @@ static HYD_status handle_bitmap_binding(const char *binding, const char *mapping
total_map_domains = (i * total_map_objs) / map_count;
/* initialize the map domains */
- HYDU_MALLOC_OR_JUMP(map_domains, hwloc_bitmap_t *, total_map_domains * sizeof(hwloc_bitmap_t), status);
+ HYDU_MALLOC_OR_JUMP(map_domains, hwloc_bitmap_t *, total_map_domains * sizeof(hwloc_bitmap_t),
+ status);
HYDU_MALLOC_OR_JUMP(start_pu, hwloc_obj_t *, total_map_domains * sizeof(hwloc_obj_t), status);
/* For each map domain, find the next map object (first map object
@@ -320,7 +321,7 @@ static HYD_status handle_bitmap_binding(const char *binding, const char *mapping
/* initialize bitmaps */
HYDU_MALLOC_OR_JUMP(HYDT_topo_hwloc_info.bitmap, hwloc_bitmap_t *,
- HYDT_topo_hwloc_info.num_bitmaps * sizeof(hwloc_bitmap_t), status);
+ HYDT_topo_hwloc_info.num_bitmaps * sizeof(hwloc_bitmap_t), status);
for (i = 0; i < HYDT_topo_hwloc_info.num_bitmaps; i++) {
HYDT_topo_hwloc_info.bitmap[i] = hwloc_bitmap_alloc();
@@ -479,11 +480,11 @@ HYD_status HYDT_topo_hwloc_bind(int idx)
}
}
- fn_exit:
+ fn_exit:
HYDU_FUNC_EXIT();
return status;
- fn_fail:
+ fn_fail:
goto fn_exit;
}
diff --git a/src/pm/hydra/ui/mpich/utils.c b/src/pm/hydra/ui/mpich/utils.c
index f9f2df4..9e18a75 100644
--- a/src/pm/hydra/ui/mpich/utils.c
+++ b/src/pm/hydra/ui/mpich/utils.c
@@ -48,7 +48,8 @@ static HYD_status get_current_exec(struct HYD_exec **exec)
static void help_help_fn(void)
{
printf("\n");
- printf("Usage: ./mpiexec [global opts] [local opts for exec1] [exec1] [exec1 args] : [local opts for exec2] [exec2] [exec2 args] : ...\n\n");
+ printf
+ ("Usage: ./mpiexec [global opts] [local opts for exec1] [exec1] [exec1 args] : [local opts for exec2] [exec2] [exec2 args] : ...\n\n");
printf("Global options (passed to all executables):\n");
@@ -359,7 +360,7 @@ static void hostlist_help_fn(void)
static HYD_status hostlist_fn(char *arg, char ***argv)
{
- char *hostlist[HYD_NUM_TMP_STRINGS+1]; /* +1 for null termination of list */
+ char *hostlist[HYD_NUM_TMP_STRINGS + 1]; /* +1 for null termination of list */
int count = 0;
HYD_status status = HYD_SUCCESS;
diff --git a/src/pm/hydra/utils/dbg/dbg.c b/src/pm/hydra/utils/dbg/dbg.c
index 7180d3f..09fd51a 100644
--- a/src/pm/hydra/utils/dbg/dbg.c
+++ b/src/pm/hydra/utils/dbg/dbg.c
@@ -14,7 +14,7 @@ HYD_status HYDU_dbg_init(const char *str)
HYD_status status = HYD_SUCCESS;
#ifdef USE_MEMORY_TRACING
- MPL_trinit(0,0);
+ MPL_trinit(0, 0);
#endif
if (gethostname(hostname, MAX_HOSTNAME_LEN) < 0)
diff --git a/src/pm/hydra/utils/launch/launch.c b/src/pm/hydra/utils/launch/launch.c
index 6b311ef..0b5f6f5 100644
--- a/src/pm/hydra/utils/launch/launch.c
+++ b/src/pm/hydra/utils/launch/launch.c
@@ -71,8 +71,7 @@ HYD_status HYDU_create_process(char **client_arg, struct HYD_env *env_list,
/* The child process should never get back to the proxy
* code; if there is an error, just throw it here and
* exit. */
- HYDU_error_printf("execvp error on file %s (%s)\n", client_arg[0],
- MPL_strerror(errno));
+ HYDU_error_printf("execvp error on file %s (%s)\n", client_arg[0], MPL_strerror(errno));
exit(-1);
}
}
diff --git a/src/pm/hydra/utils/sock/sock.c b/src/pm/hydra/utils/sock/sock.c
index d3f91cc..fb40caf 100644
--- a/src/pm/hydra/utils/sock/sock.c
+++ b/src/pm/hydra/utils/sock/sock.c
@@ -475,7 +475,7 @@ HYD_status HYDU_sock_get_iface_ip(char *iface, char **ip)
sa = (struct sockaddr_in *) ifa->ifa_addr;
#if defined HAVE_INET_NTOP
(*ip) = MPL_strdup((char *)
- inet_ntop(AF_INET, (const void *) &(sa->sin_addr), buf, MAX_HOSTNAME_LEN));
+ inet_ntop(AF_INET, (const void *) &(sa->sin_addr), buf, MAX_HOSTNAME_LEN));
#else
(*ip) = NULL;
#endif /* HAVE_INET_NTOP */
@@ -554,7 +554,7 @@ HYD_status HYDU_sock_is_local(char *host, int *is_local)
/* Find the IP address of the host */
host_ip = MPL_strdup((char *) inet_ntop(AF_INET, (const void *) &sa.sin_addr, buf,
- MAX_HOSTNAME_LEN));
+ MAX_HOSTNAME_LEN));
HYDU_ASSERT(host_ip, status);
}
@@ -570,7 +570,7 @@ HYD_status HYDU_sock_is_local(char *host, int *is_local)
/* Find the IP address of the host */
lhost_ip = MPL_strdup((char *) inet_ntop(AF_INET, (const void *) &sa.sin_addr, buf,
- MAX_HOSTNAME_LEN));
+ MAX_HOSTNAME_LEN));
HYDU_ASSERT(lhost_ip, status);
/* See if the IP address of the hostname we got matches the IP
@@ -595,8 +595,8 @@ HYD_status HYDU_sock_is_local(char *host, int *is_local)
struct sockaddr_in *sa_ptr = (struct sockaddr_in *) ifa->ifa_addr;
lhost_ip = MPL_strdup((char *)
- inet_ntop(AF_INET, (const void *) &(sa_ptr->sin_addr), buf,
- MAX_HOSTNAME_LEN));
+ inet_ntop(AF_INET, (const void *) &(sa_ptr->sin_addr), buf,
+ MAX_HOSTNAME_LEN));
HYDU_ASSERT(lhost_ip, status);
/* For each local IP address, see if it matches the "host"
http://git.mpich.org/mpich.git/commitdiff/09f7baeb7886aac7a1fb8840437a994751292271
commit 09f7baeb7886aac7a1fb8840437a994751292271
Author: Ken Raffenetti <raffenet at mcs.anl.gov>
Date: Fri Jan 29 16:13:17 2016 -0600
pm/hydra: use MPL_strerror
Signed-off-by: Pavan Balaji <balaji at anl.gov>
diff --git a/src/pm/hydra/configure.ac b/src/pm/hydra/configure.ac
index f5961fc..89e2812 100644
--- a/src/pm/hydra/configure.ac
+++ b/src/pm/hydra/configure.ac
@@ -195,7 +195,7 @@ AC_SEARCH_LIBS(hstrerror, resolv,)
# Check for necessary functions
AC_CHECK_FUNCS(gettimeofday time sigaction signal usleep alloca unsetenv \
- strerror strsignal stat fcntl alarm isatty inet_ntop getpgid \
+ strsignal stat fcntl alarm isatty inet_ntop getpgid \
setsid killpg hstrerror)
if test "$ac_cv_func_hstrerror" = "yes" ; then
diff --git a/src/pm/hydra/include/hydra.h b/src/pm/hydra/include/hydra.h
index bb9a6eb..6af5fa6 100644
--- a/src/pm/hydra/include/hydra.h
+++ b/src/pm/hydra/include/hydra.h
@@ -643,12 +643,6 @@ char *HYDU_size_t_to_str(size_t x);
char *HYDU_int_to_str(int x);
char *HYDU_int_to_str_pad(int x, int maxlen);
-#if defined HAVE_STRERROR
-#define HYDU_strerror strerror
-#else
-#define HYDU_strerror HYDU_int_to_str
-#endif /* HAVE_STRERROR */
-
#if defined HAVE_HERROR
#define HYDU_herror herror
#else
diff --git a/src/pm/hydra/pm/pmiserv/pmip_cb.c b/src/pm/hydra/pm/pmiserv/pmip_cb.c
index 157bc9d..b47f204 100644
--- a/src/pm/hydra/pm/pmiserv/pmip_cb.c
+++ b/src/pm/hydra/pm/pmiserv/pmip_cb.c
@@ -640,7 +640,7 @@ static HYD_status launch_procs(void)
if (exec->wdir && chdir(exec->wdir) < 0)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
"unable to change wdir to %s (%s)\n", exec->wdir,
- HYDU_strerror(errno));
+ MPL_strerror(errno));
for (i = 0; i < exec->proc_count; i++) {
if (using_pmi_port) {
diff --git a/src/pm/hydra/tools/demux/demux_poll.c b/src/pm/hydra/tools/demux/demux_poll.c
index 0a762aa..1f15ce5 100644
--- a/src/pm/hydra/tools/demux/demux_poll.c
+++ b/src/pm/hydra/tools/demux/demux_poll.c
@@ -45,7 +45,7 @@ HYD_status HYDT_dmxu_poll_wait_for_event(int wtime)
status = HYD_SUCCESS;
goto fn_exit;
}
- HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "poll error (%s)\n", HYDU_strerror(errno));
+ HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "poll error (%s)\n", MPL_strerror(errno));
}
work_done = 0;
diff --git a/src/pm/hydra/tools/demux/demux_select.c b/src/pm/hydra/tools/demux/demux_select.c
index de875ac..bf4ff6e 100644
--- a/src/pm/hydra/tools/demux/demux_select.c
+++ b/src/pm/hydra/tools/demux/demux_select.c
@@ -51,7 +51,7 @@ HYD_status HYDT_dmxu_select_wait_for_event(int wtime)
status = HYD_SUCCESS;
goto fn_exit;
}
- HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "select error (%s)\n", HYDU_strerror(errno));
+ HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "select error (%s)\n", MPL_strerror(errno));
}
work_done = 0;
diff --git a/src/pm/hydra/utils/launch/launch.c b/src/pm/hydra/utils/launch/launch.c
index a6bae46..6b311ef 100644
--- a/src/pm/hydra/utils/launch/launch.c
+++ b/src/pm/hydra/utils/launch/launch.c
@@ -16,13 +16,13 @@ HYD_status HYDU_create_process(char **client_arg, struct HYD_env *env_list,
HYDU_FUNC_ENTER();
if (in && (pipe(inpipe) < 0))
- HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "pipe error (%s)\n", HYDU_strerror(errno));
+ HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "pipe error (%s)\n", MPL_strerror(errno));
if (out && (pipe(outpipe) < 0))
- HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "pipe error (%s)\n", HYDU_strerror(errno));
+ HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "pipe error (%s)\n", MPL_strerror(errno));
if (err && (pipe(errpipe) < 0))
- HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "pipe error (%s)\n", HYDU_strerror(errno));
+ HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "pipe error (%s)\n", MPL_strerror(errno));
/* Fork off the process */
tpid = fork();
@@ -37,7 +37,7 @@ HYD_status HYDU_create_process(char **client_arg, struct HYD_env *env_list,
close(inpipe[1]);
if (inpipe[0] != STDIN_FILENO && dup2(inpipe[0], STDIN_FILENO) < 0)
HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "dup2 error (%s)\n",
- HYDU_strerror(errno));
+ MPL_strerror(errno));
}
close(STDOUT_FILENO);
@@ -45,7 +45,7 @@ HYD_status HYDU_create_process(char **client_arg, struct HYD_env *env_list,
close(outpipe[0]);
if (outpipe[1] != STDOUT_FILENO && dup2(outpipe[1], STDOUT_FILENO) < 0)
HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "dup2 error (%s)\n",
- HYDU_strerror(errno));
+ MPL_strerror(errno));
}
close(STDERR_FILENO);
@@ -53,7 +53,7 @@ HYD_status HYDU_create_process(char **client_arg, struct HYD_env *env_list,
close(errpipe[0]);
if (errpipe[1] != STDERR_FILENO && dup2(errpipe[1], STDERR_FILENO) < 0)
HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "dup2 error (%s)\n",
- HYDU_strerror(errno));
+ MPL_strerror(errno));
}
/* Forced environment overwrites existing environment */
@@ -72,7 +72,7 @@ HYD_status HYDU_create_process(char **client_arg, struct HYD_env *env_list,
* code; if there is an error, just throw it here and
* exit. */
HYDU_error_printf("execvp error on file %s (%s)\n", client_arg[0],
- HYDU_strerror(errno));
+ MPL_strerror(errno));
exit(-1);
}
}
diff --git a/src/pm/hydra/utils/sock/sock.c b/src/pm/hydra/utils/sock/sock.c
index 7f8a2a6..d3f91cc 100644
--- a/src/pm/hydra/utils/sock/sock.c
+++ b/src/pm/hydra/utils/sock/sock.c
@@ -58,7 +58,7 @@ HYD_status HYDU_sock_listen(int *listen_fd, char *port_range, uint16_t * port)
*listen_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (*listen_fd < 0)
HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "cannot open socket (%s)\n",
- HYDU_strerror(errno));
+ MPL_strerror(errno));
if (setsockopt(*listen_fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(int)) < 0)
HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "cannot set TCP_NODELAY\n");
@@ -82,7 +82,7 @@ HYD_status HYDU_sock_listen(int *listen_fd, char *port_range, uint16_t * port)
* port. Otherwise, it's an error. */
if (errno != EADDRINUSE)
HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "bind error (%s)\n",
- HYDU_strerror(errno));
+ MPL_strerror(errno));
}
else /* We got a port */
break;
@@ -93,7 +93,7 @@ HYD_status HYDU_sock_listen(int *listen_fd, char *port_range, uint16_t * port)
HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "no port to bind\n");
if (listen(*listen_fd, SOMAXCONN) < 0)
- HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "listen error (%s)\n", HYDU_strerror(errno));
+ HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "listen error (%s)\n", MPL_strerror(errno));
/* We asked for any port, so we need to find out which port we
* actually got. */
@@ -102,7 +102,7 @@ HYD_status HYDU_sock_listen(int *listen_fd, char *port_range, uint16_t * port)
if (getsockname(*listen_fd, (struct sockaddr *) &sa, &sinlen) < 0)
HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "getsockname error (%s)\n",
- HYDU_strerror(errno));
+ MPL_strerror(errno));
*port = ntohs(sa.sin_port);
}
@@ -142,7 +142,7 @@ HYD_status HYDU_sock_connect(const char *host, uint16_t port, int *fd, int retri
*fd = socket(AF_INET, SOCK_STREAM, 0);
if (*fd < 0)
HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "cannot open socket (%s)\n",
- HYDU_strerror(errno));
+ MPL_strerror(errno));
/* Not being able to connect is not an error in all cases. So we
* return an error, but only print a warning message. The upper
@@ -169,7 +169,7 @@ HYD_status HYDU_sock_connect(const char *host, uint16_t port, int *fd, int retri
HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR,
"unable to connect from \"%s\" to \"%s\" (%s)\n",
- localhost, host, HYDU_strerror(errno));
+ localhost, host, MPL_strerror(errno));
}
/* Disable nagle */
@@ -194,7 +194,7 @@ HYD_status HYDU_sock_accept(int listen_fd, int *fd)
*fd = accept(listen_fd, 0, 0);
if (*fd < 0)
- HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "accept error (%s)\n", HYDU_strerror(errno));
+ HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "accept error (%s)\n", MPL_strerror(errno));
/* Disable nagle */
if (setsockopt(*fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(int)) < 0)
@@ -236,7 +236,7 @@ HYD_status HYDU_sock_read(int fd, void *buf, int maxlen, int *recvd, int *closed
} while (tmp < 0 && errno == EINTR);
if (tmp < 0) {
- HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "read error (%s)\n", HYDU_strerror(errno));
+ HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "read error (%s)\n", MPL_strerror(errno));
}
else if (tmp == 0) {
*closed = 1;
@@ -283,7 +283,7 @@ HYD_status HYDU_sock_write(int fd, const void *buf, int maxlen, int *sent, int *
*closed = 1;
goto fn_exit;
}
- HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "write error (%s)\n", HYDU_strerror(errno));
+ HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "write error (%s)\n", MPL_strerror(errno));
}
else {
*sent += tmp;
http://git.mpich.org/mpich.git/commitdiff/743ff1e52d7f5cba8891cad03635bc9d43bb106e
commit 743ff1e52d7f5cba8891cad03635bc9d43bb106e
Author: Ken Raffenetti <raffenet at mcs.anl.gov>
Date: Fri Feb 5 13:42:00 2016 -0600
pm/hydra: rename memory allocation macros
Hydra provides macros HYDU_MALLOC and HYDU_REALLOC for memory allocation
with error checking. We add an _OR_JUMP suffix to these macros to better
indicate their function. HYDU_FREE is removed, as it did not add
anything to the underlying MPL_free call.
Signed-off-by: Pavan Balaji <balaji at anl.gov>
diff --git a/src/pm/hydra/include/hydra.h b/src/pm/hydra/include/hydra.h
index 3338af1..bb9a6eb 100644
--- a/src/pm/hydra/include/hydra.h
+++ b/src/pm/hydra/include/hydra.h
@@ -148,7 +148,7 @@ extern char *HYD_dbg_prefix;
else if (!strcasecmp((x), "none") || !strcasecmp((x), "no") || \
!strcasecmp((x), "dummy") || !strcasecmp((x), "null") || \
!strcasecmp((x), "nil") || !strcasecmp((x), "false")) { \
- HYDU_FREE((x)); \
+ MPL_free((x)); \
(x) = NULL; \
} \
}
@@ -193,7 +193,7 @@ struct HYD_string_stash {
#define HYD_STRING_STASH(stash, str, status) \
do { \
if ((stash).cur_count >= (stash).max_count - 1) { \
- HYDU_REALLOC((stash).strlist, char **, \
+ HYDU_REALLOC_OR_JUMP((stash).strlist, char **, \
((stash).max_count + HYD_NUM_TMP_STRINGS) * sizeof(char *), \
(status)); \
(stash).max_count += HYD_NUM_TMP_STRINGS; \
@@ -211,7 +211,7 @@ struct HYD_string_stash {
(status) = HYDU_str_alloc_and_join((stash).strlist, &(str)); \
HYDU_ERR_POP((status), "unable to join strings\n"); \
HYDU_free_strlist((stash).strlist); \
- HYDU_FREE((stash).strlist); \
+ MPL_free((stash).strlist); \
HYD_STRING_STASH_INIT((stash)); \
} \
} while (0)
@@ -221,7 +221,7 @@ struct HYD_string_stash {
if ((stash).strlist == NULL) \
break; \
HYDU_free_strlist((stash).strlist); \
- HYDU_FREE((stash).strlist); \
+ MPL_free((stash).strlist); \
(stash).max_count = 0; \
(stash).cur_count = 0; \
} while (0)
@@ -612,7 +612,7 @@ HYD_status HYDU_sock_cloexec(int fd);
/* Memory utilities */
#include <ctype.h>
-#define HYDU_MALLOC(p, type, size, status) \
+#define HYDU_MALLOC_OR_JUMP(p, type, size, status) \
{ \
(p) = NULL; /* initialize p in case assert fails */ \
HYDU_ASSERT(size, status); \
@@ -623,7 +623,7 @@ HYD_status HYDU_sock_cloexec(int fd);
(int) (size)); \
}
-#define HYDU_REALLOC(p, type, size, status) \
+#define HYDU_REALLOC_OR_JUMP(p, type, size, status) \
{ \
HYDU_ASSERT(size, status); \
(p) = (type) MPL_realloc((p),(size)); \
@@ -633,11 +633,6 @@ HYD_status HYDU_sock_cloexec(int fd);
(int) (size)); \
}
-#define HYDU_FREE(p) \
- { \
- MPL_free((void *) p); \
- }
-
HYD_status HYDU_list_append_strlist(char **exec, char **client_arg);
HYD_status HYDU_print_strlist(char **args);
void HYDU_free_strlist(char **args);
diff --git a/src/pm/hydra/pm/pmiserv/common.c b/src/pm/hydra/pm/pmiserv/common.c
index 72d3f87..fceb081 100644
--- a/src/pm/hydra/pm/pmiserv/common.c
+++ b/src/pm/hydra/pm/pmiserv/common.c
@@ -57,9 +57,9 @@ HYD_status HYD_pmcd_pmi_parse_pmi_cmd(char *obuf, int pmi_version, char **pmi_cm
HYDU_ERR_POP(status, "string split returned error\n");
fn_exit:
- HYDU_FREE(buf);
+ MPL_free(buf);
if (str1)
- HYDU_FREE(str1);
+ MPL_free(str1);
HYDU_FUNC_EXIT();
return status;
@@ -75,7 +75,7 @@ HYD_status HYD_pmcd_pmi_args_to_tokens(char *args[], struct HYD_pmcd_token **tok
for (i = 0; args[i]; i++);
*count = i;
- HYDU_MALLOC(*tokens, struct HYD_pmcd_token *, *count * sizeof(struct HYD_pmcd_token), status);
+ HYDU_MALLOC_OR_JUMP(*tokens, struct HYD_pmcd_token *, *count * sizeof(struct HYD_pmcd_token), status);
for (i = 0; args[i]; i++) {
arg = MPL_strdup(args[i]);
@@ -102,8 +102,8 @@ void HYD_pmcd_pmi_free_tokens(struct HYD_pmcd_token *tokens, int token_count)
int i;
for (i = 0; i < token_count; i++)
- HYDU_FREE(tokens[i].key);
- HYDU_FREE(tokens);
+ MPL_free(tokens[i].key);
+ MPL_free(tokens);
}
char *HYD_pmcd_pmi_find_token_keyval(struct HYD_pmcd_token *tokens, int count, const char *key)
@@ -124,7 +124,7 @@ HYD_status HYD_pmcd_pmi_allocate_kvs(struct HYD_pmcd_pmi_kvs ** kvs, int pgid)
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*kvs, struct HYD_pmcd_pmi_kvs *, sizeof(struct HYD_pmcd_pmi_kvs), status);
+ HYDU_MALLOC_OR_JUMP(*kvs, struct HYD_pmcd_pmi_kvs *, sizeof(struct HYD_pmcd_pmi_kvs), status);
MPL_snprintf((*kvs)->kvsname, PMI_MAXKVSLEN, "kvs_%d_%d", (int) getpid(), pgid);
(*kvs)->key_pair = NULL;
@@ -145,10 +145,10 @@ void HYD_pmcd_free_pmi_kvs_list(struct HYD_pmcd_pmi_kvs *kvs_list)
key_pair = kvs_list->key_pair;
while (key_pair) {
tmp = key_pair->next;
- HYDU_FREE(key_pair);
+ MPL_free(key_pair);
key_pair = tmp;
}
- HYDU_FREE(kvs_list);
+ MPL_free(kvs_list);
HYDU_FUNC_EXIT();
}
@@ -160,7 +160,7 @@ HYD_status HYD_pmcd_pmi_add_kvs(const char *key, char *val, struct HYD_pmcd_pmi_
HYDU_FUNC_ENTER();
- HYDU_MALLOC(key_pair, struct HYD_pmcd_pmi_kvs_pair *, sizeof(struct HYD_pmcd_pmi_kvs_pair),
+ HYDU_MALLOC_OR_JUMP(key_pair, struct HYD_pmcd_pmi_kvs_pair *, sizeof(struct HYD_pmcd_pmi_kvs_pair),
status);
MPL_snprintf(key_pair->key, PMI_MAXKEYLEN, "%s", key);
MPL_snprintf(key_pair->val, PMI_MAXVALLEN, "%s", val);
@@ -189,6 +189,6 @@ HYD_status HYD_pmcd_pmi_add_kvs(const char *key, char *val, struct HYD_pmcd_pmi_
return status;
fn_fail:
- HYDU_FREE(key_pair);
+ MPL_free(key_pair);
goto fn_exit;
}
diff --git a/src/pm/hydra/pm/pmiserv/pmi_v2_common.c b/src/pm/hydra/pm/pmiserv/pmi_v2_common.c
index 49739f2..9a545ab 100644
--- a/src/pm/hydra/pm/pmiserv/pmi_v2_common.c
+++ b/src/pm/hydra/pm/pmiserv/pmi_v2_common.c
@@ -15,7 +15,7 @@ HYD_status HYD_pmcd_pmi_v2_queue_req(int fd, int pid, int pgid, char *args[], ch
struct HYD_pmcd_pmi_v2_reqs *req, *tmp;
HYD_status status = HYD_SUCCESS;
- HYDU_MALLOC(req, struct HYD_pmcd_pmi_v2_reqs *, sizeof(struct HYD_pmcd_pmi_v2_reqs), status);
+ HYDU_MALLOC_OR_JUMP(req, struct HYD_pmcd_pmi_v2_reqs *, sizeof(struct HYD_pmcd_pmi_v2_reqs), status);
req->fd = fd;
req->pid = pid;
req->pgid = pgid;
diff --git a/src/pm/hydra/pm/pmiserv/pmip.c b/src/pm/hydra/pm/pmiserv/pmip.c
index 825569c..70d31d0 100644
--- a/src/pm/hydra/pm/pmiserv/pmip.c
+++ b/src/pm/hydra/pm/pmiserv/pmip.c
@@ -67,54 +67,54 @@ static void cleanup_params(void)
/* System global */
if (HYD_pmcd_pmip.system_global.pmi_fd)
- HYDU_FREE(HYD_pmcd_pmip.system_global.pmi_fd);
+ MPL_free(HYD_pmcd_pmip.system_global.pmi_fd);
if (HYD_pmcd_pmip.system_global.pmi_process_mapping)
- HYDU_FREE(HYD_pmcd_pmip.system_global.pmi_process_mapping);
+ MPL_free(HYD_pmcd_pmip.system_global.pmi_process_mapping);
/* Upstream */
if (HYD_pmcd_pmip.upstream.server_name)
- HYDU_FREE(HYD_pmcd_pmip.upstream.server_name);
+ MPL_free(HYD_pmcd_pmip.upstream.server_name);
/* Downstream */
if (HYD_pmcd_pmip.downstream.out)
- HYDU_FREE(HYD_pmcd_pmip.downstream.out);
+ MPL_free(HYD_pmcd_pmip.downstream.out);
if (HYD_pmcd_pmip.downstream.err)
- HYDU_FREE(HYD_pmcd_pmip.downstream.err);
+ MPL_free(HYD_pmcd_pmip.downstream.err);
if (HYD_pmcd_pmip.downstream.pid)
- HYDU_FREE(HYD_pmcd_pmip.downstream.pid);
+ MPL_free(HYD_pmcd_pmip.downstream.pid);
if (HYD_pmcd_pmip.downstream.exit_status)
- HYDU_FREE(HYD_pmcd_pmip.downstream.exit_status);
+ MPL_free(HYD_pmcd_pmip.downstream.exit_status);
if (HYD_pmcd_pmip.downstream.pmi_rank)
- HYDU_FREE(HYD_pmcd_pmip.downstream.pmi_rank);
+ MPL_free(HYD_pmcd_pmip.downstream.pmi_rank);
if (HYD_pmcd_pmip.downstream.pmi_fd)
- HYDU_FREE(HYD_pmcd_pmip.downstream.pmi_fd);
+ MPL_free(HYD_pmcd_pmip.downstream.pmi_fd);
if (HYD_pmcd_pmip.downstream.pmi_fd_active)
- HYDU_FREE(HYD_pmcd_pmip.downstream.pmi_fd_active);
+ MPL_free(HYD_pmcd_pmip.downstream.pmi_fd_active);
/* Local */
if (HYD_pmcd_pmip.local.iface_ip_env_name)
- HYDU_FREE(HYD_pmcd_pmip.local.iface_ip_env_name);
+ MPL_free(HYD_pmcd_pmip.local.iface_ip_env_name);
if (HYD_pmcd_pmip.local.hostname)
- HYDU_FREE(HYD_pmcd_pmip.local.hostname);
+ MPL_free(HYD_pmcd_pmip.local.hostname);
if (HYD_pmcd_pmip.local.spawner_kvsname)
- HYDU_FREE(HYD_pmcd_pmip.local.spawner_kvsname);
+ MPL_free(HYD_pmcd_pmip.local.spawner_kvsname);
if (HYD_pmcd_pmip.local.ckpoint_prefix_list) {
for (i = 0; HYD_pmcd_pmip.local.ckpoint_prefix_list[i]; i++)
- HYDU_FREE(HYD_pmcd_pmip.local.ckpoint_prefix_list[i]);
- HYDU_FREE(HYD_pmcd_pmip.local.ckpoint_prefix_list);
+ MPL_free(HYD_pmcd_pmip.local.ckpoint_prefix_list[i]);
+ MPL_free(HYD_pmcd_pmip.local.ckpoint_prefix_list);
}
HYD_pmcd_free_pmi_kvs_list(HYD_pmcd_pmip.local.kvs);
diff --git a/src/pm/hydra/pm/pmiserv/pmip_cb.c b/src/pm/hydra/pm/pmiserv/pmip_cb.c
index 63be106..157bc9d 100644
--- a/src/pm/hydra/pm/pmiserv/pmip_cb.c
+++ b/src/pm/hydra/pm/pmiserv/pmip_cb.c
@@ -168,7 +168,7 @@ static HYD_status check_pmi_cmd(char **buf, int *pmi_version, int *repeat)
if (full_command) {
/* We have a full command */
buflen = bufptr - sptr + 1;
- HYDU_MALLOC(*buf, char *, buflen, status);
+ HYDU_MALLOC_OR_JUMP(*buf, char *, buflen, status);
memcpy(*buf, sptr, buflen);
sptr += buflen;
pmi_storage_len -= buflen;
@@ -304,7 +304,7 @@ static HYD_status pmi_cb(int fd, HYD_event_t events, void *userp)
else
HYD_pmcd_pmip_pmi_handle = HYD_pmcd_pmip_pmi_v2;
- HYDU_MALLOC(args, char **, MAX_PMI_ARGS * sizeof(char *), status);
+ HYDU_MALLOC_OR_JUMP(args, char **, MAX_PMI_ARGS * sizeof(char *), status);
for(i = 0;i < MAX_PMI_ARGS; i++)
args[i]= NULL;
@@ -353,13 +353,13 @@ static HYD_status pmi_cb(int fd, HYD_event_t events, void *userp)
fn_exit:
if (pmi_cmd)
- HYDU_FREE(pmi_cmd);
+ MPL_free(pmi_cmd);
if (args) {
HYDU_free_strlist(args);
MPL_free(args);
}
if (buf)
- HYDU_FREE(buf);
+ MPL_free(buf);
HYDU_FUNC_EXIT();
return status;
@@ -376,7 +376,7 @@ static HYD_status handle_pmi_response(int fd, struct HYD_pmcd_hdr hdr)
HYDU_FUNC_ENTER();
- HYDU_MALLOC(buf, char *, hdr.buflen + 1, status);
+ HYDU_MALLOC_OR_JUMP(buf, char *, hdr.buflen + 1, status);
status = HYDU_sock_read(fd, buf, hdr.buflen, &count, &closed, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "unable to read PMI response from proxy\n");
@@ -384,7 +384,7 @@ static HYD_status handle_pmi_response(int fd, struct HYD_pmcd_hdr hdr)
buf[hdr.buflen] = 0;
- HYDU_MALLOC(args, char **, MAX_PMI_INTERNAL_ARGS * sizeof(char *), status);
+ HYDU_MALLOC_OR_JUMP(args, char **, MAX_PMI_INTERNAL_ARGS * sizeof(char *), status);
for (i = 0; i < MAX_PMI_INTERNAL_ARGS; i++)
args[i] = NULL;
@@ -417,13 +417,13 @@ static HYD_status handle_pmi_response(int fd, struct HYD_pmcd_hdr hdr)
fn_exit:
if (pmi_cmd)
- HYDU_FREE(pmi_cmd);
+ MPL_free(pmi_cmd);
if (args) {
HYDU_free_strlist(args);
MPL_free(args);
}
if (buf)
- HYDU_FREE(buf);
+ MPL_free(buf);
HYDU_FUNC_EXIT();
return status;
@@ -488,19 +488,19 @@ static HYD_status launch_procs(void)
for (exec = HYD_pmcd_pmip.exec_list; exec; exec = exec->next)
HYD_pmcd_pmip.local.proxy_process_count += exec->proc_count;
- HYDU_MALLOC(HYD_pmcd_pmip.downstream.out, int *,
+ HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.downstream.out, int *,
HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
- HYDU_MALLOC(HYD_pmcd_pmip.downstream.err, int *,
+ HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.downstream.err, int *,
HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
- HYDU_MALLOC(HYD_pmcd_pmip.downstream.pid, int *,
+ HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.downstream.pid, int *,
HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
- HYDU_MALLOC(HYD_pmcd_pmip.downstream.exit_status, int *,
+ HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.downstream.exit_status, int *,
HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
- HYDU_MALLOC(HYD_pmcd_pmip.downstream.pmi_rank, int *,
+ HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.downstream.pmi_rank, int *,
HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
- HYDU_MALLOC(HYD_pmcd_pmip.downstream.pmi_fd, int *,
+ HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.downstream.pmi_fd, int *,
HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
- HYDU_MALLOC(HYD_pmcd_pmip.downstream.pmi_fd_active, int *,
+ HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.downstream.pmi_fd_active, int *,
HYD_pmcd_pmip.local.proxy_process_count * sizeof(int), status);
/* Initialize the PMI_FD and PMI FD active state, and exit status */
@@ -654,14 +654,14 @@ static HYD_status launch_procs(void)
str = HYDU_int_to_str(HYD_pmcd_pmip.downstream.pmi_rank[process_id]);
status = HYDU_append_env_to_list("PMI_ID", str, &force_env);
HYDU_ERR_POP(status, "unable to add env to list\n");
- HYDU_FREE(str);
+ MPL_free(str);
}
else {
/* PMI_RANK */
str = HYDU_int_to_str(HYD_pmcd_pmip.downstream.pmi_rank[process_id]);
status = HYDU_append_env_to_list("PMI_RANK", str, &force_env);
HYDU_ERR_POP(status, "unable to add env to list\n");
- HYDU_FREE(str);
+ MPL_free(str);
if (socketpair(AF_UNIX, SOCK_STREAM, 0, pmi_fds) < 0)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "pipe error\n");
@@ -677,13 +677,13 @@ static HYD_status launch_procs(void)
status = HYDU_append_env_to_list("PMI_FD", str, &force_env);
HYDU_ERR_POP(status, "unable to add env to list\n");
- HYDU_FREE(str);
+ MPL_free(str);
/* PMI_SIZE */
str = HYDU_int_to_str(HYD_pmcd_pmip.system_global.global_process_count);
status = HYDU_append_env_to_list("PMI_SIZE", str, &force_env);
HYDU_ERR_POP(status, "unable to add env to list\n");
- HYDU_FREE(str);
+ MPL_free(str);
}
HYD_STRING_STASH_INIT(stash);
@@ -838,14 +838,14 @@ static HYD_status procinfo(int fd)
HYDU_ERR_POP(status, "error reading data from upstream\n");
HYDU_ASSERT(!closed, status);
- HYDU_MALLOC(arglist, char **, (num_strings + 1) * sizeof(char *), status);
+ HYDU_MALLOC_OR_JUMP(arglist, char **, (num_strings + 1) * sizeof(char *), status);
for (i = 0; i < num_strings; i++) {
status = HYDU_sock_read(fd, &str_len, sizeof(int), &recvd, &closed, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "error reading data from upstream\n");
HYDU_ASSERT(!closed, status);
- HYDU_MALLOC(arglist[i], char *, str_len, status);
+ HYDU_MALLOC_OR_JUMP(arglist[i], char *, str_len, status);
status = HYDU_sock_read(fd, arglist[i], str_len, &recvd, &closed, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "error reading data from upstream\n");
@@ -858,7 +858,7 @@ static HYD_status procinfo(int fd)
HYDU_ERR_POP(status, "unable to parse argument list\n");
HYDU_free_strlist(arglist);
- HYDU_FREE(arglist);
+ MPL_free(arglist);
/* Save this fd as we need to send back the exit status on
* this. */
@@ -915,7 +915,7 @@ HYD_status HYD_pmcd_pmip_control_cmd_cb(int fd, HYD_event_t events, void *userp)
int count;
if (hdr.buflen) {
- HYDU_MALLOC(buf, char *, hdr.buflen, status);
+ HYDU_MALLOC_OR_JUMP(buf, char *, hdr.buflen, status);
HYDU_ERR_POP(status, "unable to allocate memory\n");
status = HYDU_sock_read(fd, buf, hdr.buflen, &count, &closed, HYDU_SOCK_COMM_MSGWAIT);
@@ -923,7 +923,7 @@ HYD_status HYD_pmcd_pmip_control_cmd_cb(int fd, HYD_event_t events, void *userp)
HYDU_ASSERT(!closed, status);
if (HYD_pmcd_pmip.downstream.in == HYD_FD_CLOSED) {
- HYDU_FREE(buf);
+ MPL_free(buf);
goto fn_exit;
}
@@ -944,7 +944,7 @@ HYD_status HYD_pmcd_pmip_control_cmd_cb(int fd, HYD_event_t events, void *userp)
HYD_pmcd_pmip.downstream.in = HYD_FD_CLOSED;
}
- HYDU_FREE(buf);
+ MPL_free(buf);
}
else {
close(HYD_pmcd_pmip.downstream.in);
diff --git a/src/pm/hydra/pm/pmiserv/pmip_pmi_v1.c b/src/pm/hydra/pm/pmiserv/pmip_pmi_v1.c
index 9c9397b..452ec02 100644
--- a/src/pm/hydra/pm/pmiserv/pmip_pmi_v1.c
+++ b/src/pm/hydra/pm/pmiserv/pmip_pmi_v1.c
@@ -46,7 +46,7 @@ static HYD_status send_cmd_upstream(const char *start, int fd, int num_args, cha
/* We need two slots for each argument (one for the argument
* itself and one for a space character), one slot for the
* command, and one for the NULL character at the end. */
- HYDU_MALLOC(tmp, char **, (2 * num_args + 2) * sizeof(char *), status);
+ HYDU_MALLOC_OR_JUMP(tmp, char **, (2 * num_args + 2) * sizeof(char *), status);
j = 0;
tmp[j++] = MPL_strdup(start);
@@ -60,7 +60,7 @@ static HYD_status send_cmd_upstream(const char *start, int fd, int num_args, cha
status = HYDU_str_alloc_and_join(tmp, &buf);
HYDU_ERR_POP(status, "unable to join strings\n");
HYDU_free_strlist(tmp);
- HYDU_FREE(tmp);
+ MPL_free(tmp);
HYD_pmcd_init_header(&hdr);
hdr.cmd = PMI_CMD;
@@ -80,7 +80,7 @@ static HYD_status send_cmd_upstream(const char *start, int fd, int num_args, cha
HYDU_ERR_POP(status, "unable to send PMI command upstream\n");
HYDU_ASSERT(!closed, status);
- HYDU_FREE(buf);
+ MPL_free(buf);
fn_exit:
HYDU_FUNC_EXIT();
@@ -130,7 +130,7 @@ static HYD_status cache_put_flush(int fd)
HYDU_ERR_POP(status, "error sending command upstream\n");
for (i = 0; i < cache_put.keyval_len; i++)
- HYDU_FREE(cache_put.keyval[i]);
+ MPL_free(cache_put.keyval[i]);
cache_put.keyval_len = 0;
fn_exit:
@@ -165,7 +165,7 @@ static HYD_status fn_init(int fd, char *args[])
status = send_cmd_downstream(fd, tmp);
HYDU_ERR_POP(status, "error sending PMI response\n");
- HYDU_FREE(tmp);
+ MPL_free(tmp);
/* initialize some structures; these are initialized exactly once,
* even if the init command is sent once from each process. */
@@ -229,7 +229,7 @@ static HYD_status fn_initack(int fd, char *args[])
status = send_cmd_downstream(fd, cmd);
HYDU_ERR_POP(status, "error sending PMI response\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
HYD_pmcd_pmi_free_tokens(tokens, token_count);
@@ -261,7 +261,7 @@ static HYD_status fn_get_maxes(int fd, char *args[])
status = send_cmd_downstream(fd, cmd);
HYDU_ERR_POP(status, "error sending PMI response\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
HYDU_FUNC_EXIT();
@@ -304,7 +304,7 @@ static HYD_status fn_get_appnum(int fd, char *args[])
status = send_cmd_downstream(fd, cmd);
HYDU_ERR_POP(status, "error sending PMI response\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
HYDU_FUNC_EXIT();
@@ -331,7 +331,7 @@ static HYD_status fn_get_my_kvsname(int fd, char *args[])
status = send_cmd_downstream(fd, cmd);
HYDU_ERR_POP(status, "error sending PMI response\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
HYDU_FUNC_EXIT();
@@ -365,7 +365,7 @@ static HYD_status fn_get_usize(int fd, char *args[])
status = send_cmd_downstream(fd, cmd);
HYDU_ERR_POP(status, "error sending PMI response\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
HYDU_FUNC_EXIT();
@@ -402,7 +402,7 @@ static HYD_status fn_get(int fd, char *args[])
status = send_cmd_downstream(fd, cmd);
HYDU_ERR_POP(status, "error sending PMI response\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
}
else {
val = NULL;
@@ -424,7 +424,7 @@ static HYD_status fn_get(int fd, char *args[])
status = send_cmd_downstream(fd, cmd);
HYDU_ERR_POP(status, "error sending PMI response\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
}
else {
/* if we can't find the key locally, ask upstream */
@@ -502,9 +502,9 @@ static HYD_status fn_keyval_cache(int fd, char *args[])
/* allocate a larger space for the cached keyvals, copy over the
* older keyvals and add the new ones in */
- HYDU_REALLOC(cache_get.key, char **, (cache_get.keyval_len + token_count) * sizeof(char *),
+ HYDU_REALLOC_OR_JUMP(cache_get.key, char **, (cache_get.keyval_len + token_count) * sizeof(char *),
status);
- HYDU_REALLOC(cache_get.val, char **, (cache_get.keyval_len + token_count) * sizeof(char *),
+ HYDU_REALLOC_OR_JUMP(cache_get.val, char **, (cache_get.keyval_len + token_count) * sizeof(char *),
status);
for (i = 0; i < token_count; i++) {
@@ -562,7 +562,7 @@ static HYD_status fn_barrier_out(int fd, char *args[])
HYDU_ERR_POP(status, "error sending PMI response\n");
}
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
HYDU_FUNC_EXIT();
@@ -585,7 +585,7 @@ static HYD_status fn_finalize(int fd, char *args[])
status = send_cmd_downstream(fd, cmd);
HYDU_ERR_POP(status, "error sending PMI response\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
@@ -596,11 +596,11 @@ static HYD_status fn_finalize(int fd, char *args[])
if (finalize_count == HYD_pmcd_pmip.local.proxy_process_count) {
/* All processes have finalized */
for (i = 0; i < cache_get.keyval_len; i++) {
- HYDU_FREE(cache_get.key[i]);
- HYDU_FREE(cache_get.val[i]);
+ MPL_free(cache_get.key[i]);
+ MPL_free(cache_get.val[i]);
}
- HYDU_FREE(cache_get.key);
- HYDU_FREE(cache_get.val);
+ MPL_free(cache_get.key);
+ MPL_free(cache_get.val);
}
fn_exit:
diff --git a/src/pm/hydra/pm/pmiserv/pmip_pmi_v2.c b/src/pm/hydra/pm/pmiserv/pmip_pmi_v2.c
index bbe5190..4a7df51 100644
--- a/src/pm/hydra/pm/pmiserv/pmip_pmi_v2.c
+++ b/src/pm/hydra/pm/pmiserv/pmip_pmi_v2.c
@@ -57,7 +57,7 @@ static HYD_status send_cmd_upstream(const char *start, int fd, char *args[])
fn_exit:
if (buf)
- HYDU_FREE(buf);
+ MPL_free(buf);
HYDU_FUNC_EXIT();
return status;
@@ -132,7 +132,7 @@ static HYD_status poke_progress(char *key)
/* Free the dequeued request */
HYDU_free_strlist(req->args);
- HYDU_FREE(req);
+ MPL_free(req);
}
}
@@ -203,7 +203,7 @@ static HYD_status fn_fullinit(int fd, char *args[])
HYD_STRING_SPIT(stash, cmd, status);
send_cmd_downstream(fd, cmd);
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
HYD_pmcd_pmi_free_tokens(tokens, token_count);
@@ -243,7 +243,7 @@ static HYD_status fn_job_getid(int fd, char *args[])
HYD_STRING_SPIT(stash, cmd, status);
send_cmd_downstream(fd, cmd);
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
if (tokens)
@@ -294,7 +294,7 @@ static HYD_status fn_info_putnodeattr(int fd, char *args[])
HYD_STRING_SPIT(stash, cmd, status);
send_cmd_downstream(fd, cmd);
- HYDU_FREE(cmd);
+ MPL_free(cmd);
for (req = pending_reqs; req; req = req->next) {
if (!strcmp(req->key, key)) {
@@ -363,7 +363,7 @@ static HYD_status fn_info_getnodeattr(int fd, char *args[])
HYD_STRING_SPIT(stash, cmd, status);
send_cmd_downstream(fd, cmd);
- HYDU_FREE(cmd);
+ MPL_free(cmd);
}
else if (waitval && !strcmp(waitval, "TRUE")) {
/* The client wants to wait for a response; queue up the request */
@@ -386,7 +386,7 @@ static HYD_status fn_info_getnodeattr(int fd, char *args[])
HYD_STRING_SPIT(stash, cmd, status);
send_cmd_downstream(fd, cmd);
- HYDU_FREE(cmd);
+ MPL_free(cmd);
}
fn_exit:
@@ -433,7 +433,7 @@ static HYD_status fn_info_getjobattr(int fd, char *args[])
HYD_STRING_SPIT(stash, cmd, status);
send_cmd_downstream(fd, cmd);
- HYDU_FREE(cmd);
+ MPL_free(cmd);
}
else {
status = send_cmd_upstream("cmd=info-getjobattr;", fd, args);
@@ -477,7 +477,7 @@ static HYD_status fn_finalize(int fd, char *args[])
HYD_STRING_SPIT(stash, cmd, status);
send_cmd_downstream(fd, cmd);
- HYDU_FREE(cmd);
+ MPL_free(cmd);
status = HYDT_dmx_deregister_fd(fd);
HYDU_ERR_POP(status, "unable to deregister fd\n");
diff --git a/src/pm/hydra/pm/pmiserv/pmip_utils.c b/src/pm/hydra/pm/pmiserv/pmip_utils.c
index c3062d9..e101702 100644
--- a/src/pm/hydra/pm/pmiserv/pmip_utils.c
+++ b/src/pm/hydra/pm/pmiserv/pmip_utils.c
@@ -49,7 +49,7 @@ static HYD_status control_port_fn(char *arg, char ***argv)
fn_exit:
if (port)
- HYDU_FREE(port);
+ MPL_free(port);
return status;
fn_fail:
@@ -183,7 +183,7 @@ static HYD_status pmi_spawner_kvsname_fn(char *arg, char ***argv)
{
HYD_status status = HYD_SUCCESS;
- HYDU_MALLOC(HYD_pmcd_pmip.local.spawner_kvsname, char *, PMI_MAXKVSLEN, status);
+ HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.local.spawner_kvsname, char *, PMI_MAXKVSLEN, status);
MPL_snprintf(HYD_pmcd_pmip.local.spawner_kvsname, PMI_MAXKVSLEN, "%s", **argv);
(*argv)++;
@@ -287,7 +287,7 @@ static HYD_status parse_ckpoint_prefix(char *pathlist)
/* Add one more to the prefix list for a NULL ending string */
prefixes++;
- HYDU_MALLOC(HYD_pmcd_pmip.local.ckpoint_prefix_list, char **, prefixes * sizeof(char *),
+ HYDU_MALLOC_OR_JUMP(HYD_pmcd_pmip.local.ckpoint_prefix_list, char **, prefixes * sizeof(char *),
status);
dummy = strtok(pathlist, ":");
@@ -390,7 +390,7 @@ static HYD_status global_core_map_fn(char *arg, char ***argv)
HYDU_ASSERT(tmp, status);
HYD_pmcd_pmip.system_global.global_core_map.global_count = atoi(tmp);
- HYDU_FREE(map);
+ MPL_free(map);
(*argv)++;
@@ -419,7 +419,7 @@ static HYD_status pmi_id_map_fn(char *arg, char ***argv)
HYDU_ASSERT(tmp, status);
HYD_pmcd_pmip.system_global.pmi_id_map.non_filler_start = atoi(tmp);
- HYDU_FREE(map);
+ MPL_free(map);
(*argv)++;
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_cb.c b/src/pm/hydra/pm/pmiserv/pmiserv_cb.c
index f79a7bd..c33dca1 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_cb.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_cb.c
@@ -30,7 +30,7 @@ static HYD_status handle_pmi_cmd(int fd, int pgid, int pid, char *buf, int pmi_v
if (HYD_server_info.user_global.debug)
HYDU_dump(stdout, "[pgid: %d] got PMI command: %s\n", pgid, buf);
- HYDU_MALLOC(args, char **, MAX_PMI_ARGS * sizeof(char *), status);
+ HYDU_MALLOC_OR_JUMP(args, char **, MAX_PMI_ARGS * sizeof(char *), status);
for (i = 0; i < MAX_PMI_ARGS; i++)
args[i] = NULL;
@@ -59,7 +59,7 @@ static HYD_status handle_pmi_cmd(int fd, int pgid, int pid, char *buf, int pmi_v
fn_exit:
if (cmd)
- HYDU_FREE(cmd);
+ MPL_free(cmd);
if (args) {
HYDU_free_strlist(args);
MPL_free(args);
@@ -209,7 +209,7 @@ static HYD_status control_cb(int fd, HYD_event_t events, void *userp)
}
if (hdr.cmd == PID_LIST) { /* Got PIDs */
- HYDU_MALLOC(proxy->pid, int *, proxy->proxy_process_count * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(proxy->pid, int *, proxy->proxy_process_count * sizeof(int), status);
status = HYDU_sock_read(fd, (void *) proxy->pid,
proxy->proxy_process_count * sizeof(int),
&count, &closed, HYDU_SOCK_COMM_MSGWAIT);
@@ -232,7 +232,7 @@ static HYD_status control_cb(int fd, HYD_event_t events, void *userp)
HYDU_ERR_POP(status, "debugger setup failed\n");
}
else if (hdr.cmd == EXIT_STATUS) {
- HYDU_MALLOC(proxy->exit_status, int *, proxy->proxy_process_count * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(proxy->exit_status, int *, proxy->proxy_process_count * sizeof(int), status);
status =
HYDU_sock_read(fd, (void *) proxy->exit_status,
proxy->proxy_process_count * sizeof(int), &count, &closed,
@@ -275,7 +275,7 @@ static HYD_status control_cb(int fd, HYD_event_t events, void *userp)
}
}
else if (hdr.cmd == PMI_CMD) {
- HYDU_MALLOC(buf, char *, hdr.buflen + 1, status);
+ HYDU_MALLOC_OR_JUMP(buf, char *, hdr.buflen + 1, status);
status = HYDU_sock_read(fd, buf, hdr.buflen, &count, &closed, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "unable to read PMI command from proxy\n");
@@ -286,10 +286,10 @@ static HYD_status control_cb(int fd, HYD_event_t events, void *userp)
status = handle_pmi_cmd(fd, proxy->pg->pgid, hdr.pid, buf, hdr.pmi_version);
HYDU_ERR_POP(status, "unable to process PMI command\n");
- HYDU_FREE(buf);
+ MPL_free(buf);
}
else if (hdr.cmd == STDOUT || hdr.cmd == STDERR) {
- HYDU_MALLOC(buf, char *, hdr.buflen, status);
+ HYDU_MALLOC_OR_JUMP(buf, char *, hdr.buflen, status);
status = HYDU_sock_read(fd, buf, hdr.buflen, &count, &closed, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "unable to read PMI command from proxy\n");
@@ -301,10 +301,10 @@ static HYD_status control_cb(int fd, HYD_event_t events, void *userp)
status = HYD_server_info.stderr_cb(hdr.pgid, hdr.proxy_id, hdr.rank, buf, hdr.buflen);
HYDU_ERR_POP(status, "error in the UI defined callback\n");
- HYDU_FREE(buf);
+ MPL_free(buf);
}
else if (hdr.cmd == STDIN) {
- HYDU_MALLOC(buf, char *, HYD_TMPBUF_SIZE, status);
+ HYDU_MALLOC_OR_JUMP(buf, char *, HYD_TMPBUF_SIZE, status);
HYDU_ERR_POP(status, "unable to allocate memory\n");
HYDU_sock_read(STDIN_FILENO, buf, HYD_TMPBUF_SIZE, &count, &closed, HYDU_SOCK_COMM_NONE);
@@ -323,7 +323,7 @@ static HYD_status control_cb(int fd, HYD_event_t events, void *userp)
HYDU_ERR_POP(status, "error writing to control socket\n");
HYDU_ASSERT(!closed, status);
- HYDU_FREE(buf);
+ MPL_free(buf);
}
else {
status = HYDT_dmx_deregister_fd(STDIN_FILENO);
@@ -338,8 +338,8 @@ static HYD_status control_cb(int fd, HYD_event_t events, void *userp)
if (pg_scratch->dead_process_count == 1) {
/* This is the first dead process */
- HYDU_FREE(pg_scratch->dead_processes);
- HYDU_MALLOC(pg_scratch->dead_processes, char *, PMI_MAXVALLEN, status);
+ MPL_free(pg_scratch->dead_processes);
+ HYDU_MALLOC_OR_JUMP(pg_scratch->dead_processes, char *, PMI_MAXVALLEN, status);
MPL_snprintf(pg_scratch->dead_processes, PMI_MAXVALLEN, "%d", hdr.pid);
}
else {
@@ -373,7 +373,7 @@ static HYD_status control_cb(int fd, HYD_event_t events, void *userp)
/* Add this process to the end of the list */
if (!included) {
- HYDU_MALLOC(str, char *, PMI_MAXVALLEN, status);
+ HYDU_MALLOC_OR_JUMP(str, char *, PMI_MAXVALLEN, status);
MPL_snprintf(str, PMI_MAXVALLEN, "%s,%d", pg_scratch->dead_processes, hdr.pid);
} else {
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_pmci.c b/src/pm/hydra/pm/pmiserv/pmiserv_pmci.c
index 304f728..b28be62 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_pmci.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_pmci.c
@@ -126,7 +126,7 @@ HYD_status HYD_pmci_launch_procs(void)
for (proxy = HYD_server_info.pg_list.proxy_list; proxy; proxy = proxy->next)
node_count++;
- HYDU_MALLOC(control_fd, int *, node_count * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(control_fd, int *, node_count * sizeof(int), status);
for (i = 0; i < node_count; i++)
control_fd[i] = HYD_FD_UNSET;
@@ -143,11 +143,11 @@ HYD_status HYD_pmci_launch_procs(void)
HYDU_ERR_POP(status, "unable to register fd\n");
}
- HYDU_FREE(control_fd);
+ MPL_free(control_fd);
fn_exit:
if (control_port)
- HYDU_FREE(control_port);
+ MPL_free(control_port);
HYD_STRING_STASH_FREE(proxy_stash);
HYDU_FUNC_EXIT();
return status;
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_pmi.c b/src/pm/hydra/pm/pmiserv/pmiserv_pmi.c
index 58746b4..69e1f96 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_pmi.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_pmi.c
@@ -42,15 +42,15 @@ HYD_status HYD_pmcd_pmi_free_publish(struct HYD_pmcd_pmi_publish * publish)
HYDU_FUNC_ENTER();
- HYDU_FREE(publish->name);
- HYDU_FREE(publish->port);
+ MPL_free(publish->name);
+ MPL_free(publish->port);
for (i = 0; i < publish->infokeycount; i++) {
- HYDU_FREE(publish->info_keys[i].key);
- HYDU_FREE(publish->info_keys[i].val);
+ MPL_free(publish->info_keys[i].key);
+ MPL_free(publish->info_keys[i].val);
}
if (publish->info_keys)
- HYDU_FREE(publish->info_keys);
+ MPL_free(publish->info_keys);
fn_exit:
HYDU_FUNC_EXIT();
@@ -81,7 +81,7 @@ HYD_status HYD_pmcd_pmi_publish(char *name, char *port, int *success)
}
*success = 1;
- HYDU_MALLOC(publish, struct HYD_pmcd_pmi_publish *,
+ HYDU_MALLOC_OR_JUMP(publish, struct HYD_pmcd_pmi_publish *,
sizeof(struct HYD_pmcd_pmi_publish), status);
publish->name = MPL_strdup(name);
publish->port = MPL_strdup(port);
@@ -129,7 +129,7 @@ HYD_status HYD_pmcd_pmi_publish(char *name, char *port, int *success)
HYDU_ERR_POP(status, "error reading from nameserver\n");
HYDU_ASSERT(!closed, status);
- HYDU_MALLOC(resp, char *, len, status);
+ HYDU_MALLOC_OR_JUMP(resp, char *, len, status);
status = HYDU_sock_read(ns_fd, resp, len, &recvd, &closed, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "error reading from nameserver\n");
HYDU_ASSERT(len == recvd, status);
@@ -141,7 +141,7 @@ HYD_status HYD_pmcd_pmi_publish(char *name, char *port, int *success)
else
*success = 0;
- HYDU_FREE(resp);
+ MPL_free(resp);
}
fn_exit:
@@ -177,7 +177,7 @@ HYD_status HYD_pmcd_pmi_unpublish(char *name, int *success)
publish->next = NULL;
HYD_pmcd_pmi_free_publish(publish);
- HYDU_FREE(publish);
+ MPL_free(publish);
*success = 1;
}
else {
@@ -191,7 +191,7 @@ HYD_status HYD_pmcd_pmi_unpublish(char *name, int *success)
r->next = NULL;
HYD_pmcd_pmi_free_publish(r);
- HYDU_FREE(r);
+ MPL_free(r);
*success = 1;
}
else
@@ -231,7 +231,7 @@ HYD_status HYD_pmcd_pmi_unpublish(char *name, int *success)
HYDU_ERR_POP(status, "error reading from nameserver\n");
HYDU_ASSERT(!closed, status);
- HYDU_MALLOC(resp, char *, len, status);
+ HYDU_MALLOC_OR_JUMP(resp, char *, len, status);
status = HYDU_sock_read(ns_fd, resp, len, &recvd, &closed, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "error reading from nameserver\n");
HYDU_ASSERT(len == recvd, status);
@@ -240,7 +240,7 @@ HYD_status HYD_pmcd_pmi_unpublish(char *name, int *success)
if (!strcmp(resp, "SUCCESS"))
*success = 1;
- HYDU_FREE(resp);
+ MPL_free(resp);
}
fn_exit:
@@ -305,7 +305,7 @@ HYD_status HYD_pmcd_pmi_lookup(char *name, char **value)
HYDU_ASSERT(!closed, status);
if (len) {
- HYDU_MALLOC(resp, char *, len, status);
+ HYDU_MALLOC_OR_JUMP(resp, char *, len, status);
status = HYDU_sock_read(ns_fd, resp, len, &recvd, &closed, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "error reading from nameserver\n");
HYDU_ASSERT(len == recvd, status);
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v1.c b/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v1.c
index 0bc976d..1f170b9 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v1.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v1.c
@@ -69,7 +69,7 @@ static HYD_status bcast_keyvals(int fd, int pid)
/* Each keyval has the following four items: 'key' '=' 'val'
* '<space>'. Two additional items for the command at the start
* and the NULL at the end. */
- HYDU_MALLOC(tmp, char **, (4 * keyval_count + 3) * sizeof(char *), status);
+ HYDU_MALLOC_OR_JUMP(tmp, char **, (4 * keyval_count + 3) * sizeof(char *), status);
/* send all available keyvals downstream */
if (keyval_count) {
@@ -99,7 +99,7 @@ static HYD_status bcast_keyvals(int fd, int pid)
status = cmd_response(tproxy->control_fd, pid, cmd);
HYDU_ERR_POP(status, "error writing PMI line\n");
}
- HYDU_FREE(cmd);
+ MPL_free(cmd);
i = 0;
tmp[i++] = MPL_strdup("cmd=keyval_cache ");
@@ -118,14 +118,14 @@ static HYD_status bcast_keyvals(int fd, int pid)
status = cmd_response(tproxy->control_fd, pid, cmd);
HYDU_ERR_POP(status, "error writing PMI line\n");
}
- HYDU_FREE(cmd);
+ MPL_free(cmd);
}
HYDU_free_strlist(tmp);
}
fn_exit:
if (tmp)
- HYDU_FREE(tmp);
+ MPL_free(tmp);
HYDU_FUNC_EXIT();
return status;
@@ -268,7 +268,7 @@ static HYD_status fn_get(int fd, int pid, int pgid, char *args[])
status = cmd_response(fd, pid, cmd);
HYDU_ERR_POP(status, "error writing PMI line\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
HYD_pmcd_pmi_free_tokens(tokens, token_count);
@@ -365,7 +365,7 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
"unable to find token: totspawns\n");
total_spawns = atoi(val);
- HYDU_MALLOC(segment_list, struct HYD_pmcd_token_segment *,
+ HYDU_MALLOC_OR_JUMP(segment_list, struct HYD_pmcd_token_segment *,
total_spawns * sizeof(struct HYD_pmcd_token_segment), status);
segment_tokens(tokens, token_count, segment_list, &num_segments);
@@ -587,7 +587,7 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
status = HYD_pmcd_pmi_fill_in_proxy_args(&proxy_stash, control_port, new_pgid);
HYDU_ERR_POP(status, "unable to fill in proxy arguments\n");
- HYDU_FREE(control_port);
+ MPL_free(control_port);
status = HYD_pmcd_pmi_fill_in_exec_launch_info(pg);
HYDU_ERR_POP(status, "unable to fill in executable arguments\n");
@@ -606,7 +606,7 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
status = cmd_response(fd, pid, cmd);
HYDU_ERR_POP(status, "error writing PMI line\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
}
/* Cache the pre-initialized keyvals on the new proxies */
@@ -617,7 +617,7 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
HYD_pmcd_pmi_free_tokens(tokens, token_count);
HYD_STRING_STASH_FREE(proxy_stash);
if (segment_list)
- HYDU_FREE(segment_list);
+ MPL_free(segment_list);
HYDU_FUNC_EXIT();
return status;
@@ -664,15 +664,15 @@ static HYD_status fn_publish_name(int fd, int pid, int pgid, char *args[])
status = cmd_response(fd, pid, cmd);
HYDU_ERR_POP(status, "send command failed\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
if (tokens)
HYD_pmcd_pmi_free_tokens(tokens, token_count);
if (name)
- HYDU_FREE(name);
+ MPL_free(name);
if (port)
- HYDU_FREE(port);
+ MPL_free(port);
HYDU_FUNC_EXIT();
return status;
@@ -714,7 +714,7 @@ static HYD_status fn_unpublish_name(int fd, int pid, int pgid, char *args[])
status = cmd_response(fd, pid, cmd);
HYDU_ERR_POP(status, "send command failed\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
if (tokens)
@@ -760,13 +760,13 @@ static HYD_status fn_lookup_name(int fd, int pid, int pgid, char *args[])
status = cmd_response(fd, pid, cmd);
HYDU_ERR_POP(status, "send command failed\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
if (tokens)
HYD_pmcd_pmi_free_tokens(tokens, token_count);
if (value)
- HYDU_FREE(value);
+ MPL_free(value);
HYDU_FUNC_EXIT();
return status;
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v2.c b/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v2.c
index d6afc67..ea277b0 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v2.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v2.c
@@ -93,7 +93,7 @@ static HYD_status poke_progress(char *key)
/* Free the dequeued request */
HYDU_free_strlist(req->args);
- HYDU_FREE(req);
+ MPL_free(req);
}
}
@@ -170,7 +170,7 @@ static HYD_status fn_info_getjobattr(int fd, int pid, int pgid, char *args[])
status = cmd_response(fd, pid, cmd);
HYDU_ERR_POP(status, "send command failed\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
HYD_pmcd_pmi_free_tokens(tokens, token_count);
@@ -232,7 +232,7 @@ static HYD_status fn_kvs_put(int fd, int pid, int pgid, char *args[])
status = cmd_response(fd, pid, cmd);
HYDU_ERR_POP(status, "send command failed\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
for (req = pending_reqs; req; req = req->next) {
if (!strcmp(req->key, key)) {
@@ -334,7 +334,7 @@ static HYD_status fn_kvs_get(int fd, int pid, int pgid, char *args[])
status = cmd_response(fd, pid, cmd);
HYDU_ERR_POP(status, "send command failed\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
HYD_pmcd_pmi_free_tokens(tokens, token_count);
@@ -398,7 +398,7 @@ static HYD_status fn_kvs_fence(int fd, int pid, int pgid, char *args[])
status = cmd_response(fd, pid, cmd);
HYDU_ERR_POP(status, "send command failed\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fence_count++;
if (fence_count % proxy->pg->pg_process_count == 0) {
@@ -491,7 +491,7 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
HYDU_ERR_CHKANDJUMP(status, val == NULL, HYD_INTERNAL_ERROR, "unable to find token: ncmds\n");
ncmds = atoi(val);
- HYDU_MALLOC(segment_list, struct HYD_pmcd_token_segment *,
+ HYDU_MALLOC_OR_JUMP(segment_list, struct HYD_pmcd_token_segment *,
(ncmds + 1) * sizeof(struct HYD_pmcd_token_segment), status);
segment_tokens(tokens, token_count, segment_list, &num_segments);
HYDU_ASSERT((ncmds + 1) == num_segments, status);
@@ -702,7 +702,7 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
status = HYD_pmcd_pmi_fill_in_proxy_args(&proxy_stash, control_port, new_pgid);
HYDU_ERR_POP(status, "unable to fill in proxy arguments\n");
- HYDU_FREE(control_port);
+ MPL_free(control_port);
status = HYD_pmcd_pmi_fill_in_exec_launch_info(pg);
HYDU_ERR_POP(status, "unable to fill in executable arguments\n");
@@ -730,14 +730,14 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
status = cmd_response(fd, pid, cmd);
HYDU_ERR_POP(status, "send command failed\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
}
fn_exit:
HYD_pmcd_pmi_free_tokens(tokens, token_count);
HYD_STRING_STASH_FREE(proxy_stash);
if (segment_list)
- HYDU_FREE(segment_list);
+ MPL_free(segment_list);
HYDU_FUNC_EXIT();
return status;
@@ -790,15 +790,15 @@ static HYD_status fn_name_publish(int fd, int pid, int pgid, char *args[])
status = cmd_response(fd, pid, cmd);
HYDU_ERR_POP(status, "send command failed\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
if (tokens)
HYD_pmcd_pmi_free_tokens(tokens, token_count);
if (name)
- HYDU_FREE(name);
+ MPL_free(name);
if (port)
- HYDU_FREE(port);
+ MPL_free(port);
HYDU_FUNC_EXIT();
return status;
@@ -846,7 +846,7 @@ static HYD_status fn_name_unpublish(int fd, int pid, int pgid, char *args[])
status = cmd_response(fd, pid, cmd);
HYDU_ERR_POP(status, "send command failed\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
if (tokens)
@@ -899,7 +899,7 @@ static HYD_status fn_name_lookup(int fd, int pid, int pgid, char *args[])
status = cmd_response(fd, pid, cmd);
HYDU_ERR_POP(status, "send command failed\n");
- HYDU_FREE(cmd);
+ MPL_free(cmd);
fn_exit:
if (tokens)
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_utils.c b/src/pm/hydra/pm/pmiserv/pmiserv_utils.c
index aa94066..07f4f2c 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_utils.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_utils.c
@@ -158,7 +158,7 @@ static HYD_status pmi_process_mapping(struct HYD_pg *pg, char **process_mapping_
core_count = filler_round ? proxy->filler_processes : proxy->node->core_count;
if (blocklist_head == NULL) {
- HYDU_MALLOC(block, struct block *, sizeof(struct block), status);
+ HYDU_MALLOC_OR_JUMP(block, struct block *, sizeof(struct block), status);
block->start_idx = node->node_id;
block->num_nodes = 1;
block->core_count = core_count;
@@ -174,7 +174,7 @@ static HYD_status pmi_process_mapping(struct HYD_pg *pg, char **process_mapping_
blocklist_tail->core_count += core_count;
}
else {
- HYDU_MALLOC(blocklist_tail->next, struct block *, sizeof(struct block), status);
+ HYDU_MALLOC_OR_JUMP(blocklist_tail->next, struct block *, sizeof(struct block), status);
blocklist_tail = blocklist_tail->next;
blocklist_tail->start_idx = node->node_id;
blocklist_tail->num_nodes = 1;
@@ -196,7 +196,7 @@ static HYD_status pmi_process_mapping(struct HYD_pg *pg, char **process_mapping_
for (block = blocklist_head; block->next;) {
nblock = block->next;
block->next = nblock->next;
- HYDU_FREE(nblock);
+ MPL_free(nblock);
}
blocklist_tail = blocklist_head;
}
@@ -222,7 +222,7 @@ static HYD_status pmi_process_mapping(struct HYD_pg *pg, char **process_mapping_
for (block = blocklist_head; block; block = nblock) {
nblock = block->next;
- HYDU_FREE(block);
+ MPL_free(block);
}
fn_exit:
@@ -253,7 +253,7 @@ HYD_status HYD_pmcd_pmi_fill_in_exec_launch_info(struct HYD_pg *pg)
/* Make sure the mapping is within the size allowed by PMI */
if (strlen(mapping) > PMI_MAXVALLEN) {
- HYDU_FREE(mapping);
+ MPL_free(mapping);
mapping = NULL;
}
@@ -269,8 +269,8 @@ HYD_status HYD_pmcd_pmi_fill_in_exec_launch_info(struct HYD_pg *pg)
for (node = HYD_server_info.node_list; node; node = node->next)
total_core_count += node->core_count;
- HYDU_MALLOC(filler_pmi_ids, int *, proxy_count * sizeof(int), status);
- HYDU_MALLOC(nonfiller_pmi_ids, int *, proxy_count * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(filler_pmi_ids, int *, proxy_count * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(nonfiller_pmi_ids, int *, proxy_count * sizeof(int), status);
pmi_id = 0;
for (proxy = pg->proxy_list, i = 0; proxy; proxy = proxy->next, i++) {
@@ -501,9 +501,9 @@ HYD_status HYD_pmcd_pmi_fill_in_exec_launch_info(struct HYD_pg *pg)
fn_exit:
if (mapping)
- HYDU_FREE(mapping);
- HYDU_FREE(filler_pmi_ids);
- HYDU_FREE(nonfiller_pmi_ids);
+ MPL_free(mapping);
+ MPL_free(filler_pmi_ids);
+ MPL_free(nonfiller_pmi_ids);
return status;
fn_fail:
@@ -518,12 +518,12 @@ HYD_status HYD_pmcd_pmi_alloc_pg_scratch(struct HYD_pg *pg)
HYDU_FUNC_ENTER();
- HYDU_MALLOC(pg->pg_scratch, void *, sizeof(struct HYD_pmcd_pmi_pg_scratch), status);
+ HYDU_MALLOC_OR_JUMP(pg->pg_scratch, void *, sizeof(struct HYD_pmcd_pmi_pg_scratch), status);
pg_scratch = (struct HYD_pmcd_pmi_pg_scratch *) pg->pg_scratch;
pg_scratch->barrier_count = 0;
- HYDU_MALLOC(pg_scratch->ecount, struct HYD_pmcd_pmi_ecount *,
+ HYDU_MALLOC_OR_JUMP(pg_scratch->ecount, struct HYD_pmcd_pmi_ecount *,
pg->pg_process_count * sizeof(struct HYD_pmcd_pmi_ecount), status);
for (i = 0; i < pg->pg_process_count; i++) {
pg_scratch->ecount[i].fd = HYD_FD_UNSET;
@@ -561,14 +561,14 @@ HYD_status HYD_pmcd_pmi_free_pg_scratch(struct HYD_pg *pg)
pg_scratch = pg->pg_scratch;
if (pg_scratch->ecount)
- HYDU_FREE(pg_scratch->ecount);
+ MPL_free(pg_scratch->ecount);
if (pg_scratch->dead_processes)
- HYDU_FREE(pg_scratch->dead_processes);
+ MPL_free(pg_scratch->dead_processes);
HYD_pmcd_free_pmi_kvs_list(pg_scratch->kvs);
- HYDU_FREE(pg_scratch);
+ MPL_free(pg_scratch);
pg->pg_scratch = NULL;
}
diff --git a/src/pm/hydra/tools/bootstrap/external/external_common_launch.c b/src/pm/hydra/tools/bootstrap/external/external_common_launch.c
index c1c6bf3..f0e110e 100644
--- a/src/pm/hydra/tools/bootstrap/external/external_common_launch.c
+++ b/src/pm/hydra/tools/bootstrap/external/external_common_launch.c
@@ -51,7 +51,7 @@ static HYD_status lsf_get_path(char **path)
MPL_env2str("LSF_BINDIR", (const char **) &bin_dir);
if (bin_dir) {
length = strlen(bin_dir) + 2 + strlen("blaunch");
- HYDU_MALLOC(*path, char *, length, status);
+ HYDU_MALLOC_OR_JUMP(*path, char *, length, status);
MPL_snprintf(*path, length, "%s/blaunch", bin_dir);
}
}
@@ -81,7 +81,7 @@ static HYD_status sge_get_path(char **path)
MPL_env2str("ARC", (const char **) &arc);
if (sge_root && arc) {
length = strlen(sge_root) + strlen("/bin/") + strlen(arc) + 1 + strlen("qrsh") + 1;
- HYDU_MALLOC(*path, char *, length, status);
+ HYDU_MALLOC_OR_JUMP(*path, char *, length, status);
MPL_snprintf(*path, length, "%s/bin/%s/qrsh", sge_root, arc);
}
}
@@ -191,17 +191,17 @@ HYD_status HYDT_bscd_common_launch_procs(char **args, struct HYD_proxy *proxy_li
num_hosts++;
/* Increase pid list to accommodate these new pids */
- HYDU_MALLOC(pid, int *, (HYD_bscu_pid_count + num_hosts) * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(pid, int *, (HYD_bscu_pid_count + num_hosts) * sizeof(int), status);
for (i = 0; i < HYD_bscu_pid_count; i++)
pid[i] = HYD_bscu_pid_list[i];
- HYDU_FREE(HYD_bscu_pid_list);
+ MPL_free(HYD_bscu_pid_list);
HYD_bscu_pid_list = pid;
/* Increase fd list to accommodate these new fds */
- HYDU_MALLOC(fd_list, int *, (HYD_bscu_fd_count + (2 * num_hosts) + 1) * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(fd_list, int *, (HYD_bscu_fd_count + (2 * num_hosts) + 1) * sizeof(int), status);
for (i = 0; i < HYD_bscu_fd_count; i++)
fd_list[i] = HYD_bscu_fd_list[i];
- HYDU_FREE(HYD_bscu_fd_list);
+ MPL_free(HYD_bscu_fd_list);
HYD_bscu_fd_list = fd_list;
/* Check if the user disabled automatic forking */
@@ -213,20 +213,20 @@ HYD_status HYDT_bscd_common_launch_procs(char **args, struct HYD_proxy *proxy_li
for (proxy = proxy_list; proxy; proxy = proxy->next) {
if (targs[host_idx])
- HYDU_FREE(targs[host_idx]);
+ MPL_free(targs[host_idx]);
if (proxy->node->user == NULL) {
targs[host_idx] = MPL_strdup(proxy->node->hostname);
}
else {
len = strlen(proxy->node->user) + strlen("@") + strlen(proxy->node->hostname) + 1;
- HYDU_MALLOC(targs[host_idx], char *, len, status);
+ HYDU_MALLOC_OR_JUMP(targs[host_idx], char *, len, status);
MPL_snprintf(targs[host_idx], len, "%s@%s", proxy->node->user, proxy->node->hostname);
}
/* append proxy ID */
if (targs[idx])
- HYDU_FREE(targs[idx]);
+ MPL_free(targs[idx]);
targs[idx] = HYDU_int_to_str(proxy->proxy_id);
targs[idx + 1] = NULL;
@@ -248,7 +248,7 @@ HYD_status HYDT_bscd_common_launch_procs(char **args, struct HYD_proxy *proxy_li
str = HYDU_int_to_str(sockpair[1]);
status = HYDU_env_create(&env, "HYDI_CONTROL_FD", str);
HYDU_ERR_POP(status, "unable to create env\n");
- HYDU_FREE(str);
+ MPL_free(str);
control_fd[proxy->proxy_id] = sockpair[0];
@@ -336,7 +336,7 @@ HYD_status HYDT_bscd_common_launch_procs(char **args, struct HYD_proxy *proxy_li
fn_exit:
HYDU_free_strlist(targs);
if (path)
- HYDU_FREE(path);
+ MPL_free(path);
HYDU_FUNC_EXIT();
return status;
diff --git a/src/pm/hydra/tools/bootstrap/external/ll_launch.c b/src/pm/hydra/tools/bootstrap/external/ll_launch.c
index f7aa365..aa5bc39 100644
--- a/src/pm/hydra/tools/bootstrap/external/ll_launch.c
+++ b/src/pm/hydra/tools/bootstrap/external/ll_launch.c
@@ -73,21 +73,21 @@ HYD_status HYDT_bscd_ll_launch_procs(char **args, struct HYD_proxy *proxy_list,
* when the executable is not launched directly, but through an
* actual launcher */
MPL_snprintf(quoted_exec_string, HYD_TMP_STRLEN, "\"%s\"", targs[exec_idx]);
- HYDU_FREE(targs[exec_idx]);
+ MPL_free(targs[exec_idx]);
targs[exec_idx] = quoted_exec_string;
/* Increase pid list to accommodate the new pid */
- HYDU_MALLOC(pid, int *, (HYD_bscu_pid_count + 1) * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(pid, int *, (HYD_bscu_pid_count + 1) * sizeof(int), status);
for (i = 0; i < HYD_bscu_pid_count; i++)
pid[i] = HYD_bscu_pid_list[i];
- HYDU_FREE(HYD_bscu_pid_list);
+ MPL_free(HYD_bscu_pid_list);
HYD_bscu_pid_list = pid;
/* Increase fd list to accommodate these new fds */
- HYDU_MALLOC(fd_list, int *, (HYD_bscu_fd_count + 3) * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(fd_list, int *, (HYD_bscu_fd_count + 3) * sizeof(int), status);
for (i = 0; i < HYD_bscu_fd_count; i++)
fd_list[i] = HYD_bscu_fd_list[i];
- HYDU_FREE(HYD_bscu_fd_list);
+ MPL_free(HYD_bscu_fd_list);
HYD_bscu_fd_list = fd_list;
/* append proxy ID as -1 */
@@ -111,10 +111,10 @@ HYD_status HYDT_bscd_ll_launch_procs(char **args, struct HYD_proxy *proxy_list,
fn_exit:
if (node_list_str)
- HYDU_FREE(node_list_str);
+ MPL_free(node_list_str);
HYDU_free_strlist(targs);
if (path)
- HYDU_FREE(path);
+ MPL_free(path);
HYDU_FUNC_EXIT();
return status;
diff --git a/src/pm/hydra/tools/bootstrap/external/lsf_query_node_list.c b/src/pm/hydra/tools/bootstrap/external/lsf_query_node_list.c
index a8bbe94..566bdc2 100644
--- a/src/pm/hydra/tools/bootstrap/external/lsf_query_node_list.c
+++ b/src/pm/hydra/tools/bootstrap/external/lsf_query_node_list.c
@@ -47,7 +47,7 @@ HYD_status HYDT_bscd_lsf_query_node_list(struct HYD_node **node_list)
}
if (thosts)
- HYDU_FREE(thosts);
+ MPL_free(thosts);
}
fn_exit:
diff --git a/src/pm/hydra/tools/bootstrap/external/pbs_finalize.c b/src/pm/hydra/tools/bootstrap/external/pbs_finalize.c
index 44c544f..7bebc48 100644
--- a/src/pm/hydra/tools/bootstrap/external/pbs_finalize.c
+++ b/src/pm/hydra/tools/bootstrap/external/pbs_finalize.c
@@ -22,10 +22,10 @@ HYD_status HYDT_bscd_pbs_launcher_finalize(void)
if (HYDT_bscd_pbs_sys) {
if (HYDT_bscd_pbs_sys->task_id)
- HYDU_FREE(HYDT_bscd_pbs_sys->task_id);
+ MPL_free(HYDT_bscd_pbs_sys->task_id);
if (HYDT_bscd_pbs_sys->spawn_events)
- HYDU_FREE(HYDT_bscd_pbs_sys->spawn_events);
- HYDU_FREE(HYDT_bscd_pbs_sys);
+ MPL_free(HYDT_bscd_pbs_sys->spawn_events);
+ MPL_free(HYDT_bscd_pbs_sys);
}
fn_exit:
diff --git a/src/pm/hydra/tools/bootstrap/external/pbs_init.c b/src/pm/hydra/tools/bootstrap/external/pbs_init.c
index 4bbbc0b..394f172 100644
--- a/src/pm/hydra/tools/bootstrap/external/pbs_init.c
+++ b/src/pm/hydra/tools/bootstrap/external/pbs_init.c
@@ -24,7 +24,7 @@ HYD_status HYDT_bsci_launcher_pbs_init(void)
HYDT_bsci_fns.wait_for_completion = HYDT_bscd_pbs_wait_for_completion;
HYDT_bsci_fns.launcher_finalize = HYDT_bscd_pbs_launcher_finalize;
- HYDU_MALLOC(HYDT_bscd_pbs_sys, struct HYDT_bscd_pbs_sys_s *,
+ HYDU_MALLOC_OR_JUMP(HYDT_bscd_pbs_sys, struct HYDT_bscd_pbs_sys_s *,
sizeof(struct HYDT_bscd_pbs_sys_s), status);
/* Initialize TM and Hydra's PBS data structure */
diff --git a/src/pm/hydra/tools/bootstrap/external/pbs_launch.c b/src/pm/hydra/tools/bootstrap/external/pbs_launch.c
index c73745d..e4deafe 100644
--- a/src/pm/hydra/tools/bootstrap/external/pbs_launch.c
+++ b/src/pm/hydra/tools/bootstrap/external/pbs_launch.c
@@ -60,8 +60,8 @@ HYD_status HYDT_bscd_pbs_launch_procs(char **args, struct HYD_proxy *proxy_list,
for (args_count = 0; args[args_count]; args_count++)
targs[args_count] = MPL_strdup(args[args_count]);
- HYDU_MALLOC(HYDT_bscd_pbs_sys->task_id, tm_task_id *, proxy_count * sizeof(tm_task_id), status);
- HYDU_MALLOC(HYDT_bscd_pbs_sys->spawn_events, tm_event_t *,
+ HYDU_MALLOC_OR_JUMP(HYDT_bscd_pbs_sys->task_id, tm_task_id *, proxy_count * sizeof(tm_task_id), status);
+ HYDU_MALLOC_OR_JUMP(HYDT_bscd_pbs_sys->spawn_events, tm_event_t *,
proxy_count * sizeof(tm_event_t), status);
/* Spawn a process on each allocated node through tm_spawn() which
diff --git a/src/pm/hydra/tools/bootstrap/external/pbs_wait.c b/src/pm/hydra/tools/bootstrap/external/pbs_wait.c
index 1f13520..087554a 100644
--- a/src/pm/hydra/tools/bootstrap/external/pbs_wait.c
+++ b/src/pm/hydra/tools/bootstrap/external/pbs_wait.c
@@ -18,8 +18,8 @@ HYD_status HYDT_bscd_pbs_wait_for_completion(int timeout)
HYDU_FUNC_ENTER();
- HYDU_MALLOC(taskobits, int *, HYDT_bscd_pbs_sys->spawn_count * sizeof(int), status);
- HYDU_MALLOC(obit_events, tm_event_t *, HYDT_bscd_pbs_sys->spawn_count * sizeof(tm_event_t),
+ HYDU_MALLOC_OR_JUMP(taskobits, int *, HYDT_bscd_pbs_sys->spawn_count * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(obit_events, tm_event_t *, HYDT_bscd_pbs_sys->spawn_count * sizeof(tm_event_t),
status);
for (idx = 0; idx < HYDT_bscd_pbs_sys->spawn_count; idx++)
diff --git a/src/pm/hydra/tools/bootstrap/external/slurm_launch.c b/src/pm/hydra/tools/bootstrap/external/slurm_launch.c
index 54f8ced..477bd77 100644
--- a/src/pm/hydra/tools/bootstrap/external/slurm_launch.c
+++ b/src/pm/hydra/tools/bootstrap/external/slurm_launch.c
@@ -37,7 +37,7 @@ static HYD_status proxy_list_to_node_str(struct HYD_proxy *proxy_list, char **no
i = 0;
tmp[i++] = MPL_strdup(foo);
- HYDU_FREE(foo);
+ MPL_free(foo);
}
}
@@ -51,7 +51,7 @@ static HYD_status proxy_list_to_node_str(struct HYD_proxy *proxy_list, char **no
fn_exit:
HYDU_free_strlist(tmp);
if (foo)
- HYDU_FREE(foo);
+ MPL_free(foo);
HYDU_FUNC_EXIT();
return status;
@@ -124,17 +124,17 @@ HYD_status HYDT_bscd_slurm_launch_procs(char **args, struct HYD_proxy *proxy_lis
targs[idx++] = MPL_strdup(args[i]);
/* Increase pid list to accommodate the new pid */
- HYDU_MALLOC(pid, int *, (HYD_bscu_pid_count + 1) * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(pid, int *, (HYD_bscu_pid_count + 1) * sizeof(int), status);
for (i = 0; i < HYD_bscu_pid_count; i++)
pid[i] = HYD_bscu_pid_list[i];
- HYDU_FREE(HYD_bscu_pid_list);
+ MPL_free(HYD_bscu_pid_list);
HYD_bscu_pid_list = pid;
/* Increase fd list to accommodate these new fds */
- HYDU_MALLOC(fd_list, int *, (HYD_bscu_fd_count + 3) * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(fd_list, int *, (HYD_bscu_fd_count + 3) * sizeof(int), status);
for (i = 0; i < HYD_bscu_fd_count; i++)
fd_list[i] = HYD_bscu_fd_list[i];
- HYDU_FREE(HYD_bscu_fd_list);
+ MPL_free(HYD_bscu_fd_list);
HYD_bscu_fd_list = fd_list;
/* append proxy ID as -1 */
@@ -163,10 +163,10 @@ HYD_status HYDT_bscd_slurm_launch_procs(char **args, struct HYD_proxy *proxy_lis
fn_exit:
if (node_list_str)
- HYDU_FREE(node_list_str);
+ MPL_free(node_list_str);
HYDU_free_strlist(targs);
if (path)
- HYDU_FREE(path);
+ MPL_free(path);
HYDU_FUNC_EXIT();
return status;
diff --git a/src/pm/hydra/tools/bootstrap/external/slurm_query_node_list.c b/src/pm/hydra/tools/bootstrap/external/slurm_query_node_list.c
index 684be61..2fba09e 100644
--- a/src/pm/hydra/tools/bootstrap/external/slurm_query_node_list.c
+++ b/src/pm/hydra/tools/bootstrap/external/slurm_query_node_list.c
@@ -40,7 +40,7 @@ static HYD_status group_to_nodes(char *str)
for (i = 1; tmp; i++)
tmp = strtok(NULL, ",");
- HYDU_MALLOC(set, char **, i * sizeof(char *), status);
+ HYDU_MALLOC_OR_JUMP(set, char **, i * sizeof(char *), status);
/* Find the actual node sets */
set[0] = strtok(nodes, ",");
@@ -133,13 +133,13 @@ static HYD_status extract_tasks_per_node(int nnodes, char *task_list)
int i, j, k, p, count = 0;
HYD_status status = HYD_SUCCESS;
- HYDU_MALLOC(tasks_per_node, int *, nnodes * sizeof(int), status);
- HYDU_MALLOC(tmp_core_list, char **, nnodes * sizeof(char *), status);
+ HYDU_MALLOC_OR_JUMP(tasks_per_node, int *, nnodes * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(tmp_core_list, char **, nnodes * sizeof(char *), status);
task_set = strtok(task_list, ",");
i = 0;
do {
- HYDU_MALLOC(tmp_core_list[i], char *, strlen(task_set) + 1, status);
+ HYDU_MALLOC_OR_JUMP(tmp_core_list[i], char *, strlen(task_set) + 1, status);
MPL_snprintf(tmp_core_list[i], strlen(task_set) + 1, "%s", task_set);
i++;
task_set = strtok(NULL, ",");
@@ -164,8 +164,8 @@ static HYD_status extract_tasks_per_node(int nnodes, char *task_list)
fn_exit:
for (i = 0; i < count; i++)
- HYDU_FREE(tmp_core_list[i]);
- HYDU_FREE(tmp_core_list);
+ MPL_free(tmp_core_list[i]);
+ MPL_free(tmp_core_list);
return status;
fn_fail:
@@ -203,7 +203,7 @@ HYD_status HYDT_bscd_slurm_query_node_list(struct HYD_node **node_list)
*node_list = global_node_list;
fn_exit:
- HYDU_FREE(tasks_per_node);
+ MPL_free(tasks_per_node);
HYDU_FUNC_EXIT();
return status;
diff --git a/src/pm/hydra/tools/bootstrap/external/ssh.c b/src/pm/hydra/tools/bootstrap/external/ssh.c
index 6858232..251b904 100644
--- a/src/pm/hydra/tools/bootstrap/external/ssh.c
+++ b/src/pm/hydra/tools/bootstrap/external/ssh.c
@@ -18,8 +18,8 @@ static HYD_status create_element(char *hostname, struct HYDT_bscd_ssh_time **e)
HYD_status status = HYD_SUCCESS;
/* FIXME: These are never getting freed */
- HYDU_MALLOC((*e), struct HYDT_bscd_ssh_time *, sizeof(struct HYDT_bscd_ssh_time), status);
- HYDU_MALLOC((*e)->init_time, struct timeval *,
+ HYDU_MALLOC_OR_JUMP((*e), struct HYDT_bscd_ssh_time *, sizeof(struct HYDT_bscd_ssh_time), status);
+ HYDU_MALLOC_OR_JUMP((*e)->init_time, struct timeval *,
HYDT_bscd_ssh_limit_time * sizeof(struct timeval), status);
(*e)->hostname = MPL_strdup(hostname);
diff --git a/src/pm/hydra/tools/bootstrap/external/ssh_finalize.c b/src/pm/hydra/tools/bootstrap/external/ssh_finalize.c
index 7f1a27a..e4ce983 100644
--- a/src/pm/hydra/tools/bootstrap/external/ssh_finalize.c
+++ b/src/pm/hydra/tools/bootstrap/external/ssh_finalize.c
@@ -16,9 +16,9 @@ HYD_status HYDT_bscd_ssh_launcher_finalize(void)
HYDU_FUNC_ENTER();
for (e = HYDT_bscd_ssh_time; e;) {
- HYDU_FREE(e->hostname);
+ MPL_free(e->hostname);
tmp = e->next;
- HYDU_FREE(e);
+ MPL_free(e);
e = tmp;
}
diff --git a/src/pm/hydra/tools/bootstrap/persist/persist_launch.c b/src/pm/hydra/tools/bootstrap/persist/persist_launch.c
index b24db99..9d06fdd 100644
--- a/src/pm/hydra/tools/bootstrap/persist/persist_launch.c
+++ b/src/pm/hydra/tools/bootstrap/persist/persist_launch.c
@@ -74,7 +74,7 @@ HYD_status HYDT_bscd_persist_launch_procs(char **args, struct HYD_proxy *proxy_l
for (idx = 0; args[idx]; idx++);
args[idx + 1] = NULL;
- HYDU_MALLOC(HYDT_bscd_persist_control_fd, int *,
+ HYDU_MALLOC_OR_JUMP(HYDT_bscd_persist_control_fd, int *,
HYDT_bscd_persist_node_count * sizeof(int), status);
for (proxy = proxy_list, i = 0; proxy; proxy = proxy->next, i++) {
diff --git a/src/pm/hydra/tools/bootstrap/persist/persist_server.c b/src/pm/hydra/tools/bootstrap/persist/persist_server.c
index 1a12121..c35ee08 100644
--- a/src/pm/hydra/tools/bootstrap/persist/persist_server.c
+++ b/src/pm/hydra/tools/bootstrap/persist/persist_server.c
@@ -180,7 +180,7 @@ static HYD_status listen_cb(int fd, HYD_event_t events, void *userp)
HYDU_ERR_POP(status, "error reading data from upstream\n");
HYDU_ASSERT(!closed, status);
- HYDU_MALLOC(args, char **, (num_strings + 1) * sizeof(char *), status);
+ HYDU_MALLOC_OR_JUMP(args, char **, (num_strings + 1) * sizeof(char *), status);
for (i = 0; i < num_strings; i++) {
status = HYDU_sock_read(private.client_fd, &str_len, sizeof(int), &recvd, &closed,
@@ -188,7 +188,7 @@ static HYD_status listen_cb(int fd, HYD_event_t events, void *userp)
HYDU_ERR_POP(status, "error reading data from upstream\n");
HYDU_ASSERT(!closed, status);
- HYDU_MALLOC(args[i], char *, str_len, status);
+ HYDU_MALLOC_OR_JUMP(args[i], char *, str_len, status);
status = HYDU_sock_read(private.client_fd, args[i], str_len, &recvd, &closed,
HYDU_SOCK_COMM_MSGWAIT);
diff --git a/src/pm/hydra/tools/bootstrap/utils/bscu_wait.c b/src/pm/hydra/tools/bootstrap/utils/bscu_wait.c
index 21148f1..2daaded 100644
--- a/src/pm/hydra/tools/bootstrap/utils/bscu_wait.c
+++ b/src/pm/hydra/tools/bootstrap/utils/bscu_wait.c
@@ -110,13 +110,13 @@ HYD_status HYDT_bscu_wait_for_completion(int timeout)
}
if (HYD_bscu_pid_list) {
- HYDU_FREE(HYD_bscu_pid_list);
+ MPL_free(HYD_bscu_pid_list);
HYD_bscu_pid_list = NULL;
HYD_bscu_pid_count = 0;
}
if (HYD_bscu_fd_list) {
- HYDU_FREE(HYD_bscu_fd_list);
+ MPL_free(HYD_bscu_fd_list);
HYD_bscu_fd_list = NULL;
HYD_bscu_fd_count = 0;
}
diff --git a/src/pm/hydra/tools/debugger/debugger.c b/src/pm/hydra/tools/debugger/debugger.c
index ea9cf96..357943c 100644
--- a/src/pm/hydra/tools/debugger/debugger.c
+++ b/src/pm/hydra/tools/debugger/debugger.c
@@ -33,7 +33,7 @@ HYD_status HYDT_dbg_setup_procdesc(struct HYD_pg * pg)
HYDU_FUNC_ENTER();
- HYDU_MALLOC(MPIR_proctable, struct MPIR_PROCDESC *,
+ HYDU_MALLOC_OR_JUMP(MPIR_proctable, struct MPIR_PROCDESC *,
pg->pg_process_count * sizeof(struct MPIR_PROCDESC), status);
round = 0;
@@ -103,13 +103,13 @@ void HYDT_dbg_free_procdesc(void)
/* skip over duplicate pointers when freeing */
if (MPIR_proctable[i].host_name) {
if (i == 0 || MPIR_proctable[i].host_name != MPIR_proctable[i - 1].host_name)
- HYDU_FREE(MPIR_proctable[i].host_name);
+ MPL_free(MPIR_proctable[i].host_name);
}
if (MPIR_proctable[i].executable_name) {
if (i == 0 ||
MPIR_proctable[i].executable_name != MPIR_proctable[i - 1].executable_name)
- HYDU_FREE(MPIR_proctable[i].executable_name);
+ MPL_free(MPIR_proctable[i].executable_name);
}
}
- HYDU_FREE(MPIR_proctable);
+ MPL_free(MPIR_proctable);
}
diff --git a/src/pm/hydra/tools/demux/demux.c b/src/pm/hydra/tools/demux/demux.c
index 8193520..3206742 100644
--- a/src/pm/hydra/tools/demux/demux.c
+++ b/src/pm/hydra/tools/demux/demux.c
@@ -106,9 +106,9 @@ HYD_status HYDT_dmx_register_fd(int num_fds, int *fd, HYD_event_t events, void *
}
#endif /* HAVE_ERROR_CHECKING */
- HYDU_MALLOC(cb_element, struct HYDT_dmxu_callback *, sizeof(struct HYDT_dmxu_callback), status);
+ HYDU_MALLOC_OR_JUMP(cb_element, struct HYDT_dmxu_callback *, sizeof(struct HYDT_dmxu_callback), status);
cb_element->num_fds = num_fds;
- HYDU_MALLOC(cb_element->fd, int *, num_fds * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(cb_element->fd, int *, num_fds * sizeof(int), status);
memcpy(cb_element->fd, fd, num_fds * sizeof(int));
cb_element->events = events;
cb_element->userp = userp;
@@ -206,8 +206,8 @@ HYD_status HYDT_dmx_finalize(void)
while (run1) {
run2 = run1->next;
if (run1->fd)
- HYDU_FREE(run1->fd);
- HYDU_FREE(run1);
+ MPL_free(run1->fd);
+ MPL_free(run1);
run1 = run2;
}
HYDT_dmxu_cb_list = NULL;
diff --git a/src/pm/hydra/tools/demux/demux_poll.c b/src/pm/hydra/tools/demux/demux_poll.c
index b10ab96..0a762aa 100644
--- a/src/pm/hydra/tools/demux/demux_poll.c
+++ b/src/pm/hydra/tools/demux/demux_poll.c
@@ -15,7 +15,7 @@ HYD_status HYDT_dmxu_poll_wait_for_event(int wtime)
HYDU_FUNC_ENTER();
- HYDU_MALLOC(pollfds, struct pollfd *, HYDT_dmxu_num_cb_fds * sizeof(struct pollfd), status);
+ HYDU_MALLOC_OR_JUMP(pollfds, struct pollfd *, HYDT_dmxu_num_cb_fds * sizeof(struct pollfd), status);
for (i = 0, run = HYDT_dmxu_cb_list; run; run = run->next) {
for (j = 0; j < run->num_fds; j++) {
@@ -91,7 +91,7 @@ HYD_status HYDT_dmxu_poll_wait_for_event(int wtime)
fn_exit:
if (pollfds)
- HYDU_FREE(pollfds);
+ MPL_free(pollfds);
HYDU_FUNC_EXIT();
return status;
diff --git a/src/pm/hydra/tools/nameserver/hydra_nameserver.c b/src/pm/hydra/tools/nameserver/hydra_nameserver.c
index 6b4d93e..5179483 100644
--- a/src/pm/hydra/tools/nameserver/hydra_nameserver.c
+++ b/src/pm/hydra/tools/nameserver/hydra_nameserver.c
@@ -85,12 +85,12 @@ static void free_publish_element(struct HYDT_ns_publish *publish)
return;
if (publish->name)
- HYDU_FREE(publish->name);
+ MPL_free(publish->name);
if (publish->info)
- HYDU_FREE(publish->info);
+ MPL_free(publish->info);
- HYDU_FREE(publish);
+ MPL_free(publish);
}
static HYD_status cmd_response(int fd, const char *str)
@@ -142,19 +142,19 @@ static HYD_status request_cb(int fd, HYD_event_t events, void *userp)
HYDU_ERR_POP(status, "error reading data\n");
HYDU_ASSERT(!closed, status);
- HYDU_MALLOC(cmd, char *, len + 1, status);
+ HYDU_MALLOC_OR_JUMP(cmd, char *, len + 1, status);
status = HYDU_sock_read(fd, cmd, len, &recvd, &closed, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "error reading data\n");
HYDU_ASSERT(!closed, status);
if (!strcmp(cmd, "PUBLISH")) {
- HYDU_MALLOC(publish, struct HYDT_ns_publish *, sizeof(struct HYDT_ns_publish), status);
+ HYDU_MALLOC_OR_JUMP(publish, struct HYDT_ns_publish *, sizeof(struct HYDT_ns_publish), status);
status = HYDU_sock_read(fd, &len, sizeof(int), &recvd, &closed, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "error reading data\n");
HYDU_ASSERT(!closed, status);
- HYDU_MALLOC(publish->name, char *, len + 1, status);
+ HYDU_MALLOC_OR_JUMP(publish->name, char *, len + 1, status);
status = HYDU_sock_read(fd, publish->name, len, &recvd, &closed, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "error reading data\n");
HYDU_ASSERT(!closed, status);
@@ -163,7 +163,7 @@ static HYD_status request_cb(int fd, HYD_event_t events, void *userp)
HYDU_ERR_POP(status, "error reading data\n");
HYDU_ASSERT(!closed, status);
- HYDU_MALLOC(publish->info, char *, len + 1, status);
+ HYDU_MALLOC_OR_JUMP(publish->info, char *, len + 1, status);
status = HYDU_sock_read(fd, publish->info, len, &recvd, &closed, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "error reading data\n");
HYDU_ASSERT(!closed, status);
@@ -197,7 +197,7 @@ static HYD_status request_cb(int fd, HYD_event_t events, void *userp)
HYDU_ERR_POP(status, "error reading data\n");
HYDU_ASSERT(!closed, status);
- HYDU_MALLOC(name, char *, len + 1, status);
+ HYDU_MALLOC_OR_JUMP(name, char *, len + 1, status);
status = HYDU_sock_read(fd, name, len, &recvd, &closed, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "error reading data\n");
HYDU_ASSERT(!closed, status);
@@ -234,7 +234,7 @@ static HYD_status request_cb(int fd, HYD_event_t events, void *userp)
HYDU_ERR_POP(status, "error reading data\n");
HYDU_ASSERT(!closed, status);
- HYDU_MALLOC(name, char *, len + 1, status);
+ HYDU_MALLOC_OR_JUMP(name, char *, len + 1, status);
status = HYDU_sock_read(fd, name, len, &recvd, &closed, HYDU_SOCK_COMM_MSGWAIT);
HYDU_ERR_POP(status, "error reading data\n");
HYDU_ASSERT(!closed, status);
diff --git a/src/pm/hydra/tools/topo/hwloc/topo_hwloc.c b/src/pm/hydra/tools/topo/hwloc/topo_hwloc.c
index 896d8f5..4ba91b2 100644
--- a/src/pm/hydra/tools/topo/hwloc/topo_hwloc.c
+++ b/src/pm/hydra/tools/topo/hwloc/topo_hwloc.c
@@ -30,8 +30,8 @@ static HYD_status handle_user_binding(const char *binding)
for (i = 0; binding[i]; i++)
if (binding[i] == ',')
num_bind_entries++;
- HYDU_MALLOC(bind_entries, char **, num_bind_entries * sizeof(char *), status);
- HYDU_MALLOC(bind_entry_lengths, int *, num_bind_entries * sizeof(int), status);
+ HYDU_MALLOC_OR_JUMP(bind_entries, char **, num_bind_entries * sizeof(char *), status);
+ HYDU_MALLOC_OR_JUMP(bind_entry_lengths, int *, num_bind_entries * sizeof(int), status);
for (i = 0; i < num_bind_entries; i++)
bind_entry_lengths[i] = 0;
@@ -45,7 +45,7 @@ static HYD_status handle_user_binding(const char *binding)
}
for (i = 0; i < num_bind_entries; i++) {
- HYDU_MALLOC(bind_entries[i], char *, bind_entry_lengths[i] * sizeof(char), status);
+ HYDU_MALLOC_OR_JUMP(bind_entries[i], char *, bind_entry_lengths[i] * sizeof(char), status);
}
j = 0;
@@ -62,7 +62,7 @@ static HYD_status handle_user_binding(const char *binding)
bind_entries[j][k++] = 0;
/* initialize bitmaps */
- HYDU_MALLOC(HYDT_topo_hwloc_info.bitmap, hwloc_bitmap_t *,
+ HYDU_MALLOC_OR_JUMP(HYDT_topo_hwloc_info.bitmap, hwloc_bitmap_t *,
num_bind_entries * sizeof(hwloc_bitmap_t), status);
for (i = 0; i < num_bind_entries; i++) {
@@ -80,10 +80,10 @@ static HYD_status handle_user_binding(const char *binding)
/* free temporary memory */
for (i = 0; i < num_bind_entries; i++) {
- HYDU_FREE(bind_entries[i]);
+ MPL_free(bind_entries[i]);
}
- HYDU_FREE(bind_entries);
- HYDU_FREE(bind_entry_lengths);
+ MPL_free(bind_entries);
+ MPL_free(bind_entry_lengths);
fn_exit:
HYDU_FUNC_EXIT();
@@ -105,7 +105,7 @@ static HYD_status handle_rr_binding(void)
/* initialize bitmaps */
HYDT_topo_hwloc_info.num_bitmaps = hwloc_get_nbobjs_by_type(topology, HWLOC_OBJ_PU);
- HYDU_MALLOC(HYDT_topo_hwloc_info.bitmap, hwloc_bitmap_t *,
+ HYDU_MALLOC_OR_JUMP(HYDT_topo_hwloc_info.bitmap, hwloc_bitmap_t *,
HYDT_topo_hwloc_info.num_bitmaps * sizeof(hwloc_bitmap_t), status);
for (i = 0; i < HYDT_topo_hwloc_info.num_bitmaps; i++) {
@@ -271,8 +271,8 @@ static HYD_status handle_bitmap_binding(const char *binding, const char *mapping
total_map_domains = (i * total_map_objs) / map_count;
/* initialize the map domains */
- HYDU_MALLOC(map_domains, hwloc_bitmap_t *, total_map_domains * sizeof(hwloc_bitmap_t), status);
- HYDU_MALLOC(start_pu, hwloc_obj_t *, total_map_domains * sizeof(hwloc_obj_t), status);
+ HYDU_MALLOC_OR_JUMP(map_domains, hwloc_bitmap_t *, total_map_domains * sizeof(hwloc_bitmap_t), status);
+ HYDU_MALLOC_OR_JUMP(start_pu, hwloc_obj_t *, total_map_domains * sizeof(hwloc_obj_t), status);
/* For each map domain, find the next map object (first map object
* for the first map domain) and add the following "map_count"
@@ -319,7 +319,7 @@ static HYD_status handle_bitmap_binding(const char *binding, const char *mapping
}
/* initialize bitmaps */
- HYDU_MALLOC(HYDT_topo_hwloc_info.bitmap, hwloc_bitmap_t *,
+ HYDU_MALLOC_OR_JUMP(HYDT_topo_hwloc_info.bitmap, hwloc_bitmap_t *,
HYDT_topo_hwloc_info.num_bitmaps * sizeof(hwloc_bitmap_t), status);
for (i = 0; i < HYDT_topo_hwloc_info.num_bitmaps; i++) {
@@ -372,8 +372,8 @@ static HYD_status handle_bitmap_binding(const char *binding, const char *mapping
}
/* free temporary memory */
- HYDU_FREE(map_domains);
- HYDU_FREE(start_pu);
+ MPL_free(map_domains);
+ MPL_free(start_pu);
fn_exit:
HYDU_FUNC_EXIT();
@@ -459,7 +459,7 @@ HYD_status HYDT_topo_hwloc_bind(int idx)
int i;
char *binding;
- HYDU_MALLOC(binding, char *, HYDT_topo_hwloc_info.total_num_pus + 1, status);
+ HYDU_MALLOC_OR_JUMP(binding, char *, HYDT_topo_hwloc_info.total_num_pus + 1, status);
memset(binding, '\0', HYDT_topo_hwloc_info.total_num_pus + 1);
for (i = 0; i < HYDT_topo_hwloc_info.total_num_pus; i++) {
@@ -470,7 +470,7 @@ HYD_status HYDT_topo_hwloc_bind(int idx)
}
HYDU_dump_noprefix(stdout, "process %d binding: %s\n", idx, binding);
- HYDU_FREE(binding);
+ MPL_free(binding);
}
else {
hwloc_set_cpubind(topology, HYDT_topo_hwloc_info.bitmap[id], 0);
diff --git a/src/pm/hydra/tools/topo/topo.c b/src/pm/hydra/tools/topo/topo.c
index 9c3eb05..4c0f060 100644
--- a/src/pm/hydra/tools/topo/topo.c
+++ b/src/pm/hydra/tools/topo/topo.c
@@ -113,7 +113,7 @@ HYD_status HYDT_topo_finalize(void)
#endif /* HAVE_HWLOC */
if (HYDT_topo_info.topolib)
- HYDU_FREE(HYDT_topo_info.topolib);
+ MPL_free(HYDT_topo_info.topolib);
fn_exit:
HYDU_FUNC_EXIT();
diff --git a/src/pm/hydra/ui/mpich/mpiexec.c b/src/pm/hydra/ui/mpich/mpiexec.c
index d3e1652..f68ce2d 100644
--- a/src/pm/hydra/ui/mpich/mpiexec.c
+++ b/src/pm/hydra/ui/mpich/mpiexec.c
@@ -103,7 +103,7 @@ static HYD_status qsort_node_list(void)
for (count = 0, node = HYD_server_info.node_list; node; node = node->next, count++)
/* skip */ ;
- HYDU_MALLOC(node_list, struct HYD_node **, count * sizeof(struct HYD_node *), status);
+ HYDU_MALLOC_OR_JUMP(node_list, struct HYD_node **, count * sizeof(struct HYD_node *), status);
for (i = 0, node = HYD_server_info.node_list; node; node = node->next, i++)
node_list[i] = node;
@@ -117,7 +117,7 @@ static HYD_status qsort_node_list(void)
}
HYD_server_info.node_list = new_list;
- HYDU_FREE(node_list);
+ MPL_free(node_list);
fn_exit:
return status;
@@ -293,7 +293,7 @@ int main(int argc, char **argv)
if (node)
HYD_server_info.localhost = MPL_strdup(node->hostname);
else {
- HYDU_MALLOC(HYD_server_info.localhost, char *, MAX_HOSTNAME_LEN, status);
+ HYDU_MALLOC_OR_JUMP(HYD_server_info.localhost, char *, MAX_HOSTNAME_LEN, status);
if (gethostname(HYD_server_info.localhost, MAX_HOSTNAME_LEN) < 0)
HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "unable to get local hostname\n");
}
diff --git a/src/pm/hydra/ui/mpich/utils.c b/src/pm/hydra/ui/mpich/utils.c
index 000480e..f9f2df4 100644
--- a/src/pm/hydra/ui/mpich/utils.c
+++ b/src/pm/hydra/ui/mpich/utils.c
@@ -210,13 +210,13 @@ static HYD_status genv_fn(char *arg, char ***argv)
HYDU_append_env_to_list(env_name, env_value, &HYD_server_info.user_global.global_env.user);
if (str[0])
- HYDU_FREE(str[0]);
+ MPL_free(str[0]);
if (str[1])
- HYDU_FREE(str[1]);
+ MPL_free(str[1]);
if (env_name)
- HYDU_FREE(env_name);
+ MPL_free(env_name);
if (env_value)
- HYDU_FREE(env_value);
+ MPL_free(env_value);
fn_exit:
return status;
@@ -249,7 +249,7 @@ static HYD_status genvlist_fn(char *arg, char ***argv)
HYD_INTERNAL_ERROR, "duplicate environment setting\n");
len = strlen("list:") + strlen(**argv) + 1;
- HYDU_MALLOC(HYD_server_info.user_global.global_env.prop, char *, len, status);
+ HYDU_MALLOC_OR_JUMP(HYD_server_info.user_global.global_env.prop, char *, len, status);
MPL_snprintf(HYD_server_info.user_global.global_env.prop, len, "list:%s", **argv);
fn_exit:
@@ -657,13 +657,13 @@ static HYD_status env_fn(char *arg, char ***argv)
HYDU_append_env_to_list(env_name, env_value, &exec->user_env);
if (str[0])
- HYDU_FREE(str[0]);
+ MPL_free(str[0]);
if (str[1])
- HYDU_FREE(str[1]);
+ MPL_free(str[1]);
if (env_name)
- HYDU_FREE(env_name);
+ MPL_free(env_name);
if (env_value)
- HYDU_FREE(env_value);
+ MPL_free(env_value);
fn_exit:
return status;
@@ -695,7 +695,7 @@ static HYD_status envlist_fn(char *arg, char ***argv)
"duplicate environment setting\n");
len = strlen("list:") + strlen(**argv) + 1;
- HYDU_MALLOC(exec->env_prop, char *, len, status);
+ HYDU_MALLOC_OR_JUMP(exec->env_prop, char *, len, status);
MPL_snprintf(exec->env_prop, len, "list:%s", **argv);
(*argv)++;
@@ -1664,12 +1664,12 @@ HYD_status HYD_uii_mpx_get_parameters(char **t_argv)
if (ret) {
len = strlen(home) + strlen("/.mpiexec.hydra.conf") + 1;
- HYDU_MALLOC(conf_file, char *, len, status);
+ HYDU_MALLOC_OR_JUMP(conf_file, char *, len, status);
MPL_snprintf(conf_file, len, "%s/.mpiexec.hydra.conf", home);
ret = open(conf_file, O_RDONLY);
if (ret < 0) {
- HYDU_FREE(conf_file);
+ MPL_free(conf_file);
}
else {
close(ret);
@@ -1682,7 +1682,7 @@ HYD_status HYD_uii_mpx_get_parameters(char **t_argv)
conf_file = MPL_strdup(HYDRA_CONF_FILE);
ret = open(conf_file, O_RDONLY);
if (ret < 0) {
- HYDU_FREE(conf_file);
+ MPL_free(conf_file);
}
else {
close(ret);
@@ -1694,7 +1694,7 @@ HYD_status HYD_uii_mpx_get_parameters(char **t_argv)
config_file_check_exit:
if (config_file) {
HYDU_ASSERT(config_argv == NULL, status);
- HYDU_MALLOC(config_argv, char **, HYD_NUM_TMP_STRINGS * sizeof(char *), status);
+ HYDU_MALLOC_OR_JUMP(config_argv, char **, HYD_NUM_TMP_STRINGS * sizeof(char *), status);
status = HYDU_parse_hostfile(config_file, NULL, process_config_token);
HYDU_ERR_POP(status, "error parsing config file\n");
@@ -1704,7 +1704,7 @@ HYD_status HYD_uii_mpx_get_parameters(char **t_argv)
HYDU_ERR_POP(status, "error parsing config args\n");
reading_config_file = 0;
- HYDU_FREE(config_file);
+ MPL_free(config_file);
}
/* Get the base path */
@@ -1733,7 +1733,7 @@ HYD_status HYD_uii_mpx_get_parameters(char **t_argv)
HYD_server_info.base_path = MPL_strdup(post);
}
}
- HYDU_FREE(post);
+ MPL_free(post);
status = set_default_values();
HYDU_ERR_POP(status, "setting default values failed\n");
diff --git a/src/pm/hydra/ui/utils/uiu.c b/src/pm/hydra/ui/utils/uiu.c
index f935442..2f6c654 100644
--- a/src/pm/hydra/ui/utils/uiu.c
+++ b/src/pm/hydra/ui/utils/uiu.c
@@ -56,19 +56,19 @@ void HYD_uiu_free_params(void)
HYDU_finalize_user_global(&HYD_server_info.user_global);
if (HYD_server_info.base_path)
- HYDU_FREE(HYD_server_info.base_path);
+ MPL_free(HYD_server_info.base_path);
if (HYD_server_info.port_range)
- HYDU_FREE(HYD_server_info.port_range);
+ MPL_free(HYD_server_info.port_range);
if (HYD_server_info.iface_ip_env_name)
- HYDU_FREE(HYD_server_info.iface_ip_env_name);
+ MPL_free(HYD_server_info.iface_ip_env_name);
if (HYD_server_info.nameserver)
- HYDU_FREE(HYD_server_info.nameserver);
+ MPL_free(HYD_server_info.nameserver);
if (HYD_server_info.localhost)
- HYDU_FREE(HYD_server_info.localhost);
+ MPL_free(HYD_server_info.localhost);
if (HYD_server_info.node_list)
HYDU_free_node_list(HYD_server_info.node_list);
@@ -80,18 +80,18 @@ void HYD_uiu_free_params(void)
HYDU_free_pg_list(HYD_server_info.pg_list.next);
if (HYD_ui_info.prepend_pattern)
- HYDU_FREE(HYD_ui_info.prepend_pattern);
+ MPL_free(HYD_ui_info.prepend_pattern);
if (HYD_ui_info.outfile_pattern)
- HYDU_FREE(HYD_ui_info.outfile_pattern);
+ MPL_free(HYD_ui_info.outfile_pattern);
if (HYD_ui_info.errfile_pattern)
- HYDU_FREE(HYD_ui_info.errfile_pattern);
+ MPL_free(HYD_ui_info.errfile_pattern);
for (run = stdoe_fd_list; run;) {
close(run->fd);
tmp = run->next;
- HYDU_FREE(run);
+ MPL_free(run);
run = tmp;
}
@@ -180,7 +180,7 @@ static HYD_status resolve_pattern_string(const char *pattern, char **str, int pg
tpos = 0;
pos = 0;
i = 0;
- HYDU_MALLOC(tmp[i], char *, HYD_TMP_STRLEN, status);
+ HYDU_MALLOC_OR_JUMP(tmp[i], char *, HYD_TMP_STRLEN, status);
tmp[i][0] = '\0';
while (1) {
@@ -202,7 +202,7 @@ static HYD_status resolve_pattern_string(const char *pattern, char **str, int pg
tmp[i][tpos] = '\0';
++i;
tpos = 0;
- HYDU_MALLOC(tmp[i], char *, HYD_TMP_STRLEN, status);
+ HYDU_MALLOC_OR_JUMP(tmp[i], char *, HYD_TMP_STRLEN, status);
tmp[i][0] = '\0';
switch (pattern[pos]) {
@@ -240,7 +240,7 @@ static HYD_status resolve_pattern_string(const char *pattern, char **str, int pg
++i;
tpos = 0;
- HYDU_MALLOC(tmp[i], char *, HYD_TMP_STRLEN, status);
+ HYDU_MALLOC_OR_JUMP(tmp[i], char *, HYD_TMP_STRLEN, status);
tmp[i][0] = '\0';
}
}
@@ -283,10 +283,10 @@ static HYD_status stdoe_cb(int _fd, int pgid, int proxy_id, int rank, void *_buf
if (run) {
fd = run->fd;
- HYDU_FREE(pattern_resolve);
+ MPL_free(pattern_resolve);
}
else {
- HYDU_MALLOC(tmp, struct stdoe_fd *, sizeof(struct stdoe_fd), status);
+ HYDU_MALLOC_OR_JUMP(tmp, struct stdoe_fd *, sizeof(struct stdoe_fd), status);
tmp->pattern = pattern_resolve;
tmp->fd = open(tmp->pattern, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
HYDU_ASSERT(tmp->fd >= 0, status);
@@ -330,7 +330,7 @@ static HYD_status stdoe_cb(int _fd, int pgid, int proxy_id, int rank, void *_buf
}
}
- HYDU_FREE(prepend);
+ MPL_free(prepend);
}
fn_exit:
diff --git a/src/pm/hydra/utils/alloc/alloc.c b/src/pm/hydra/utils/alloc/alloc.c
index 5271eb6..d204ceb 100644
--- a/src/pm/hydra/utils/alloc/alloc.c
+++ b/src/pm/hydra/utils/alloc/alloc.c
@@ -34,31 +34,31 @@ void HYDU_init_user_global(struct HYD_user_global *user_global)
void HYDU_finalize_user_global(struct HYD_user_global *user_global)
{
if (user_global->rmk)
- HYDU_FREE(user_global->rmk);
+ MPL_free(user_global->rmk);
if (user_global->launcher)
- HYDU_FREE(user_global->launcher);
+ MPL_free(user_global->launcher);
if (user_global->launcher_exec)
- HYDU_FREE(user_global->launcher_exec);
+ MPL_free(user_global->launcher_exec);
if (user_global->binding)
- HYDU_FREE(user_global->binding);
+ MPL_free(user_global->binding);
if (user_global->topolib)
- HYDU_FREE(user_global->topolib);
+ MPL_free(user_global->topolib);
if (user_global->ckpointlib)
- HYDU_FREE(user_global->ckpointlib);
+ MPL_free(user_global->ckpointlib);
if (user_global->ckpoint_prefix)
- HYDU_FREE(user_global->ckpoint_prefix);
+ MPL_free(user_global->ckpoint_prefix);
if (user_global->demux)
- HYDU_FREE(user_global->demux);
+ MPL_free(user_global->demux);
if (user_global->iface)
- HYDU_FREE(user_global->iface);
+ MPL_free(user_global->iface);
HYDU_finalize_global_env(&user_global->global_env);
}
@@ -83,7 +83,7 @@ void HYDU_finalize_global_env(struct HYD_env_global *global_env)
HYDU_env_free_list(global_env->inherited);
if (global_env->prop)
- HYDU_FREE(global_env->prop);
+ MPL_free(global_env->prop);
}
HYD_status HYDU_alloc_node(struct HYD_node **node)
@@ -92,7 +92,7 @@ HYD_status HYDU_alloc_node(struct HYD_node **node)
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*node, struct HYD_node *, sizeof(struct HYD_node), status);
+ HYDU_MALLOC_OR_JUMP(*node, struct HYD_node *, sizeof(struct HYD_node), status);
(*node)->hostname = NULL;
(*node)->core_count = 0;
(*node)->active_processes = 0;
@@ -118,15 +118,15 @@ void HYDU_free_node_list(struct HYD_node *node_list)
tnode = node->next;
if (node->hostname)
- HYDU_FREE(node->hostname);
+ MPL_free(node->hostname);
if (node->user)
- HYDU_FREE(node->user);
+ MPL_free(node->user);
if (node->local_binding)
- HYDU_FREE(node->local_binding);
+ MPL_free(node->local_binding);
- HYDU_FREE(node);
+ MPL_free(node);
node = tnode;
}
@@ -151,7 +151,7 @@ HYD_status HYDU_alloc_pg(struct HYD_pg **pg, int pgid)
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*pg, struct HYD_pg *, sizeof(struct HYD_pg), status);
+ HYDU_MALLOC_OR_JUMP(*pg, struct HYD_pg *, sizeof(struct HYD_pg), status);
HYDU_init_pg(*pg, pgid);
fn_exit:
@@ -176,7 +176,7 @@ void HYDU_free_pg_list(struct HYD_pg *pg_list)
if (pg->user_node_list)
HYDU_free_node_list(pg->user_node_list);
- HYDU_FREE(pg);
+ MPL_free(pg);
pg = tpg;
}
@@ -188,7 +188,7 @@ static HYD_status alloc_proxy(struct HYD_proxy **proxy, struct HYD_pg *pg, struc
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*proxy, struct HYD_proxy *, sizeof(struct HYD_proxy), status);
+ HYDU_MALLOC_OR_JUMP(*proxy, struct HYD_proxy *, sizeof(struct HYD_proxy), status);
(*proxy)->node = node;
(*proxy)->pg = pg;
@@ -229,18 +229,18 @@ void HYDU_free_proxy_list(struct HYD_proxy *proxy_list)
if (proxy->exec_launch_info) {
HYDU_free_strlist(proxy->exec_launch_info);
- HYDU_FREE(proxy->exec_launch_info);
+ MPL_free(proxy->exec_launch_info);
}
if (proxy->pid)
- HYDU_FREE(proxy->pid);
+ MPL_free(proxy->pid);
if (proxy->exit_status)
- HYDU_FREE(proxy->exit_status);
+ MPL_free(proxy->exit_status);
HYDU_free_exec_list(proxy->exec_list);
- HYDU_FREE(proxy);
+ MPL_free(proxy);
proxy = tproxy;
}
@@ -253,7 +253,7 @@ HYD_status HYDU_alloc_exec(struct HYD_exec **exec)
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*exec, struct HYD_exec *, sizeof(struct HYD_exec), status);
+ HYDU_MALLOC_OR_JUMP(*exec, struct HYD_exec *, sizeof(struct HYD_exec), status);
(*exec)->exec[0] = NULL;
(*exec)->wdir = NULL;
(*exec)->proc_count = -1;
@@ -282,15 +282,15 @@ void HYDU_free_exec_list(struct HYD_exec *exec_list)
HYDU_free_strlist(exec->exec);
if (exec->wdir)
- HYDU_FREE(exec->wdir);
+ MPL_free(exec->wdir);
if (exec->env_prop)
- HYDU_FREE(exec->env_prop);
+ MPL_free(exec->env_prop);
HYDU_env_free_list(exec->user_env);
exec->user_env = NULL;
- HYDU_FREE(exec);
+ MPL_free(exec);
exec = run;
}
@@ -505,7 +505,7 @@ HYD_status HYDU_correct_wdir(char **wdir)
tmp[2] = MPL_strdup(*wdir);
tmp[3] = NULL;
- HYDU_FREE(*wdir);
+ MPL_free(*wdir);
status = HYDU_str_alloc_and_join(tmp, wdir);
HYDU_ERR_POP(status, "unable to join strings\n");
HYDU_free_strlist(tmp);
diff --git a/src/pm/hydra/utils/args/args.c b/src/pm/hydra/utils/args/args.c
index 923b590..850edd3 100644
--- a/src/pm/hydra/utils/args/args.c
+++ b/src/pm/hydra/utils/args/args.c
@@ -86,7 +86,7 @@ HYD_status HYDU_find_in_path(const char *execname, char **path)
goto fn_exit; /* We are done */
}
- HYDU_FREE(path_loc);
+ MPL_free(path_loc);
path_loc = NULL;
status = get_abs_wd(strtok(NULL, ";:"), &test_loc);
@@ -100,9 +100,9 @@ HYD_status HYDU_find_in_path(const char *execname, char **path)
fn_exit:
if (user_path)
- HYDU_FREE(user_path);
+ MPL_free(user_path);
if (path_loc)
- HYDU_FREE(path_loc);
+ MPL_free(path_loc);
HYDU_FUNC_EXIT();
return status;
@@ -228,7 +228,7 @@ char *HYDU_getcwd(void)
if (MPL_env2str("PWD", &pwdval) == 0)
pwdval = NULL;
- HYDU_MALLOC(cwdval, char *, HYDRA_MAX_PATH, status);
+ HYDU_MALLOC_OR_JUMP(cwdval, char *, HYDRA_MAX_PATH, status);
if (getcwd(cwdval, HYDRA_MAX_PATH) == NULL)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
"allocated space is too small for absolute path\n");
@@ -344,7 +344,7 @@ HYD_status HYDU_parse_hostfile(const char *hostfile, struct HYD_node **node_list
}
HYDU_free_strlist(tokens);
- HYDU_FREE(tokens);
+ MPL_free(tokens);
}
fclose(fp);
@@ -380,7 +380,7 @@ char *HYDU_find_full_path(const char *execname)
fn_exit:
HYDU_free_strlist(tmp);
if (test_path)
- HYDU_FREE(test_path);
+ MPL_free(test_path);
HYDU_FUNC_EXIT();
return path;
diff --git a/src/pm/hydra/utils/dbg/dbg.c b/src/pm/hydra/utils/dbg/dbg.c
index 4a95628..7180d3f 100644
--- a/src/pm/hydra/utils/dbg/dbg.c
+++ b/src/pm/hydra/utils/dbg/dbg.c
@@ -20,7 +20,7 @@ HYD_status HYDU_dbg_init(const char *str)
if (gethostname(hostname, MAX_HOSTNAME_LEN) < 0)
HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "unable to get local host name\n");
- HYDU_MALLOC(HYD_dbg_prefix, char *, strlen(hostname) + 1 + strlen(str) + 1, status);
+ HYDU_MALLOC_OR_JUMP(HYD_dbg_prefix, char *, strlen(hostname) + 1 + strlen(str) + 1, status);
MPL_snprintf(HYD_dbg_prefix, strlen(hostname) + 1 + strlen(str) + 1, "%s@%s", str, hostname);
fn_exit:
@@ -33,5 +33,5 @@ HYD_status HYDU_dbg_init(const char *str)
void HYDU_dbg_finalize(void)
{
- HYDU_FREE(HYD_dbg_prefix);
+ MPL_free(HYD_dbg_prefix);
}
diff --git a/src/pm/hydra/utils/env/env.c b/src/pm/hydra/utils/env/env.c
index 3584e0c..c59fe22 100644
--- a/src/pm/hydra/utils/env/env.c
+++ b/src/pm/hydra/utils/env/env.c
@@ -27,7 +27,7 @@ HYD_status HYDU_env_to_str(struct HYD_env *env, char **str)
HYDU_ERR_POP(status, "unable to join strings\n");
for (i = 0; tmp[i]; i++)
- HYDU_FREE(tmp[i]);
+ MPL_free(tmp[i]);
fn_exit:
HYDU_FUNC_EXIT();
@@ -55,7 +55,7 @@ HYD_status HYDU_list_inherited_env(struct HYD_env **env_list)
status = HYDT_bsci_query_env_inherit(env_name, &ret);
HYDU_ERR_POP(status, "error querying environment propagation\n");
- HYDU_FREE(env_str);
+ MPL_free(env_str);
env_str = NULL;
if (!ret) {
@@ -71,7 +71,7 @@ HYD_status HYDU_list_inherited_env(struct HYD_env **env_list)
fn_exit:
if (env_str)
- HYDU_FREE(env_str);
+ MPL_free(env_str);
HYDU_FUNC_EXIT();
return status;
@@ -111,7 +111,7 @@ HYD_status HYDU_env_create(struct HYD_env **env, const char *env_name, const cha
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*env, struct HYD_env *, sizeof(struct HYD_env), status);
+ HYDU_MALLOC_OR_JUMP(*env, struct HYD_env *, sizeof(struct HYD_env), status);
(*env)->env_name = MPL_strdup(env_name);
(*env)->env_value = env_value ? MPL_strdup(env_value) : NULL;
(*env)->next = NULL;
@@ -132,10 +132,10 @@ HYD_status HYDU_env_free(struct HYD_env *env)
HYDU_FUNC_ENTER();
if (env->env_name)
- HYDU_FREE(env->env_name);
+ MPL_free(env->env_name);
if (env->env_value)
- HYDU_FREE(env->env_value);
- HYDU_FREE(env);
+ MPL_free(env->env_value);
+ MPL_free(env);
HYDU_FUNC_EXIT();
return status;
@@ -204,21 +204,21 @@ HYD_status HYDU_append_env_to_list(const char *env_name, const char *env_value,
if (!strcmp(run->env_name, env_name)) {
/* If we found an entry for this environment variable, just update it */
if (run->env_value != NULL && tenv->env_value != NULL) {
- HYDU_FREE(run->env_value);
+ MPL_free(run->env_value);
run->env_value = MPL_strdup(tenv->env_value);
}
else if (run->env_value != NULL) {
- HYDU_FREE(run->env_value);
+ MPL_free(run->env_value);
run->env_value = NULL;
}
else if (env_value != NULL) {
run->env_value = MPL_strdup(tenv->env_value);
}
- HYDU_FREE(tenv->env_name);
+ MPL_free(tenv->env_name);
if (tenv->env_value)
- HYDU_FREE(tenv->env_value);
- HYDU_FREE(tenv);
+ MPL_free(tenv->env_value);
+ MPL_free(tenv);
break;
}
@@ -256,7 +256,7 @@ HYD_status HYDU_append_env_str_to_list(const char *str, struct HYD_env **env_lis
fn_exit:
if (my_str)
- HYDU_FREE(my_str);
+ MPL_free(my_str);
HYDU_FUNC_EXIT();
return status;
@@ -287,7 +287,7 @@ HYD_status HYDU_putenv(struct HYD_env *env, HYD_env_overwrite_t overwrite)
MPL_putenv(str);
for (i = 0; tmp[i]; i++)
- HYDU_FREE(tmp[i]);
+ MPL_free(tmp[i]);
fn_exit:
HYDU_FUNC_EXIT();
diff --git a/src/pm/hydra/utils/sock/sock.c b/src/pm/hydra/utils/sock/sock.c
index 37e4f49..7f8a2a6 100644
--- a/src/pm/hydra/utils/sock/sock.c
+++ b/src/pm/hydra/utils/sock/sock.c
@@ -329,7 +329,7 @@ static HYD_status alloc_fwd_hash(struct fwd_hash **fwd_hash, int in, int out)
HYDU_FUNC_ENTER();
- HYDU_MALLOC(*fwd_hash, struct fwd_hash *, sizeof(struct fwd_hash), status);
+ HYDU_MALLOC_OR_JUMP(*fwd_hash, struct fwd_hash *, sizeof(struct fwd_hash), status);
(*fwd_hash)->in = in;
(*fwd_hash)->out = out;
@@ -446,7 +446,7 @@ void HYDU_sock_finalize(void)
for (fwd_hash = fwd_hash_list; fwd_hash;) {
tmp = fwd_hash->next;
- HYDU_FREE(fwd_hash);
+ MPL_free(fwd_hash);
fwd_hash = tmp;
}
}
@@ -607,7 +607,7 @@ HYD_status HYDU_sock_is_local(char *host, int *is_local)
goto fn_exit;
}
- HYDU_FREE(lhost_ip);
+ MPL_free(lhost_ip);
lhost_ip = NULL;
}
}
@@ -616,9 +616,9 @@ HYD_status HYDU_sock_is_local(char *host, int *is_local)
fn_exit:
if (host_ip)
- HYDU_FREE(host_ip);
+ MPL_free(host_ip);
if (lhost_ip)
- HYDU_FREE(lhost_ip);
+ MPL_free(lhost_ip);
return status;
fn_fail:
@@ -686,13 +686,13 @@ HYDU_sock_create_and_listen_portstr(char *iface, char *hostname, char *port_rang
}
sport = HYDU_int_to_str(port);
- HYDU_MALLOC(*port_str, char *, strlen(ip) + 1 + strlen(sport) + 1, status);
+ HYDU_MALLOC_OR_JUMP(*port_str, char *, strlen(ip) + 1 + strlen(sport) + 1, status);
MPL_snprintf(*port_str, strlen(ip) + 1 + strlen(sport) + 1, "%s:%s", ip, sport);
- HYDU_FREE(sport);
+ MPL_free(sport);
fn_exit:
if (ip)
- HYDU_FREE(ip);
+ MPL_free(ip);
return status;
fn_fail:
diff --git a/src/pm/hydra/utils/string/string.c b/src/pm/hydra/utils/string/string.c
index 3278600..30d8a6c 100644
--- a/src/pm/hydra/utils/string/string.c
+++ b/src/pm/hydra/utils/string/string.c
@@ -46,7 +46,7 @@ void HYDU_free_strlist(char **strlist)
HYDU_FUNC_ENTER();
for (arg = 0; strlist[arg]; arg++)
- HYDU_FREE(strlist[arg]);
+ MPL_free(strlist[arg]);
HYDU_FUNC_EXIT();
}
@@ -63,7 +63,7 @@ HYD_status HYDU_str_alloc_and_join(char **strlist, char **strjoin)
len += strlen(strlist[i]);
}
- HYDU_MALLOC(*strjoin, char *, len + 1, status);
+ HYDU_MALLOC_OR_JUMP(*strjoin, char *, len + 1, status);
count = 0;
(*strjoin)[0] = 0;
@@ -118,7 +118,7 @@ HYD_status HYDU_strdup_list(char *src[], char **dest[])
HYDU_FUNC_ENTER();
count = HYDU_strlist_lastidx(src);
- HYDU_MALLOC(*dest, char **, (count + 1) * sizeof(char *), status);
+ HYDU_MALLOC_OR_JUMP(*dest, char **, (count + 1) * sizeof(char *), status);
for (i = 0; i < count; i++)
(*dest)[i] = MPL_strdup(src[i]);
@@ -148,7 +148,7 @@ char *HYDU_size_t_to_str(size_t x)
}
len++;
- HYDU_MALLOC(str, char *, len, status);
+ HYDU_MALLOC_OR_JUMP(str, char *, len, status);
HYDU_ERR_POP(status, "unable to allocate memory\n");
for (i = 0; i < len; i++)
@@ -197,7 +197,7 @@ char *HYDU_int_to_str_pad(int x, int maxlen)
else
actual_len = maxlen + 1;
- HYDU_MALLOC(str, char *, actual_len, status);
+ HYDU_MALLOC_OR_JUMP(str, char *, actual_len, status);
HYDU_ERR_POP(status, "unable to allocate memory\n");
for (i = 0; i < actual_len; i++)
@@ -231,7 +231,7 @@ char **HYDU_str_to_strlist(char *str)
HYDU_FUNC_ENTER();
- HYDU_MALLOC(strlist, char **, HYD_NUM_TMP_STRINGS * sizeof(char *), status);
+ HYDU_MALLOC_OR_JUMP(strlist, char **, HYD_NUM_TMP_STRINGS * sizeof(char *), status);
if (!strlist)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "Unable to allocate mem for strlist\n");
@@ -246,7 +246,7 @@ char **HYDU_str_to_strlist(char *str)
if (argc >= HYD_NUM_TMP_STRINGS)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "too many arguments in line\n");
- HYDU_MALLOC(strlist[argc], char *, HYD_TMP_STRLEN, status);
+ HYDU_MALLOC_OR_JUMP(strlist[argc], char *, HYD_TMP_STRLEN, status);
/* Copy till you hit a space */
i = 0;
@@ -261,7 +261,7 @@ char **HYDU_str_to_strlist(char *str)
}
}
if (strlist[argc])
- HYDU_FREE(strlist[argc]);
+ MPL_free(strlist[argc]);
strlist[argc] = NULL;
fn_exit:
http://git.mpich.org/mpich.git/commitdiff/7951766d3f3a37f54e73a8f1abc3d3783914039f
commit 7951766d3f3a37f54e73a8f1abc3d3783914039f
Author: Ken Raffenetti <raffenet at mcs.anl.gov>
Date: Fri Feb 5 13:39:40 2016 -0600
pm/hydra: use MPL memory utils directly
Instead of maintaining separate macros for memory tracing in Hydra,
use the MPL routines directly, which will enable tracing internally
when configured.
HYDU_malloc -> MPL_malloc
HYDU_realloc -> MPL_realloc
HYDU_strdup -> MPL_strdup
HYDU_free -> MPL_free
Signed-off-by: Pavan Balaji <balaji at anl.gov>
diff --git a/src/pm/hydra/configure.ac b/src/pm/hydra/configure.ac
index 19ff6a1..f5961fc 100644
--- a/src/pm/hydra/configure.ac
+++ b/src/pm/hydra/configure.ac
@@ -194,7 +194,7 @@ AC_SEARCH_LIBS(gethostbyname,nsl,)
AC_SEARCH_LIBS(hstrerror, resolv,)
# Check for necessary functions
-AC_CHECK_FUNCS(gettimeofday time strdup sigaction signal usleep alloca unsetenv \
+AC_CHECK_FUNCS(gettimeofday time sigaction signal usleep alloca unsetenv \
strerror strsignal stat fcntl alarm isatty inet_ntop getpgid \
setsid killpg hstrerror)
diff --git a/src/pm/hydra/include/hydra.h b/src/pm/hydra/include/hydra.h
index ecea5a1..3338af1 100644
--- a/src/pm/hydra/include/hydra.h
+++ b/src/pm/hydra/include/hydra.h
@@ -205,7 +205,7 @@ struct HYD_string_stash {
#define HYD_STRING_SPIT(stash, str, status) \
do { \
if ((stash).cur_count == 0) { \
- (str) = HYDU_strdup(""); \
+ (str) = MPL_strdup(""); \
} \
else { \
(status) = HYDU_str_alloc_and_join((stash).strlist, &(str)); \
@@ -612,40 +612,11 @@ HYD_status HYDU_sock_cloexec(int fd);
/* Memory utilities */
#include <ctype.h>
-#if defined USE_MEMORY_TRACING
-
-#define HYDU_mem_init() MPL_trinit(0,0)
-
-#define HYDU_strdup(a) MPL_trstrdup(a,__LINE__,__FILE__)
-#ifdef strdup
-#undef strdup
-#endif
-#define strdup(a) 'Error use HYDU_strdup' :::
-
-#define HYDU_malloc(a) MPL_trmalloc((unsigned)(a),__LINE__,__FILE__)
-#define malloc(a) 'Error use HYDU_malloc' :::
-
-#define HYDU_realloc(a,b) MPL_trrealloc((void *)(a),(unsigned)(b),__LINE__,__FILE__)
-#define realloc(a) 'Error use HYDU_realloc' :::
-
-#define HYDU_free(a) MPL_trfree(a,__LINE__,__FILE__)
-#define free(a) 'Error use HYDU_free' :::
-
-#else /* if !defined USE_MEMORY_TRACING */
-
-#define HYDU_mem_init()
-#define HYDU_strdup MPL_strdup
-#define HYDU_malloc malloc
-#define HYDU_realloc realloc
-#define HYDU_free free
-
-#endif /* USE_MEMORY_TRACING */
-
#define HYDU_MALLOC(p, type, size, status) \
{ \
(p) = NULL; /* initialize p in case assert fails */ \
HYDU_ASSERT(size, status); \
- (p) = (type) HYDU_malloc((size)); \
+ (p) = (type) MPL_malloc((size)); \
if ((p) == NULL) \
HYDU_ERR_SETANDJUMP((status), HYD_NO_MEM, \
"failed to allocate %d bytes\n", \
@@ -655,7 +626,7 @@ HYD_status HYDU_sock_cloexec(int fd);
#define HYDU_REALLOC(p, type, size, status) \
{ \
HYDU_ASSERT(size, status); \
- (p) = (type) HYDU_realloc((p),(size)); \
+ (p) = (type) MPL_realloc((p),(size)); \
if ((p) == NULL) \
HYDU_ERR_SETANDJUMP((status), HYD_NO_MEM, \
"failed to allocate %d bytes\n", \
@@ -664,7 +635,7 @@ HYD_status HYDU_sock_cloexec(int fd);
#define HYDU_FREE(p) \
{ \
- HYDU_free((void *) p); \
+ MPL_free((void *) p); \
}
HYD_status HYDU_list_append_strlist(char **exec, char **client_arg);
diff --git a/src/pm/hydra/pm/pmiserv/common.c b/src/pm/hydra/pm/pmiserv/common.c
index 2664024..72d3f87 100644
--- a/src/pm/hydra/pm/pmiserv/common.c
+++ b/src/pm/hydra/pm/pmiserv/common.c
@@ -30,7 +30,7 @@ HYD_status HYD_pmcd_pmi_parse_pmi_cmd(char *obuf, int pmi_version, char **pmi_cm
HYDU_FUNC_ENTER();
/* Make a copy of the original buffer */
- buf = HYDU_strdup(obuf);
+ buf = MPL_strdup(obuf);
if (buf[strlen(obuf) - 1] == '\n')
buf[strlen(obuf) - 1] = '\0';
@@ -49,7 +49,7 @@ HYD_status HYD_pmcd_pmi_parse_pmi_cmd(char *obuf, int pmi_version, char **pmi_cm
args[i] = strtok(NULL, delim);
if (args[i] == NULL)
break;
- args[i] = HYDU_strdup(args[i]);
+ args[i] = MPL_strdup(args[i]);
}
/* Search for the PMI command in our table */
@@ -78,7 +78,7 @@ HYD_status HYD_pmcd_pmi_args_to_tokens(char *args[], struct HYD_pmcd_token **tok
HYDU_MALLOC(*tokens, struct HYD_pmcd_token *, *count * sizeof(struct HYD_pmcd_token), status);
for (i = 0; args[i]; i++) {
- arg = HYDU_strdup(args[i]);
+ arg = MPL_strdup(args[i]);
(*tokens)[i].key = arg;
for (j = 0; arg[j] && arg[j] != '='; j++);
if (!arg[j]) {
diff --git a/src/pm/hydra/pm/pmiserv/pmi_v2_common.c b/src/pm/hydra/pm/pmiserv/pmi_v2_common.c
index 4913ddd..49739f2 100644
--- a/src/pm/hydra/pm/pmiserv/pmi_v2_common.c
+++ b/src/pm/hydra/pm/pmiserv/pmi_v2_common.c
@@ -25,7 +25,7 @@ HYD_status HYD_pmcd_pmi_v2_queue_req(int fd, int pid, int pgid, char *args[], ch
status = HYDU_strdup_list(args, &req->args);
HYDU_ERR_POP(status, "unable to dup args\n");
- req->key = HYDU_strdup(key);
+ req->key = MPL_strdup(key);
if (*pending_reqs == NULL)
*pending_reqs = req;
diff --git a/src/pm/hydra/pm/pmiserv/pmip_cb.c b/src/pm/hydra/pm/pmiserv/pmip_cb.c
index 7fe88f0..63be106 100644
--- a/src/pm/hydra/pm/pmiserv/pmip_cb.c
+++ b/src/pm/hydra/pm/pmiserv/pmip_cb.c
@@ -356,7 +356,7 @@ static HYD_status pmi_cb(int fd, HYD_event_t events, void *userp)
HYDU_FREE(pmi_cmd);
if (args) {
HYDU_free_strlist(args);
- HYDU_free(args);
+ MPL_free(args);
}
if (buf)
HYDU_FREE(buf);
@@ -420,7 +420,7 @@ static HYD_status handle_pmi_response(int fd, struct HYD_pmcd_hdr hdr)
HYDU_FREE(pmi_cmd);
if (args) {
HYDU_free_strlist(args);
- HYDU_free(args);
+ MPL_free(args);
}
if (buf)
HYDU_FREE(buf);
@@ -564,7 +564,7 @@ static HYD_status launch_procs(void)
* written value if needed. */
if (!exec->env_prop && HYD_pmcd_pmip.user_global.global_env.prop)
- exec->env_prop = HYDU_strdup(HYD_pmcd_pmip.user_global.global_env.prop);
+ exec->env_prop = MPL_strdup(HYD_pmcd_pmip.user_global.global_env.prop);
if (!exec->env_prop) {
/* user didn't specify anything; add inherited env to optional env */
@@ -582,9 +582,9 @@ static HYD_status launch_procs(void)
}
else if (!strncmp(exec->env_prop, "list", strlen("list"))) {
if (exec->env_prop)
- list = HYDU_strdup(exec->env_prop + strlen("list:"));
+ list = MPL_strdup(exec->env_prop + strlen("list:"));
else
- list = HYDU_strdup(HYD_pmcd_pmip.user_global.global_env.prop + strlen("list:"));
+ list = MPL_strdup(HYD_pmcd_pmip.user_global.global_env.prop + strlen("list:"));
envstr = strtok(list, ",");
while (envstr) {
@@ -688,7 +688,7 @@ static HYD_status launch_procs(void)
HYD_STRING_STASH_INIT(stash);
for (j = 0; exec->exec[j]; j++)
- HYD_STRING_STASH(stash, HYDU_strdup(exec->exec[j]), status);
+ HYD_STRING_STASH(stash, MPL_strdup(exec->exec[j]), status);
/* For non rank-0 processes, store the stdin socket in a
* dummy variable instead of passing NULL. Passing NULL
@@ -805,14 +805,14 @@ static HYD_status parse_exec_params(char **t_argv)
/* Set default values */
if (HYD_pmcd_pmip.user_global.binding == NULL)
- HYD_pmcd_pmip.user_global.binding = HYDU_strdup("none");
+ HYD_pmcd_pmip.user_global.binding = MPL_strdup("none");
if (HYD_pmcd_pmip.user_global.topolib == NULL && HYDRA_DEFAULT_TOPOLIB)
- HYD_pmcd_pmip.user_global.topolib = HYDU_strdup(HYDRA_DEFAULT_TOPOLIB);
+ HYD_pmcd_pmip.user_global.topolib = MPL_strdup(HYDRA_DEFAULT_TOPOLIB);
#ifdef HYDRA_DEFAULT_CKPOINTLIB
if (HYD_pmcd_pmip.user_global.ckpointlib == NULL)
- HYD_pmcd_pmip.user_global.ckpointlib = HYDU_strdup(HYDRA_DEFAULT_CKPOINTLIB);
+ HYD_pmcd_pmip.user_global.ckpointlib = MPL_strdup(HYDRA_DEFAULT_CKPOINTLIB);
#endif
fn_exit:
diff --git a/src/pm/hydra/pm/pmiserv/pmip_pmi_v1.c b/src/pm/hydra/pm/pmiserv/pmip_pmi_v1.c
index c2ec7e9..9c9397b 100644
--- a/src/pm/hydra/pm/pmiserv/pmip_pmi_v1.c
+++ b/src/pm/hydra/pm/pmiserv/pmip_pmi_v1.c
@@ -49,11 +49,11 @@ static HYD_status send_cmd_upstream(const char *start, int fd, int num_args, cha
HYDU_MALLOC(tmp, char **, (2 * num_args + 2) * sizeof(char *), status);
j = 0;
- tmp[j++] = HYDU_strdup(start);
+ tmp[j++] = MPL_strdup(start);
for (i = 0; i < num_args; i++) {
- tmp[j++] = HYDU_strdup(args[i]);
+ tmp[j++] = MPL_strdup(args[i]);
if (args[i + 1])
- tmp[j++] = HYDU_strdup(" ");
+ tmp[j++] = MPL_strdup(" ");
}
tmp[j] = NULL;
@@ -156,9 +156,9 @@ static HYD_status fn_init(int fd, char *args[])
pmi_subversion = atoi(strtok(NULL, "="));
if (pmi_version == 1 && pmi_subversion <= 1)
- tmp = HYDU_strdup("cmd=response_to_init pmi_version=1 pmi_subversion=1 rc=0\n");
+ tmp = MPL_strdup("cmd=response_to_init pmi_version=1 pmi_subversion=1 rc=0\n");
else if (pmi_version == 2 && pmi_subversion == 0)
- tmp = HYDU_strdup("cmd=response_to_init pmi_version=2 pmi_subversion=0 rc=0\n");
+ tmp = MPL_strdup("cmd=response_to_init pmi_version=2 pmi_subversion=0 rc=0\n");
else /* PMI version mismatch */
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
"PMI version mismatch; %d.%d\n", pmi_version, pmi_subversion);
@@ -214,16 +214,16 @@ static HYD_status fn_initack(int fd, char *args[])
HYDU_ASSERT(i < HYD_pmcd_pmip.local.proxy_process_count, status);
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=initack\ncmd=set size="), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=initack\ncmd=set size="), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(HYD_pmcd_pmip.system_global.global_process_count),
status);
- HYD_STRING_STASH(stash, HYDU_strdup("\ncmd=set rank="), status);
+ HYD_STRING_STASH(stash, MPL_strdup("\ncmd=set rank="), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(id), status);
- HYD_STRING_STASH(stash, HYDU_strdup("\ncmd=set debug="), status);
+ HYD_STRING_STASH(stash, MPL_strdup("\ncmd=set debug="), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(HYD_pmcd_pmip.user_global.debug), status);
- HYD_STRING_STASH(stash, HYDU_strdup("\n"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("\n"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -249,13 +249,13 @@ static HYD_status fn_get_maxes(int fd, char *args[])
HYDU_FUNC_ENTER();
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=maxes kvsname_max="), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=maxes kvsname_max="), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(PMI_MAXKVSLEN), status);
- HYD_STRING_STASH(stash, HYDU_strdup(" keylen_max="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(" keylen_max="), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(PMI_MAXKEYLEN), status);
- HYD_STRING_STASH(stash, HYDU_strdup(" vallen_max="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(" vallen_max="), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(PMI_MAXVALLEN), status);
- HYD_STRING_STASH(stash, HYDU_strdup("\n"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("\n"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -296,9 +296,9 @@ static HYD_status fn_get_appnum(int fd, char *args[])
}
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=appnum appnum="), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=appnum appnum="), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(exec->appnum), status);
- HYD_STRING_STASH(stash, HYDU_strdup("\n"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("\n"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -323,9 +323,9 @@ static HYD_status fn_get_my_kvsname(int fd, char *args[])
HYDU_FUNC_ENTER();
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=my_kvsname kvsname="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(HYD_pmcd_pmip.local.kvs->kvsname), status);
- HYD_STRING_STASH(stash, HYDU_strdup("\n"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=my_kvsname kvsname="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(HYD_pmcd_pmip.local.kvs->kvsname), status);
+ HYD_STRING_STASH(stash, MPL_strdup("\n"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -350,7 +350,7 @@ static HYD_status fn_get_usize(int fd, char *args[])
HYDU_FUNC_ENTER();
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=universe_size size="), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=universe_size size="), status);
if (HYD_pmcd_pmip.user_global.usize == HYD_USIZE_SYSTEM)
HYD_STRING_STASH(stash,
HYDU_int_to_str(HYD_pmcd_pmip.system_global.global_core_map.global_count),
@@ -359,7 +359,7 @@ static HYD_status fn_get_usize(int fd, char *args[])
HYD_STRING_STASH(stash, HYDU_int_to_str(-1), status);
else
HYD_STRING_STASH(stash, HYDU_int_to_str(HYD_pmcd_pmip.user_global.usize), status);
- HYD_STRING_STASH(stash, HYDU_strdup("\n"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("\n"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -393,10 +393,10 @@ static HYD_status fn_get(int fd, char *args[])
if (!strcmp(key, "PMI_process_mapping")) {
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=get_result rc=0 msg=success value="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(HYD_pmcd_pmip.system_global.pmi_process_mapping),
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=get_result rc=0 msg=success value="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(HYD_pmcd_pmip.system_global.pmi_process_mapping),
status);
- HYD_STRING_STASH(stash, HYDU_strdup("\n"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("\n"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -415,10 +415,10 @@ static HYD_status fn_get(int fd, char *args[])
if (val) {
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=get_result rc="), status);
- HYD_STRING_STASH(stash, HYDU_strdup("0 msg=success value="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(val), status);
- HYD_STRING_STASH(stash, HYDU_strdup("\n"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=get_result rc="), status);
+ HYD_STRING_STASH(stash, MPL_strdup("0 msg=success value="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(val), status);
+ HYD_STRING_STASH(stash, MPL_strdup("\n"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -461,13 +461,13 @@ static HYD_status fn_put(int fd, char *args[])
val = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "value");
if (val == NULL)
- val = HYDU_strdup("");
+ val = MPL_strdup("");
/* add to the cache */
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup(key), status);
- HYD_STRING_STASH(stash, HYDU_strdup("="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(val), status);
+ HYD_STRING_STASH(stash, MPL_strdup(key), status);
+ HYD_STRING_STASH(stash, MPL_strdup("="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(val), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -508,8 +508,8 @@ static HYD_status fn_keyval_cache(int fd, char *args[])
status);
for (i = 0; i < token_count; i++) {
- cache_get.key[cache_get.keyval_len + i] = HYDU_strdup(tokens[i].key);
- cache_get.val[cache_get.keyval_len + i] = HYDU_strdup(tokens[i].val);
+ cache_get.key[cache_get.keyval_len + i] = MPL_strdup(tokens[i].key);
+ cache_get.val[cache_get.keyval_len + i] = MPL_strdup(tokens[i].val);
}
cache_get.keyval_len += token_count;
@@ -555,7 +555,7 @@ static HYD_status fn_barrier_out(int fd, char *args[])
HYDU_FUNC_ENTER();
- cmd = HYDU_strdup("cmd=barrier_out\n");
+ cmd = MPL_strdup("cmd=barrier_out\n");
for (i = 0; i < HYD_pmcd_pmip.local.proxy_process_count; i++) {
status = send_cmd_downstream(HYD_pmcd_pmip.downstream.pmi_fd[i], cmd);
@@ -581,7 +581,7 @@ static HYD_status fn_finalize(int fd, char *args[])
HYDU_FUNC_ENTER();
- cmd = HYDU_strdup("cmd=finalize_ack\n");
+ cmd = MPL_strdup("cmd=finalize_ack\n");
status = send_cmd_downstream(fd, cmd);
HYDU_ERR_POP(status, "error sending PMI response\n");
diff --git a/src/pm/hydra/pm/pmiserv/pmip_pmi_v2.c b/src/pm/hydra/pm/pmiserv/pmip_pmi_v2.c
index 31b96fb..bbe5190 100644
--- a/src/pm/hydra/pm/pmiserv/pmip_pmi_v2.c
+++ b/src/pm/hydra/pm/pmiserv/pmip_pmi_v2.c
@@ -26,11 +26,11 @@ static HYD_status send_cmd_upstream(const char *start, int fd, char *args[])
HYDU_FUNC_ENTER();
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup(start), status);
+ HYD_STRING_STASH(stash, MPL_strdup(start), status);
for (i = 0; args[i]; i++) {
- HYD_STRING_STASH(stash, HYDU_strdup(args[i]), status);
+ HYD_STRING_STASH(stash, MPL_strdup(args[i]), status);
if (args[i + 1])
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
HYD_STRING_SPIT(stash, buf, status);
@@ -180,25 +180,25 @@ static HYD_status fn_fullinit(int fd, char *args[])
HYD_STRING_STASH_INIT(stash);
HYD_STRING_STASH(stash,
- HYDU_strdup("cmd=fullinit-response;pmi-version=2;pmi-subversion=0;rank="),
+ MPL_strdup("cmd=fullinit-response;pmi-version=2;pmi-subversion=0;rank="),
status);
HYD_STRING_STASH(stash, HYDU_int_to_str(id), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";size="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";size="), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(HYD_pmcd_pmip.system_global.global_process_count),
status);
- HYD_STRING_STASH(stash, HYDU_strdup(";appnum=0"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";appnum=0"), status);
if (HYD_pmcd_pmip.local.spawner_kvsname) {
- HYD_STRING_STASH(stash, HYDU_strdup(";spawner-jobid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(HYD_pmcd_pmip.local.spawner_kvsname), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";spawner-jobid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(HYD_pmcd_pmip.local.spawner_kvsname), status);
}
if (HYD_pmcd_pmip.user_global.debug) {
- HYD_STRING_STASH(stash, HYDU_strdup(";debugged=TRUE;pmiverbose=TRUE"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";debugged=TRUE;pmiverbose=TRUE"), status);
}
else {
- HYD_STRING_STASH(stash, HYDU_strdup(";debugged=FALSE;pmiverbose=FALSE"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";debugged=FALSE;pmiverbose=FALSE"), status);
}
- HYD_STRING_STASH(stash, HYDU_strdup(";rc=0;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";rc=0;"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -230,15 +230,15 @@ static HYD_status fn_job_getid(int fd, char *args[])
thrid = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "thrid");
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=job-getid-response;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=job-getid-response;"), status);
if (thrid) {
- HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(thrid), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("thrid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(thrid), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
- HYD_STRING_STASH(stash, HYDU_strdup("jobid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(HYD_pmcd_pmip.local.kvs->kvsname), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";rc=0;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("jobid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(HYD_pmcd_pmip.local.kvs->kvsname), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";rc=0;"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -281,15 +281,15 @@ static HYD_status fn_info_putnodeattr(int fd, char *args[])
HYDU_ERR_POP(status, "unable to put data into kvs\n");
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=info-putnodeattr-response;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=info-putnodeattr-response;"), status);
if (thrid) {
- HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(thrid), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("thrid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(thrid), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
- HYD_STRING_STASH(stash, HYDU_strdup("rc="), status);
+ HYD_STRING_STASH(stash, MPL_strdup("rc="), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(ret), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -350,15 +350,15 @@ static HYD_status fn_info_getnodeattr(int fd, char *args[])
if (found) { /* We found the attribute */
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=info-getnodeattr-response;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=info-getnodeattr-response;"), status);
if (thrid) {
- HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(thrid), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("thrid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(thrid), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
- HYD_STRING_STASH(stash, HYDU_strdup("found=TRUE;value="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(run->val), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";rc=0;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("found=TRUE;value="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(run->val), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";rc=0;"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -375,13 +375,13 @@ static HYD_status fn_info_getnodeattr(int fd, char *args[])
else {
/* Tell the client that we can't find the attribute */
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=info-getnodeattr-response;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=info-getnodeattr-response;"), status);
if (thrid) {
- HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(thrid), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("thrid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(thrid), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
- HYD_STRING_STASH(stash, HYDU_strdup("found=FALSE;rc=0;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("found=FALSE;rc=0;"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -419,16 +419,16 @@ static HYD_status fn_info_getjobattr(int fd, char *args[])
if (!strcmp(key, "PMI_process_mapping")) {
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=info-getjobattr-response;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=info-getjobattr-response;"), status);
if (thrid) {
- HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(thrid), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("thrid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(thrid), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
- HYD_STRING_STASH(stash, HYDU_strdup("found=TRUE;value="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(HYD_pmcd_pmip.system_global.pmi_process_mapping),
+ HYD_STRING_STASH(stash, MPL_strdup("found=TRUE;value="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(HYD_pmcd_pmip.system_global.pmi_process_mapping),
status);
- HYD_STRING_STASH(stash, HYDU_strdup(";rc=0;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";rc=0;"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -466,13 +466,13 @@ static HYD_status fn_finalize(int fd, char *args[])
thrid = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "thrid");
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=finalize-response;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=finalize-response;"), status);
if (thrid) {
- HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(thrid), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("thrid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(thrid), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
- HYD_STRING_STASH(stash, HYDU_strdup("rc=0;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("rc=0;"), status);
HYD_STRING_SPIT(stash, cmd, status);
diff --git a/src/pm/hydra/pm/pmiserv/pmip_utils.c b/src/pm/hydra/pm/pmiserv/pmip_utils.c
index 58ae0d7..c3062d9 100644
--- a/src/pm/hydra/pm/pmiserv/pmip_utils.c
+++ b/src/pm/hydra/pm/pmiserv/pmip_utils.c
@@ -41,8 +41,8 @@ static HYD_status control_port_fn(char *arg, char ***argv)
HYDU_ERR_CHKANDJUMP(status, HYD_pmcd_pmip.upstream.server_name, HYD_INTERNAL_ERROR,
"duplicate control port setting\n");
- port = HYDU_strdup(**argv);
- HYD_pmcd_pmip.upstream.server_name = HYDU_strdup(strtok(port, ":"));
+ port = MPL_strdup(**argv);
+ HYD_pmcd_pmip.upstream.server_name = MPL_strdup(strtok(port, ":"));
HYD_pmcd_pmip.upstream.server_port = atoi(strtok(NULL, ":"));
(*argv)++;
@@ -293,7 +293,7 @@ static HYD_status parse_ckpoint_prefix(char *pathlist)
dummy = strtok(pathlist, ":");
i = 0;
while (dummy) {
- HYD_pmcd_pmip.local.ckpoint_prefix_list[i] = HYDU_strdup(dummy);
+ HYD_pmcd_pmip.local.ckpoint_prefix_list[i] = MPL_strdup(dummy);
dummy = strtok(NULL, ":");
i++;
}
@@ -375,7 +375,7 @@ static HYD_status global_core_map_fn(char *arg, char ***argv)
HYD_status status = HYD_SUCCESS;
/* Split the core map into three different segments */
- map = HYDU_strdup(**argv);
+ map = MPL_strdup(**argv);
HYDU_ASSERT(map, status);
tmp = strtok(map, ",");
@@ -408,7 +408,7 @@ static HYD_status pmi_id_map_fn(char *arg, char ***argv)
HYD_status status = HYD_SUCCESS;
/* Split the core map into three different segments */
- map = HYDU_strdup(**argv);
+ map = MPL_strdup(**argv);
HYDU_ASSERT(map, status);
tmp = strtok(map, ",");
@@ -618,7 +618,7 @@ static HYD_status exec_args_fn(char *arg, char ***argv)
count = atoi(**argv);
for (i = 0; i < count; i++) {
(*argv)++;
- exec->exec[i] = HYDU_strdup(**argv);
+ exec->exec[i] = MPL_strdup(**argv);
}
exec->exec[i] = NULL;
(*argv)++;
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_cb.c b/src/pm/hydra/pm/pmiserv/pmiserv_cb.c
index a9d2c1c..f79a7bd 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_cb.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_cb.c
@@ -62,7 +62,7 @@ static HYD_status handle_pmi_cmd(int fd, int pgid, int pid, char *buf, int pmi_v
HYDU_FREE(cmd);
if (args) {
HYDU_free_strlist(args);
- HYDU_free(args);
+ MPL_free(args);
}
HYDU_FUNC_EXIT();
return status;
@@ -357,7 +357,7 @@ static HYD_status control_cb(int fd, HYD_event_t events, void *userp)
int included = 0, value;
/* Create a sorted list of processes */
- current_list = HYDU_strdup(pg_scratch->dead_processes);
+ current_list = MPL_strdup(pg_scratch->dead_processes);
/* Search to see if this process is already in the list */
included = 0;
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_pmi.c b/src/pm/hydra/pm/pmiserv/pmiserv_pmi.c
index 82b6db7..58746b4 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_pmi.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_pmi.c
@@ -83,8 +83,8 @@ HYD_status HYD_pmcd_pmi_publish(char *name, char *port, int *success)
HYDU_MALLOC(publish, struct HYD_pmcd_pmi_publish *,
sizeof(struct HYD_pmcd_pmi_publish), status);
- publish->name = HYDU_strdup(name);
- publish->port = HYDU_strdup(port);
+ publish->name = MPL_strdup(name);
+ publish->port = MPL_strdup(port);
publish->infokeycount = 0;
publish->info_keys = NULL;
publish->next = NULL;
@@ -102,7 +102,7 @@ HYD_status HYD_pmcd_pmi_publish(char *name, char *port, int *success)
/* connect to the external nameserver and store the
* information there */
- ns = HYDU_strdup(HYD_server_info.nameserver);
+ ns = MPL_strdup(HYD_server_info.nameserver);
ns_host = strtok(ns, ":");
HYDU_ASSERT(ns_host, status);
@@ -117,9 +117,9 @@ HYD_status HYD_pmcd_pmi_publish(char *name, char *port, int *success)
HYDU_ERR_POP(status, "error connecting to the nameserver\n");
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("PUBLISH"), status);
- HYD_STRING_STASH(stash, HYDU_strdup(name), status);
- HYD_STRING_STASH(stash, HYDU_strdup(port), status);
+ HYD_STRING_STASH(stash, MPL_strdup("PUBLISH"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(name), status);
+ HYD_STRING_STASH(stash, MPL_strdup(port), status);
status = HYDU_send_strlist(ns_fd, stash.strlist);
HYDU_ERR_POP(status, "error sending string list\n");
@@ -205,7 +205,7 @@ HYD_status HYD_pmcd_pmi_unpublish(char *name, int *success)
/* connect to the external nameserver and get the information
* from there */
- ns = HYDU_strdup(HYD_server_info.nameserver);
+ ns = MPL_strdup(HYD_server_info.nameserver);
ns_host = strtok(ns, ":");
HYDU_ASSERT(ns_host, status);
@@ -220,8 +220,8 @@ HYD_status HYD_pmcd_pmi_unpublish(char *name, int *success)
HYDU_ERR_POP(status, "error connecting to the nameserver\n");
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("UNPUBLISH"), status);
- HYD_STRING_STASH(stash, HYDU_strdup(name), status);
+ HYD_STRING_STASH(stash, MPL_strdup("UNPUBLISH"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(name), status);
status = HYDU_send_strlist(ns_fd, stash.strlist);
HYDU_ERR_POP(status, "error sending string list\n");
@@ -270,7 +270,7 @@ HYD_status HYD_pmcd_pmi_lookup(char *name, char **value)
break;
if (publish)
- *value = HYDU_strdup(publish->port);
+ *value = MPL_strdup(publish->port);
}
else {
int len, recvd, closed;
@@ -278,7 +278,7 @@ HYD_status HYD_pmcd_pmi_lookup(char *name, char **value)
/* connect to the external nameserver and get the information
* from there */
- ns = HYDU_strdup(HYD_server_info.nameserver);
+ ns = MPL_strdup(HYD_server_info.nameserver);
ns_host = strtok(ns, ":");
HYDU_ASSERT(ns_host, status);
@@ -293,8 +293,8 @@ HYD_status HYD_pmcd_pmi_lookup(char *name, char **value)
HYDU_ERR_POP(status, "error connecting to the nameserver\n");
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("LOOKUP"), status);
- HYD_STRING_STASH(stash, HYDU_strdup(name), status);
+ HYD_STRING_STASH(stash, MPL_strdup("LOOKUP"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(name), status);
status = HYDU_send_strlist(ns_fd, stash.strlist);
HYDU_ERR_POP(status, "error sending string list\n");
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v1.c b/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v1.c
index bfb8048..0bc976d 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v1.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v1.c
@@ -75,19 +75,19 @@ static HYD_status bcast_keyvals(int fd, int pid)
if (keyval_count) {
arg_count = 1;
i = 0;
- tmp[i++] = HYDU_strdup("cmd=keyval_cache ");
+ tmp[i++] = MPL_strdup("cmd=keyval_cache ");
for (run = pg_scratch->kvs->key_pair, j = 0; run; run = run->next, j++) {
if (j < pg_scratch->keyval_dist_count)
continue;
- tmp[i++] = HYDU_strdup(run->key);
- tmp[i++] = HYDU_strdup("=");
- tmp[i++] = HYDU_strdup(run->val);
- tmp[i++] = HYDU_strdup(" ");
+ tmp[i++] = MPL_strdup(run->key);
+ tmp[i++] = MPL_strdup("=");
+ tmp[i++] = MPL_strdup(run->val);
+ tmp[i++] = MPL_strdup(" ");
arg_count++;
if (arg_count >= MAX_PMI_INTERNAL_ARGS) {
- tmp[i++] = HYDU_strdup("\n");
+ tmp[i++] = MPL_strdup("\n");
tmp[i++] = NULL;
status = HYDU_str_alloc_and_join(tmp, &cmd);
@@ -102,11 +102,11 @@ static HYD_status bcast_keyvals(int fd, int pid)
HYDU_FREE(cmd);
i = 0;
- tmp[i++] = HYDU_strdup("cmd=keyval_cache ");
+ tmp[i++] = MPL_strdup("cmd=keyval_cache ");
arg_count = 1;
}
}
- tmp[i++] = HYDU_strdup("\n");
+ tmp[i++] = MPL_strdup("\n");
tmp[i++] = NULL;
if (arg_count > 1) {
@@ -249,17 +249,17 @@ static HYD_status fn_get(int fd, int pid, int pgid, char *args[])
found_val:
i = 0;
- tmp[i++] = HYDU_strdup("cmd=get_result rc=");
+ tmp[i++] = MPL_strdup("cmd=get_result rc=");
if (val) {
- tmp[i++] = HYDU_strdup("0 msg=success value=");
- tmp[i++] = HYDU_strdup(val);
+ tmp[i++] = MPL_strdup("0 msg=success value=");
+ tmp[i++] = MPL_strdup(val);
}
else {
- tmp[i++] = HYDU_strdup("-1 msg=key_");
- tmp[i++] = HYDU_strdup(key);
- tmp[i++] = HYDU_strdup("_not_found value=unknown");
+ tmp[i++] = MPL_strdup("-1 msg=key_");
+ tmp[i++] = MPL_strdup(key);
+ tmp[i++] = MPL_strdup("_not_found value=unknown");
}
- tmp[i++] = HYDU_strdup("\n");
+ tmp[i++] = MPL_strdup("\n");
tmp[i++] = NULL;
status = HYDU_str_alloc_and_join(tmp, &cmd);
@@ -330,7 +330,7 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
HYDU_FUNC_ENTER();
for (i = 0; args[i]; i++)
- mcmd_args[mcmd_num_args++] = HYDU_strdup(args[i]);
+ mcmd_args[mcmd_num_args++] = MPL_strdup(args[i]);
mcmd_args[mcmd_num_args] = NULL;
/* Initialize the proxy stash, so it can be freed if we jump to
@@ -450,10 +450,10 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
info_val = val;
if (!strcmp(info_key, "path")) {
- path = HYDU_strdup(info_val);
+ path = MPL_strdup(info_val);
}
else if (!strcmp(info_key, "wdir")) {
- exec->wdir = HYDU_strdup(info_val);
+ exec->wdir = MPL_strdup(info_val);
}
else if (!strcmp(info_key, "host") || !strcmp(info_key, "hosts")) {
char *saveptr;
@@ -482,12 +482,12 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
HYDU_ERR_CHKANDJUMP(status, val == NULL, HYD_INTERNAL_ERROR,
"unable to find token: execname\n");
if (path == NULL)
- execname = HYDU_strdup(val);
+ execname = MPL_strdup(val);
else {
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup(path), status);
- HYD_STRING_STASH(stash, HYDU_strdup("/"), status);
- HYD_STRING_STASH(stash, HYDU_strdup(val), status);
+ HYD_STRING_STASH(stash, MPL_strdup(path), status);
+ HYD_STRING_STASH(stash, MPL_strdup("/"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(val), status);
HYD_STRING_SPIT(stash, execname, status);
}
@@ -500,7 +500,7 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
segment_list[j].token_count, key);
HYDU_ERR_CHKANDJUMP(status, val == NULL, HYD_INTERNAL_ERROR,
"unable to find token: %s\n", key);
- exec->exec[i++] = HYDU_strdup(val);
+ exec->exec[i++] = MPL_strdup(val);
}
exec->exec[i++] = NULL;
@@ -599,8 +599,8 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
char *cmd;
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=spawn_result rc=0"), status);
- HYD_STRING_STASH(stash, HYDU_strdup("\n"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=spawn_result rc=0"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("\n"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -642,22 +642,22 @@ static HYD_status fn_publish_name(int fd, int pid, int pgid, char *args[])
if ((val = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "service")) == NULL)
HYDU_ERR_POP(status, "cannot find token: service\n");
- name = HYDU_strdup(val);
+ name = MPL_strdup(val);
if ((val = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "port")) == NULL)
HYDU_ERR_POP(status, "cannot find token: port\n");
- port = HYDU_strdup(val);
+ port = MPL_strdup(val);
status = HYD_pmcd_pmi_publish(name, port, &success);
HYDU_ERR_POP(status, "error publishing service\n");
HYD_STRING_STASH_INIT(stash);
if (success)
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=publish_result info=ok rc=0 msg=success\n"),
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=publish_result info=ok rc=0 msg=success\n"),
status);
else
HYD_STRING_STASH(stash,
- HYDU_strdup("cmd=publish_result info=ok rc=1 msg=key_already_present\n"),
+ MPL_strdup("cmd=publish_result info=ok rc=1 msg=key_already_present\n"),
status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -703,11 +703,11 @@ static HYD_status fn_unpublish_name(int fd, int pid, int pgid, char *args[])
HYD_STRING_STASH_INIT(stash);
if (success)
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=unpublish_result info=ok rc=0 msg=success\n"),
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=unpublish_result info=ok rc=0 msg=success\n"),
status);
else
HYD_STRING_STASH(stash,
- HYDU_strdup("cmd=unpublish_result info=ok rc=1 msg=service_not_found\n"),
+ MPL_strdup("cmd=unpublish_result info=ok rc=1 msg=service_not_found\n"),
status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -746,14 +746,14 @@ static HYD_status fn_lookup_name(int fd, int pid, int pgid, char *args[])
HYDU_ERR_POP(status, "error while looking up service\n");
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=lookup_result"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=lookup_result"), status);
if (value) {
- HYD_STRING_STASH(stash, HYDU_strdup(" port="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(value), status);
- HYD_STRING_STASH(stash, HYDU_strdup(" info=ok rc=0 msg=success\n"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(" port="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(value), status);
+ HYD_STRING_STASH(stash, MPL_strdup(" info=ok rc=0 msg=success\n"), status);
}
else {
- HYD_STRING_STASH(stash, HYDU_strdup(" rc=1 msg=service_not_found\n"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(" rc=1 msg=service_not_found\n"), status);
}
HYD_STRING_SPIT(stash, cmd, status);
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v2.c b/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v2.c
index 2c385a6..d6afc67 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v2.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_pmi_v2.c
@@ -149,20 +149,20 @@ static HYD_status fn_info_getjobattr(int fd, int pid, int pgid, char *args[])
}
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=info-getjobattr-response;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=info-getjobattr-response;"), status);
if (thrid) {
- HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(thrid), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("thrid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(thrid), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
- HYD_STRING_STASH(stash, HYDU_strdup("found="), status);
+ HYD_STRING_STASH(stash, MPL_strdup("found="), status);
if (val) {
- HYD_STRING_STASH(stash, HYDU_strdup("TRUE;value="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(val), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";rc=0;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("TRUE;value="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(val), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";rc=0;"), status);
}
else {
- HYD_STRING_STASH(stash, HYDU_strdup("FALSE;rc=0;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("FALSE;rc=0;"), status);
}
HYD_STRING_SPIT(stash, cmd, status);
@@ -204,7 +204,7 @@ static HYD_status fn_kvs_put(int fd, int pid, int pgid, char *args[])
val = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "value");
if (val == NULL) {
/* the user sent an empty string */
- val = HYDU_strdup("");
+ val = MPL_strdup("");
}
thrid = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "thrid");
@@ -218,15 +218,15 @@ static HYD_status fn_kvs_put(int fd, int pid, int pgid, char *args[])
HYDU_ERR_POP(status, "unable to put data into kvs\n");
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=kvs-put-response;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=kvs-put-response;"), status);
if (thrid) {
- HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(thrid), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("thrid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(thrid), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
- HYD_STRING_STASH(stash, HYDU_strdup("rc="), status);
+ HYD_STRING_STASH(stash, MPL_strdup("rc="), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(ret), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -314,21 +314,21 @@ static HYD_status fn_kvs_get(int fd, int pid, int pgid, char *args[])
}
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=kvs-get-response;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=kvs-get-response;"), status);
if (thrid) {
- HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(thrid), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("thrid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(thrid), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
if (found) {
- HYD_STRING_STASH(stash, HYDU_strdup("found=TRUE;value="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(run->val), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("found=TRUE;value="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(run->val), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
else {
- HYD_STRING_STASH(stash, HYDU_strdup("found=FALSE;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("found=FALSE;"), status);
}
- HYD_STRING_STASH(stash, HYDU_strdup("rc=0;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("rc=0;"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -386,13 +386,13 @@ static HYD_status fn_kvs_fence(int fd, int pid, int pgid, char *args[])
}
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=kvs-fence-response;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=kvs-fence-response;"), status);
if (thrid) {
- HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(thrid), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("thrid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(thrid), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
- HYD_STRING_STASH(stash, HYDU_strdup("rc=0;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("rc=0;"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -566,10 +566,10 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
info_val = val;
if (!strcmp(info_key, "path")) {
- path = HYDU_strdup(info_val);
+ path = MPL_strdup(info_val);
}
else if (!strcmp(info_key, "wdir")) {
- exec->wdir = HYDU_strdup(info_val);
+ exec->wdir = MPL_strdup(info_val);
}
else if (!strcmp(info_key, "host") || !strcmp(info_key, "hosts")) {
char *saveptr;
@@ -598,12 +598,12 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
HYDU_ERR_CHKANDJUMP(status, val == NULL, HYD_INTERNAL_ERROR,
"unable to find token: subcmd\n");
if (path == NULL)
- execname = HYDU_strdup(val);
+ execname = MPL_strdup(val);
else {
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup(path), status);
- HYD_STRING_STASH(stash, HYDU_strdup("/"), status);
- HYD_STRING_STASH(stash, HYDU_strdup(val), status);
+ HYD_STRING_STASH(stash, MPL_strdup(path), status);
+ HYD_STRING_STASH(stash, MPL_strdup("/"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(val), status);
HYD_STRING_SPIT(stash, execname, status);
}
@@ -616,7 +616,7 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
segment_list[j].token_count, key);
HYDU_ERR_CHKANDJUMP(status, val == NULL, HYD_INTERNAL_ERROR,
"unable to find token: %s\n", key);
- exec->exec[i++] = HYDU_strdup(val);
+ exec->exec[i++] = MPL_strdup(val);
}
exec->exec[i++] = NULL;
@@ -714,17 +714,17 @@ static HYD_status fn_spawn(int fd, int pid, int pgid, char *args[])
char *cmd;
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=spawn-response;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=spawn-response;"), status);
if (thrid) {
- HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(thrid), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("thrid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(thrid), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
- HYD_STRING_STASH(stash, HYDU_strdup("rc=0;"), status);
- HYD_STRING_STASH(stash, HYDU_strdup("jobid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(pg_scratch->kvs->kvsname), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
- HYD_STRING_STASH(stash, HYDU_strdup("nerrs=0;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("rc=0;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("jobid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(pg_scratch->kvs->kvsname), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("nerrs=0;"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -762,29 +762,29 @@ static HYD_status fn_name_publish(int fd, int pid, int pgid, char *args[])
if ((val = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "name")) == NULL)
HYDU_ERR_POP(status, "cannot find token: name\n");
- name = HYDU_strdup(val);
+ name = MPL_strdup(val);
if ((val = HYD_pmcd_pmi_find_token_keyval(tokens, token_count, "port")) == NULL)
HYDU_ERR_POP(status, "cannot find token: port\n");
- port = HYDU_strdup(val);
+ port = MPL_strdup(val);
status = HYD_pmcd_pmi_publish(name, port, &success);
HYDU_ERR_POP(status, "error publishing service\n");
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=name-publish-response;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=name-publish-response;"), status);
if (thrid) {
- HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(thrid), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("thrid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(thrid), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
if (!success) {
- HYD_STRING_STASH(stash, HYDU_strdup("rc=1;errmsg=duplicate_service_"), status);
- HYD_STRING_STASH(stash, HYDU_strdup(name), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("rc=1;errmsg=duplicate_service_"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(name), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
else
- HYD_STRING_STASH(stash, HYDU_strdup("rc=0;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("rc=0;"), status);
HYD_STRING_SPIT(stash, cmd, status);
@@ -828,18 +828,18 @@ static HYD_status fn_name_unpublish(int fd, int pid, int pgid, char *args[])
HYDU_ERR_POP(status, "error unpublishing service\n");
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=name-unpublish-response;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=name-unpublish-response;"), status);
if (thrid) {
- HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(thrid), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("thrid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(thrid), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
if (success)
- HYD_STRING_STASH(stash, HYDU_strdup("rc=0;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("rc=0;"), status);
else {
- HYD_STRING_STASH(stash, HYDU_strdup("rc=1;errmsg=service_"), status);
- HYD_STRING_STASH(stash, HYDU_strdup(name), status);
- HYD_STRING_STASH(stash, HYDU_strdup("_not_found;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("rc=1;errmsg=service_"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(name), status);
+ HYD_STRING_STASH(stash, MPL_strdup("_not_found;"), status);
}
HYD_STRING_SPIT(stash, cmd, status);
@@ -880,19 +880,19 @@ static HYD_status fn_name_lookup(int fd, int pid, int pgid, char *args[])
HYDU_ERR_POP(status, "error while looking up service\n");
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("cmd=name-lookup-response;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("cmd=name-lookup-response;"), status);
if (thrid) {
- HYD_STRING_STASH(stash, HYDU_strdup("thrid="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(thrid), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("thrid="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(thrid), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";"), status);
}
if (value) {
- HYD_STRING_STASH(stash, HYDU_strdup("port="), status);
- HYD_STRING_STASH(stash, HYDU_strdup(value), status);
- HYD_STRING_STASH(stash, HYDU_strdup(";found=TRUE;rc=0;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("port="), status);
+ HYD_STRING_STASH(stash, MPL_strdup(value), status);
+ HYD_STRING_STASH(stash, MPL_strdup(";found=TRUE;rc=0;"), status);
}
else {
- HYD_STRING_STASH(stash, HYDU_strdup("found=FALSE;rc=1;"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("found=FALSE;rc=1;"), status);
}
HYD_STRING_SPIT(stash, cmd, status);
diff --git a/src/pm/hydra/pm/pmiserv/pmiserv_utils.c b/src/pm/hydra/pm/pmiserv/pmiserv_utils.c
index 00dff91..aa94066 100644
--- a/src/pm/hydra/pm/pmiserv/pmiserv_utils.c
+++ b/src/pm/hydra/pm/pmiserv/pmiserv_utils.c
@@ -28,74 +28,74 @@ HYD_status HYD_pmcd_pmi_fill_in_proxy_args(struct HYD_string_stash *proxy_stash,
HYD_STRING_STASH_INIT(*proxy_stash);
if (use_ddd) {
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("ddd"), status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("--args"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("ddd"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("--args"), status);
}
if (use_valgrind) {
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("valgrind"), status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("--leak-check=full"), status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("--show-reachable=yes"), status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("--track-origins=yes"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("valgrind"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("--leak-check=full"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("--show-reachable=yes"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("--track-origins=yes"), status);
}
if (use_strace) {
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("strace"), status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("-o"), status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("hydra_strace"), status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("-ff"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("strace"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("-o"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("hydra_strace"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("-ff"), status);
}
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup(HYD_server_info.base_path), status);
- HYD_STRING_STASH(stash, HYDU_strdup(HYDRA_PMI_PROXY), status);
+ HYD_STRING_STASH(stash, MPL_strdup(HYD_server_info.base_path), status);
+ HYD_STRING_STASH(stash, MPL_strdup(HYDRA_PMI_PROXY), status);
HYD_STRING_SPIT(stash, str, status);
HYD_STRING_STASH(*proxy_stash, str, status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("--control-port"), status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup(control_port), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("--control-port"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup(control_port), status);
if (HYD_server_info.user_global.debug)
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("--debug"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("--debug"), status);
if (HYDT_bsci_info.rmk) {
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("--rmk"), status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup(HYDT_bsci_info.rmk), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("--rmk"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup(HYDT_bsci_info.rmk), status);
}
if (HYDT_bsci_info.launcher) {
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("--launcher"), status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup(HYDT_bsci_info.launcher), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("--launcher"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup(HYDT_bsci_info.launcher), status);
}
if (HYDT_bsci_info.launcher_exec) {
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("--launcher-exec"), status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup(HYDT_bsci_info.launcher_exec), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("--launcher-exec"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup(HYDT_bsci_info.launcher_exec), status);
}
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("--demux"), status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup(HYD_server_info.user_global.demux), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("--demux"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup(HYD_server_info.user_global.demux), status);
if (HYD_server_info.user_global.iface) {
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("--iface"), status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup(HYD_server_info.user_global.iface), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("--iface"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup(HYD_server_info.user_global.iface), status);
}
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("--pgid"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("--pgid"), status);
HYD_STRING_STASH(*proxy_stash, HYDU_int_to_str(pgid), status);
ret = MPL_env2int("HYDRA_PROXY_RETRY_COUNT", &retries);
if (ret == 0)
retries = HYD_DEFAULT_RETRY_COUNT;
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("--retries"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("--retries"), status);
HYD_STRING_STASH(*proxy_stash, HYDU_int_to_str(retries), status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("--usize"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("--usize"), status);
HYD_STRING_STASH(*proxy_stash, HYDU_int_to_str(HYD_server_info.user_global.usize), status);
- HYD_STRING_STASH(*proxy_stash, HYDU_strdup("--proxy-id"), status);
+ HYD_STRING_STASH(*proxy_stash, MPL_strdup("--proxy-id"), status);
if (HYD_server_info.user_global.debug) {
HYDU_dump_noprefix(stdout, "\nProxy launch args: ");
@@ -203,20 +203,20 @@ static HYD_status pmi_process_mapping(struct HYD_pg *pg, char **process_mapping_
/* Create the mapping out of the blocks */
HYD_STRING_STASH_INIT(stash);
- HYD_STRING_STASH(stash, HYDU_strdup("("), status);
- HYD_STRING_STASH(stash, HYDU_strdup("vector,"), status);
+ HYD_STRING_STASH(stash, MPL_strdup("("), status);
+ HYD_STRING_STASH(stash, MPL_strdup("vector,"), status);
for (block = blocklist_head; block; block = block->next) {
- HYD_STRING_STASH(stash, HYDU_strdup("("), status);
+ HYD_STRING_STASH(stash, MPL_strdup("("), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(block->start_idx), status);
- HYD_STRING_STASH(stash, HYDU_strdup(","), status);
+ HYD_STRING_STASH(stash, MPL_strdup(","), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(block->num_nodes), status);
- HYD_STRING_STASH(stash, HYDU_strdup(","), status);
+ HYD_STRING_STASH(stash, MPL_strdup(","), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(block->core_count), status);
- HYD_STRING_STASH(stash, HYDU_strdup(")"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(")"), status);
if (block->next)
- HYD_STRING_STASH(stash, HYDU_strdup(","), status);
+ HYD_STRING_STASH(stash, MPL_strdup(","), status);
}
- HYD_STRING_STASH(stash, HYDU_strdup(")"), status);
+ HYD_STRING_STASH(stash, MPL_strdup(")"), status);
HYD_STRING_SPIT(stash, *process_mapping_str, status);
@@ -296,26 +296,26 @@ HYD_status HYD_pmcd_pmi_fill_in_exec_launch_info(struct HYD_pg *pg)
HYD_STRING_STASH_INIT(exec_stash);
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--version"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(HYDRA_VERSION), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--version"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(HYDRA_VERSION), status);
if (HYD_server_info.iface_ip_env_name) {
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--iface-ip-env-name"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(HYD_server_info.iface_ip_env_name), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--iface-ip-env-name"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(HYD_server_info.iface_ip_env_name), status);
}
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--hostname"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(proxy->node->hostname), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--hostname"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(proxy->node->hostname), status);
/* This map has three fields: filler cores on this node,
* remaining cores on this node, total cores in the system */
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--global-core-map"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--global-core-map"), status);
HYD_STRING_STASH_INIT(stash);
HYD_STRING_STASH(stash, HYDU_int_to_str(proxy->filler_processes), status);
- HYD_STRING_STASH(stash, HYDU_strdup(","), status);
+ HYD_STRING_STASH(stash, MPL_strdup(","), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(proxy->node->core_count), status);
- HYD_STRING_STASH(stash, HYDU_strdup(","), status);
+ HYD_STRING_STASH(stash, MPL_strdup(","), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(total_core_count), status);
HYD_STRING_SPIT(stash, map, status);
@@ -323,79 +323,79 @@ HYD_status HYD_pmcd_pmi_fill_in_exec_launch_info(struct HYD_pg *pg)
/* This map has two fields: start PMI ID during the filler
* phase, start PMI ID for the remaining phase */
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--pmi-id-map"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--pmi-id-map"), status);
HYD_STRING_STASH_INIT(stash);
HYD_STRING_STASH(stash, HYDU_int_to_str(filler_pmi_ids[proxy_count]), status);
- HYD_STRING_STASH(stash, HYDU_strdup(","), status);
+ HYD_STRING_STASH(stash, MPL_strdup(","), status);
HYD_STRING_STASH(stash, HYDU_int_to_str(nonfiller_pmi_ids[proxy_count]), status);
HYD_STRING_SPIT(stash, map, status);
HYD_STRING_STASH(exec_stash, map, status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--global-process-count"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--global-process-count"), status);
HYD_STRING_STASH(exec_stash, HYDU_int_to_str(pg->pg_process_count), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--auto-cleanup"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--auto-cleanup"), status);
HYD_STRING_STASH(exec_stash, HYDU_int_to_str(HYD_server_info.user_global.auto_cleanup),
status);
pg_scratch = (struct HYD_pmcd_pmi_pg_scratch *) pg->pg_scratch;
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--pmi-kvsname"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(pg_scratch->kvs->kvsname), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--pmi-kvsname"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(pg_scratch->kvs->kvsname), status);
if (pg->spawner_pg) {
pg_scratch = (struct HYD_pmcd_pmi_pg_scratch *) pg->spawner_pg->pg_scratch;
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--pmi-spawner-kvsname"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(pg_scratch->kvs->kvsname), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--pmi-spawner-kvsname"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(pg_scratch->kvs->kvsname), status);
}
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--pmi-process-mapping"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(mapping), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--pmi-process-mapping"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(mapping), status);
if (proxy->node->local_binding) {
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--binding"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(proxy->node->local_binding), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--binding"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(proxy->node->local_binding), status);
}
else if (HYD_server_info.user_global.binding) {
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--binding"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(HYD_server_info.user_global.binding), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--binding"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(HYD_server_info.user_global.binding), status);
}
if (HYD_server_info.user_global.mapping) {
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--mapping"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(HYD_server_info.user_global.mapping), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--mapping"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(HYD_server_info.user_global.mapping), status);
}
if (HYD_server_info.user_global.membind) {
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--membind"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(HYD_server_info.user_global.membind), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--membind"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(HYD_server_info.user_global.membind), status);
}
if (HYD_server_info.user_global.topolib) {
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--topolib"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(HYD_server_info.user_global.topolib), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--topolib"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(HYD_server_info.user_global.topolib), status);
}
if (HYD_server_info.user_global.ckpointlib) {
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--ckpointlib"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(HYD_server_info.user_global.ckpointlib),
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--ckpointlib"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(HYD_server_info.user_global.ckpointlib),
status);
}
if (HYD_server_info.user_global.ckpoint_prefix) {
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--ckpoint-prefix"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(HYD_server_info.user_global.ckpoint_prefix),
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--ckpoint-prefix"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(HYD_server_info.user_global.ckpoint_prefix),
status);
}
if (HYD_server_info.user_global.ckpoint_num) {
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--ckpoint-num"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--ckpoint-num"), status);
HYD_STRING_STASH(exec_stash, HYDU_int_to_str(HYD_server_info.user_global.ckpoint_num),
status);
}
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--global-inherited-env"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--global-inherited-env"), status);
for (i = 0, env = HYD_server_info.user_global.global_env.inherited; env;
env = env->next, i++);
HYD_STRING_STASH(exec_stash, HYDU_int_to_str(i), status);
@@ -409,7 +409,7 @@ HYD_status HYD_pmcd_pmi_fill_in_exec_launch_info(struct HYD_pg *pg)
HYD_STRING_STASH(exec_stash, envstr, status);
}
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--global-user-env"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--global-user-env"), status);
for (i = 0, env = HYD_server_info.user_global.global_env.user; env; env = env->next, i++);
HYD_STRING_STASH(exec_stash, HYDU_int_to_str(i), status);
@@ -422,7 +422,7 @@ HYD_status HYD_pmcd_pmi_fill_in_exec_launch_info(struct HYD_pg *pg)
HYD_STRING_STASH(exec_stash, envstr, status);
}
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--global-system-env"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--global-system-env"), status);
for (i = 0, env = HYD_server_info.user_global.global_env.system; env; env = env->next, i++);
HYD_STRING_STASH(exec_stash, HYDU_int_to_str(i), status);
@@ -436,25 +436,25 @@ HYD_status HYD_pmcd_pmi_fill_in_exec_launch_info(struct HYD_pg *pg)
}
if (HYD_server_info.user_global.global_env.prop) {
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--genv-prop"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(HYD_server_info.user_global.global_env.prop),
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--genv-prop"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(HYD_server_info.user_global.global_env.prop),
status);
}
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--proxy-core-count"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--proxy-core-count"), status);
HYD_STRING_STASH(exec_stash, HYDU_int_to_str(proxy->node->core_count), status);
/* Now pass the local executable information */
for (exec = proxy->exec_list; exec; exec = exec->next) {
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--exec"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--exec"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--exec-appnum"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--exec-appnum"), status);
HYD_STRING_STASH(exec_stash, HYDU_int_to_str(exec->appnum), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--exec-proc-count"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--exec-proc-count"), status);
HYD_STRING_STASH(exec_stash, HYDU_int_to_str(exec->proc_count), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--exec-local-env"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--exec-local-env"), status);
for (i = 0, env = exec->user_env; env; env = env->next, i++);
HYD_STRING_STASH(exec_stash, HYDU_int_to_str(i), status);
@@ -468,21 +468,21 @@ HYD_status HYD_pmcd_pmi_fill_in_exec_launch_info(struct HYD_pg *pg)
}
if (exec->env_prop) {
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--exec-env-prop"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(exec->env_prop), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--exec-env-prop"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(exec->env_prop), status);
}
if (exec->wdir) {
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--exec-wdir"), status);
- HYD_STRING_STASH(exec_stash, HYDU_strdup(exec->wdir), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--exec-wdir"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(exec->wdir), status);
}
- HYD_STRING_STASH(exec_stash, HYDU_strdup("--exec-args"), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup("--exec-args"), status);
for (i = 0; exec->exec[i]; i++);
HYD_STRING_STASH(exec_stash, HYDU_int_to_str(i), status);
for (i = 0; exec->exec[i]; i++)
- HYD_STRING_STASH(exec_stash, HYDU_strdup(exec->exec[i]), status);
+ HYD_STRING_STASH(exec_stash, MPL_strdup(exec->exec[i]), status);
}
if (HYD_server_info.user_global.debug) {
@@ -534,7 +534,7 @@ HYD_status HYD_pmcd_pmi_alloc_pg_scratch(struct HYD_pg *pg)
pg_scratch->control_listen_fd = HYD_FD_UNSET;
pg_scratch->pmi_listen_fd = HYD_FD_UNSET;
- pg_scratch->dead_processes = HYDU_strdup("");
+ pg_scratch->dead_processes = MPL_strdup("");
pg_scratch->dead_process_count = 0;
status = HYD_pmcd_pmi_allocate_kvs(&pg_scratch->kvs, pg->pgid);
diff --git a/src/pm/hydra/tools/bootstrap/external/external_common_launch.c b/src/pm/hydra/tools/bootstrap/external/external_common_launch.c
index 0bfd5f7..c1c6bf3 100644
--- a/src/pm/hydra/tools/bootstrap/external/external_common_launch.c
+++ b/src/pm/hydra/tools/bootstrap/external/external_common_launch.c
@@ -17,11 +17,11 @@ static int fd_stdout, fd_stderr;
static HYD_status ssh_get_path(char **path)
{
if (HYDT_bsci_info.launcher_exec)
- *path = HYDU_strdup(HYDT_bsci_info.launcher_exec);
+ *path = MPL_strdup(HYDT_bsci_info.launcher_exec);
if (*path == NULL)
*path = HYDU_find_full_path("ssh");
if (*path == NULL)
- *path = HYDU_strdup("/usr/bin/ssh");
+ *path = MPL_strdup("/usr/bin/ssh");
return HYD_SUCCESS;
}
@@ -29,11 +29,11 @@ static HYD_status ssh_get_path(char **path)
static HYD_status rsh_get_path(char **path)
{
if (HYDT_bsci_info.launcher_exec)
- *path = HYDU_strdup(HYDT_bsci_info.launcher_exec);
+ *path = MPL_strdup(HYDT_bsci_info.launcher_exec);
if (*path == NULL)
*path = HYDU_find_full_path("rsh");
if (*path == NULL)
- *path = HYDU_strdup("/usr/bin/rsh");
+ *path = MPL_strdup("/usr/bin/rsh");
return HYD_SUCCESS;
}
@@ -45,7 +45,7 @@ static HYD_status lsf_get_path(char **path)
HYD_status status = HYD_SUCCESS;
if (HYDT_bsci_info.launcher_exec)
- *path = HYDU_strdup(HYDT_bsci_info.launcher_exec);
+ *path = MPL_strdup(HYDT_bsci_info.launcher_exec);
if (*path == NULL) {
MPL_env2str("LSF_BINDIR", (const char **) &bin_dir);
@@ -58,7 +58,7 @@ static HYD_status lsf_get_path(char **path)
if (*path == NULL)
*path = HYDU_find_full_path("blaunch");
if (*path == NULL)
- *path = HYDU_strdup("/usr/bin/blaunch");
+ *path = MPL_strdup("/usr/bin/blaunch");
fn_exit:
return status;
@@ -74,7 +74,7 @@ static HYD_status sge_get_path(char **path)
HYD_status status = HYD_SUCCESS;
if (HYDT_bsci_info.launcher_exec)
- *path = HYDU_strdup(HYDT_bsci_info.launcher_exec);
+ *path = MPL_strdup(HYDT_bsci_info.launcher_exec);
if (*path == NULL) {
MPL_env2str("SGE_ROOT", (const char **) &sge_root);
@@ -88,7 +88,7 @@ static HYD_status sge_get_path(char **path)
if (*path == NULL)
*path = HYDU_find_full_path("qrsh");
if (*path == NULL)
- *path = HYDU_strdup("/usr/bin/qrsh");
+ *path = MPL_strdup("/usr/bin/qrsh");
fn_exit:
return status;
@@ -140,31 +140,31 @@ HYD_status HYDT_bscd_common_launch_procs(char **args, struct HYD_proxy *proxy_li
idx = 0;
if (path)
- targs[idx++] = HYDU_strdup(path);
+ targs[idx++] = MPL_strdup(path);
targs[idx] = NULL;
/* Allow X forwarding only if explicitly requested */
if (!strcmp(HYDT_bsci_info.launcher, "ssh")) {
if (HYDT_bsci_info.enablex == 1)
- targs[idx++] = HYDU_strdup("-X");
+ targs[idx++] = MPL_strdup("-X");
else if (HYDT_bsci_info.enablex == 0)
- targs[idx++] = HYDU_strdup("-x");
+ targs[idx++] = MPL_strdup("-x");
else /* default mode is disable X */
- targs[idx++] = HYDU_strdup("-x");
+ targs[idx++] = MPL_strdup("-x");
}
else if (!strcmp(HYDT_bsci_info.launcher, "lsf")) {
- targs[idx++] = HYDU_strdup("-n");
+ targs[idx++] = MPL_strdup("-n");
}
else if (!strcmp(HYDT_bsci_info.launcher, "sge")) {
- targs[idx++] = HYDU_strdup("-inherit");
- targs[idx++] = HYDU_strdup("-V");
+ targs[idx++] = MPL_strdup("-inherit");
+ targs[idx++] = MPL_strdup("-V");
}
MPL_env2str("HYDRA_LAUNCHER_EXTRA_ARGS", (const char **) &extra_arg_list);
if (extra_arg_list) {
extra_arg = strtok(extra_arg_list, " ");
while (extra_arg) {
- targs[idx++] = HYDU_strdup(extra_arg);
+ targs[idx++] = MPL_strdup(extra_arg);
extra_arg = strtok(NULL, " ");
}
}
@@ -175,7 +175,7 @@ HYD_status HYDT_bscd_common_launch_procs(char **args, struct HYD_proxy *proxy_li
/* Fill in the remaining arguments */
exec_idx = idx; /* Store the executable index */
for (i = 0; args[i]; i++)
- targs[idx++] = HYDU_strdup(args[i]);
+ targs[idx++] = MPL_strdup(args[i]);
/* Store the original exec string */
original_exec_string = targs[exec_idx];
@@ -215,7 +215,7 @@ HYD_status HYDT_bscd_common_launch_procs(char **args, struct HYD_proxy *proxy_li
if (targs[host_idx])
HYDU_FREE(targs[host_idx]);
if (proxy->node->user == NULL) {
- targs[host_idx] = HYDU_strdup(proxy->node->hostname);
+ targs[host_idx] = MPL_strdup(proxy->node->hostname);
}
else {
len = strlen(proxy->node->user) + strlen("@") + strlen(proxy->node->hostname) + 1;
diff --git a/src/pm/hydra/tools/bootstrap/external/ll_launch.c b/src/pm/hydra/tools/bootstrap/external/ll_launch.c
index c14cdea..f7aa365 100644
--- a/src/pm/hydra/tools/bootstrap/external/ll_launch.c
+++ b/src/pm/hydra/tools/bootstrap/external/ll_launch.c
@@ -28,14 +28,14 @@ HYD_status HYDT_bscd_ll_launch_procs(char **args, struct HYD_proxy *proxy_list,
* (1) user-specified; (2) search in path; (3) Hard-coded
* location */
if (HYDT_bsci_info.launcher_exec)
- path = HYDU_strdup(HYDT_bsci_info.launcher_exec);
+ path = MPL_strdup(HYDT_bsci_info.launcher_exec);
if (!path)
path = HYDU_find_full_path("poe");
if (!path)
- path = HYDU_strdup("/usr/bin/poe");
+ path = MPL_strdup("/usr/bin/poe");
idx = 0;
- targs[idx++] = HYDU_strdup(path);
+ targs[idx++] = MPL_strdup(path);
if (!strcmp(HYDT_bsci_info.rmk, "ll")) {
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
@@ -59,7 +59,7 @@ HYD_status HYDT_bscd_ll_launch_procs(char **args, struct HYD_proxy *proxy_list,
if (extra_arg_list) {
extra_arg = strtok(extra_arg_list, " ");
while (extra_arg) {
- targs[idx++] = HYDU_strdup(extra_arg);
+ targs[idx++] = MPL_strdup(extra_arg);
extra_arg = strtok(NULL, " ");
}
}
@@ -67,7 +67,7 @@ HYD_status HYDT_bscd_ll_launch_procs(char **args, struct HYD_proxy *proxy_list,
/* Fill in the remaining arguments */
exec_idx = idx;
for (i = 0; args[i]; i++)
- targs[idx++] = HYDU_strdup(args[i]);
+ targs[idx++] = MPL_strdup(args[i]);
/* Create a quoted version of the exec string, which is only used
* when the executable is not launched directly, but through an
diff --git a/src/pm/hydra/tools/bootstrap/external/lsf_query_node_list.c b/src/pm/hydra/tools/bootstrap/external/lsf_query_node_list.c
index c20502a..a8bbe94 100644
--- a/src/pm/hydra/tools/bootstrap/external/lsf_query_node_list.c
+++ b/src/pm/hydra/tools/bootstrap/external/lsf_query_node_list.c
@@ -25,7 +25,7 @@ HYD_status HYDT_bscd_lsf_query_node_list(struct HYD_node **node_list)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "No LSF node list found\n");
}
else {
- hosts = HYDU_strdup(hosts);
+ hosts = MPL_strdup(hosts);
thosts = hosts;
hostname = strtok(hosts, " ");
diff --git a/src/pm/hydra/tools/bootstrap/external/pbs_launch.c b/src/pm/hydra/tools/bootstrap/external/pbs_launch.c
index 27245d8..c73745d 100644
--- a/src/pm/hydra/tools/bootstrap/external/pbs_launch.c
+++ b/src/pm/hydra/tools/bootstrap/external/pbs_launch.c
@@ -58,7 +58,7 @@ HYD_status HYDT_bscd_pbs_launch_procs(char **args, struct HYD_proxy *proxy_list,
/* Duplicate the args in local copy, targs */
for (args_count = 0; args[args_count]; args_count++)
- targs[args_count] = HYDU_strdup(args[args_count]);
+ targs[args_count] = MPL_strdup(args[args_count]);
HYDU_MALLOC(HYDT_bscd_pbs_sys->task_id, tm_task_id *, proxy_count * sizeof(tm_task_id), status);
HYDU_MALLOC(HYDT_bscd_pbs_sys->spawn_events, tm_event_t *,
diff --git a/src/pm/hydra/tools/bootstrap/external/sge_query_node_list.c b/src/pm/hydra/tools/bootstrap/external/sge_query_node_list.c
index 8256f36..29ca1bc 100644
--- a/src/pm/hydra/tools/bootstrap/external/sge_query_node_list.c
+++ b/src/pm/hydra/tools/bootstrap/external/sge_query_node_list.c
@@ -22,7 +22,7 @@ static HYD_status process_mfile_token(char *token, int newline, struct HYD_node
entry_count = 1;
if (hostname)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "unexpected token %s\n", token);
- hostname = HYDU_strdup(token);
+ hostname = MPL_strdup(token);
}
else { /* Not a new line */
if (entry_count != 2)
diff --git a/src/pm/hydra/tools/bootstrap/external/slurm_launch.c b/src/pm/hydra/tools/bootstrap/external/slurm_launch.c
index b88009c..54f8ced 100644
--- a/src/pm/hydra/tools/bootstrap/external/slurm_launch.c
+++ b/src/pm/hydra/tools/bootstrap/external/slurm_launch.c
@@ -23,10 +23,10 @@ static HYD_status proxy_list_to_node_str(struct HYD_proxy *proxy_list, char **no
i = 0;
for (proxy = proxy_list; proxy; proxy = proxy->next) {
- tmp[i++] = HYDU_strdup(proxy->node->hostname);
+ tmp[i++] = MPL_strdup(proxy->node->hostname);
if (proxy->node->next)
- tmp[i++] = HYDU_strdup(",");
+ tmp[i++] = MPL_strdup(",");
/* If we used up more than half of the array elements, merge
* what we have so far */
@@ -36,7 +36,7 @@ static HYD_status proxy_list_to_node_str(struct HYD_proxy *proxy_list, char **no
HYDU_ERR_POP(status, "error joining strings\n");
i = 0;
- tmp[i++] = HYDU_strdup(foo);
+ tmp[i++] = MPL_strdup(foo);
HYDU_FREE(foo);
}
}
@@ -75,44 +75,44 @@ HYD_status HYDT_bscd_slurm_launch_procs(char **args, struct HYD_proxy *proxy_lis
* (1) user-specified; (2) search in path; (3) Hard-coded
* location */
if (HYDT_bsci_info.launcher_exec)
- path = HYDU_strdup(HYDT_bsci_info.launcher_exec);
+ path = MPL_strdup(HYDT_bsci_info.launcher_exec);
if (!path)
path = HYDU_find_full_path("srun");
if (!path)
- path = HYDU_strdup("/usr/bin/srun");
+ path = MPL_strdup("/usr/bin/srun");
idx = 0;
- targs[idx++] = HYDU_strdup(path);
+ targs[idx++] = MPL_strdup(path);
if (use_rmk == HYD_FALSE || strcmp(HYDT_bsci_info.rmk, "slurm")) {
- targs[idx++] = HYDU_strdup("--nodelist");
+ targs[idx++] = MPL_strdup("--nodelist");
status = proxy_list_to_node_str(proxy_list, &node_list_str);
HYDU_ERR_POP(status, "unable to build a node list string\n");
- targs[idx++] = HYDU_strdup(node_list_str);
+ targs[idx++] = MPL_strdup(node_list_str);
}
num_hosts = 0;
for (proxy = proxy_list; proxy; proxy = proxy->next)
num_hosts++;
- targs[idx++] = HYDU_strdup("-N");
+ targs[idx++] = MPL_strdup("-N");
targs[idx++] = HYDU_int_to_str(num_hosts);
- targs[idx++] = HYDU_strdup("-n");
+ targs[idx++] = MPL_strdup("-n");
targs[idx++] = HYDU_int_to_str(num_hosts);
/* Force srun to ignore stdin to avoid issues with
* unexpected files open on fd 0 */
- targs[idx++] = HYDU_strdup("--input");
- targs[idx++] = HYDU_strdup("none");
+ targs[idx++] = MPL_strdup("--input");
+ targs[idx++] = MPL_strdup("none");
MPL_env2str("HYDRA_LAUNCHER_EXTRA_ARGS", (const char **) &extra_arg_list);
if (extra_arg_list) {
extra_arg = strtok(extra_arg_list, " ");
while (extra_arg) {
- targs[idx++] = HYDU_strdup(extra_arg);
+ targs[idx++] = MPL_strdup(extra_arg);
extra_arg = strtok(NULL, " ");
}
}
@@ -121,7 +121,7 @@ HYD_status HYDT_bscd_slurm_launch_procs(char **args, struct HYD_proxy *proxy_lis
/* We do not need to create a quoted version of the string for
* SLURM. It seems to be internally quoting it anyway. */
for (i = 0; args[i]; i++)
- targs[idx++] = HYDU_strdup(args[i]);
+ targs[idx++] = MPL_strdup(args[i]);
/* Increase pid list to accommodate the new pid */
HYDU_MALLOC(pid, int *, (HYD_bscu_pid_count + 1) * sizeof(int), status);
diff --git a/src/pm/hydra/tools/bootstrap/external/slurm_query_node_list.c b/src/pm/hydra/tools/bootstrap/external/slurm_query_node_list.c
index b631746..684be61 100644
--- a/src/pm/hydra/tools/bootstrap/external/slurm_query_node_list.c
+++ b/src/pm/hydra/tools/bootstrap/external/slurm_query_node_list.c
@@ -35,7 +35,7 @@ static HYD_status group_to_nodes(char *str)
*tmp = 0; /* remove the closing ']' */
/* Find the number of sets */
- tnodes = HYDU_strdup(nodes);
+ tnodes = MPL_strdup(nodes);
tmp = strtok(tnodes, ",");
for (i = 1; tmp; i++)
tmp = strtok(NULL, ",");
@@ -58,7 +58,7 @@ static HYD_status group_to_nodes(char *str)
for (j = start; j <= end; j++) {
char *node_str[HYD_NUM_TMP_STRINGS];
- node_str[0] = HYDU_strdup(str);
+ node_str[0] = MPL_strdup(str);
node_str[1] = HYDU_int_to_str_pad(j, strlen(start_str));
node_str[2] = NULL;
diff --git a/src/pm/hydra/tools/bootstrap/external/ssh.c b/src/pm/hydra/tools/bootstrap/external/ssh.c
index 0e82892..6858232 100644
--- a/src/pm/hydra/tools/bootstrap/external/ssh.c
+++ b/src/pm/hydra/tools/bootstrap/external/ssh.c
@@ -22,7 +22,7 @@ static HYD_status create_element(char *hostname, struct HYDT_bscd_ssh_time **e)
HYDU_MALLOC((*e)->init_time, struct timeval *,
HYDT_bscd_ssh_limit_time * sizeof(struct timeval), status);
- (*e)->hostname = HYDU_strdup(hostname);
+ (*e)->hostname = MPL_strdup(hostname);
for (i = 0; i < HYDT_bscd_ssh_limit; i++) {
(*e)->init_time[i].tv_sec = 0;
(*e)->init_time[i].tv_usec = 0;
diff --git a/src/pm/hydra/tools/debugger/debugger.c b/src/pm/hydra/tools/debugger/debugger.c
index 39ce83a..ea9cf96 100644
--- a/src/pm/hydra/tools/debugger/debugger.c
+++ b/src/pm/hydra/tools/debugger/debugger.c
@@ -61,7 +61,7 @@ HYD_status HYDT_dbg_setup_procdesc(struct HYD_pg * pg)
if (i > 0 && strcmp(MPIR_proctable[i - 1].host_name, proxy->node->hostname) == 0)
MPIR_proctable[i].host_name = MPIR_proctable[i - 1].host_name;
else
- MPIR_proctable[i].host_name = HYDU_strdup(proxy->node->hostname);
+ MPIR_proctable[i].host_name = MPL_strdup(proxy->node->hostname);
MPIR_proctable[i].pid = proxy->pid[(proxy->node->core_count * round) + j];
j++;
if (exec->exec[0]) {
@@ -69,7 +69,7 @@ HYD_status HYDT_dbg_setup_procdesc(struct HYD_pg * pg)
if (i > 0 && strcmp(exec->exec[0], MPIR_proctable[i - 1].executable_name) == 0)
MPIR_proctable[i].executable_name = MPIR_proctable[i - 1].executable_name;
else
- MPIR_proctable[i].executable_name = HYDU_strdup(exec->exec[0]);
+ MPIR_proctable[i].executable_name = MPL_strdup(exec->exec[0]);
}
else {
MPIR_proctable[i].executable_name = NULL;
diff --git a/src/pm/hydra/tools/demux/demux.c b/src/pm/hydra/tools/demux/demux.c
index de72774..8193520 100644
--- a/src/pm/hydra/tools/demux/demux.c
+++ b/src/pm/hydra/tools/demux/demux.c
@@ -38,11 +38,11 @@ HYD_status HYDT_dmx_init(char **demux)
#if defined HAVE_POLL
HYDT_dmxu_fns.wait_for_event = HYDT_dmxu_poll_wait_for_event;
HYDT_dmxu_fns.stdin_valid = HYDT_dmxu_poll_stdin_valid;
- *demux = HYDU_strdup("poll");
+ *demux = MPL_strdup("poll");
#elif defined HAVE_SELECT
HYDT_dmxu_fns.wait_for_event = HYDT_dmxu_select_wait_for_event;
HYDT_dmxu_fns.stdin_valid = HYDT_dmxu_select_stdin_valid;
- *demux = HYDU_strdup("select");
+ *demux = MPL_strdup("select");
#endif /* HAVE_SELECT */
}
else if (!strcmp(*demux, "poll")) { /* user wants to use poll */
diff --git a/src/pm/hydra/tools/topo/hwloc/topo_hwloc.c b/src/pm/hydra/tools/topo/hwloc/topo_hwloc.c
index c441841..896d8f5 100644
--- a/src/pm/hydra/tools/topo/hwloc/topo_hwloc.c
+++ b/src/pm/hydra/tools/topo/hwloc/topo_hwloc.c
@@ -123,7 +123,7 @@ static HYD_status handle_rr_binding(void)
static HYD_status split_count_field(const char *str, char **split_str, int *count)
{
- char *full_str = HYDU_strdup(str), *count_str;
+ char *full_str = MPL_strdup(str), *count_str;
HYD_status status = HYD_SUCCESS;
HYDU_FUNC_ENTER();
@@ -150,7 +150,7 @@ static int parse_cache_string(const char *str)
if (str[0] != 'l')
return 0;
- t1 = HYDU_strdup(str + 1);
+ t1 = MPL_strdup(str + 1);
for (t2 = t1;; t2++) {
if (*t2 == 'c') {
*t2 = 0;
diff --git a/src/pm/hydra/tools/topo/topo.c b/src/pm/hydra/tools/topo/topo.c
index 2b3a6ce..9c3eb05 100644
--- a/src/pm/hydra/tools/topo/topo.c
+++ b/src/pm/hydra/tools/topo/topo.c
@@ -24,11 +24,11 @@ HYD_status HYDT_topo_init(char *user_topolib, char *user_binding, char *user_map
HYDU_FUNC_ENTER();
if (user_topolib)
- HYDT_topo_info.topolib = HYDU_strdup(user_topolib);
+ HYDT_topo_info.topolib = MPL_strdup(user_topolib);
else if (MPL_env2str("HYDRA_TOPOLIB", &topolib))
- HYDT_topo_info.topolib = HYDU_strdup(topolib);
+ HYDT_topo_info.topolib = MPL_strdup(topolib);
else if (HYDRA_DEFAULT_TOPOLIB)
- HYDT_topo_info.topolib = HYDU_strdup(HYDRA_DEFAULT_TOPOLIB);
+ HYDT_topo_info.topolib = MPL_strdup(HYDRA_DEFAULT_TOPOLIB);
else
HYDT_topo_info.topolib = NULL;
diff --git a/src/pm/hydra/ui/mpich/mpiexec.c b/src/pm/hydra/ui/mpich/mpiexec.c
index 09ed094..d3e1652 100644
--- a/src/pm/hydra/ui/mpich/mpiexec.c
+++ b/src/pm/hydra/ui/mpich/mpiexec.c
@@ -291,7 +291,7 @@ int main(int argc, char **argv)
}
if (node)
- HYD_server_info.localhost = HYDU_strdup(node->hostname);
+ HYD_server_info.localhost = MPL_strdup(node->hostname);
else {
HYDU_MALLOC(HYD_server_info.localhost, char *, MAX_HOSTNAME_LEN, status);
if (gethostname(HYD_server_info.localhost, MAX_HOSTNAME_LEN) < 0)
@@ -321,7 +321,7 @@ int main(int argc, char **argv)
MPL_env2str("MPICH_PORT_RANGE", (const char **) &HYD_server_info.port_range) ||
MPL_env2str("MPIEXEC_PORTRANGE", (const char **) &HYD_server_info.port_range) ||
MPL_env2str("MPIEXEC_PORT_RANGE", (const char **) &HYD_server_info.port_range))
- HYD_server_info.port_range = HYDU_strdup(HYD_server_info.port_range);
+ HYD_server_info.port_range = MPL_strdup(HYD_server_info.port_range);
/* Add the stdout/stderr callback handlers */
HYD_server_info.stdout_cb = HYD_uiu_stdout_cb;
diff --git a/src/pm/hydra/ui/mpich/utils.c b/src/pm/hydra/ui/mpich/utils.c
index 9abe0b5..000480e 100644
--- a/src/pm/hydra/ui/mpich/utils.c
+++ b/src/pm/hydra/ui/mpich/utils.c
@@ -194,17 +194,17 @@ static HYD_status genv_fn(char *arg, char ***argv)
HYDU_ERR_POP(status, "string break returned error\n");
(*argv)++;
- env_name = HYDU_strdup(str[0]);
+ env_name = MPL_strdup(str[0]);
if (str[1] == NULL) { /* The environment is not of the form x=foo */
if (**argv == NULL) {
status = HYD_INTERNAL_ERROR;
goto fn_fail;
}
- env_value = HYDU_strdup(**argv);
+ env_value = MPL_strdup(**argv);
(*argv)++;
}
else {
- env_value = HYDU_strdup(str[1]);
+ env_value = MPL_strdup(str[1]);
}
HYDU_append_env_to_list(env_name, env_value, &HYD_server_info.user_global.global_env.user);
@@ -608,7 +608,7 @@ static HYD_status config_fn(char *arg, char ***argv)
HYD_status status = HYD_SUCCESS;
HYDU_ASSERT(!config_file, status);
- config_file = HYDU_strdup(**argv);
+ config_file = MPL_strdup(**argv);
(*argv)++;
fn_exit:
@@ -638,17 +638,17 @@ static HYD_status env_fn(char *arg, char ***argv)
HYDU_ERR_POP(status, "string break returned error\n");
(*argv)++;
- env_name = HYDU_strdup(str[0]);
+ env_name = MPL_strdup(str[0]);
if (str[1] == NULL) { /* The environment is not of the form x=foo */
if (**argv == NULL) {
status = HYD_INTERNAL_ERROR;
goto fn_fail;
}
- env_value = HYDU_strdup(**argv);
+ env_value = MPL_strdup(**argv);
(*argv)++;
}
else {
- env_value = HYDU_strdup(str[1]);
+ env_value = MPL_strdup(str[1]);
}
status = get_current_exec(&exec);
@@ -1472,7 +1472,7 @@ static HYD_status set_default_values(void)
if (HYD_server_info.user_global.ckpoint_prefix == NULL) {
if (MPL_env2str("HYDRA_CKPOINT_PREFIX", (const char **) &tmp) != 0)
- HYD_server_info.user_global.ckpoint_prefix = HYDU_strdup(tmp);
+ HYD_server_info.user_global.ckpoint_prefix = MPL_strdup(tmp);
tmp = NULL;
}
@@ -1504,7 +1504,7 @@ static HYD_status set_default_values(void)
/* don't clobber existing iface values from the command line */
if (HYD_server_info.user_global.iface == NULL) {
if (MPL_env2str("HYDRA_IFACE", (const char **) &tmp) != 0)
- HYD_server_info.user_global.iface = HYDU_strdup(tmp);
+ HYD_server_info.user_global.iface = MPL_strdup(tmp);
tmp = NULL;
}
@@ -1517,7 +1517,7 @@ static HYD_status set_default_values(void)
if (HYD_server_info.user_global.global_env.prop == NULL &&
MPL_env2str("HYDRA_ENV", (const char **) &tmp))
HYD_server_info.user_global.global_env.prop =
- !strcmp(tmp, "all") ? HYDU_strdup("all") : HYDU_strdup("none");
+ !strcmp(tmp, "all") ? MPL_strdup("all") : MPL_strdup("none");
if (HYD_server_info.user_global.auto_cleanup == -1)
HYD_server_info.user_global.auto_cleanup = 1;
@@ -1550,7 +1550,7 @@ static HYD_status set_default_values(void)
/* If hostname propagation is requested (or not set), set the
* environment variable for doing that */
if (hostname_propagation || hostname_propagation == -1)
- HYD_server_info.iface_ip_env_name = HYDU_strdup("MPIR_CVAR_CH3_INTERFACE_HOSTNAME");
+ HYD_server_info.iface_ip_env_name = MPL_strdup("MPIR_CVAR_CH3_INTERFACE_HOSTNAME");
/* Default universe size if the user did not specify anything is
* INFINITE */
@@ -1572,10 +1572,10 @@ static HYD_status process_config_token(char *token, int newline, struct HYD_node
/* If this is a newline, but not the first one, and the
* previous token was not a ":", add an executable delimiter
* ':' */
- config_argv[idx++] = HYDU_strdup(":");
+ config_argv[idx++] = MPL_strdup(":");
}
- config_argv[idx++] = HYDU_strdup(token);
+ config_argv[idx++] = MPL_strdup(token);
config_argv[idx] = NULL;
return HYD_SUCCESS;
@@ -1615,7 +1615,7 @@ static HYD_status parse_args(char **t_argv)
i = 0;
while (exec->exec[i] != NULL)
i++;
- exec->exec[i] = HYDU_strdup(*argv);
+ exec->exec[i] = MPL_strdup(*argv);
exec->exec[i + 1] = NULL;
} while (++argv && *argv);
} while (1);
@@ -1654,7 +1654,7 @@ HYD_status HYD_uii_mpx_get_parameters(char **t_argv)
ret = open(env_file, O_RDONLY);
if (ret >= 0) {
close(ret);
- config_file = HYDU_strdup(env_file);
+ config_file = MPL_strdup(env_file);
goto config_file_check_exit;
}
}
@@ -1679,7 +1679,7 @@ HYD_status HYD_uii_mpx_get_parameters(char **t_argv)
}
/* Check if there's a config file in the hard-coded location */
- conf_file = HYDU_strdup(HYDRA_CONF_FILE);
+ conf_file = MPL_strdup(HYDRA_CONF_FILE);
ret = open(conf_file, O_RDONLY);
if (ret < 0) {
HYDU_FREE(conf_file);
@@ -1709,7 +1709,7 @@ HYD_status HYD_uii_mpx_get_parameters(char **t_argv)
/* Get the base path */
/* Find the last '/' in the executable name */
- post = HYDU_strdup(progname);
+ post = MPL_strdup(progname);
loc = strrchr(post, '/');
if (!loc) { /* If there is no path */
HYD_server_info.base_path = NULL;
@@ -1722,15 +1722,15 @@ HYD_status HYD_uii_mpx_get_parameters(char **t_argv)
/* Check if its absolute or relative */
if (post[0] != '/') { /* relative */
tmp[0] = HYDU_getcwd();
- tmp[1] = HYDU_strdup("/");
- tmp[2] = HYDU_strdup(post);
+ tmp[1] = MPL_strdup("/");
+ tmp[2] = MPL_strdup(post);
tmp[3] = NULL;
status = HYDU_str_alloc_and_join(tmp, &HYD_server_info.base_path);
HYDU_ERR_POP(status, "unable to join strings\n");
HYDU_free_strlist(tmp);
}
else { /* absolute */
- HYD_server_info.base_path = HYDU_strdup(post);
+ HYD_server_info.base_path = MPL_strdup(post);
}
}
HYDU_FREE(post);
diff --git a/src/pm/hydra/utils/alloc/alloc.c b/src/pm/hydra/utils/alloc/alloc.c
index 89012c4..5271eb6 100644
--- a/src/pm/hydra/utils/alloc/alloc.c
+++ b/src/pm/hydra/utils/alloc/alloc.c
@@ -308,12 +308,12 @@ static HYD_status add_exec_to_proxy(struct HYD_exec *exec, struct HYD_proxy *pro
HYDU_ERR_POP(status, "unable to allocate proxy exec\n");
for (i = 0; exec->exec[i]; i++)
- proxy->exec_list->exec[i] = HYDU_strdup(exec->exec[i]);
+ proxy->exec_list->exec[i] = MPL_strdup(exec->exec[i]);
proxy->exec_list->exec[i] = NULL;
- proxy->exec_list->wdir = HYDU_strdup(exec->wdir);
+ proxy->exec_list->wdir = MPL_strdup(exec->wdir);
proxy->exec_list->proc_count = num_procs;
- proxy->exec_list->env_prop = exec->env_prop ? HYDU_strdup(exec->env_prop) : NULL;
+ proxy->exec_list->env_prop = exec->env_prop ? MPL_strdup(exec->env_prop) : NULL;
proxy->exec_list->user_env = HYDU_env_list_dup(exec->user_env);
proxy->exec_list->appnum = exec->appnum;
}
@@ -325,12 +325,12 @@ static HYD_status add_exec_to_proxy(struct HYD_exec *exec, struct HYD_proxy *pro
texec = texec->next;
for (i = 0; exec->exec[i]; i++)
- texec->exec[i] = HYDU_strdup(exec->exec[i]);
+ texec->exec[i] = MPL_strdup(exec->exec[i]);
texec->exec[i] = NULL;
- texec->wdir = HYDU_strdup(exec->wdir);
+ texec->wdir = MPL_strdup(exec->wdir);
texec->proc_count = num_procs;
- texec->env_prop = exec->env_prop ? HYDU_strdup(exec->env_prop) : NULL;
+ texec->env_prop = exec->env_prop ? MPL_strdup(exec->env_prop) : NULL;
texec->user_env = HYDU_env_list_dup(exec->user_env);
texec->appnum = exec->appnum;
}
@@ -501,8 +501,8 @@ HYD_status HYDU_correct_wdir(char **wdir)
}
else if (*wdir[0] != '/') {
tmp[0] = HYDU_getcwd();
- tmp[1] = HYDU_strdup("/");
- tmp[2] = HYDU_strdup(*wdir);
+ tmp[1] = MPL_strdup("/");
+ tmp[2] = MPL_strdup(*wdir);
tmp[3] = NULL;
HYDU_FREE(*wdir);
diff --git a/src/pm/hydra/utils/args/args.c b/src/pm/hydra/utils/args/args.c
index bc7ea5e..923b590 100644
--- a/src/pm/hydra/utils/args/args.c
+++ b/src/pm/hydra/utils/args/args.c
@@ -59,15 +59,15 @@ HYD_status HYDU_find_in_path(const char *execname, char **path)
/* The executable is somewhere in the user's path. Find it. */
if (MPL_env2str("PATH", (const char **) &user_path))
- user_path = HYDU_strdup(user_path);
+ user_path = MPL_strdup(user_path);
if (user_path) { /* If the PATH environment exists */
status = get_abs_wd(strtok(user_path, ";:"), &test_loc);
HYDU_ERR_POP(status, "error getting absolute working dir\n");
do {
- tmp[0] = HYDU_strdup(test_loc);
- tmp[1] = HYDU_strdup("/");
- tmp[2] = HYDU_strdup(execname);
+ tmp[0] = MPL_strdup(test_loc);
+ tmp[1] = MPL_strdup("/");
+ tmp[2] = MPL_strdup(execname);
tmp[3] = NULL;
status = HYDU_str_alloc_and_join(tmp, &path_loc);
@@ -75,8 +75,8 @@ HYD_status HYDU_find_in_path(const char *execname, char **path)
HYDU_free_strlist(tmp);
if (exists(path_loc)) {
- tmp[0] = HYDU_strdup(test_loc);
- tmp[1] = HYDU_strdup("/");
+ tmp[0] = MPL_strdup(test_loc);
+ tmp[1] = MPL_strdup("/");
tmp[2] = NULL;
status = HYDU_str_alloc_and_join(tmp, path);
@@ -96,7 +96,7 @@ HYD_status HYDU_find_in_path(const char *execname, char **path)
/* There is either no PATH environment or we could not find the
* file in the PATH. Just return an empty path */
- *path = HYDU_strdup("");
+ *path = MPL_strdup("");
fn_exit:
if (user_path)
@@ -193,7 +193,7 @@ HYD_status HYDU_set_str(char *arg, char **var, const char *val)
if (val == NULL)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "cannot assign NULL object\n");
- *var = HYDU_strdup(val);
+ *var = MPL_strdup(val);
fn_exit:
return status;
@@ -237,8 +237,8 @@ char *HYDU_getcwd(void)
if (pwdval && stat(pwdval, &spwd) != -1 && stat(cwdval, &scwd) != -1 &&
spwd.st_dev == scwd.st_dev && spwd.st_ino == scwd.st_ino) {
/* PWD and getcwd() match; use the PWD value */
- retval = HYDU_strdup(pwdval);
- HYDU_free(cwdval);
+ retval = MPL_strdup(pwdval);
+ MPL_free(cwdval);
}
else
#endif /* HAVE_STAT */
@@ -280,7 +280,7 @@ HYD_status HYDU_process_mfile_token(char *token, int newline, struct HYD_node **
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
"duplicate local binding setting\n");
- node->local_binding = HYDU_strdup(binding);
+ node->local_binding = MPL_strdup(binding);
}
else if (!strcmp(tmp, "user")) {
user = strtok_r(NULL, "=", &saveptr);
@@ -289,7 +289,7 @@ HYD_status HYDU_process_mfile_token(char *token, int newline, struct HYD_node **
if (node->user)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "duplicate username setting\n");
- node->user = HYDU_strdup(user);
+ node->user = MPL_strdup(user);
}
else {
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR,
@@ -369,8 +369,8 @@ char *HYDU_find_full_path(const char *execname)
HYDU_ERR_POP(status, "error while searching for executable in user path\n");
if (test_path) {
- tmp[0] = HYDU_strdup(test_path);
- tmp[1] = HYDU_strdup(execname);
+ tmp[0] = MPL_strdup(test_path);
+ tmp[1] = MPL_strdup(execname);
tmp[2] = NULL;
status = HYDU_str_alloc_and_join(tmp, &path);
diff --git a/src/pm/hydra/utils/dbg/dbg.c b/src/pm/hydra/utils/dbg/dbg.c
index e7f129a..4a95628 100644
--- a/src/pm/hydra/utils/dbg/dbg.c
+++ b/src/pm/hydra/utils/dbg/dbg.c
@@ -13,7 +13,9 @@ HYD_status HYDU_dbg_init(const char *str)
char hostname[MAX_HOSTNAME_LEN];
HYD_status status = HYD_SUCCESS;
- HYDU_mem_init();
+#ifdef USE_MEMORY_TRACING
+ MPL_trinit(0,0);
+#endif
if (gethostname(hostname, MAX_HOSTNAME_LEN) < 0)
HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "unable to get local host name\n");
diff --git a/src/pm/hydra/utils/env/env.c b/src/pm/hydra/utils/env/env.c
index be2bec6..3584e0c 100644
--- a/src/pm/hydra/utils/env/env.c
+++ b/src/pm/hydra/utils/env/env.c
@@ -16,11 +16,11 @@ HYD_status HYDU_env_to_str(struct HYD_env *env, char **str)
HYDU_FUNC_ENTER();
i = 0;
- tmp[i++] = HYDU_strdup("'");
- tmp[i++] = HYDU_strdup(env->env_name);
- tmp[i++] = HYDU_strdup("=");
- tmp[i++] = env->env_value ? HYDU_strdup(env->env_value) : HYDU_strdup("");
- tmp[i++] = HYDU_strdup("'");
+ tmp[i++] = MPL_strdup("'");
+ tmp[i++] = MPL_strdup(env->env_name);
+ tmp[i++] = MPL_strdup("=");
+ tmp[i++] = env->env_value ? MPL_strdup(env->env_value) : MPL_strdup("");
+ tmp[i++] = MPL_strdup("'");
tmp[i++] = NULL;
status = HYDU_str_alloc_and_join(tmp, str);
@@ -49,7 +49,7 @@ HYD_status HYDU_list_inherited_env(struct HYD_env **env_list)
*env_list = NULL;
i = 0;
while (environ[i]) {
- env_str = HYDU_strdup(environ[i]);
+ env_str = MPL_strdup(environ[i]);
env_name = strtok(env_str, "=");
status = HYDT_bsci_query_env_inherit(env_name, &ret);
@@ -112,8 +112,8 @@ HYD_status HYDU_env_create(struct HYD_env **env, const char *env_name, const cha
HYDU_FUNC_ENTER();
HYDU_MALLOC(*env, struct HYD_env *, sizeof(struct HYD_env), status);
- (*env)->env_name = HYDU_strdup(env_name);
- (*env)->env_value = env_value ? HYDU_strdup(env_value) : NULL;
+ (*env)->env_name = MPL_strdup(env_name);
+ (*env)->env_value = env_value ? MPL_strdup(env_value) : NULL;
(*env)->next = NULL;
fn_exit:
@@ -205,14 +205,14 @@ HYD_status HYDU_append_env_to_list(const char *env_name, const char *env_value,
/* If we found an entry for this environment variable, just update it */
if (run->env_value != NULL && tenv->env_value != NULL) {
HYDU_FREE(run->env_value);
- run->env_value = HYDU_strdup(tenv->env_value);
+ run->env_value = MPL_strdup(tenv->env_value);
}
else if (run->env_value != NULL) {
HYDU_FREE(run->env_value);
run->env_value = NULL;
}
else if (env_value != NULL) {
- run->env_value = HYDU_strdup(tenv->env_value);
+ run->env_value = MPL_strdup(tenv->env_value);
}
HYDU_FREE(tenv->env_name);
@@ -246,7 +246,7 @@ HYD_status HYDU_append_env_str_to_list(const char *str, struct HYD_env **env_lis
HYDU_FUNC_ENTER();
- my_str = env_value = HYDU_strdup(str);
+ my_str = env_value = MPL_strdup(str);
/* don't use strtok, it will mangle env values that contain '=' */
env_name = MPL_strsep(&env_value, "=");
HYDU_ASSERT(env_name != NULL, status);
@@ -277,9 +277,9 @@ HYD_status HYDU_putenv(struct HYD_env *env, HYD_env_overwrite_t overwrite)
goto fn_exit;
i = 0;
- tmp[i++] = HYDU_strdup(env->env_name);
- tmp[i++] = HYDU_strdup("=");
- tmp[i++] = env->env_value ? HYDU_strdup(env->env_value) : HYDU_strdup("");
+ tmp[i++] = MPL_strdup(env->env_name);
+ tmp[i++] = MPL_strdup("=");
+ tmp[i++] = env->env_value ? MPL_strdup(env->env_value) : MPL_strdup("");
tmp[i++] = NULL;
status = HYDU_str_alloc_and_join(tmp, &str);
HYDU_ERR_POP(status, "unable to join strings\n");
diff --git a/src/pm/hydra/utils/others/others.c b/src/pm/hydra/utils/others/others.c
index 2aa538e..fa22e93 100644
--- a/src/pm/hydra/utils/others/others.c
+++ b/src/pm/hydra/utils/others/others.c
@@ -29,7 +29,7 @@ HYD_status HYDU_add_to_node_list(const char *hostname, int num_procs, struct HYD
status = HYDU_alloc_node(node_list);
HYDU_ERR_POP(status, "unable to allocate node\n");
- (*node_list)->hostname = HYDU_strdup(hostname);
+ (*node_list)->hostname = MPL_strdup(hostname);
(*node_list)->core_count = num_procs;
(*node_list)->node_id = 0;
}
@@ -44,7 +44,7 @@ HYD_status HYDU_add_to_node_list(const char *hostname, int num_procs, struct HYD
node->next->node_id = node->node_id + 1;
node = node->next;
- node->hostname = HYDU_strdup(hostname);
+ node->hostname = MPL_strdup(hostname);
}
node->core_count += num_procs;
diff --git a/src/pm/hydra/utils/sock/sock.c b/src/pm/hydra/utils/sock/sock.c
index 9234c97..37e4f49 100644
--- a/src/pm/hydra/utils/sock/sock.c
+++ b/src/pm/hydra/utils/sock/sock.c
@@ -474,7 +474,7 @@ HYD_status HYDU_sock_get_iface_ip(char *iface, char **ip)
sa = (struct sockaddr_in *) ifa->ifa_addr;
#if defined HAVE_INET_NTOP
- (*ip) = HYDU_strdup((char *)
+ (*ip) = MPL_strdup((char *)
inet_ntop(AF_INET, (const void *) &(sa->sin_addr), buf, MAX_HOSTNAME_LEN));
#else
(*ip) = NULL;
@@ -553,7 +553,7 @@ HYD_status HYDU_sock_is_local(char *host, int *is_local)
memcpy(&sa.sin_addr, ht->h_addr_list[0], ht->h_length);
/* Find the IP address of the host */
- host_ip = HYDU_strdup((char *) inet_ntop(AF_INET, (const void *) &sa.sin_addr, buf,
+ host_ip = MPL_strdup((char *) inet_ntop(AF_INET, (const void *) &sa.sin_addr, buf,
MAX_HOSTNAME_LEN));
HYDU_ASSERT(host_ip, status);
}
@@ -569,7 +569,7 @@ HYD_status HYDU_sock_is_local(char *host, int *is_local)
memcpy(&sa.sin_addr, ht->h_addr_list[0], ht->h_length);
/* Find the IP address of the host */
- lhost_ip = HYDU_strdup((char *) inet_ntop(AF_INET, (const void *) &sa.sin_addr, buf,
+ lhost_ip = MPL_strdup((char *) inet_ntop(AF_INET, (const void *) &sa.sin_addr, buf,
MAX_HOSTNAME_LEN));
HYDU_ASSERT(lhost_ip, status);
@@ -594,7 +594,7 @@ HYD_status HYDU_sock_is_local(char *host, int *is_local)
if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET) {
struct sockaddr_in *sa_ptr = (struct sockaddr_in *) ifa->ifa_addr;
- lhost_ip = HYDU_strdup((char *)
+ lhost_ip = MPL_strdup((char *)
inet_ntop(AF_INET, (const void *) &(sa_ptr->sin_addr), buf,
MAX_HOSTNAME_LEN));
HYDU_ASSERT(lhost_ip, status);
@@ -660,7 +660,7 @@ HYDU_sock_create_and_listen_portstr(char *iface, char *hostname, char *port_rang
/* Listen on a port in the port range */
port = 0;
- real_port_range = port_range ? HYDU_strdup(port_range) : NULL;
+ real_port_range = port_range ? MPL_strdup(port_range) : NULL;
status = HYDU_sock_listen(&listenfd, real_port_range, &port);
HYDU_ERR_POP(status, "unable to listen on port\n");
@@ -674,7 +674,7 @@ HYDU_sock_create_and_listen_portstr(char *iface, char *hostname, char *port_rang
HYDU_ERR_POP(status, "unable to get network interface IP\n");
}
else if (hostname) {
- ip = HYDU_strdup(hostname);
+ ip = MPL_strdup(hostname);
}
else {
char localhost[MAX_HOSTNAME_LEN] = { 0 };
@@ -682,7 +682,7 @@ HYDU_sock_create_and_listen_portstr(char *iface, char *hostname, char *port_rang
if (gethostname(localhost, MAX_HOSTNAME_LEN) < 0)
HYDU_ERR_SETANDJUMP(status, HYD_SOCK_ERROR, "unable to get local hostname\n");
- ip = HYDU_strdup(localhost);
+ ip = MPL_strdup(localhost);
}
sport = HYDU_int_to_str(port);
diff --git a/src/pm/hydra/utils/string/string.c b/src/pm/hydra/utils/string/string.c
index 243cf1d..3278600 100644
--- a/src/pm/hydra/utils/string/string.c
+++ b/src/pm/hydra/utils/string/string.c
@@ -15,7 +15,7 @@ HYD_status HYDU_list_append_strlist(char **src_strlist, char **dest_strlist)
i = HYDU_strlist_lastidx(dest_strlist);
for (j = 0; src_strlist[j]; j++)
- dest_strlist[i++] = HYDU_strdup(src_strlist[j]);
+ dest_strlist[i++] = MPL_strdup(src_strlist[j]);
dest_strlist[i++] = NULL;
HYDU_FUNC_EXIT();
@@ -91,13 +91,13 @@ HYD_status HYDU_strsplit(char *str, char **str1, char **str2, char sep)
if (str == NULL)
HYDU_ERR_SETANDJUMP(status, HYD_INTERNAL_ERROR, "%s", "");
- *str1 = HYDU_strdup(str);
+ *str1 = MPL_strdup(str);
for (i = 0; (*str1)[i] && ((*str1)[i] != sep); i++);
if ((*str1)[i] == 0) /* End of the string */
*str2 = NULL;
else {
- *str2 = HYDU_strdup(&((*str1)[i + 1]));
+ *str2 = MPL_strdup(&((*str1)[i + 1]));
(*str1)[i] = 0;
}
@@ -121,7 +121,7 @@ HYD_status HYDU_strdup_list(char *src[], char **dest[])
HYDU_MALLOC(*dest, char **, (count + 1) * sizeof(char *), status);
for (i = 0; i < count; i++)
- (*dest)[i] = HYDU_strdup(src[i]);
+ (*dest)[i] = MPL_strdup(src[i]);
(*dest)[i] = NULL;
fn_exit:
-----------------------------------------------------------------------
Summary of changes:
src/pm/hydra/configure.ac | 4 +-
src/pm/hydra/include/hydra.h | 124 ++++--------
src/pm/hydra/pm/pmiserv/common.c | 29 ++--
src/pm/hydra/pm/pmiserv/common.h | 2 +-
src/pm/hydra/pm/pmiserv/pmi_v2_common.c | 5 +-
src/pm/hydra/pm/pmiserv/pmip.c | 30 ++--
src/pm/hydra/pm/pmiserv/pmip_cb.c | 95 +++++-----
src/pm/hydra/pm/pmiserv/pmip_pmi_v1.c | 114 ++++++------
src/pm/hydra/pm/pmiserv/pmip_pmi_v2.c | 114 ++++++------
src/pm/hydra/pm/pmiserv/pmip_utils.c | 26 ++--
src/pm/hydra/pm/pmiserv/pmiserv_cb.c | 34 ++--
src/pm/hydra/pm/pmiserv/pmiserv_pmci.c | 6 +-
src/pm/hydra/pm/pmiserv/pmiserv_pmi.c | 54 +++---
src/pm/hydra/pm/pmiserv/pmiserv_pmi_v1.c | 104 +++++-----
src/pm/hydra/pm/pmiserv/pmiserv_pmi_v2.c | 174 ++++++++--------
src/pm/hydra/pm/pmiserv/pmiserv_utils.c | 208 ++++++++++----------
.../bootstrap/external/external_common_launch.c | 59 +++---
src/pm/hydra/tools/bootstrap/external/ll_launch.c | 24 ++--
.../tools/bootstrap/external/lsf_query_node_list.c | 4 +-
.../hydra/tools/bootstrap/external/pbs_finalize.c | 6 +-
src/pm/hydra/tools/bootstrap/external/pbs_init.c | 4 +-
src/pm/hydra/tools/bootstrap/external/pbs_launch.c | 9 +-
src/pm/hydra/tools/bootstrap/external/pbs_wait.c | 6 +-
.../tools/bootstrap/external/sge_query_node_list.c | 2 +-
.../hydra/tools/bootstrap/external/slurm_launch.c | 44 ++--
.../bootstrap/external/slurm_query_node_list.c | 18 +-
src/pm/hydra/tools/bootstrap/external/ssh.c | 9 +-
.../hydra/tools/bootstrap/external/ssh_finalize.c | 4 +-
.../hydra/tools/bootstrap/persist/persist_launch.c | 4 +-
.../hydra/tools/bootstrap/persist/persist_server.c | 4 +-
src/pm/hydra/tools/bootstrap/utils/bscu_wait.c | 4 +-
src/pm/hydra/tools/debugger/debugger.c | 14 +-
src/pm/hydra/tools/demux/demux.c | 13 +-
src/pm/hydra/tools/demux/demux_poll.c | 7 +-
src/pm/hydra/tools/demux/demux_select.c | 2 +-
src/pm/hydra/tools/nameserver/hydra_nameserver.c | 19 +-
src/pm/hydra/tools/topo/hwloc/topo_hwloc.c | 45 +++--
src/pm/hydra/tools/topo/topo.c | 8 +-
src/pm/hydra/ui/mpich/mpiexec.c | 10 +-
src/pm/hydra/ui/mpich/utils.c | 77 ++++----
src/pm/hydra/ui/utils/uiu.c | 30 ++--
src/pm/hydra/utils/alloc/alloc.c | 70 ++++----
src/pm/hydra/utils/args/args.c | 40 ++--
src/pm/hydra/utils/dbg/dbg.c | 8 +-
src/pm/hydra/utils/env/env.c | 56 +++---
src/pm/hydra/utils/launch/launch.c | 15 +-
src/pm/hydra/utils/others/others.c | 4 +-
src/pm/hydra/utils/sock/sock.c | 58 +++---
src/pm/hydra/utils/string/string.c | 24 ++--
49 files changed, 898 insertions(+), 926 deletions(-)
hooks/post-receive
--
MPICH primary repository
More information about the commits
mailing list