diff --git a/slurm/slurm.h.in b/slurm/slurm.h.in
index 5bb063352718f0ab80152067860b575f1b68ae73..613f215449cfa61e90117f00df67d1816ff3a1c4 100644
--- a/slurm/slurm.h.in
+++ b/slurm/slurm.h.in
@@ -1060,68 +1060,68 @@ typedef struct {
char *owner_name;
char *ramdiskimage; /* RamDiskImage for this block */
uint16_t state;
-} bg_info_record_t;
+} block_info_t;
typedef struct {
- bg_info_record_t *bg_info_array;
+ block_info_t *block_array;
time_t last_update;
uint32_t record_count;
-} node_select_info_msg_t;
+} block_info_msg_t;
-typedef bg_info_record_t update_block_msg_t;
+typedef block_info_t update_block_msg_t;
/*
- * slurm_print_node_select_info_msg - output information about all Bluegene
- * blocks based upon message as loaded using slurm_load_node_select
+ * slurm_print_block_info_msg - output information about all Bluegene
+ * blocks based upon message as loaded using slurm_load_block
* IN out - file to write to
- * IN info_ptr - node_select information message pointer
+ * IN info_ptr - block information message pointer
* IN one_liner - print as a single line if true
*/
-extern void slurm_print_node_select_info_msg PARAMS((
- FILE *out, node_select_info_msg_t *info_ptr, int one_liner));
+extern void slurm_print_block_info_msg PARAMS((
+ FILE *out, block_info_msg_t *info_ptr, int one_liner));
/*
- * slurm_print_node_select_info - output information about a specific Bluegene
- * block based upon message as loaded using slurm_load_node_select
+ * slurm_print_block_info - output information about a specific Bluegene
+ * block based upon message as loaded using slurm_load_block
* IN out - file to write to
* IN bg_info_ptr - an individual block information record pointer
* IN one_liner - print as a single line if true
*/
-extern void slurm_print_node_select_info PARAMS((
- FILE *out, bg_info_record_t *bg_info_ptr, int one_liner));
+extern void slurm_print_block_info PARAMS((
+ FILE *out, block_info_t *bg_info_ptr, int one_liner));
/*
- * slurm_sprint_node_select_info - output information about a specific Bluegene
- * block based upon message as loaded using slurm_load_node_select
+ * slurm_sprint_block_info - output information about a specific Bluegene
+ * block based upon message as loaded using slurm_load_block
* IN bg_info_ptr - an individual partition information record pointer
* IN one_liner - print as a single line if true
* RET out - char * containing formatted output (must be freed after call)
* NULL is returned on failure.
*/
-extern char *slurm_sprint_node_select_info PARAMS((
- bg_info_record_t * bg_info_ptr, int one_liner));
+extern char *slurm_sprint_block_info PARAMS((
+ block_info_t * bg_info_ptr, int one_liner));
/*
- * slurm_load_node_select - issue RPC to get slurm all node select plugin
+ * slurm_load_block_info - issue RPC to get slurm all node select plugin
* information if changed since update_time
* IN update_time - time of current configuration data
- * IN node_select_info_msg_pptr - place to store a node select configuration
+ * IN block_info_msg_pptr - place to store a node select configuration
* pointer
* RET 0 or a slurm error code
- * NOTE: free the response using slurm_free_node_select_info_msg
+ * NOTE: free the response using slurm_free_block_info_msg
*/
-extern int slurm_load_node_select PARAMS((
+extern int slurm_load_block_info PARAMS((
time_t update_time,
- node_select_info_msg_t **node_select_info_msg_pptr));
+ block_info_msg_t **block_info_msg_pptr));
/*
- * node_select_info_msg_free - free buffer returned by
- * slurm_load_node_select
- * IN node_select_info_msg_pptr - data is freed and pointer is set to NULL
+ * slurm_free_block_info_msg - free buffer returned by
+ * slurm_load_block
+ * IN block_info_msg_pptr - data is freed and pointer is set to NULL
* RET 0 or a slurm error code
*/
-extern int slurm_free_node_select PARAMS((
- node_select_info_msg_t **node_select_info_msg_pptr));
+extern int slurm_free_block_info_msg PARAMS((
+ block_info_msg_t **block_info_msg_pptr));
/* update state or remove block */
extern int slurm_update_block PARAMS((update_block_msg_t *block_msg));
diff --git a/src/api/Makefile.am b/src/api/Makefile.am
index b7fea2f9c0345efd9816932e56170b781e8580b1..143f0249d02c25f8d8c33009eb1b0d522c97b95e 100644
--- a/src/api/Makefile.am
+++ b/src/api/Makefile.am
@@ -74,7 +74,7 @@ slurmapi_src = \
job_info.c job_info.h \
job_step_info.c \
node_info.c \
- node_select_info.c \
+ block_info.c \
partition_info.c \
reservation_info.c \
signal.c \
diff --git a/src/api/Makefile.in b/src/api/Makefile.in
index 789716edaf3dca7197bdbf910ac8368dee531034..d22c6c7d1f41e934c7249c7ecb945e47e49139b4 100644
--- a/src/api/Makefile.in
+++ b/src/api/Makefile.in
@@ -106,11 +106,11 @@ am__DEPENDENCIES_1 = $(common_dir)/libcommon.la \
libslurmhelper_la_DEPENDENCIES = $(am__DEPENDENCIES_1)
am__objects_1 = allocate.lo allocate_msg.lo cancel.lo checkpoint.lo \
complete.lo config_info.lo init_msg.lo job_info.lo \
- job_step_info.lo node_info.lo node_select_info.lo \
- partition_info.lo reservation_info.lo signal.lo \
- slurm_hostlist.lo slurm_pmi.lo step_ctx.lo step_io.lo \
- step_launch.lo pmi_server.lo submit.lo suspend.lo topo_info.lo \
- triggers.lo reconfigure.lo update_config.lo
+ job_step_info.lo node_info.lo block_info.lo partition_info.lo \
+ reservation_info.lo signal.lo slurm_hostlist.lo slurm_pmi.lo \
+ step_ctx.lo step_io.lo step_launch.lo pmi_server.lo submit.lo \
+ suspend.lo topo_info.lo triggers.lo reconfigure.lo \
+ update_config.lo
am_libslurmhelper_la_OBJECTS = $(am__objects_1)
libslurmhelper_la_OBJECTS = $(am_libslurmhelper_la_OBJECTS)
PROGRAMS = $(noinst_PROGRAMS)
@@ -388,7 +388,7 @@ slurmapi_src = \
job_info.c job_info.h \
job_step_info.c \
node_info.c \
- node_select_info.c \
+ block_info.c \
partition_info.c \
reservation_info.c \
signal.c \
@@ -545,6 +545,7 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/allocate.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/allocate_msg.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/block_info.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cancel.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/checkpoint.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/complete.Plo@am__quote@
@@ -553,7 +554,6 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/job_info.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/job_step_info.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/node_info.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/node_select_info.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/partition_info.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pmi.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pmi_server.Plo@am__quote@
diff --git a/src/api/node_select_info.c b/src/api/block_info.c
similarity index 65%
rename from src/api/node_select_info.c
rename to src/api/block_info.c
index 033b3f002266f966c5933f0e999a76bccf692bae..337c40b148fbf90dee6dc2630078cb4c6d2bb263 100644
--- a/src/api/node_select_info.c
+++ b/src/api/block_info.c
@@ -66,17 +66,17 @@
/*
- * slurm_print_node_select_info_msg - output information about all Bluegene
- * blocks based upon message as loaded using slurm_load_node_select
+ * slurm_print_block_info_msg - output information about all Bluegene
+ * blocks based upon message as loaded using slurm_load_block
* IN out - file to write to
- * IN info_ptr - node_select information message pointer
+ * IN info_ptr - block information message pointer
* IN one_liner - print as a single line if true
*/
-void slurm_print_node_select_info_msg(
- FILE *out, node_select_info_msg_t *info_ptr, int one_liner)
+void slurm_print_block_info_msg(
+ FILE *out, block_info_msg_t *info_ptr, int one_liner)
{
int i ;
- bg_info_record_t * bg_info_ptr = info_ptr->bg_info_array;
+ block_info_t * block_ptr = info_ptr->block_array;
char time_str[32];
slurm_make_time_str ((time_t *)&info_ptr->last_update, time_str,
@@ -85,36 +85,36 @@ void slurm_print_node_select_info_msg(
time_str, info_ptr->record_count);
for (i = 0; i < info_ptr->record_count; i++)
- slurm_print_node_select_info(out, & bg_info_ptr[i], one_liner);
+ slurm_print_block_info(out, & block_ptr[i], one_liner);
}
/*
- * slurm_print_node_select_info - output information about a specific Bluegene
- * block based upon message as loaded using slurm_load_node_select
+ * slurm_print_block_info - output information about a specific Bluegene
+ * block based upon message as loaded using slurm_load_block
* IN out - file to write to
- * IN bg_info_ptr - an individual block information record pointer
+ * IN block_ptr - an individual block information record pointer
* IN one_liner - print as a single line if true
*/
-void slurm_print_node_select_info(
- FILE *out, bg_info_record_t *bg_info_ptr, int one_liner)
+void slurm_print_block_info(
+ FILE *out, block_info_t *block_ptr, int one_liner)
{
- char *print_this = slurm_sprint_node_select_info(
- bg_info_ptr, one_liner);
+ char *print_this = slurm_sprint_block_info(
+ block_ptr, one_liner);
fprintf(out, "%s", print_this);
xfree(print_this);
}
/*
- * slurm_sprint_node_select_info - output information about a specific Bluegene
- * block based upon message as loaded using slurm_load_node_select
- * IN bg_info_ptr - an individual partition information record pointer
+ * slurm_sprint_block_info - output information about a specific Bluegene
+ * block based upon message as loaded using slurm_load_block
+ * IN block_ptr - an individual partition information record pointer
* IN one_liner - print as a single line if true
* RET out - char * containing formatted output (must be freed after call)
* NULL is returned on failure.
*/
-char *slurm_sprint_node_select_info(
- bg_info_record_t * bg_info_ptr, int one_liner)
+char *slurm_sprint_block_info(
+ block_info_t * block_ptr, int one_liner)
{
int j;
char tmp1[16];
@@ -125,61 +125,61 @@ char *slurm_sprint_node_select_info(
line_end = " ";
/****** Line 1 ******/
- convert_num_unit((float)bg_info_ptr->node_cnt, tmp1, sizeof(tmp1),
+ convert_num_unit((float)block_ptr->node_cnt, tmp1, sizeof(tmp1),
UNIT_NONE);
out = xstrdup_printf("BlockName=%s TotalNodes=%s State=%s%s",
- bg_info_ptr->bg_block_id, tmp1,
- bg_block_state_string(bg_info_ptr->state),
+ block_ptr->bg_block_id, tmp1,
+ bg_block_state_string(block_ptr->state),
line_end);
/****** Line 2 ******/
- if (bg_info_ptr->job_running > NO_JOB_RUNNING)
- xstrfmtcat(out, "JobRunning=%u ", bg_info_ptr->job_running);
+ if (block_ptr->job_running > NO_JOB_RUNNING)
+ xstrfmtcat(out, "JobRunning=%u ", block_ptr->job_running);
else
xstrcat(out, "JobRunning=NONE ");
xstrfmtcat(out, "User=%s ConnType=%s",
- bg_info_ptr->owner_name,
- conn_type_string(bg_info_ptr->conn_type));
+ block_ptr->owner_name,
+ conn_type_string(block_ptr->conn_type));
#ifdef HAVE_BGL
xstrfmtcat(out, " NodeUse=%s",
- node_use_string(bg_info_ptr->node_use));
+ node_use_string(block_ptr->node_use));
#endif
xstrcat(out, line_end);
/****** Line 3 ******/
- if(bg_info_ptr->ionodes)
+ if(block_ptr->ionodes)
xstrfmtcat(out, "BasePartitions=%s[%s] BPIndices=",
- bg_info_ptr->nodes, bg_info_ptr->ionodes);
+ block_ptr->nodes, block_ptr->ionodes);
else
- xstrfmtcat(out, "BasePartitions=%s BPIndices=", bg_info_ptr->nodes);
+ xstrfmtcat(out, "BasePartitions=%s BPIndices=", block_ptr->nodes);
for (j = 0;
- (bg_info_ptr->bp_inx && (bg_info_ptr->bp_inx[j] != -1));
+ (block_ptr->bp_inx && (block_ptr->bp_inx[j] != -1));
j+=2) {
if (j > 0)
xstrcat(out, ",");
- xstrfmtcat(out, "%d-%d", bg_info_ptr->bp_inx[j],
- bg_info_ptr->bp_inx[j+1]);
+ xstrfmtcat(out, "%d-%d", block_ptr->bp_inx[j],
+ block_ptr->bp_inx[j+1]);
}
xstrcat(out, line_end);
/****** Line 4 ******/
xstrfmtcat(out, "MloaderImage=%s%s",
- bg_info_ptr->mloaderimage, line_end);
+ block_ptr->mloaderimage, line_end);
#ifdef HAVE_BGL
/****** Line 5 ******/
- xstrfmtcat(out, "BlrtsImage=%s%s", bg_info_ptr->blrtsimage, line_end);
+ xstrfmtcat(out, "BlrtsImage=%s%s", block_ptr->blrtsimage, line_end);
/****** Line 6 ******/
- xstrfmtcat(out, "LinuxImage=%s%s", bg_info_ptr->linuximage, line_end);
+ xstrfmtcat(out, "LinuxImage=%s%s", block_ptr->linuximage, line_end);
/****** Line 7 ******/
- xstrfmtcat(out, "RamdiskImage=%s", bg_info_ptr->ramdiskimage);
+ xstrfmtcat(out, "RamdiskImage=%s", block_ptr->ramdiskimage);
#else
/****** Line 5 ******/
- xstrfmtcat(out, "CnloadImage=%s%s", bg_info_ptr->linuximage, line_end);
+ xstrfmtcat(out, "CnloadImage=%s%s", block_ptr->linuximage, line_end);
/****** Line 6 ******/
- xstrfmtcat(out, "IoloadImage=%s", bg_info_ptr->ramdiskimage);
+ xstrfmtcat(out, "IoloadImage=%s", block_ptr->ramdiskimage);
#endif
if (one_liner)
xstrcat(out, "\n");
@@ -190,35 +190,35 @@ char *slurm_sprint_node_select_info(
}
/*
- * slurm_load_node_select - issue RPC to get slurm all node select plugin
+ * slurm_load_block_info - issue RPC to get slurm all node select plugin
* information if changed since update_time
* IN update_time - time of current configuration data
- * IN node_select_info_msg_pptr - place to store a node select configuration
+ * IN block_info_msg_pptr - place to store a node select configuration
* pointer
* RET 0 or a slurm error code
- * NOTE: free the response using slurm_free_node_select_info_msg
+ * NOTE: free the response using slurm_free_block_info_msg
*/
-extern int slurm_load_node_select (
- time_t update_time, node_select_info_msg_t **node_select_info_msg_pptr)
+extern int slurm_load_block_info (
+ time_t update_time, block_info_msg_t **block_info_msg_pptr)
{
int rc;
slurm_msg_t req_msg;
slurm_msg_t resp_msg;
- node_info_select_request_msg_t req;
+ block_info_request_msg_t req;
slurm_msg_t_init(&req_msg);
slurm_msg_t_init(&resp_msg);
req.last_update = update_time;
- req_msg.msg_type = REQUEST_NODE_SELECT_INFO;
+ req_msg.msg_type = REQUEST_BLOCK_INFO;
req_msg.data = &req;
if (slurm_send_recv_controller_msg(&req_msg, &resp_msg) < 0)
return SLURM_ERROR;
switch (resp_msg.msg_type) {
- case RESPONSE_NODE_SELECT_INFO:
- *node_select_info_msg_pptr = (node_select_info_msg_t *)
+ case RESPONSE_BLOCK_INFO:
+ *block_info_msg_pptr = (block_info_msg_t *)
resp_msg.data;
break;
case RESPONSE_SLURM_RC:
@@ -226,10 +226,10 @@ extern int slurm_load_node_select (
slurm_free_return_code_msg(resp_msg.data);
if (rc)
slurm_seterrno_ret(rc);
- *node_select_info_msg_pptr = NULL;
+ *block_info_msg_pptr = NULL;
break;
default:
- *node_select_info_msg_pptr = NULL;
+ *block_info_msg_pptr = NULL;
slurm_seterrno_ret(SLURM_UNEXPECTED_MSG_ERROR);
break;
}
@@ -237,10 +237,9 @@ extern int slurm_load_node_select (
return SLURM_SUCCESS;
}
-extern int slurm_free_node_select(
- node_select_info_msg_t **node_select_info_msg_pptr)
+extern int slurm_free_block_info_msg(block_info_msg_t **block_info_msg_pptr)
{
- return node_select_info_msg_free(node_select_info_msg_pptr);
+ return node_select_block_info_msg_free(block_info_msg_pptr);
}
extern int slurm_get_select_jobinfo(select_jobinfo_t *jobinfo,
diff --git a/src/common/node_select.c b/src/common/node_select.c
index e548e274e64be2ad106b6fdae136e2089e2704ea..56527776391429840e2c61ffa585cb3d18720781 100644
--- a/src/common/node_select.c
+++ b/src/common/node_select.c
@@ -305,19 +305,19 @@ static int _select_context_destroy( slurm_select_context_t *c )
return rc;
}
-static void _free_bg_info_record(bg_info_record_t *bg_info_record)
+static void _free_block_info(block_info_t *block_info)
{
- if(bg_info_record) {
- xfree(bg_info_record->bg_block_id);
- xfree(bg_info_record->blrtsimage);
- xfree(bg_info_record->bp_inx);
- xfree(bg_info_record->ionodes);
- xfree(bg_info_record->ionode_inx);
- xfree(bg_info_record->linuximage);
- xfree(bg_info_record->mloaderimage);
- xfree(bg_info_record->nodes);
- xfree(bg_info_record->owner_name);
- xfree(bg_info_record->ramdiskimage);
+ if(block_info) {
+ xfree(block_info->bg_block_id);
+ xfree(block_info->blrtsimage);
+ xfree(block_info->bp_inx);
+ xfree(block_info->ionodes);
+ xfree(block_info->ionode_inx);
+ xfree(block_info->linuximage);
+ xfree(block_info->mloaderimage);
+ xfree(block_info->nodes);
+ xfree(block_info->owner_name);
+ xfree(block_info->ramdiskimage);
}
}
@@ -325,72 +325,70 @@ static void _free_bg_info_record(bg_info_record_t *bg_info_record)
* plugin. The unpack functions can not be there since the plugin is
* dependent upon libraries which do not exist on the BlueGene front-end
* nodes. */
-static int _unpack_bg_info_record_info(bg_info_record_t *bg_info_record,
- Buf buffer)
+static int _unpack_block_info(block_info_t *block_info, Buf buffer)
{
uint32_t uint32_tmp;
char *bp_inx_str = NULL;
- safe_unpackstr_xmalloc(&bg_info_record->bg_block_id,
+ safe_unpackstr_xmalloc(&block_info->bg_block_id,
&uint32_tmp, buffer);
#ifdef HAVE_BGL
- safe_unpackstr_xmalloc(&bg_info_record->blrtsimage,
+ safe_unpackstr_xmalloc(&block_info->blrtsimage,
&uint32_tmp, buffer);
#endif
safe_unpackstr_xmalloc(&bp_inx_str, &uint32_tmp, buffer);
if (bp_inx_str == NULL) {
- bg_info_record->bp_inx = bitfmt2int("");
+ block_info->bp_inx = bitfmt2int("");
} else {
- bg_info_record->bp_inx = bitfmt2int(bp_inx_str);
+ block_info->bp_inx = bitfmt2int(bp_inx_str);
xfree(bp_inx_str);
}
- safe_unpack16(&bg_info_record->conn_type, buffer);
- safe_unpackstr_xmalloc(&(bg_info_record->ionodes),
+ safe_unpack16(&block_info->conn_type, buffer);
+ safe_unpackstr_xmalloc(&(block_info->ionodes),
&uint32_tmp, buffer);
safe_unpackstr_xmalloc(&bp_inx_str, &uint32_tmp, buffer);
if (bp_inx_str == NULL) {
- bg_info_record->ionode_inx = bitfmt2int("");
+ block_info->ionode_inx = bitfmt2int("");
} else {
- bg_info_record->ionode_inx = bitfmt2int(bp_inx_str);
+ block_info->ionode_inx = bitfmt2int(bp_inx_str);
xfree(bp_inx_str);
}
- safe_unpack32(&bg_info_record->job_running, buffer);
- safe_unpackstr_xmalloc(&bg_info_record->linuximage,
+ safe_unpack32(&block_info->job_running, buffer);
+ safe_unpackstr_xmalloc(&block_info->linuximage,
&uint32_tmp, buffer);
- safe_unpackstr_xmalloc(&bg_info_record->mloaderimage,
+ safe_unpackstr_xmalloc(&block_info->mloaderimage,
&uint32_tmp, buffer);
- safe_unpackstr_xmalloc(&(bg_info_record->nodes), &uint32_tmp, buffer);
- safe_unpack32(&bg_info_record->node_cnt, buffer);
+ safe_unpackstr_xmalloc(&(block_info->nodes), &uint32_tmp, buffer);
+ safe_unpack32(&block_info->node_cnt, buffer);
#ifdef HAVE_BGL
- safe_unpack16(&bg_info_record->node_use, buffer);
+ safe_unpack16(&block_info->node_use, buffer);
#endif
- safe_unpackstr_xmalloc(&bg_info_record->owner_name,
+ safe_unpackstr_xmalloc(&block_info->owner_name,
&uint32_tmp, buffer);
- safe_unpackstr_xmalloc(&bg_info_record->ramdiskimage,
+ safe_unpackstr_xmalloc(&block_info->ramdiskimage,
&uint32_tmp, buffer);
- safe_unpack16(&bg_info_record->state, buffer);
+ safe_unpack16(&block_info->state, buffer);
return SLURM_SUCCESS;
unpack_error:
error("_unpack_node_info: error unpacking here");
- _free_bg_info_record(bg_info_record);
+ _free_block_info(block_info);
return SLURM_ERROR;
}
-extern int node_select_free_bg_info_record(bg_info_record_t *bg_info_record)
+extern int node_select_free_block_info(block_info_t *block_info)
{
- if(bg_info_record) {
- _free_bg_info_record(bg_info_record);
- xfree(bg_info_record);
+ if(block_info) {
+ _free_block_info(block_info);
+ xfree(block_info);
}
return SLURM_SUCCESS;
}
-extern void node_select_pack_bg_info_record(bg_info_record_t *bg_info_record,
- Buf buffer)
+extern void node_select_pack_block_info(block_info_t *block_info, Buf buffer)
{
- if(!bg_info_record) {
+ if(!block_info) {
packnull(buffer);
#ifdef HAVE_BGL
packnull(buffer);
@@ -415,102 +413,100 @@ extern void node_select_pack_bg_info_record(bg_info_record_t *bg_info_record,
packnull(buffer);
pack16((uint16_t)NO_VAL, buffer);
} else {
- packstr(bg_info_record->bg_block_id, buffer);
+ packstr(block_info->bg_block_id, buffer);
#ifdef HAVE_BGL
- packstr(bg_info_record->blrtsimage, buffer);
+ packstr(block_info->blrtsimage, buffer);
#endif
- if(bg_info_record->bp_inx) {
- char *bitfmt = inx2bitfmt(bg_info_record->bp_inx);
+ if(block_info->bp_inx) {
+ char *bitfmt = inx2bitfmt(block_info->bp_inx);
packstr(bitfmt, buffer);
xfree(bitfmt);
} else
packnull(buffer);
- pack16(bg_info_record->conn_type, buffer);
+ pack16(block_info->conn_type, buffer);
- packstr(bg_info_record->ionodes, buffer);
+ packstr(block_info->ionodes, buffer);
- if(bg_info_record->ionode_inx) {
- char *bitfmt = inx2bitfmt(bg_info_record->ionode_inx);
+ if(block_info->ionode_inx) {
+ char *bitfmt = inx2bitfmt(block_info->ionode_inx);
packstr(bitfmt, buffer);
xfree(bitfmt);
} else
packnull(buffer);
- pack32(bg_info_record->job_running, buffer);
+ pack32(block_info->job_running, buffer);
- packstr(bg_info_record->linuximage, buffer);
- packstr(bg_info_record->mloaderimage, buffer);
- packstr(bg_info_record->nodes, buffer);
- pack32(bg_info_record->node_cnt, buffer);
+ packstr(block_info->linuximage, buffer);
+ packstr(block_info->mloaderimage, buffer);
+ packstr(block_info->nodes, buffer);
+ pack32(block_info->node_cnt, buffer);
#ifdef HAVE_BGL
- pack16(bg_info_record->node_use, buffer);
+ pack16(block_info->node_use, buffer);
#endif
- packstr(bg_info_record->owner_name, buffer);
- packstr(bg_info_record->ramdiskimage, buffer);
- pack16(bg_info_record->state, buffer);
+ packstr(block_info->owner_name, buffer);
+ packstr(block_info->ramdiskimage, buffer);
+ pack16(block_info->state, buffer);
}
}
-extern int node_select_unpack_bg_info_record(bg_info_record_t **bg_info_record,
- Buf buffer)
+extern int node_select_unpack_block_info(block_info_t **block_info, Buf buffer)
{
int rc = SLURM_SUCCESS;
- bg_info_record_t *bg_rec = xmalloc(sizeof(bg_info_record_t));
+ block_info_t *bg_rec = xmalloc(sizeof(block_info_t));
- if((rc = _unpack_bg_info_record_info(bg_rec, buffer)) != SLURM_SUCCESS)
+ if((rc = _unpack_block_info(bg_rec, buffer)) != SLURM_SUCCESS)
xfree(bg_rec);
else
- *bg_info_record = bg_rec;
+ *block_info = bg_rec;
return rc;
}
-extern int node_select_info_msg_free (
- node_select_info_msg_t **node_select_info_msg_pptr)
+extern int node_select_block_info_msg_free (
+ block_info_msg_t **block_info_msg_pptr)
{
- node_select_info_msg_t *node_select_info_msg = NULL;
+ block_info_msg_t *block_info_msg = NULL;
- if (node_select_info_msg_pptr == NULL)
+ if (block_info_msg_pptr == NULL)
return EINVAL;
- node_select_info_msg = *node_select_info_msg_pptr;
- if (node_select_info_msg->bg_info_array) {
+ block_info_msg = *block_info_msg_pptr;
+ if (block_info_msg->block_array) {
int i;
- for(i=0; i<node_select_info_msg->record_count; i++)
- _free_bg_info_record(
- &(node_select_info_msg->bg_info_array[i]));
- xfree(node_select_info_msg->bg_info_array);
+ for(i=0; i<block_info_msg->record_count; i++)
+ _free_block_info(
+ &(block_info_msg->block_array[i]));
+ xfree(block_info_msg->block_array);
}
- xfree(node_select_info_msg);
+ xfree(block_info_msg);
- *node_select_info_msg_pptr = NULL;
+ *block_info_msg_pptr = NULL;
return SLURM_SUCCESS;
}
/* Unpack node select info from a buffer */
-extern int node_select_info_msg_unpack(
- node_select_info_msg_t **node_select_info_msg_pptr, Buf buffer)
+extern int node_select_block_info_msg_unpack(
+ block_info_msg_t **block_info_msg_pptr, Buf buffer)
{
int i;
- node_select_info_msg_t *buf;
+ block_info_msg_t *buf;
- buf = xmalloc(sizeof(bg_info_record_t));
+ buf = xmalloc(sizeof(block_info_t));
safe_unpack32(&(buf->record_count), buffer);
safe_unpack_time(&(buf->last_update), buffer);
- buf->bg_info_array = xmalloc(sizeof(bg_info_record_t) *
+ buf->block_array = xmalloc(sizeof(block_info_t) *
buf->record_count);
for(i=0; i<buf->record_count; i++) {
- if (_unpack_bg_info_record_info(&(buf->bg_info_array[i]),
- buffer))
+ if (_unpack_block_info(&(buf->block_array[i]), buffer))
goto unpack_error;
}
- *node_select_info_msg_pptr = buf;
+ *block_info_msg_pptr = buf;
return SLURM_SUCCESS;
unpack_error:
- node_select_info_msg_free(&buf);
- *node_select_info_msg_pptr = NULL;
+ node_select_block_info_msg_free(&buf);
+ *block_info_msg_pptr = NULL;
return SLURM_ERROR;
}
diff --git a/src/common/node_select.h b/src/common/node_select.h
index 36fb49fcc7266e04ec76f190ecbca6f3fdd32649..67f45eed810602fdd46d07df6c3c9c697311525d 100644
--- a/src/common/node_select.h
+++ b/src/common/node_select.h
@@ -64,25 +64,23 @@ typedef struct {
* GLOBAL SELECT STATE MANGEMENT FUNCIONS *
\*****************************************/
-extern int node_select_free_bg_info_record(bg_info_record_t *bg_info_record);
+extern int node_select_free_block_info(block_info_t *block_info);
-extern void node_select_pack_bg_info_record(bg_info_record_t *bg_info_record,
- Buf buffer);
-extern int node_select_unpack_bg_info_record(bg_info_record_t **bg_info_record,
- Buf buffer);
+extern void node_select_pack_block_info(block_info_t *block_info, Buf buffer);
+extern int node_select_unpack_block_info(block_info_t **block_info, Buf buffer);
/*
- * node_select_info_msg_free - free buffer returned by
+ * node_select_block_info_msg_free - free buffer returned by
* slurm_load_node_select
- * IN node_select_info_msg_pptr - data is freed and pointer is set to NULL
+ * IN block_info_msg_pptr - data is freed and pointer is set to NULL
* RET 0 or a slurm error code
*/
-extern int node_select_info_msg_free (
- node_select_info_msg_t **node_select_info_msg_pptr);
+extern int node_select_block_info_msg_free (
+ block_info_msg_t **block_info_msg_pptr);
/* Unpack node select info from a buffer */
-extern int node_select_info_msg_unpack(
- node_select_info_msg_t **node_select_info_msg_pptr, Buf buffer);
+extern int node_select_block_info_msg_unpack(
+ block_info_msg_t **block_info_msg_pptr, Buf buffer);
/*
* Initialize context for node selection plugin
diff --git a/src/common/slurm_protocol_defs.c b/src/common/slurm_protocol_defs.c
index 198f7208653610476f934127e94b6ec8bb9ec20a..655771fcbe880408babb113de5afd1ff6b011ca9 100644
--- a/src/common/slurm_protocol_defs.c
+++ b/src/common/slurm_protocol_defs.c
@@ -1714,8 +1714,8 @@ extern void slurm_free_stat_jobacct_msg(stat_jobacct_msg_t *msg)
}
}
-void inline slurm_free_node_select_msg(
- node_info_select_request_msg_t *msg)
+void inline slurm_free_block_info_request_msg(
+ block_info_request_msg_t *msg)
{
xfree(msg);
}
@@ -1910,8 +1910,8 @@ extern int slurm_free_msg_data(slurm_msg_type_t type, void *data)
case RESPONSE_PRIORITY_FACTORS:
slurm_free_priority_factors_response_msg(data);
break;
- case REQUEST_NODE_SELECT_INFO:
- slurm_free_node_select_msg(data);
+ case REQUEST_BLOCK_INFO:
+ slurm_free_block_info_request_msg(data);
break;
case REQUEST_STEP_COMPLETE:
slurm_free_step_complete_msg(data);
diff --git a/src/common/slurm_protocol_defs.h b/src/common/slurm_protocol_defs.h
index ebf691d5f129e3dfdb0eefc53d662e70b29fbd28..4753ec41416e934a9fd9877102e8c307b13a6e59 100644
--- a/src/common/slurm_protocol_defs.h
+++ b/src/common/slurm_protocol_defs.h
@@ -177,8 +177,8 @@ typedef enum {
RESPONSE_ACCOUNTING_INFO,
REQUEST_JOB_ID,
RESPONSE_JOB_ID,
- REQUEST_NODE_SELECT_INFO,
- RESPONSE_NODE_SELECT_INFO,
+ REQUEST_BLOCK_INFO,
+ RESPONSE_BLOCK_INFO,
REQUEST_TRIGGER_SET,
REQUEST_TRIGGER_GET,
REQUEST_TRIGGER_CLEAR,
@@ -468,9 +468,9 @@ typedef struct node_info_request_msg {
uint16_t show_flags;
} node_info_request_msg_t;
-typedef struct node_info_select_request_msg {
+typedef struct block_info_request_msg {
time_t last_update;
-} node_info_select_request_msg_t;
+} block_info_request_msg_t;
typedef struct part_info_request_msg {
time_t last_update;
@@ -1022,8 +1022,8 @@ void slurm_free_will_run_response_msg(will_run_response_msg_t *msg);
void inline slurm_free_file_bcast_msg(file_bcast_msg_t *msg);
void inline slurm_free_step_complete_msg(step_complete_msg_t *msg);
void inline slurm_free_stat_jobacct_msg(stat_jobacct_msg_t *msg);
-void inline slurm_free_node_select_msg(
- node_info_select_request_msg_t *msg);
+void inline slurm_free_block_info_request_msg(
+ block_info_request_msg_t *msg);
void inline slurm_free_job_notify_msg(job_notify_msg_t * msg);
void inline slurm_free_accounting_update_msg(accounting_update_msg_t *msg);
diff --git a/src/common/slurm_protocol_pack.c b/src/common/slurm_protocol_pack.c
index 6775e384e94700e2e29de6f1935f289fe15a7888..b26fbe726276a972f95793bffe0788ee2950aa72 100644
--- a/src/common/slurm_protocol_pack.c
+++ b/src/common/slurm_protocol_pack.c
@@ -67,7 +67,7 @@
#define _pack_job_info_msg(msg,buf) _pack_buffer_msg(msg,buf)
#define _pack_job_step_info_msg(msg,buf) _pack_buffer_msg(msg,buf)
-#define _pack_node_select_info_msg(msg,buf) _pack_buffer_msg(msg,buf)
+#define _pack_block_info_msg(msg,buf) _pack_buffer_msg(msg,buf)
#define _pack_node_info_msg(msg,buf) _pack_buffer_msg(msg,buf)
#define _pack_partition_info_msg(msg,buf) _pack_buffer_msg(msg,buf)
#define _pack_reserve_info_msg(msg,buf) _pack_buffer_msg(msg,buf)
@@ -130,8 +130,6 @@ static int _unpack_node_info_request_msg(
static int _unpack_node_info_msg(node_info_msg_t ** msg, Buf buffer);
static int _unpack_node_info_members(node_info_t * node, Buf buffer);
-static int _unpack_node_select_info_msg(node_select_info_msg_t ** msg,
- Buf buffer);
static void _pack_update_partition_msg(update_part_msg_t * msg, Buf buffer);
static int _unpack_update_partition_msg(update_part_msg_t ** msg, Buf buffer);
@@ -238,9 +236,9 @@ static void _pack_job_info_request_msg(job_info_request_msg_t *
static int _unpack_job_info_request_msg(job_info_request_msg_t**
msg, Buf buffer);
-static void _pack_node_select_info_req_msg(node_info_select_request_msg_t *
+static void _pack_block_info_req_msg(block_info_request_msg_t *
msg, Buf buffer);
-static int _unpack_node_select_info_req_msg(node_info_select_request_msg_t **
+static int _unpack_block_info_req_msg(block_info_request_msg_t **
msg, Buf buffer);
static void _pack_job_step_info_req_msg(job_step_info_request_msg_t * msg,
@@ -592,8 +590,7 @@ pack_msg(slurm_msg_t const *msg, Buf buffer)
data, buffer);
break;
case REQUEST_UPDATE_BLOCK:
- node_select_pack_bg_info_record((bg_info_record_t *)
- msg->data, buffer);
+ node_select_pack_block_info((block_info_t *)msg->data, buffer);
break;
case REQUEST_REATTACH_TASKS:
_pack_reattach_tasks_request_msg(
@@ -791,12 +788,12 @@ pack_msg(slurm_msg_t const *msg, Buf buffer)
(priority_factors_response_msg_t*)msg->data,
buffer);
break;
- case REQUEST_NODE_SELECT_INFO:
- _pack_node_select_info_req_msg(
- (node_info_select_request_msg_t *) msg->data, buffer);
+ case REQUEST_BLOCK_INFO:
+ _pack_block_info_req_msg(
+ (block_info_request_msg_t *) msg->data, buffer);
break;
- case RESPONSE_NODE_SELECT_INFO:
- _pack_node_select_info_msg((slurm_msg_t *) msg, buffer);
+ case RESPONSE_BLOCK_INFO:
+ _pack_block_info_msg((slurm_msg_t *) msg, buffer);
break;
case REQUEST_FILE_BCAST:
_pack_file_bcast((file_bcast_msg_t *) msg->data, buffer);
@@ -976,8 +973,8 @@ unpack_msg(slurm_msg_t * msg, Buf buffer)
&(msg->data), buffer);
break;
case REQUEST_UPDATE_BLOCK:
- rc = node_select_unpack_bg_info_record((bg_info_record_t **)
- &(msg->data), buffer);
+ rc = node_select_unpack_block_info(
+ (block_info_t **)&(msg->data), buffer);
break;
case RESPONSE_RESERVATION_INFO:
rc = _unpack_reserve_info_msg((reserve_info_msg_t **)
@@ -1201,14 +1198,14 @@ unpack_msg(slurm_msg_t * msg, Buf buffer)
(priority_factors_response_msg_t**)&msg->data,
buffer);
break;
- case REQUEST_NODE_SELECT_INFO:
- rc = _unpack_node_select_info_req_msg(
- (node_info_select_request_msg_t **) &msg->data,
+ case REQUEST_BLOCK_INFO:
+ rc = _unpack_block_info_req_msg(
+ (block_info_request_msg_t **) &msg->data,
buffer);
break;
- case RESPONSE_NODE_SELECT_INFO:
- rc = _unpack_node_select_info_msg((node_select_info_msg_t **) &
- (msg->data), buffer);
+ case RESPONSE_BLOCK_INFO:
+ rc = node_select_block_info_msg_unpack(
+ (block_info_msg_t **) &(msg->data), buffer);
break;
case REQUEST_FILE_BCAST:
rc = _unpack_file_bcast( (file_bcast_msg_t **)
@@ -2070,14 +2067,6 @@ unpack_error:
return SLURM_ERROR;
}
-static int _unpack_node_select_info_msg(node_select_info_msg_t ** msg,
- Buf buffer)
-{
- xassert(msg != NULL);
-
- return node_select_info_msg_unpack(msg, buffer);
-}
-
static void
_pack_update_partition_msg(update_part_msg_t * msg, Buf buffer)
{
@@ -4367,25 +4356,25 @@ unpack_error:
}
static void
-_pack_node_select_info_req_msg(node_info_select_request_msg_t *msg, Buf buffer)
+_pack_block_info_req_msg(block_info_request_msg_t *msg, Buf buffer)
{
pack_time(msg->last_update, buffer);
}
static int
-_unpack_node_select_info_req_msg(node_info_select_request_msg_t **msg,
+_unpack_block_info_req_msg(block_info_request_msg_t **msg,
Buf buffer)
{
- node_info_select_request_msg_t *node_sel_info;
+ block_info_request_msg_t *node_sel_info;
- node_sel_info = xmalloc(sizeof(node_info_select_request_msg_t));
+ node_sel_info = xmalloc(sizeof(block_info_request_msg_t));
*msg = node_sel_info;
safe_unpack_time(&node_sel_info->last_update, buffer);
return SLURM_SUCCESS;
unpack_error:
- slurm_free_node_select_msg(node_sel_info);
+ slurm_free_block_info_request_msg(node_sel_info);
*msg = NULL;
return SLURM_ERROR;
}
diff --git a/src/plugins/select/bluegene/plugin/bg_block_info.h b/src/plugins/select/bluegene/plugin/bg_block_info.h
index 9d20a11b64973519eb080b55bf13091db32bbca5..0f801a93a5a370a70a008fe072d045f36e14e54d 100644
--- a/src/plugins/select/bluegene/plugin/bg_block_info.h
+++ b/src/plugins/select/bluegene/plugin/bg_block_info.h
@@ -43,7 +43,6 @@
/*****************************************************/
extern int block_ready(struct job_record *job_ptr);
extern void pack_block(bg_record_t *bg_record, Buf buffer);
-extern int unpack_block(bg_info_record_t *bg_info_record, Buf buffer);
extern int update_block_list();
extern int update_freeing_block_list();
#endif /* _BG_PART_INFO_H_ */
diff --git a/src/plugins/select/bluegene/plugin/block_sys.c b/src/plugins/select/bluegene/plugin/block_sys.c
index 66609df69527d52c3ef124c8b7b7fa302f44e9c7..14bcd0d57a50db2ffffedafea36d5192ddb29733 100755
--- a/src/plugins/select/bluegene/plugin/block_sys.c
+++ b/src/plugins/select/bluegene/plugin/block_sys.c
@@ -969,9 +969,9 @@ extern int load_state_file(List curr_block_list, char *dir_name)
Buf buffer = NULL;
char *data = NULL;
int data_size = 0;
- node_select_info_msg_t *node_select_ptr = NULL;
+ block_info_msg_t *block_ptr = NULL;
bg_record_t *bg_record = NULL;
- bg_info_record_t *bg_info_record = NULL;
+ block_info_t *block_info = NULL;
bitstr_t *node_bitmap = NULL, *ionode_bitmap = NULL;
int geo[BA_SYSTEM_DIMENSIONS];
char temp[256];
@@ -1049,35 +1049,35 @@ extern int load_state_file(List curr_block_list, char *dir_name)
return EFAULT;
}
xfree(ver_str);
- if(node_select_info_msg_unpack(&node_select_ptr, buffer)
+ if(node_select_block_info_msg_unpack(&block_ptr, buffer)
== SLURM_ERROR) {
- error("select_p_state_restore: problem unpacking node_info");
+ error("select_p_state_restore: problem unpacking block_info");
goto unpack_error;
}
#ifdef HAVE_BG_FILES
- for (i=0; i<node_select_ptr->record_count; i++) {
- bg_info_record = &(node_select_ptr->bg_info_array[i]);
+ for (i=0; i<block_ptr->record_count; i++) {
+ block_info = &(block_ptr->bg_info_array[i]);
/* we only care about the states we need here
* everthing else should have been set up already */
- if(bg_info_record->state == RM_PARTITION_ERROR) {
+ if(block_info->state == RM_PARTITION_ERROR) {
slurm_mutex_lock(&block_state_mutex);
if((bg_record = find_bg_record_in_list(
curr_block_list,
- bg_info_record->bg_block_id)))
+ block_info->bg_block_id)))
/* put_block_in_error_state should be
called after the bg_lists->main has been
made. We can't call it here since
this record isn't the record kept
around in bg_lists->main.
*/
- bg_record->state = bg_info_record->state;
+ bg_record->state = block_info->state;
slurm_mutex_unlock(&block_state_mutex);
}
}
- node_select_info_msg_free(&node_select_ptr);
+ block_info_msg_free(&block_ptr);
free_buf(buffer);
return SLURM_SUCCESS;
#endif
@@ -1102,49 +1102,49 @@ extern int load_state_file(List curr_block_list, char *dir_name)
node_bitmap = bit_alloc(node_record_count);
ionode_bitmap = bit_alloc(bg_conf->numpsets);
- for (i=0; i<node_select_ptr->record_count; i++) {
- bg_info_record = &(node_select_ptr->bg_info_array[i]);
+ for (i=0; i<block_ptr->record_count; i++) {
+ block_info = &(block_ptr->block_array[i]);
bit_nclear(node_bitmap, 0, bit_size(node_bitmap) - 1);
bit_nclear(ionode_bitmap, 0, bit_size(ionode_bitmap) - 1);
j = 0;
- while(bg_info_record->bp_inx[j] >= 0) {
- if (bg_info_record->bp_inx[j+1]
+ while(block_info->bp_inx[j] >= 0) {
+ if (block_info->bp_inx[j+1]
>= node_record_count) {
fatal("Job state recovered incompatable with "
"bluegene.conf. bp=%u state=%d",
node_record_count,
- bg_info_record->bp_inx[j+1]);
+ block_info->bp_inx[j+1]);
}
bit_nset(node_bitmap,
- bg_info_record->bp_inx[j],
- bg_info_record->bp_inx[j+1]);
+ block_info->bp_inx[j],
+ block_info->bp_inx[j+1]);
j += 2;
}
j = 0;
- while(bg_info_record->ionode_inx[j] >= 0) {
- if (bg_info_record->ionode_inx[j+1]
+ while(block_info->ionode_inx[j] >= 0) {
+ if (block_info->ionode_inx[j+1]
>= bg_conf->numpsets) {
fatal("Job state recovered incompatable with "
"bluegene.conf. ionodes=%u state=%d",
bg_conf->numpsets,
- bg_info_record->ionode_inx[j+1]);
+ block_info->ionode_inx[j+1]);
}
bit_nset(ionode_bitmap,
- bg_info_record->ionode_inx[j],
- bg_info_record->ionode_inx[j+1]);
+ block_info->ionode_inx[j],
+ block_info->ionode_inx[j+1]);
j += 2;
}
bg_record = xmalloc(sizeof(bg_record_t));
bg_record->bg_block_id =
- xstrdup(bg_info_record->bg_block_id);
+ xstrdup(block_info->bg_block_id);
bg_record->nodes =
- xstrdup(bg_info_record->nodes);
+ xstrdup(block_info->nodes);
bg_record->ionodes =
- xstrdup(bg_info_record->ionodes);
+ xstrdup(block_info->ionodes);
bg_record->ionode_bitmap = bit_copy(ionode_bitmap);
/* put_block_in_error_state should be
called after the bg_lists->main has been
@@ -1152,11 +1152,11 @@ extern int load_state_file(List curr_block_list, char *dir_name)
this record isn't the record kept
around in bg_lists->main.
*/
- bg_record->state = bg_info_record->state;
+ bg_record->state = block_info->state;
bg_record->job_running = NO_JOB_RUNNING;
bg_record->bp_count = bit_set_count(node_bitmap);
- bg_record->node_cnt = bg_info_record->node_cnt;
+ bg_record->node_cnt = block_info->node_cnt;
if(bg_conf->bp_node_cnt > bg_record->node_cnt) {
ionodes = bg_conf->bp_node_cnt
/ bg_record->node_cnt;
@@ -1166,9 +1166,9 @@ extern int load_state_file(List curr_block_list, char *dir_name)
* bg_record->bp_count;
}
#ifdef HAVE_BGL
- bg_record->node_use = bg_info_record->node_use;
+ bg_record->node_use = block_info->node_use;
#endif
- bg_record->conn_type = bg_info_record->conn_type;
+ bg_record->conn_type = block_info->conn_type;
bg_record->boot_state = 0;
process_nodes(bg_record, true);
@@ -1185,14 +1185,14 @@ extern int load_state_file(List curr_block_list, char *dir_name)
#ifdef HAVE_BGL
bg_record->blrtsimage =
- xstrdup(bg_info_record->blrtsimage);
+ xstrdup(block_info->blrtsimage);
#endif
bg_record->linuximage =
- xstrdup(bg_info_record->linuximage);
+ xstrdup(block_info->linuximage);
bg_record->mloaderimage =
- xstrdup(bg_info_record->mloaderimage);
+ xstrdup(block_info->mloaderimage);
bg_record->ramdiskimage =
- xstrdup(bg_info_record->ramdiskimage);
+ xstrdup(block_info->ramdiskimage);
for(j=0; j<BA_SYSTEM_DIMENSIONS; j++)
geo[j] = bg_record->geo[j];
@@ -1254,7 +1254,7 @@ extern int load_state_file(List curr_block_list, char *dir_name)
slurm_mutex_unlock(&block_state_mutex);
info("Recovered %d blocks", blocks);
- node_select_info_msg_free(&node_select_ptr);
+ node_select_block_info_msg_free(&block_ptr);
free_buf(buffer);
return SLURM_SUCCESS;
diff --git a/src/plugins/select/bluegene/plugin/sfree.c b/src/plugins/select/bluegene/plugin/sfree.c
index 712a98f38a6bb33692646f3754fc55e6859b3abc..cb1eb2a835628ea9d10a44fb79e23299fa6c1738 100644
--- a/src/plugins/select/bluegene/plugin/sfree.c
+++ b/src/plugins/select/bluegene/plugin/sfree.c
@@ -50,33 +50,32 @@ bool wait_full = false;
/************
* Functions *
************/
-static int _get_new_info_node_select(node_select_info_msg_t **node_select_ptr)
+static int _get_new_info_block(block_info_msg_t **block_ptr)
{
int error_code = SLURM_NO_CHANGE_IN_DATA;
#ifdef HAVE_BG
- static node_select_info_msg_t *bg_info_ptr = NULL;
- static node_select_info_msg_t *new_bg_ptr = NULL;
+ static block_info_msg_t *bg_info_ptr = NULL;
+ static block_info_msg_t *new_bg_ptr = NULL;
if (bg_info_ptr) {
- error_code = slurm_load_node_select(bg_info_ptr->last_update,
- &new_bg_ptr);
+ error_code = slurm_load_block_info(bg_info_ptr->last_update,
+ &new_bg_ptr);
if (error_code == SLURM_SUCCESS) {
- node_select_info_msg_free(&bg_info_ptr);
+ slurm_free_block_info_msg(&bg_info_ptr);
} else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_NO_CHANGE_IN_DATA;
new_bg_ptr = bg_info_ptr;
}
} else {
- error_code = slurm_load_node_select((time_t) NULL,
- &new_bg_ptr);
+ error_code = slurm_load_block_info((time_t) NULL, &new_bg_ptr);
}
bg_info_ptr = new_bg_ptr;
- if(*node_select_ptr != bg_info_ptr)
+ if(*block_ptr != bg_info_ptr)
error_code = SLURM_SUCCESS;
- *node_select_ptr = new_bg_ptr;
+ *block_ptr = new_bg_ptr;
#endif
return error_code;
}
@@ -85,23 +84,23 @@ static int _check_status()
{
ListIterator itr = list_iterator_create(block_list);
int i=0;
- node_select_info_msg_t *node_select_ptr = NULL;
+ block_info_msg_t *block_ptr = NULL;
char *block_name = NULL;
while(list_count(block_list)) {
info("waiting for %d bgblocks to free...",
list_count(block_list));
- if(_get_new_info_node_select(&node_select_ptr)
+ if(_get_new_info_block(&block_ptr)
== SLURM_SUCCESS) {
while((block_name = list_next(itr))) {
- for (i=0; i<node_select_ptr->record_count;
+ for (i=0; i<block_ptr->record_count;
i++) {
if(!strcmp(block_name,
- node_select_ptr->
- bg_info_array[i].
+ block_ptr->
+ block_array[i].
bg_block_id)) {
- if(node_select_ptr->
- bg_info_array[i].
+ if(block_ptr->
+ block_array[i].
state == RM_PARTITION_FREE)
list_delete_item(itr);
break;
@@ -109,7 +108,7 @@ static int _check_status()
}
/* Here if we didn't find the record
it is gone so we just will delete it. */
- if(i >= node_select_ptr->record_count)
+ if(i >= block_ptr->record_count)
list_delete_item(itr);
}
list_iterator_reset(itr);
@@ -139,17 +138,17 @@ int main(int argc, char *argv[])
if(all_blocks) {
int i=0;
- node_select_info_msg_t *node_select_ptr = NULL;
- _get_new_info_node_select(&node_select_ptr);
+ block_info_msg_t *block_ptr = NULL;
+ _get_new_info_block(&block_ptr);
if(block_list)
list_flush(block_list);
else
block_list = list_create(slurm_destroy_char);
- for (i=0; i<node_select_ptr->record_count; i++) {
+ for (i=0; i<block_ptr->record_count; i++) {
list_append(block_list,
- xstrdup(node_select_ptr->
- bg_info_array[i].bg_block_id));
+ xstrdup(block_ptr->
+ block_array[i].bg_block_id));
}
}
diff --git a/src/plugins/select/bluegene/plugin/slurm_prolog.c b/src/plugins/select/bluegene/plugin/slurm_prolog.c
index bfd9b422db46ee5b1eb3269a748767c358526c63..47db9480df9fa5addc42c2d43ad6f6478b7f7636 100644
--- a/src/plugins/select/bluegene/plugin/slurm_prolog.c
+++ b/src/plugins/select/bluegene/plugin/slurm_prolog.c
@@ -187,20 +187,20 @@ static int _get_job_size(uint32_t job_id)
*/
static int _partitions_dealloc()
{
- static node_select_info_msg_t *bg_info_ptr = NULL, *new_bg_ptr = NULL;
+ static block_info_msg_t *bg_info_ptr = NULL, *new_bg_ptr = NULL;
int rc = 0, error_code = 0, i;
if (bg_info_ptr) {
- error_code = slurm_load_node_select(bg_info_ptr->last_update,
+ error_code = slurm_load_block_info(bg_info_ptr->last_update,
&new_bg_ptr);
if (error_code == SLURM_SUCCESS)
- node_select_info_msg_free(&bg_info_ptr);
+ slurm_free_block_info_msg(&bg_info_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_bg_ptr = bg_info_ptr;
}
} else {
- error_code = slurm_load_node_select((time_t) NULL, &new_bg_ptr);
+ error_code = slurm_load_block_info((time_t) NULL, &new_bg_ptr);
}
if (error_code) {
@@ -209,7 +209,7 @@ static int _partitions_dealloc()
return -1;
}
for (i=0; i<new_bg_ptr->record_count; i++) {
- if(new_bg_ptr->bg_info_array[i].state
+ if(new_bg_ptr->block_array[i].state
== RM_PARTITION_DEALLOCATING) {
rc = 1;
break;
diff --git a/src/salloc/salloc.c b/src/salloc/salloc.c
index 7ec4904e3f8043208f95671ac1da8c5a70b972a2..68f657a506e17408d48b5a147ad5645032ced46a 100644
--- a/src/salloc/salloc.c
+++ b/src/salloc/salloc.c
@@ -736,20 +736,20 @@ static int _wait_bluegene_block_ready(resource_allocation_response_msg_t *alloc)
*/
static int _blocks_dealloc(void)
{
- static node_select_info_msg_t *bg_info_ptr = NULL, *new_bg_ptr = NULL;
+ static block_info_msg_t *bg_info_ptr = NULL, *new_bg_ptr = NULL;
int rc = 0, error_code = 0, i;
if (bg_info_ptr) {
- error_code = slurm_load_node_select(bg_info_ptr->last_update,
+ error_code = slurm_load_block_info(bg_info_ptr->last_update,
&new_bg_ptr);
if (error_code == SLURM_SUCCESS)
- node_select_info_msg_free(&bg_info_ptr);
+ slurm_free_block_info_msg(&bg_info_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_bg_ptr = bg_info_ptr;
}
} else {
- error_code = slurm_load_node_select((time_t) NULL, &new_bg_ptr);
+ error_code = slurm_load_block_info((time_t) NULL, &new_bg_ptr);
}
if (error_code) {
@@ -758,7 +758,7 @@ static int _blocks_dealloc(void)
return -1;
}
for (i=0; i<new_bg_ptr->record_count; i++) {
- if(new_bg_ptr->bg_info_array[i].state
+ if(new_bg_ptr->block_array[i].state
== RM_PARTITION_DEALLOCATING) {
rc = 1;
break;
diff --git a/src/scontrol/info_block.c b/src/scontrol/info_block.c
index ebd610c3141843864cd7d651847bc0027eca1ce2..5f8e79b2fde41f2272873520d0a064c788253c02 100644
--- a/src/scontrol/info_block.c
+++ b/src/scontrol/info_block.c
@@ -40,71 +40,71 @@
/* Load current partiton table information into *part_buffer_pptr */
extern int
-scontrol_load_node_select (node_select_info_msg_t **node_select_info_pptr)
+scontrol_load_block (block_info_msg_t **block_info_pptr)
{
int error_code;
- static node_select_info_msg_t *last_info_ptr = NULL;
- node_select_info_msg_t *info_ptr = NULL;
+ static block_info_msg_t *last_info_ptr = NULL;
+ block_info_msg_t *info_ptr = NULL;
if (last_info_ptr) {
- error_code = slurm_load_node_select(
+ error_code = slurm_load_block_info(
last_info_ptr->last_update, &info_ptr);
if (error_code == SLURM_SUCCESS)
- slurm_free_node_select(&last_info_ptr);
+ slurm_free_block_info_msg(&last_info_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
info_ptr = last_info_ptr;
error_code = SLURM_SUCCESS;
if (quiet_flag == -1)
- printf ("slurm_load_node_select no "
+ printf ("slurm_load_block no "
"change in data\n");
}
} else
- error_code = slurm_load_node_select((time_t)NULL, &info_ptr);
+ error_code = slurm_load_block_info((time_t)NULL, &info_ptr);
if (error_code == SLURM_SUCCESS) {
last_info_ptr = info_ptr;
- *node_select_info_pptr = info_ptr;
+ *block_info_pptr = info_ptr;
}
return error_code;
}
/*
- * scontrol_print_node_select - print the specified block's information
+ * scontrol_print_block - print the specified block's information
* IN block_name - NULL to print information about all block
*/
extern void
-scontrol_print_node_select (char *block_name)
+scontrol_print_block (char *block_name)
{
int error_code, i, print_cnt = 0;
- node_select_info_msg_t *node_select_info_ptr = NULL;
- bg_info_record_t *node_select_ptr = NULL;
+ block_info_msg_t *block_info_ptr = NULL;
+ block_info_t *block_ptr = NULL;
- error_code = scontrol_load_node_select(&node_select_info_ptr);
+ error_code = scontrol_load_block(&block_info_ptr);
if (error_code) {
exit_code = 1;
if (quiet_flag != 1)
- slurm_perror ("slurm_load_node_select error");
+ slurm_perror ("slurm_load_block error");
return;
}
if (quiet_flag == -1) {
char time_str[32];
slurm_make_time_str(
- (time_t *)&node_select_info_ptr->last_update,
+ (time_t *)&block_info_ptr->last_update,
time_str, sizeof(time_str));
printf ("last_update_time=%s, records=%d\n",
- time_str, node_select_info_ptr->record_count);
+ time_str, block_info_ptr->record_count);
}
- node_select_ptr = node_select_info_ptr->bg_info_array;
- for (i = 0; i < node_select_info_ptr->record_count; i++) {
+ block_ptr = block_info_ptr->block_array;
+ for (i = 0; i < block_info_ptr->record_count; i++) {
if (block_name
- && strcmp(block_name, node_select_ptr[i].bg_block_id))
+ && strcmp(block_name, block_ptr[i].bg_block_id))
continue;
print_cnt++;
- slurm_print_node_select_info(
- stdout, &node_select_ptr[i], one_liner);
+ slurm_print_block_info(
+ stdout, &block_ptr[i], one_liner);
if (block_name)
break;
}
diff --git a/src/scontrol/scontrol.c b/src/scontrol/scontrol.c
index 667a7a51b27233ce3ab94086bc595c89d9dcb04d..3fafc5cbf95bfcc50415ef25cfaebf8735406c91 100644
--- a/src/scontrol/scontrol.c
+++ b/src/scontrol/scontrol.c
@@ -996,7 +996,7 @@ _show_it (int argc, char *argv[])
}
if (strncasecmp (tag, "blocks", MAX(taglen, 1)) == 0) {
- scontrol_print_node_select (val);
+ scontrol_print_block (val);
} else if (strncasecmp (tag, "config", MAX(taglen, 1)) == 0) {
_print_config (val);
} else if (strncasecmp (tag, "daemons", MAX(taglen, 1)) == 0) {
diff --git a/src/scontrol/scontrol.h b/src/scontrol/scontrol.h
index ad5d0ec607e870478152303486d9320fcd77e20d..83b068b5961bd9c95b3076f7f82fac5762b19d79 100644
--- a/src/scontrol/scontrol.h
+++ b/src/scontrol/scontrol.h
@@ -109,8 +109,8 @@ extern int scontrol_load_nodes (node_info_msg_t ** node_buffer_pptr,
uint16_t show_flags);
extern int scontrol_load_partitions (
partition_info_msg_t **part_info_pptr);
-extern int scontrol_load_node_select(
- node_select_info_msg_t **node_select_info_pptr);
+extern int scontrol_load_block(
+ block_info_msg_t **block_info_pptr);
extern void scontrol_pid_info(pid_t job_pid);
extern void scontrol_print_completing (void);
extern void scontrol_print_completing_job(job_info_t *job_ptr,
@@ -121,7 +121,7 @@ extern void scontrol_print_node (char *node_name,
node_info_msg_t *node_info_ptr);
extern void scontrol_print_node_list (char *node_list);
extern void scontrol_print_part (char *partition_name);
-extern void scontrol_print_node_select (char *block_name);
+extern void scontrol_print_block (char *block_name);
extern void scontrol_print_res (char *reservation_name);
extern void scontrol_print_step (char *job_step_id_str);
extern void scontrol_print_topo (char *node_list);
diff --git a/src/sinfo/sinfo.c b/src/sinfo/sinfo.c
index 878085002320c805719cb2719ab8416af6076b79..f6e77175fb0ae43bc57b15af41a6be2cc1a8370a 100644
--- a/src/sinfo/sinfo.c
+++ b/src/sinfo/sinfo.c
@@ -66,7 +66,7 @@ static int cpus_per_node = 1;
/************
* Funtions *
************/
-static int _bg_report(node_select_info_msg_t *node_select_ptr);
+static int _bg_report(block_info_msg_t *block_ptr);
static int _build_sinfo_data(List sinfo_list,
partition_info_msg_t *partition_msg,
node_info_msg_t *node_msg);
@@ -81,7 +81,7 @@ static bool _match_part_data(sinfo_data_t *sinfo_ptr,
partition_info_t* part_ptr);
static int _query_server(partition_info_msg_t ** part_pptr,
node_info_msg_t ** node_pptr,
- node_select_info_msg_t ** node_select_pptr);
+ block_info_msg_t ** block_pptr);
static void _sort_hostlist(List sinfo_list);
static int _strcmp(char *data1, char *data2);
static void _update_sinfo(sinfo_data_t *sinfo_ptr, node_info_t *node_ptr,
@@ -99,7 +99,7 @@ int main(int argc, char *argv[])
log_options_t opts = LOG_OPTS_STDERR_ONLY;
partition_info_msg_t *partition_msg = NULL;
node_info_msg_t *node_msg = NULL;
- node_select_info_msg_t *node_select_msg = NULL;
+ block_info_msg_t *block_msg = NULL;
List sinfo_list = NULL;
int rc = 0;
@@ -115,11 +115,11 @@ int main(int argc, char *argv[])
&& (params.iterate || params.verbose || params.long_output))
print_date();
- if (_query_server(&partition_msg, &node_msg, &node_select_msg)
+ if (_query_server(&partition_msg, &node_msg, &block_msg)
!= 0)
rc = 1;
else if (params.bg_flag)
- (void) _bg_report(node_select_msg);
+ (void) _bg_report(block_msg);
else {
sinfo_list = list_create(_sinfo_list_delete);
_build_sinfo_data(sinfo_list, partition_msg, node_msg);
@@ -197,12 +197,12 @@ static char *_part_state_str(int state)
/*
* _bg_report - download and print current bgblock state information
*/
-static int _bg_report(node_select_info_msg_t *node_select_ptr)
+static int _bg_report(block_info_msg_t *block_ptr)
{
int i;
- if (!node_select_ptr) {
- slurm_perror("No node_select_ptr given");
+ if (!block_ptr) {
+ slurm_perror("No block_ptr given");
return SLURM_ERROR;
}
@@ -211,17 +211,17 @@ static int _bg_report(node_select_info_msg_t *node_select_ptr)
/* 1234567890123456 123456789012 12345678 12345678 1234567890 12345+ */
/* RMP_22Apr1544018 bg[123x456] name READY TORUS COPROCESSOR */
- for (i=0; i<node_select_ptr->record_count; i++) {
+ for (i=0; i<block_ptr->record_count; i++) {
printf("%-16.16s %-12.12s %-8.8s %-8.8s %-10.10s %s\n",
- node_select_ptr->bg_info_array[i].bg_block_id,
- node_select_ptr->bg_info_array[i].nodes,
- node_select_ptr->bg_info_array[i].owner_name,
+ block_ptr->block_array[i].bg_block_id,
+ block_ptr->block_array[i].nodes,
+ block_ptr->block_array[i].owner_name,
_part_state_str(
- node_select_ptr->bg_info_array[i].state),
+ block_ptr->block_array[i].state),
_conn_type_str(
- node_select_ptr->bg_info_array[i].conn_type),
+ block_ptr->block_array[i].conn_type),
_node_use_str(
- node_select_ptr->bg_info_array[i].node_use));
+ block_ptr->block_array[i].node_use));
}
return SLURM_SUCCESS;
@@ -236,12 +236,12 @@ static int _bg_report(node_select_info_msg_t *node_select_ptr)
static int
_query_server(partition_info_msg_t ** part_pptr,
node_info_msg_t ** node_pptr,
- node_select_info_msg_t ** node_select_pptr)
+ block_info_msg_t ** block_pptr)
{
static partition_info_msg_t *old_part_ptr = NULL, *new_part_ptr;
static node_info_msg_t *old_node_ptr = NULL, *new_node_ptr;
#ifdef HAVE_BG
- static node_select_info_msg_t *old_bg_ptr = NULL, *new_bg_ptr;
+ static block_info_msg_t *old_bg_ptr = NULL, *new_bg_ptr;
#endif
int error_code;
uint16_t show_flags = 0;
@@ -293,24 +293,24 @@ _query_server(partition_info_msg_t ** part_pptr,
#ifdef HAVE_BG
if (old_bg_ptr) {
- error_code = slurm_load_node_select(old_bg_ptr->last_update,
- &new_bg_ptr);
+ error_code = slurm_load_block_info(old_bg_ptr->last_update,
+ &new_bg_ptr);
if (error_code == SLURM_SUCCESS)
- node_select_info_msg_free(&old_bg_ptr);
+ slurm_free_block_info_msg(&old_bg_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_bg_ptr = old_bg_ptr;
}
} else {
- error_code = slurm_load_node_select((time_t) NULL,
- &new_bg_ptr);
+ error_code = slurm_load_block_info((time_t) NULL,
+ &new_bg_ptr);
}
if (error_code) {
- slurm_perror("slurm_load_node_select");
+ slurm_perror("slurm_load_block");
return error_code;
}
old_bg_ptr = new_bg_ptr;
- *node_select_pptr = new_bg_ptr;
+ *block_pptr = new_bg_ptr;
#endif
return SLURM_SUCCESS;
}
diff --git a/src/slurmctld/proc_req.c b/src/slurmctld/proc_req.c
index 6d4210ca443291e7320b9dcf2d203d90872f596a..7cb094d0bc0379d3ce95d3ee9a06dbc00eb121a8 100644
--- a/src/slurmctld/proc_req.c
+++ b/src/slurmctld/proc_req.c
@@ -113,7 +113,7 @@ inline static void _slurm_rpc_job_step_create(slurm_msg_t * msg);
inline static void _slurm_rpc_job_step_get_info(slurm_msg_t * msg);
inline static void _slurm_rpc_job_will_run(slurm_msg_t * msg);
inline static void _slurm_rpc_node_registration(slurm_msg_t * msg);
-inline static void _slurm_rpc_node_select_info(slurm_msg_t * msg);
+inline static void _slurm_rpc_block_info(slurm_msg_t * msg);
inline static void _slurm_rpc_job_alloc_info(slurm_msg_t * msg);
inline static void _slurm_rpc_job_alloc_info_lite(slurm_msg_t * msg);
inline static void _slurm_rpc_ping(slurm_msg_t * msg);
@@ -299,7 +299,7 @@ void slurmctld_req (slurm_msg_t * msg)
break;
case REQUEST_UPDATE_BLOCK:
_slurm_rpc_update_block(msg);
- node_select_free_bg_info_record(msg->data);
+ node_select_block_info_msg_free(msg->data);
break;
case REQUEST_RESERVATION_INFO:
_slurm_rpc_resv_show(msg);
@@ -334,9 +334,9 @@ void slurmctld_req (slurm_msg_t * msg)
_slurm_rpc_job_ready(msg);
slurm_free_job_id_msg(msg->data);
break;
- case REQUEST_NODE_SELECT_INFO:
- _slurm_rpc_node_select_info(msg);
- slurm_free_node_select_msg(msg->data);
+ case REQUEST_BLOCK_INFO:
+ _slurm_rpc_block_info(msg);
+ slurm_free_block_info_request_msg(msg->data);
break;
case REQUEST_STEP_COMPLETE:
_slurm_rpc_step_complete(msg);
@@ -2792,12 +2792,12 @@ static void _slurm_rpc_job_ready(slurm_msg_t * msg)
}
/* get node select info plugin */
-static void _slurm_rpc_node_select_info(slurm_msg_t * msg)
+static void _slurm_rpc_block_info(slurm_msg_t * msg)
{
int error_code = SLURM_SUCCESS;
Buf buffer = NULL;
- node_info_select_request_msg_t *sel_req_msg =
- (node_info_select_request_msg_t *) msg->data;
+ block_info_request_msg_t *sel_req_msg =
+ (block_info_request_msg_t *) msg->data;
slurm_msg_t response_msg;
/* Locks: read config */
slurmctld_lock_t config_read_lock = {
@@ -2806,13 +2806,13 @@ static void _slurm_rpc_node_select_info(slurm_msg_t * msg)
uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, NULL);
START_TIMER;
- debug2("Processing RPC: REQUEST_NODE_SELECT_INFO from uid=%u",
+ debug2("Processing RPC: REQUEST_BLOCK_INFO from uid=%u",
(unsigned int) uid);
lock_slurmctld(config_read_lock);
if ((slurmctld_conf.private_data & PRIVATE_DATA_NODES)
&& (!validate_super_user(uid))) {
error_code = ESLURM_ACCESS_DENIED;
- error("Security violation, NODE_SELECT_INFO RPC from uid=u",
+ error("Security violation, REQUEST_BLOCK_INFO RPC from uid=u",
(unsigned int) uid);
}
unlock_slurmctld(config_read_lock);
@@ -2821,17 +2821,17 @@ static void _slurm_rpc_node_select_info(slurm_msg_t * msg)
sel_req_msg->last_update,
&buffer);
}
- END_TIMER2("_slurm_rpc_node_select_info");
+ END_TIMER2("_slurm_rpc_block_info");
if (error_code) {
- debug3("_slurm_rpc_node_select_info: %s",
+ debug3("_slurm_rpc_block_info: %s",
slurm_strerror(error_code));
slurm_send_rc_msg(msg, error_code);
} else {
/* init response_msg structure */
slurm_msg_t_init(&response_msg);
response_msg.address = msg->address;
- response_msg.msg_type = RESPONSE_NODE_SELECT_INFO;
+ response_msg.msg_type = RESPONSE_BLOCK_INFO;
response_msg.data = get_buf_data(buffer);
response_msg.data_size = get_buf_offset(buffer);
/* send message */
diff --git a/src/smap/partition_functions.c b/src/smap/partition_functions.c
index aac40d87524dd4691379a2216d5f714b78f3cc24..c3a2a5fa0ea4fe64415d00a0cd2d86ff1d9c8783 100644
--- a/src/smap/partition_functions.c
+++ b/src/smap/partition_functions.c
@@ -189,8 +189,8 @@ extern void get_bg_part()
int error_code, i, j, recs=0, count = 0, last_count = -1;
static partition_info_msg_t *part_info_ptr = NULL;
static partition_info_msg_t *new_part_ptr = NULL;
- static node_select_info_msg_t *bg_info_ptr = NULL;
- static node_select_info_msg_t *new_bg_ptr = NULL;
+ static block_info_msg_t *bg_info_ptr = NULL;
+ static block_info_msg_t *new_bg_ptr = NULL;
partition_info_t part;
db2_block_info_t *block_ptr = NULL;
@@ -229,28 +229,28 @@ extern void get_bg_part()
return;
}
if (bg_info_ptr) {
- error_code = slurm_load_node_select(bg_info_ptr->last_update,
- &new_bg_ptr);
+ error_code = slurm_load_block_info(bg_info_ptr->last_update,
+ &new_bg_ptr);
if (error_code == SLURM_SUCCESS)
- node_select_info_msg_free(&bg_info_ptr);
+ slurm_free_block_info_msg(&bg_info_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_bg_ptr = bg_info_ptr;
}
} else {
- error_code = slurm_load_node_select((time_t) NULL,
- &new_bg_ptr);
+ error_code = slurm_load_block_info((time_t) NULL,
+ &new_bg_ptr);
}
if (error_code) {
if (quiet_flag != 1) {
if(!params.commandline) {
mvwprintw(text_win,
main_ycord, 1,
- "slurm_load_node_select: %s",
+ "slurm_load_block: %s",
slurm_strerror(slurm_get_errno()));
main_ycord++;
} else {
- printf("slurm_load_node_select: %s\n",
+ printf("slurm_load_block: %s\n",
slurm_strerror(slurm_get_errno()));
}
}
@@ -277,18 +277,18 @@ extern void get_bg_part()
int overlap = 0;
bitstr_t *loc_bitmap = bit_alloc(bit_size(nodes_req));
inx2bitstr(loc_bitmap,
- new_bg_ptr->bg_info_array[i].bp_inx);
+ new_bg_ptr->block_array[i].bp_inx);
overlap = bit_overlap(loc_bitmap, nodes_req);
FREE_NULL_BITMAP(loc_bitmap);
if(!overlap)
continue;
}
- if(params.io_bit && new_bg_ptr->bg_info_array[i].ionodes) {
+ if(params.io_bit && new_bg_ptr->block_array[i].ionodes) {
int overlap = 0;
bitstr_t *loc_bitmap =
bit_alloc(bit_size(params.io_bit));
inx2bitstr(loc_bitmap,
- new_bg_ptr->bg_info_array[i].ionode_inx);
+ new_bg_ptr->block_array[i].ionode_inx);
overlap = bit_overlap(loc_bitmap,
params.io_bit);
FREE_NULL_BITMAP(loc_bitmap);
@@ -299,26 +299,21 @@ extern void get_bg_part()
block_ptr = xmalloc(sizeof(db2_block_info_t));
block_ptr->bg_block_name
- = xstrdup(new_bg_ptr->bg_info_array[i].bg_block_id);
- block_ptr->nodes
- = xstrdup(new_bg_ptr->bg_info_array[i].nodes);
+ = xstrdup(new_bg_ptr->block_array[i].bg_block_id);
+ block_ptr->nodes = xstrdup(new_bg_ptr->block_array[i].nodes);
block_ptr->nodelist = list_create(_nodelist_del);
_make_nodelist(block_ptr->nodes,block_ptr->nodelist);
block_ptr->bg_user_name
- = xstrdup(new_bg_ptr->bg_info_array[i].owner_name);
- block_ptr->state
- = new_bg_ptr->bg_info_array[i].state;
- block_ptr->bg_conn_type
- = new_bg_ptr->bg_info_array[i].conn_type;
+ = xstrdup(new_bg_ptr->block_array[i].owner_name);
+ block_ptr->state = new_bg_ptr->block_array[i].state;
+ block_ptr->bg_conn_type = new_bg_ptr->block_array[i].conn_type;
#ifdef HAVE_BGL
- block_ptr->bg_node_use
- = new_bg_ptr->bg_info_array[i].node_use;
+ block_ptr->bg_node_use = new_bg_ptr->block_array[i].node_use;
#endif
block_ptr->ionodes
- = xstrdup(new_bg_ptr->bg_info_array[i].ionodes);
- block_ptr->node_cnt
- = new_bg_ptr->bg_info_array[i].node_cnt;
+ = xstrdup(new_bg_ptr->block_array[i].ionodes);
+ block_ptr->node_cnt = new_bg_ptr->block_array[i].node_cnt;
itr = list_iterator_create(block_list);
while ((found_block = (db2_block_info_t*)list_next(itr))
@@ -336,7 +331,7 @@ extern void get_bg_part()
_marknodes(block_ptr, last_count);
}
block_ptr->job_running =
- new_bg_ptr->bg_info_array[i].job_running;
+ new_bg_ptr->block_array[i].job_running;
if(block_ptr->bg_conn_type >= SELECT_SMALL)
block_ptr->size = 0;
diff --git a/src/srun/allocate.c b/src/srun/allocate.c
index 44f49e2dbc2a7e3d784d8bd32a6d39044efb1f2e..ef8bddcb77465b877724687a642a700c5cea14e9 100644
--- a/src/srun/allocate.c
+++ b/src/srun/allocate.c
@@ -284,20 +284,20 @@ static int _wait_bluegene_block_ready(resource_allocation_response_msg_t *alloc)
*/
static int _blocks_dealloc(void)
{
- static node_select_info_msg_t *bg_info_ptr = NULL, *new_bg_ptr = NULL;
+ static block_info_msg_t *bg_info_ptr = NULL, *new_bg_ptr = NULL;
int rc = 0, error_code = 0, i;
if (bg_info_ptr) {
- error_code = slurm_load_node_select(bg_info_ptr->last_update,
- &new_bg_ptr);
+ error_code = slurm_load_block_info(bg_info_ptr->last_update,
+ &new_bg_ptr);
if (error_code == SLURM_SUCCESS)
- node_select_info_msg_free(&bg_info_ptr);
+ slurm_free_block_info_msg(&bg_info_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_bg_ptr = bg_info_ptr;
}
} else {
- error_code = slurm_load_node_select((time_t) NULL, &new_bg_ptr);
+ error_code = slurm_load_block_info((time_t) NULL, &new_bg_ptr);
}
if (error_code) {
@@ -306,7 +306,7 @@ static int _blocks_dealloc(void)
return -1;
}
for (i=0; i<new_bg_ptr->record_count; i++) {
- if(new_bg_ptr->bg_info_array[i].state
+ if(new_bg_ptr->block_array[i].state
== RM_PARTITION_DEALLOCATING) {
rc = 1;
break;
diff --git a/src/sview/block_info.c b/src/sview/block_info.c
index 8aae42f20c0b235c7775d9df7575e980239c24d9..5d1d3a90ab422ffa3c1422a15395efe602d5d4fd 100644
--- a/src/sview/block_info.c
+++ b/src/sview/block_info.c
@@ -447,7 +447,7 @@ static int _sview_block_sort_aval_dec(sview_block_info_t* rec_a,
}
static List _create_block_list(partition_info_msg_t *part_info_ptr,
- node_select_info_msg_t *node_select_ptr,
+ block_info_msg_t *block_info_ptr,
int changed)
{
int i, j;
@@ -468,12 +468,12 @@ static List _create_block_list(partition_info_msg_t *part_info_ptr,
g_print("malloc error\n");
return NULL;
}
- for (i=0; i<node_select_ptr->record_count; i++) {
+ for (i=0; i<block_info_ptr->record_count; i++) {
block_ptr = xmalloc(sizeof(sview_block_info_t));
block_ptr->bg_block_name
- = xstrdup(node_select_ptr->
- bg_info_array[i].bg_block_id);
+ = xstrdup(block_info_ptr->
+ block_array[i].bg_block_id);
#ifdef HAVE_BG_FILES
block_ptr->color_inx =
atoi(block_ptr->bg_block_name+7);
@@ -484,42 +484,42 @@ static List _create_block_list(partition_info_msg_t *part_info_ptr,
block_ptr->color_inx %= sview_colors_cnt;
block_ptr->nodes
- = xstrdup(node_select_ptr->bg_info_array[i].nodes);
- if(node_select_ptr->bg_info_array[i].ionodes) {
+ = xstrdup(block_info_ptr->block_array[i].nodes);
+ if(block_info_ptr->block_array[i].ionodes) {
snprintf(tmp_nodes, sizeof(tmp_nodes),
"%s[%s]",
block_ptr->nodes,
- node_select_ptr->bg_info_array[i].ionodes);
+ block_info_ptr->block_array[i].ionodes);
xfree(block_ptr->nodes);
block_ptr->nodes = xstrdup(tmp_nodes);
}
block_ptr->bg_user_name
- = xstrdup(node_select_ptr->
- bg_info_array[i].owner_name);
+ = xstrdup(block_info_ptr->
+ block_array[i].owner_name);
#ifdef HAVE_BGL
block_ptr->blrtsimage = xstrdup(
- node_select_ptr->bg_info_array[i].blrtsimage);
+ block_info_ptr->block_array[i].blrtsimage);
#endif
block_ptr->linuximage = xstrdup(
- node_select_ptr->bg_info_array[i].linuximage);
+ block_info_ptr->block_array[i].linuximage);
block_ptr->mloaderimage = xstrdup(
- node_select_ptr->bg_info_array[i].mloaderimage);
+ block_info_ptr->block_array[i].mloaderimage);
block_ptr->ramdiskimage = xstrdup(
- node_select_ptr->bg_info_array[i].ramdiskimage);
+ block_info_ptr->block_array[i].ramdiskimage);
block_ptr->state
- = node_select_ptr->bg_info_array[i].state;
+ = block_info_ptr->block_array[i].state;
block_ptr->bg_conn_type
- = node_select_ptr->bg_info_array[i].conn_type;
+ = block_info_ptr->block_array[i].conn_type;
#ifdef HAVE_BGL
block_ptr->bg_node_use
- = node_select_ptr->bg_info_array[i].node_use;
+ = block_info_ptr->block_array[i].node_use;
#endif
block_ptr->node_cnt
- = node_select_ptr->bg_info_array[i].node_cnt;
+ = block_info_ptr->block_array[i].node_cnt;
block_ptr->bp_inx
- = node_select_ptr->bg_info_array[i].bp_inx;
+ = block_info_ptr->block_array[i].bp_inx;
for(j = 0; j < part_info_ptr->record_count; j++) {
part = part_info_ptr->partition_array[j];
if(_in_slurm_partition(part.node_inx,
@@ -530,7 +530,7 @@ static List _create_block_list(partition_info_msg_t *part_info_ptr,
}
}
block_ptr->job_running =
- node_select_ptr->bg_info_array[i].job_running;
+ block_info_ptr->block_array[i].job_running;
if(block_ptr->bg_conn_type >= SELECT_SMALL)
block_ptr->size = 0;
@@ -645,31 +645,31 @@ extern void refresh_block(GtkAction *action, gpointer user_data)
specific_info_block(popup_win);
}
-extern int get_new_info_node_select(node_select_info_msg_t **node_select_ptr,
+extern int get_new_info_block(block_info_msg_t **block_ptr,
int force)
{
int error_code = SLURM_NO_CHANGE_IN_DATA;
#ifdef HAVE_BG
- static node_select_info_msg_t *bg_info_ptr = NULL;
- static node_select_info_msg_t *new_bg_ptr = NULL;
+ static block_info_msg_t *bg_info_ptr = NULL;
+ static block_info_msg_t *new_bg_ptr = NULL;
time_t now = time(NULL);
static time_t last;
static bool changed = 0;
if(!force && ((now - last) < global_sleep_time)) {
- if(*node_select_ptr != bg_info_ptr)
+ if(*block_ptr != bg_info_ptr)
error_code = SLURM_SUCCESS;
- *node_select_ptr = bg_info_ptr;
+ *block_ptr = bg_info_ptr;
if(changed)
return SLURM_SUCCESS;
return error_code;
}
last = now;
if (bg_info_ptr) {
- error_code = slurm_load_node_select(bg_info_ptr->last_update,
- &new_bg_ptr);
+ error_code = slurm_load_block_info(bg_info_ptr->last_update,
+ &new_bg_ptr);
if (error_code == SLURM_SUCCESS) {
- node_select_info_msg_free(&bg_info_ptr);
+ slurm_free_block_info_msg(&bg_info_ptr);
changed = 1;
} else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_NO_CHANGE_IN_DATA;
@@ -677,17 +677,17 @@ extern int get_new_info_node_select(node_select_info_msg_t **node_select_ptr,
changed = 0;
}
} else {
- error_code = slurm_load_node_select((time_t) NULL,
- &new_bg_ptr);
+ error_code = slurm_load_block_info((time_t) NULL,
+ &new_bg_ptr);
changed = 1;
}
bg_info_ptr = new_bg_ptr;
- if(*node_select_ptr != bg_info_ptr)
+ if(*block_ptr != bg_info_ptr)
error_code = SLURM_SUCCESS;
- *node_select_ptr = new_bg_ptr;
+ *block_ptr = new_bg_ptr;
#endif
return error_code;
}
@@ -828,7 +828,7 @@ extern void get_info_block(GtkTable *table, display_data_t *display_data)
int block_error_code = SLURM_SUCCESS;
static int view = -1;
static partition_info_msg_t *part_info_ptr = NULL;
- static node_select_info_msg_t *node_select_ptr = NULL;
+ static block_info_msg_t *block_ptr = NULL;
char error_char[100];
GtkWidget *label = NULL;
GtkTreeView *tree_view = NULL;
@@ -871,7 +871,7 @@ extern void get_info_block(GtkTable *table, display_data_t *display_data)
goto end_it;
}
- if((block_error_code = get_new_info_node_select(&node_select_ptr,
+ if((block_error_code = get_new_info_block(&block_ptr,
force_refresh))
== SLURM_NO_CHANGE_IN_DATA) {
if((!display_widget || view == ERROR_VIEW)
@@ -885,7 +885,7 @@ extern void get_info_block(GtkTable *table, display_data_t *display_data)
view = ERROR_VIEW;
if(display_widget)
gtk_widget_destroy(display_widget);
- sprintf(error_char, "slurm_load_node_select: %s",
+ sprintf(error_char, "slurm_load_block: %s",
slurm_strerror(slurm_get_errno()));
label = gtk_label_new(error_char);
gtk_table_attach_defaults(table,
@@ -898,7 +898,7 @@ extern void get_info_block(GtkTable *table, display_data_t *display_data)
display_it:
- block_list = _create_block_list(part_info_ptr, node_select_ptr,
+ block_list = _create_block_list(part_info_ptr, block_ptr,
changed);
if(!block_list)
return;
@@ -953,7 +953,7 @@ extern void specific_info_block(popup_info_t *popup_win)
int part_error_code = SLURM_SUCCESS;
int block_error_code = SLURM_SUCCESS;
static partition_info_msg_t *part_info_ptr = NULL;
- static node_select_info_msg_t *node_select_ptr = NULL;
+ static block_info_msg_t *block_info_ptr = NULL;
specific_info_t *spec_info = popup_win->spec_info;
sview_search_info_t *search_info = spec_info->search_info;
char error_char[100];
@@ -999,8 +999,7 @@ extern void specific_info_block(popup_info_t *popup_win)
}
if((block_error_code =
- get_new_info_node_select(&node_select_ptr,
- popup_win->force_refresh))
+ get_new_info_block(&block_info_ptr, popup_win->force_refresh))
== SLURM_NO_CHANGE_IN_DATA) {
if((!spec_info->display_widget
|| spec_info->view == ERROR_VIEW)
@@ -1015,7 +1014,7 @@ extern void specific_info_block(popup_info_t *popup_win)
spec_info->view = ERROR_VIEW;
if(spec_info->display_widget)
gtk_widget_destroy(spec_info->display_widget);
- sprintf(error_char, "slurm_load_node_select: %s",
+ sprintf(error_char, "slurm_load_block: %s",
slurm_strerror(slurm_get_errno()));
label = gtk_label_new(error_char);
gtk_table_attach_defaults(popup_win->table,
@@ -1027,7 +1026,7 @@ extern void specific_info_block(popup_info_t *popup_win)
}
display_it:
- block_list = _create_block_list(part_info_ptr, node_select_ptr,
+ block_list = _create_block_list(part_info_ptr, block_info_ptr,
changed);
if(!block_list)
return;
diff --git a/src/sview/grid.c b/src/sview/grid.c
index 57ca84e2b7ca85d08de1e004c77ff30ea2c067a9..5388130f764ebfd5b7380c937ae0c4574558e083 100644
--- a/src/sview/grid.c
+++ b/src/sview/grid.c
@@ -561,8 +561,8 @@ extern List copy_main_button_list(int initial_color)
extern void add_extra_bluegene_buttons(List *button_list, int inx,
int *color_inx)
{
- node_select_info_msg_t *node_select_ptr = NULL;
- bg_info_record_t *bg_info_ptr = NULL;
+ block_info_msg_t *block_ptr = NULL;
+ block_info_t *bg_info_ptr = NULL;
int error_code = SLURM_SUCCESS;
ListIterator itr = NULL;
grid_button_t *grid_button = NULL;
@@ -574,7 +574,7 @@ extern void add_extra_bluegene_buttons(List *button_list, int inx,
int coord_y=0;
uint16_t orig_state;
- error_code = get_new_info_node_select(&node_select_ptr, 0);
+ error_code = get_new_info_block(&block_ptr, 0);
if (error_code != SLURM_SUCCESS
&& error_code != SLURM_NO_CHANGE_IN_DATA) {
@@ -606,8 +606,8 @@ extern void add_extra_bluegene_buttons(List *button_list, int inx,
}
list_iterator_destroy(itr);
- for (i=0; i < node_select_ptr->record_count; i++) {
- bg_info_ptr = &node_select_ptr->bg_info_array[i];
+ for (i=0; i < block_ptr->record_count; i++) {
+ bg_info_ptr = &block_ptr->block_array[i];
if(!_block_in_node(bg_info_ptr->bp_inx, inx))
continue;
found = 1;
diff --git a/src/sview/part_info.c b/src/sview/part_info.c
index 00605fccf095148a1d9582638a859878a16f4b26..9c99a03bc27350dbde0dc6cc1bb348fe37f74f16 100644
--- a/src/sview/part_info.c
+++ b/src/sview/part_info.c
@@ -1466,7 +1466,7 @@ static int _sview_sub_part_sort(sview_part_sub_t* rec_a,
static List _create_part_info_list(partition_info_msg_t *part_info_ptr,
node_info_msg_t *node_info_ptr,
- node_select_info_msg_t *node_select_ptr,
+ block_info_msg_t *block_ptr,
int changed)
{
sview_part_info_t *sview_part_info = NULL;
@@ -1877,7 +1877,7 @@ extern void get_info_part(GtkTable *table, display_data_t *display_data)
static int view = -1;
static partition_info_msg_t *part_info_ptr = NULL;
static node_info_msg_t *node_info_ptr = NULL;
- static node_select_info_msg_t *node_select_ptr = NULL;
+ static block_info_msg_t *block_ptr = NULL;
char error_char[100];
GtkWidget *label = NULL;
GtkTreeView *tree_view = NULL;
@@ -1937,8 +1937,7 @@ extern void get_info_part(GtkTable *table, display_data_t *display_data)
goto end_it;
}
- if((block_error_code = get_new_info_node_select(&node_select_ptr,
- force_refresh))
+ if((block_error_code = get_new_info_block(&block_ptr, force_refresh))
== SLURM_NO_CHANGE_IN_DATA) {
if((!display_widget || view == ERROR_VIEW)
|| (part_error_code != SLURM_NO_CHANGE_IN_DATA)
@@ -1952,7 +1951,7 @@ extern void get_info_part(GtkTable *table, display_data_t *display_data)
view = ERROR_VIEW;
if(display_widget)
gtk_widget_destroy(display_widget);
- sprintf(error_char, "slurm_load_node_select: %s",
+ sprintf(error_char, "slurm_load_block: %s",
slurm_strerror(slurm_get_errno()));
label = gtk_label_new(error_char);
gtk_table_attach_defaults(table,
@@ -1967,7 +1966,7 @@ display_it:
info_list = _create_part_info_list(part_info_ptr,
node_info_ptr,
- node_select_ptr,
+ block_ptr,
changed);
if(!info_list)
return;
@@ -2026,7 +2025,7 @@ extern void specific_info_part(popup_info_t *popup_win)
int block_error_code = SLURM_SUCCESS;
static partition_info_msg_t *part_info_ptr = NULL;
static node_info_msg_t *node_info_ptr = NULL;
- static node_select_info_msg_t *node_select_ptr = NULL;
+ static block_info_msg_t *block_ptr = NULL;
specific_info_t *spec_info = popup_win->spec_info;
char error_char[100];
GtkWidget *label = NULL;
@@ -2089,8 +2088,7 @@ extern void specific_info_part(popup_info_t *popup_win)
goto end_it;
}
- if((block_error_code = get_new_info_node_select(&node_select_ptr,
- force_refresh))
+ if((block_error_code = get_new_info_block(&block_ptr, force_refresh))
== SLURM_NO_CHANGE_IN_DATA) {
if((!spec_info->display_widget
|| spec_info->view == ERROR_VIEW)
@@ -2104,7 +2102,7 @@ extern void specific_info_part(popup_info_t *popup_win)
if(spec_info->display_widget)
gtk_widget_destroy(spec_info->display_widget);
spec_info->view = ERROR_VIEW;
- sprintf(error_char, "slurm_load_node_select: %s",
+ sprintf(error_char, "slurm_load_block: %s",
slurm_strerror(slurm_get_errno()));
label = gtk_label_new(error_char);
spec_info->display_widget = gtk_widget_ref(label);
@@ -2117,7 +2115,7 @@ display_it:
info_list = _create_part_info_list(part_info_ptr,
node_info_ptr,
- node_select_ptr,
+ block_ptr,
changed);
if(!info_list)
return;
diff --git a/src/sview/sview.h b/src/sview/sview.h
index 4b2144dd1c1f179e3516033fb406d942b1a28047..dfae31707f1f071df3cd7d906e9ce6bb5e0f15d1 100644
--- a/src/sview/sview.h
+++ b/src/sview/sview.h
@@ -336,8 +336,7 @@ extern void admin_edit_block(GtkCellRendererText *cell,
const char *path_string,
const char *new_text,
gpointer data);
-extern int get_new_info_node_select(node_select_info_msg_t **node_select_ptr,
- int force);
+extern int get_new_info_block(block_info_msg_t **block_ptr, int force);
extern void get_info_block(GtkTable *table, display_data_t *display_data);
extern void specific_info_block(popup_info_t *popup_win);
extern void set_menus_block(void *arg, GtkTreePath *path,