diff --git a/src/common/gres.c b/src/common/gres.c
index aa8cfb583f70f03754e435898890c3c3c0dc6a38..aa7a9125a42c12eafe0f9f8019d790fe53648573 100644
--- a/src/common/gres.c
+++ b/src/common/gres.c
@@ -2695,9 +2695,9 @@ extern int gres_plugin_job_state_pack(List gres_list, Buf buffer,
if (gres_job_ptr->gres_bit_alloc) {
pack8((uint8_t) 1, buffer);
for (i = 0; i < gres_job_ptr->node_cnt; i++) {
- pack_bit_str(gres_job_ptr->
- gres_bit_alloc[i],
- buffer);
+ pack_bit_str_hex(gres_job_ptr->
+ gres_bit_alloc[i],
+ buffer);
}
} else {
pack8((uint8_t) 0, buffer);
@@ -2705,9 +2705,9 @@ extern int gres_plugin_job_state_pack(List gres_list, Buf buffer,
if (details && gres_job_ptr->gres_bit_step_alloc) {
pack8((uint8_t) 1, buffer);
for (i = 0; i < gres_job_ptr->node_cnt; i++) {
- pack_bit_str(gres_job_ptr->
- gres_bit_step_alloc[i],
- buffer);
+ pack_bit_str_hex(gres_job_ptr->
+ gres_bit_step_alloc[i],
+ buffer);
}
} else {
pack8((uint8_t) 0, buffer);
@@ -2824,10 +2824,10 @@ extern int gres_plugin_job_state_unpack(List *gres_list, Buf buffer,
gres_job_ptr->gres_bit_alloc =
xmalloc(sizeof(bitstr_t *) *
gres_job_ptr->node_cnt);
- for (i=0; i<gres_job_ptr->node_cnt; i++) {
- unpack_bit_str(&gres_job_ptr->
- gres_bit_alloc[i],
- buffer);
+ for (i = 0; i < gres_job_ptr->node_cnt; i++) {
+ unpack_bit_str_hex(&gres_job_ptr->
+ gres_bit_alloc[i],
+ buffer);
}
}
safe_unpack8(&has_more, buffer);
@@ -2835,10 +2835,10 @@ extern int gres_plugin_job_state_unpack(List *gres_list, Buf buffer,
gres_job_ptr->gres_bit_step_alloc =
xmalloc(sizeof(bitstr_t *) *
gres_job_ptr->node_cnt);
- for (i=0; i<gres_job_ptr->node_cnt; i++) {
- unpack_bit_str(&gres_job_ptr->
- gres_bit_step_alloc[i],
- buffer);
+ for (i = 0; i < gres_job_ptr->node_cnt; i++) {
+ unpack_bit_str_hex(&gres_job_ptr->
+ gres_bit_step_alloc[i],
+ buffer);
}
}
safe_unpack8(&has_more, buffer);
@@ -4820,7 +4820,23 @@ extern int gres_plugin_step_state_pack(List gres_list, Buf buffer,
gres_iter = list_iterator_create(gres_list);
while ((gres_ptr = (gres_state_t *) list_next(gres_iter))) {
gres_step_ptr = (gres_step_state_t *) gres_ptr->gres_data;
- if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
+ if (protocol_version >= SLURM_14_11_PROTOCOL_VERSION) {
+ pack32(magic, buffer);
+ pack32(gres_ptr->plugin_id, buffer);
+ pack32(gres_step_ptr->gres_cnt_alloc, buffer);
+ pack32(gres_step_ptr->node_cnt, buffer);
+ pack_bit_str_hex(gres_step_ptr->node_in_use, buffer);
+ if (gres_step_ptr->gres_bit_alloc) {
+ pack8((uint8_t) 1, buffer);
+ for (i = 0; i < gres_step_ptr->node_cnt; i++)
+ pack_bit_str_hex(gres_step_ptr->
+ gres_bit_alloc[i],
+ buffer);
+ } else {
+ pack8((uint8_t) 0, buffer);
+ }
+ rec_cnt++;
+ } else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
pack32(magic, buffer);
pack32(gres_ptr->plugin_id, buffer);
pack32(gres_step_ptr->gres_cnt_alloc, buffer);
@@ -4886,7 +4902,27 @@ extern int gres_plugin_step_state_unpack(List *gres_list, Buf buffer,
break;
rec_cnt--;
- if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
+ if (protocol_version >= SLURM_14_11_PROTOCOL_VERSION) {
+ safe_unpack32(&magic, buffer);
+ if (magic != GRES_MAGIC)
+ goto unpack_error;
+ safe_unpack32(&plugin_id, buffer);
+ gres_step_ptr = xmalloc(sizeof(gres_step_state_t));
+ safe_unpack32(&gres_step_ptr->gres_cnt_alloc, buffer);
+ safe_unpack32(&gres_step_ptr->node_cnt, buffer);
+ unpack_bit_str_hex(&gres_step_ptr->node_in_use, buffer);
+ safe_unpack8(&has_file, buffer);
+ if (has_file) {
+ gres_step_ptr->gres_bit_alloc =
+ xmalloc(sizeof(bitstr_t *) *
+ gres_step_ptr->node_cnt);
+ for (i = 0; i < gres_step_ptr->node_cnt; i++) {
+ unpack_bit_str_hex(&gres_step_ptr->
+ gres_bit_alloc[i],
+ buffer);
+ }
+ }
+ } else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
safe_unpack32(&magic, buffer);
if (magic != GRES_MAGIC)
goto unpack_error;
diff --git a/src/common/job_resources.c b/src/common/job_resources.c
index 96a4ea9d731050f4202a65ae363c9d7fe88fa581..03d0def0500e4bf066bcfe1a5b05c099e8f1a04d 100644
--- a/src/common/job_resources.c
+++ b/src/common/job_resources.c
@@ -531,7 +531,87 @@ extern void pack_job_resources(job_resources_t *job_resrcs_ptr, Buf buffer,
{
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
- if (protocol_version >= SLURM_14_03_PROTOCOL_VERSION) {
+ if (protocol_version >= SLURM_14_11_PROTOCOL_VERSION) {
+ if (job_resrcs_ptr == NULL) {
+ uint32_t empty = NO_VAL;
+ pack32(empty, buffer);
+ return;
+ }
+
+ pack32(job_resrcs_ptr->nhosts, buffer);
+ pack32(job_resrcs_ptr->ncpus, buffer);
+ pack32(job_resrcs_ptr->node_req, buffer);
+ packstr(job_resrcs_ptr->nodes, buffer);
+ pack8(job_resrcs_ptr->whole_node, buffer);
+
+ if (job_resrcs_ptr->cpu_array_reps)
+ pack32_array(job_resrcs_ptr->cpu_array_reps,
+ job_resrcs_ptr->cpu_array_cnt, buffer);
+ else
+ pack32_array(job_resrcs_ptr->cpu_array_reps, 0, buffer);
+
+ if (job_resrcs_ptr->cpu_array_value)
+ pack16_array(job_resrcs_ptr->cpu_array_value,
+ job_resrcs_ptr->cpu_array_cnt, buffer);
+ else
+ pack16_array(job_resrcs_ptr->cpu_array_value,
+ 0, buffer);
+
+ if (job_resrcs_ptr->cpus)
+ pack16_array(job_resrcs_ptr->cpus,
+ job_resrcs_ptr->nhosts, buffer);
+ else
+ pack16_array(job_resrcs_ptr->cpus, 0, buffer);
+
+ if (job_resrcs_ptr->cpus_used)
+ pack16_array(job_resrcs_ptr->cpus_used,
+ job_resrcs_ptr->nhosts, buffer);
+ else
+ pack16_array(job_resrcs_ptr->cpus_used, 0, buffer);
+
+ if (job_resrcs_ptr->memory_allocated)
+ pack32_array(job_resrcs_ptr->memory_allocated,
+ job_resrcs_ptr->nhosts, buffer);
+ else
+ pack32_array(job_resrcs_ptr->memory_allocated,
+ 0, buffer);
+
+ if (job_resrcs_ptr->memory_used)
+ pack32_array(job_resrcs_ptr->memory_used,
+ job_resrcs_ptr->nhosts, buffer);
+ else
+ pack32_array(job_resrcs_ptr->memory_used, 0, buffer);
+ if (!(cluster_flags & CLUSTER_FLAG_BG)) {
+ int i;
+ uint32_t core_cnt = 0, sock_recs = 0;
+ xassert(job_resrcs_ptr->cores_per_socket);
+ xassert(job_resrcs_ptr->sock_core_rep_count);
+ xassert(job_resrcs_ptr->sockets_per_node);
+
+ for (i=0; i<job_resrcs_ptr->nhosts; i++) {
+ core_cnt += job_resrcs_ptr->sockets_per_node[i]
+ * job_resrcs_ptr->cores_per_socket[i] *
+ job_resrcs_ptr->sock_core_rep_count[i];
+ sock_recs += job_resrcs_ptr->
+ sock_core_rep_count[i];
+ if (sock_recs >= job_resrcs_ptr->nhosts)
+ break;
+ }
+ i++;
+ pack16_array(job_resrcs_ptr->sockets_per_node,
+ (uint32_t) i, buffer);
+ pack16_array(job_resrcs_ptr->cores_per_socket,
+ (uint32_t) i, buffer);
+ pack32_array(job_resrcs_ptr->sock_core_rep_count,
+ (uint32_t) i, buffer);
+
+ xassert(job_resrcs_ptr->core_bitmap);
+ xassert(job_resrcs_ptr->core_bitmap_used);
+ pack_bit_str_hex(job_resrcs_ptr->core_bitmap, buffer);
+ pack_bit_str_hex(job_resrcs_ptr->core_bitmap_used,
+ buffer);
+ }
+ } else if (protocol_version >= SLURM_14_03_PROTOCOL_VERSION) {
if (job_resrcs_ptr == NULL) {
uint32_t empty = NO_VAL;
pack32(empty, buffer);
@@ -703,7 +783,70 @@ extern int unpack_job_resources(job_resources_t **job_resrcs_pptr,
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
xassert(job_resrcs_pptr);
- if (protocol_version >= SLURM_14_03_PROTOCOL_VERSION) {
+ if (protocol_version >= SLURM_14_11_PROTOCOL_VERSION) {
+ safe_unpack32(&empty, buffer);
+ if (empty == NO_VAL) {
+ *job_resrcs_pptr = NULL;
+ return SLURM_SUCCESS;
+ }
+
+ job_resrcs = xmalloc(sizeof(struct job_resources));
+ job_resrcs->nhosts = empty;
+ safe_unpack32(&job_resrcs->ncpus, buffer);
+ safe_unpack32(&job_resrcs->node_req, buffer);
+ safe_unpackstr_xmalloc(&job_resrcs->nodes, &tmp32, buffer);
+ safe_unpack8(&job_resrcs->whole_node, buffer);
+
+ safe_unpack32_array(&job_resrcs->cpu_array_reps,
+ &tmp32, buffer);
+ if (tmp32 == 0)
+ xfree(job_resrcs->cpu_array_reps);
+ job_resrcs->cpu_array_cnt = tmp32;
+
+ safe_unpack16_array(&job_resrcs->cpu_array_value,
+ &tmp32, buffer);
+ if (tmp32 == 0)
+ xfree(job_resrcs->cpu_array_value);
+
+ if (tmp32 != job_resrcs->cpu_array_cnt)
+ goto unpack_error;
+
+ safe_unpack16_array(&job_resrcs->cpus, &tmp32, buffer);
+ if (tmp32 == 0)
+ xfree(job_resrcs->cpus);
+ if (tmp32 != job_resrcs->nhosts)
+ goto unpack_error;
+ safe_unpack16_array(&job_resrcs->cpus_used, &tmp32, buffer);
+ if (tmp32 == 0)
+ xfree(job_resrcs->cpus_used);
+
+ safe_unpack32_array(&job_resrcs->memory_allocated,
+ &tmp32, buffer);
+ if (tmp32 == 0)
+ xfree(job_resrcs->memory_allocated);
+ safe_unpack32_array(&job_resrcs->memory_used, &tmp32, buffer);
+ if (tmp32 == 0)
+ xfree(job_resrcs->memory_used);
+
+ if (!(cluster_flags & CLUSTER_FLAG_BG)) {
+ safe_unpack16_array(&job_resrcs->sockets_per_node,
+ &tmp32, buffer);
+ if (tmp32 == 0)
+ xfree(job_resrcs->sockets_per_node);
+ safe_unpack16_array(&job_resrcs->cores_per_socket,
+ &tmp32, buffer);
+ if (tmp32 == 0)
+ xfree(job_resrcs->cores_per_socket);
+ safe_unpack32_array(&job_resrcs->sock_core_rep_count,
+ &tmp32, buffer);
+ if (tmp32 == 0)
+ xfree(job_resrcs->sock_core_rep_count);
+
+ unpack_bit_str_hex(&job_resrcs->core_bitmap, buffer);
+ unpack_bit_str_hex(&job_resrcs->core_bitmap_used,
+ buffer);
+ }
+ } else if (protocol_version >= SLURM_14_03_PROTOCOL_VERSION) {
safe_unpack32(&empty, buffer);
if (empty == NO_VAL) {
*job_resrcs_pptr = NULL;
diff --git a/src/common/pack.h b/src/common/pack.h
index 4d6a7828e00486a67d37821772ee5d9352659174..286e01a541c6be99c4fe47045755adc61f52563b 100644
--- a/src/common/pack.h
+++ b/src/common/pack.h
@@ -57,6 +57,7 @@
#include <assert.h>
#include <time.h>
#include <string.h>
+#include "src/common/bitstring.h"
#define BUF_MAGIC 0x42554545
#define BUF_SIZE (16 * 1024)
@@ -271,7 +272,7 @@ int unpackmem_array(char *valp, uint32_t size_valp, Buf buffer);
uint32_t _size; \
bit_fmt(_tmp_str,max_len,bitmap); \
_size = strlen(_tmp_str)+1; \
- packmem(_tmp_str,_size,buf); \
+ packmem(_tmp_str,_size,buf); \
} else \
packmem(NULL,(uint32_t)0,buf); \
} while (0)
@@ -308,19 +309,21 @@ int unpackmem_array(char *valp, uint32_t size_valp, Buf buffer);
packmem(NULL, 0, buf); \
} while (0)
-#define pack_bit_fmt(bitmap,buf) do { \
+#define pack_bit_fmt(bitmap,buf) do { \
assert(buf->magic == BUF_MAGIC); \
if (bitmap) { \
char _tmp_str[0xfffe]; \
uint32_t _size; \
bit_fmt(_tmp_str,0xfffe,bitmap); \
_size = strlen(_tmp_str)+1; \
- packmem(_tmp_str,_size,buf); \
+ packmem(_tmp_str,_size,buf); \
} else \
packmem(NULL,(uint32_t)0,buf); \
} while (0)
-#define pack_bit_str(bitmap,buf) do { \
+/* NOTE: un/pack_bit_str_hex() is much faster than un/pack_bit_str(),
+ * especially for larger and/or sparse bitmaps. */
+#define pack_bit_str(bitmap,buf) do { \
assert(buf->magic == BUF_MAGIC); \
if (bitmap) { \
char _tmp_str[0xfffe]; \
@@ -334,19 +337,49 @@ int unpackmem_array(char *valp, uint32_t size_valp, Buf buffer);
pack32(NO_VAL, buf); \
} while (0)
-#define unpack_bit_str(bitmap,buf) do { \
- char *tmp_str = NULL; \
- uint32_t _size = NO_VAL; \
- assert(*bitmap == NULL); \
+#define unpack_bit_str(bitmap,buf) do { \
+ char *tmp_str = NULL; \
+ uint32_t _size = NO_VAL; \
+ assert(*bitmap == NULL); \
+ assert(buf->magic == BUF_MAGIC); \
+ safe_unpack32(&_size, buf); \
+ if (_size != NO_VAL) { \
+ *bitmap = bit_alloc(_size); \
+ safe_unpackstr_xmalloc(&tmp_str, &_size, buf); \
+ bit_unfmt(*bitmap, tmp_str); \
+ xfree(tmp_str); \
+ } else \
+ *bitmap = NULL; \
+} while (0)
+
+#define pack_bit_str_hex(bitmap,buf) do { \
assert(buf->magic == BUF_MAGIC); \
- safe_unpack32(&_size, buf); \
- if (_size != NO_VAL) { \
- *bitmap = bit_alloc(_size); \
- safe_unpackstr_xmalloc(&tmp_str, &_size, buf); \
- bit_unfmt(*bitmap, tmp_str); \
- xfree(tmp_str); \
- } else \
- *bitmap = NULL; \
+ if (bitmap) { \
+ char *_tmp_str; \
+ uint32_t _size; \
+ _tmp_str = bit_fmt_hexmask(bitmap); \
+ _size = bit_size(bitmap); \
+ pack32(_size, buf); \
+ _size = strlen(_tmp_str)+1; \
+ packmem(_tmp_str,_size,buf); \
+ xfree(_tmp_str); \
+ } else \
+ pack32(NO_VAL, buf); \
+} while (0)
+
+#define unpack_bit_str_hex(bitmap,buf) do { \
+ char *tmp_str = NULL; \
+ uint32_t _size = NO_VAL; \
+ assert(*bitmap == NULL); \
+ assert(buf->magic == BUF_MAGIC); \
+ safe_unpack32(&_size, buf); \
+ if (_size != NO_VAL) { \
+ *bitmap = bit_alloc(_size); \
+ safe_unpackstr_xmalloc(&tmp_str, &_size, buf); \
+ bit_unfmt_hexmask(*bitmap, tmp_str); \
+ xfree(tmp_str); \
+ } else \
+ *bitmap = NULL; \
} while (0)
#define unpackstr_ptr \
diff --git a/src/common/slurmdb_pack.c b/src/common/slurmdb_pack.c
index 2b7c8f9fbf3830fa02d10637eaa3654ac924e542..4cc58b50d4b6f9fd098f2e522d2cf506b8676db4 100644
--- a/src/common/slurmdb_pack.c
+++ b/src/common/slurmdb_pack.c
@@ -1125,7 +1125,94 @@ extern void slurmdb_pack_qos_rec(void *in, uint16_t rpc_version, Buf buffer)
uint32_t count = NO_VAL;
char *tmp_info = NULL;
- if (rpc_version >= SLURMDBD_MIN_VERSION) {
+ if (rpc_version >= SLURM_14_11_PROTOCOL_VERSION) {
+ if (!object) {
+ packnull(buffer);
+ pack32(0, buffer);
+
+ pack32(QOS_FLAG_NOTSET, buffer);
+
+ pack32(NO_VAL, buffer);
+ pack64(NO_VAL, buffer);
+ pack64(NO_VAL, buffer);
+ pack32(NO_VAL, buffer);
+ pack32(NO_VAL, buffer);
+ pack32(NO_VAL, buffer);
+ pack32(NO_VAL, buffer);
+ pack32(NO_VAL, buffer);
+ pack32(NO_VAL, buffer);
+
+ pack64(NO_VAL, buffer);
+ pack64(NO_VAL, buffer);
+ pack32(NO_VAL, buffer);
+ pack32(NO_VAL, buffer);
+ pack32(NO_VAL, buffer);
+ pack32(NO_VAL, buffer);
+ pack32(NO_VAL, buffer);
+ pack32(NO_VAL, buffer);
+ pack32(NO_VAL, buffer);
+
+ packnull(buffer);
+
+ pack_bit_str_hex(NULL, buffer);
+ pack32(NO_VAL, buffer);
+
+ pack16(0, buffer);
+ pack32(0, buffer);
+
+ packdouble((double)NO_VAL, buffer);
+ packdouble((double)NO_VAL, buffer);
+ return;
+ }
+ packstr(object->description, buffer);
+ pack32(object->id, buffer);
+
+ pack32(object->flags, buffer);
+
+ pack32(object->grace_time, buffer);
+ pack64(object->grp_cpu_mins, buffer);
+ pack64(object->grp_cpu_run_mins, buffer);
+ pack32(object->grp_cpus, buffer);
+ pack32(object->grp_jobs, buffer);
+ pack32(object->grp_mem, buffer);
+ pack32(object->grp_nodes, buffer);
+ pack32(object->grp_submit_jobs, buffer);
+ pack32(object->grp_wall, buffer);
+
+ pack64(object->max_cpu_mins_pj, buffer);
+ pack64(object->max_cpu_run_mins_pu, buffer);
+ pack32(object->max_cpus_pj, buffer);
+ pack32(object->max_cpus_pu, buffer);
+ pack32(object->max_jobs_pu, buffer);
+ pack32(object->max_nodes_pj, buffer);
+ pack32(object->max_nodes_pu, buffer);
+ pack32(object->max_submit_jobs_pu, buffer);
+ pack32(object->max_wall_pj, buffer);
+
+ packstr(object->name, buffer);
+
+ pack_bit_str_hex(object->preempt_bitstr, buffer);
+
+ if (object->preempt_list)
+ count = list_count(object->preempt_list);
+
+ pack32(count, buffer);
+
+ if (count && count != NO_VAL) {
+ itr = list_iterator_create(object->preempt_list);
+ while ((tmp_info = list_next(itr))) {
+ packstr(tmp_info, buffer);
+ }
+ list_iterator_destroy(itr);
+ }
+ count = NO_VAL;
+
+ pack16(object->preempt_mode, buffer);
+ pack32(object->priority, buffer);
+
+ packdouble(object->usage_factor, buffer);
+ packdouble(object->usage_thres, buffer);
+ } else if (rpc_version >= SLURMDBD_MIN_VERSION) {
if (!object) {
packnull(buffer);
pack32(0, buffer);
@@ -1228,7 +1315,55 @@ extern int slurmdb_unpack_qos_rec(void **object, uint16_t rpc_version,
slurmdb_init_qos_rec(object_ptr, 0);
- if (rpc_version >= SLURMDBD_MIN_VERSION) {
+ if (rpc_version >= SLURM_14_11_PROTOCOL_VERSION) {
+ safe_unpackstr_xmalloc(&object_ptr->description,
+ &uint32_tmp, buffer);
+ safe_unpack32(&object_ptr->id, buffer);
+
+ safe_unpack32(&object_ptr->flags, buffer);
+
+ safe_unpack32(&object_ptr->grace_time, buffer);
+ safe_unpack64(&object_ptr->grp_cpu_mins, buffer);
+ safe_unpack64(&object_ptr->grp_cpu_run_mins, buffer);
+ safe_unpack32(&object_ptr->grp_cpus, buffer);
+ safe_unpack32(&object_ptr->grp_jobs, buffer);
+ safe_unpack32(&object_ptr->grp_mem, buffer);
+ safe_unpack32(&object_ptr->grp_nodes, buffer);
+ safe_unpack32(&object_ptr->grp_submit_jobs, buffer);
+ safe_unpack32(&object_ptr->grp_wall, buffer);
+
+ safe_unpack64(&object_ptr->max_cpu_mins_pj, buffer);
+ safe_unpack64(&object_ptr->max_cpu_run_mins_pu, buffer);
+ safe_unpack32(&object_ptr->max_cpus_pj, buffer);
+ safe_unpack32(&object_ptr->max_cpus_pu, buffer);
+ safe_unpack32(&object_ptr->max_jobs_pu, buffer);
+ safe_unpack32(&object_ptr->max_nodes_pj, buffer);
+ safe_unpack32(&object_ptr->max_nodes_pu, buffer);
+ safe_unpack32(&object_ptr->max_submit_jobs_pu, buffer);
+ safe_unpack32(&object_ptr->max_wall_pj, buffer);
+
+ safe_unpackstr_xmalloc(&object_ptr->name, &uint32_tmp, buffer);
+
+ unpack_bit_str_hex(&object_ptr->preempt_bitstr, buffer);
+
+ safe_unpack32(&count, buffer);
+ if (count != NO_VAL) {
+ object_ptr->preempt_list =
+ list_create(slurm_destroy_char);
+ for (i = 0; i < count; i++) {
+ safe_unpackstr_xmalloc(&tmp_info, &uint32_tmp,
+ buffer);
+ list_append(object_ptr->preempt_list,
+ tmp_info);
+ }
+ }
+
+ safe_unpack16(&object_ptr->preempt_mode, buffer);
+ safe_unpack32(&object_ptr->priority, buffer);
+
+ safe_unpackdouble(&object_ptr->usage_factor, buffer);
+ safe_unpackdouble(&object_ptr->usage_thres, buffer);
+ } else if (rpc_version >= SLURMDBD_MIN_VERSION) {
safe_unpackstr_xmalloc(&object_ptr->description,
&uint32_tmp, buffer);
safe_unpack32(&object_ptr->id, buffer);
diff --git a/src/plugins/select/cray/select_cray.c b/src/plugins/select/cray/select_cray.c
index 447a6308ff5287be8f91722ce6d89e1060fe8d1d..8f9bf7ebe20339d043018d194b47261345fc4532 100644
--- a/src/plugins/select/cray/select_cray.c
+++ b/src/plugins/select/cray/select_cray.c
@@ -777,17 +777,30 @@ static void _free_blade(blade_info_t *blade_info)
static void _pack_blade(blade_info_t *blade_info, Buf buffer,
uint16_t protocol_version)
{
- pack64(blade_info->id, buffer);
- pack32(blade_info->job_cnt, buffer);
- pack_bit_str(blade_info->node_bitmap, buffer);
+ if (protocol_version >= SLURM_14_11_PROTOCOL_VERSION) {
+ pack64(blade_info->id, buffer);
+ pack32(blade_info->job_cnt, buffer);
+ pack_bit_str_hex(blade_info->node_bitmap, buffer);
+ } else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
+ pack64(blade_info->id, buffer);
+ pack32(blade_info->job_cnt, buffer);
+ pack_bit_str(blade_info->node_bitmap, buffer);
+ }
+
}
static int _unpack_blade(blade_info_t *blade_info, Buf buffer,
uint16_t protocol_version)
{
- safe_unpack64(&blade_info->id, buffer);
- safe_unpack32(&blade_info->job_cnt, buffer);
- unpack_bit_str(&blade_info->node_bitmap, buffer);
+ if (protocol_version >= SLURM_14_11_PROTOCOL_VERSION) {
+ safe_unpack64(&blade_info->id, buffer);
+ safe_unpack32(&blade_info->job_cnt, buffer);
+ unpack_bit_str_hex(&blade_info->node_bitmap, buffer);
+ } else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
+ safe_unpack64(&blade_info->id, buffer);
+ safe_unpack32(&blade_info->job_cnt, buffer);
+ unpack_bit_str(&blade_info->node_bitmap, buffer);
+ }
return SLURM_SUCCESS;
@@ -1007,16 +1020,30 @@ static void _spawn_cleanup_thread(
static void _select_jobinfo_pack(select_jobinfo_t *jobinfo, Buf buffer,
uint16_t protocol_version)
{
- if (!jobinfo) {
- pack_bit_str(NULL, buffer);
- pack16(0, buffer);
- pack8(0, buffer);
- pack_bit_str(NULL, buffer);
- } else {
- pack_bit_str(jobinfo->blade_map, buffer);
- pack16(jobinfo->cleaning, buffer);
- pack8(jobinfo->npc, buffer);
- pack_bit_str(jobinfo->used_blades, buffer);
+ if (protocol_version >= SLURM_14_11_PROTOCOL_VERSION) {
+ if (!jobinfo) {
+ pack_bit_str_hex(NULL, buffer);
+ pack16(0, buffer);
+ pack8(0, buffer);
+ pack_bit_str_hex(NULL, buffer);
+ } else {
+ pack_bit_str_hex(jobinfo->blade_map, buffer);
+ pack16(jobinfo->cleaning, buffer);
+ pack8(jobinfo->npc, buffer);
+ pack_bit_str_hex(jobinfo->used_blades, buffer);
+ }
+ } else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
+ if (!jobinfo) {
+ pack_bit_str(NULL, buffer);
+ pack16(0, buffer);
+ pack8(0, buffer);
+ pack_bit_str(NULL, buffer);
+ } else {
+ pack_bit_str(jobinfo->blade_map, buffer);
+ pack16(jobinfo->cleaning, buffer);
+ pack8(jobinfo->npc, buffer);
+ pack_bit_str(jobinfo->used_blades, buffer);
+ }
}
}
@@ -1029,10 +1056,17 @@ static int _select_jobinfo_unpack(select_jobinfo_t **jobinfo_pptr,
jobinfo->magic = JOBINFO_MAGIC;
- unpack_bit_str(&jobinfo->blade_map, buffer);
- safe_unpack16(&jobinfo->cleaning, buffer);
- safe_unpack8(&jobinfo->npc, buffer);
- unpack_bit_str(&jobinfo->used_blades, buffer);
+ if (protocol_version >= SLURM_14_11_PROTOCOL_VERSION) {
+ unpack_bit_str_hex(&jobinfo->blade_map, buffer);
+ safe_unpack16(&jobinfo->cleaning, buffer);
+ safe_unpack8(&jobinfo->npc, buffer);
+ unpack_bit_str_hex(&jobinfo->used_blades, buffer);
+ } else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
+ unpack_bit_str(&jobinfo->blade_map, buffer);
+ safe_unpack16(&jobinfo->cleaning, buffer);
+ safe_unpack8(&jobinfo->npc, buffer);
+ unpack_bit_str(&jobinfo->used_blades, buffer);
+ }
return SLURM_SUCCESS;
diff --git a/src/plugins/switch/cray/switch_cray.c b/src/plugins/switch/cray/switch_cray.c
index 43ce0dca067593ac4fd5c0df6c59bf27a7fa9cb4..66093807ffb6e22ab41e15e0f7a42a59fd86b6d3 100644
--- a/src/plugins/switch/cray/switch_cray.c
+++ b/src/plugins/switch/cray/switch_cray.c
@@ -159,7 +159,7 @@ static void _state_read_buf(Buf buffer)
safe_unpack32(&last_alloc_port, buffer);
/* make sure we are NULL here */
FREE_NULL_BITMAP(port_resv);
- unpack_bit_str(&port_resv, buffer);
+ unpack_bit_str_hex(&port_resv, buffer);
} else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
uint8_t port_set = 0;
safe_unpack32(&min_port, buffer);
@@ -208,7 +208,7 @@ static void _state_write_buf(Buf buffer)
pthread_mutex_lock(&port_mutex);
pack32(last_alloc_port, buffer);
- pack_bit_str(port_resv, buffer);
+ pack_bit_str_hex(port_resv, buffer);
pthread_mutex_unlock(&port_mutex);
}