static void _set_block_partition(partition_info_msg_t *part_info_ptr,
sview_block_info_t *block_ptr)
{
int j;
partition_info_t part;
for (j = 0; j < part_info_ptr->record_count; j++) {
part = part_info_ptr->partition_array[j];
if (_in_slurm_partition(part.node_inx,
block_ptr->mp_inx)) {
xfree(block_ptr->slurm_part_name);
block_ptr->slurm_part_name = xstrdup(part.name);
return;
}
}
}
extern void get_bg_part(void)
{
int error_code, i, 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 block_info_msg_t *bg_info_ptr = NULL;
static block_info_msg_t *new_bg_ptr = NULL;
uint16_t show_flags = 0;
partition_info_t part;
db2_block_info_t *block_ptr = NULL;
db2_block_info_t *found_block = NULL;
ListIterator itr;
List nodelist = NULL;
bitstr_t *nodes_req = NULL;
if (!(params.cluster_flags & CLUSTER_FLAG_BG))
return;
if (params.all_flag)
show_flags |= SHOW_ALL;
if (part_info_ptr) {
error_code = slurm_load_partitions(part_info_ptr->last_update,
&new_part_ptr, show_flags);
if (error_code == SLURM_SUCCESS)
slurm_free_partition_info_msg(part_info_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_part_ptr = part_info_ptr;
}
} else {
error_code = slurm_load_partitions((time_t) NULL,
&new_part_ptr, show_flags);
}
if (error_code) {
if (quiet_flag != 1) {
if (!params.commandline) {
mvwprintw(text_win,
main_ycord, 1,
"slurm_load_partitions: %s",
slurm_strerror(slurm_get_errno()));
main_ycord++;
} else {
printf("slurm_load_partitions: %s\n",
slurm_strerror(slurm_get_errno()));
}
}
return;
}
if (bg_info_ptr) {
error_code = slurm_load_block_info(bg_info_ptr->last_update,
&new_bg_ptr, show_flags);
if (error_code == SLURM_SUCCESS)
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_block_info((time_t) NULL,
&new_bg_ptr, show_flags);
}
if (error_code) {
if (quiet_flag != 1) {
if (!params.commandline) {
mvwprintw(text_win,
main_ycord, 1,
"slurm_load_block: %s",
slurm_strerror(slurm_get_errno()));
main_ycord++;
} else {
printf("slurm_load_block: %s\n",
slurm_strerror(slurm_get_errno()));
}
}
return;
}
if (block_list) {
/* clear the old list */
list_flush(block_list);
} else {
block_list = list_create(_block_list_del);
}
if (!params.commandline)
if ((new_bg_ptr->record_count - text_line_cnt)
< (getmaxy(text_win) - 4))
text_line_cnt--;
if (params.hl)
nodes_req = get_requested_node_bitmap();
for (i = 0; i < new_bg_ptr->record_count; i++) {
if (nodes_req) {
int overlap = 0;
bitstr_t *loc_bitmap = bit_alloc(bit_size(nodes_req));
inx2bitstr(loc_bitmap,
new_bg_ptr->block_array[i].mp_inx);
overlap = bit_overlap(loc_bitmap, nodes_req);
FREE_NULL_BITMAP(loc_bitmap);
if (!overlap)
continue;
}
if (params.io_bit && new_bg_ptr->block_array[i].ionode_str) {
int overlap = 0;
bitstr_t *loc_bitmap =
bit_alloc(bit_size(params.io_bit));
inx2bitstr(loc_bitmap,
new_bg_ptr->block_array[i].ionode_inx);
overlap = bit_overlap(loc_bitmap, params.io_bit);
FREE_NULL_BITMAP(loc_bitmap);
if (!overlap)
continue;
}
block_ptr = xmalloc(sizeof(db2_block_info_t));
block_ptr->bg_block_name
= xstrdup(new_bg_ptr->block_array[i].bg_block_id);
block_ptr->mp_str = xstrdup(new_bg_ptr->block_array[i].mp_str);
block_ptr->nodelist = list_create(_nodelist_del);
_make_nodelist(block_ptr->mp_str, block_ptr->nodelist);
block_ptr->state = new_bg_ptr->block_array[i].state;
memcpy(block_ptr->bg_conn_type,
new_bg_ptr->block_array[i].conn_type,
sizeof(block_ptr->bg_conn_type));
block_ptr->ionode_str
= xstrdup(new_bg_ptr->block_array[i].ionode_str);
block_ptr->cnode_cnt = new_bg_ptr->block_array[i].cnode_cnt;
itr = list_iterator_create(block_list);
while ((found_block = (db2_block_info_t*)list_next(itr))) {
if (!xstrcmp(block_ptr->mp_str, found_block->mp_str)) {
block_ptr->letter_num =
found_block->letter_num;
break;
}
}
list_iterator_destroy(itr);
if (!found_block) {
last_count++;
_marknodes(block_ptr, last_count);
}
block_ptr->job_list = list_create(slurm_free_block_job_info);
if (new_bg_ptr->block_array[i].job_list) {
block_job_info_t *found_job;
ListIterator itr = list_iterator_create(
new_bg_ptr->block_array[i].job_list);
while ((found_job = list_next(itr))) {
block_job_info_t *block_job =
xmalloc(sizeof(block_job_info_t));
block_job->job_id = found_job->job_id;
list_append(block_ptr->job_list, block_job);
}
list_iterator_destroy(itr);
}
if (block_ptr->bg_conn_type[0] >= SELECT_SMALL)
block_ptr->size = 0;
list_append(block_list, block_ptr);
}
if (!params.no_header)
_print_header_part();
if (new_part_ptr)
recs = new_part_ptr->record_count;
else
recs = 0;
for (i = 0; i < recs; i++) {
part = new_part_ptr->partition_array[i];
if (!part.nodes || (part.nodes[0] == '\0'))
continue; /* empty partition */
nodelist = list_create(_nodelist_del);
_make_nodelist(part.nodes, nodelist);
if (block_list) {
itr = list_iterator_create(block_list);
while ((block_ptr = (db2_block_info_t*)
list_next(itr)) != NULL) {
if (_in_slurm_partition(nodelist,
block_ptr->nodelist)) {
block_ptr->slurm_part_name
= xstrdup(part.name);
}
}
list_iterator_destroy(itr);
}
FREE_NULL_LIST(nodelist);
}
/* Report the BG Blocks */
if (block_list) {
itr = list_iterator_create(block_list);
while ((block_ptr = (db2_block_info_t*)
list_next(itr)) != NULL) {
if (params.commandline)
block_ptr->printed = 1;
else {
if (count>=text_line_cnt)
block_ptr->printed = 1;
}
_print_rest(block_ptr);
count++;
}
list_iterator_destroy(itr);
}
if (params.commandline && params.iterate)
printf("\n");
part_info_ptr = new_part_ptr;
bg_info_ptr = new_bg_ptr;
return;
}
static List _create_block_list(partition_info_msg_t *part_info_ptr,
block_info_msg_t *block_info_ptr,
int changed)
{
int i, j;
static List block_list = NULL;
partition_info_t part;
sview_block_info_t *block_ptr = NULL;
char tmp_mp_str[50];
if (!changed && block_list) {
return block_list;
}
if (block_list)
list_flush(block_list);
else
block_list = list_create(_block_list_del);
if (!block_list) {
g_print("malloc error\n");
return NULL;
}
for (i=0; i<block_info_ptr->record_count; i++) {
block_ptr = xmalloc(sizeof(sview_block_info_t));
block_ptr->bg_block_name
= xstrdup(block_info_ptr->
block_array[i].bg_block_id);
/* If we don't have a block name just continue since
ths block hasn't been made in the system yet. */
if (!block_ptr->bg_block_name)
continue;
block_ptr->color_inx =
atoi(block_ptr->bg_block_name+7);
/* on some systems they make there own blocks named
whatever they want, so doing this fixes what could
be a negative number.
*/
if (block_ptr->color_inx < 0)
block_ptr->color_inx = i;
block_ptr->color_inx %= sview_colors_cnt;
block_ptr->mp_str
= xstrdup(block_info_ptr->block_array[i].mp_str);
if (block_info_ptr->block_array[i].ionode_str) {
block_ptr->small_block = 1;
snprintf(tmp_mp_str, sizeof(tmp_mp_str),
"%s[%s]",
block_ptr->mp_str,
block_info_ptr->block_array[i].ionode_str);
xfree(block_ptr->mp_str);
block_ptr->mp_str = xstrdup(tmp_mp_str);
}
block_ptr->bg_user_name
= xstrdup(block_info_ptr->
block_array[i].owner_name);
if (cluster_flags & CLUSTER_FLAG_BGL)
block_ptr->imageblrts = xstrdup(
block_info_ptr->block_array[i].blrtsimage);
block_ptr->imagelinux = xstrdup(
block_info_ptr->block_array[i].linuximage);
block_ptr->imagemloader = xstrdup(
block_info_ptr->block_array[i].mloaderimage);
block_ptr->imageramdisk = xstrdup(
block_info_ptr->block_array[i].ramdiskimage);
block_ptr->state
= block_info_ptr->block_array[i].state;
block_ptr->bg_conn_type
= block_info_ptr->block_array[i].conn_type[0];
if (cluster_flags & CLUSTER_FLAG_BGL)
block_ptr->bg_node_use
= block_info_ptr->block_array[i].node_use;
block_ptr->cnode_cnt
= block_info_ptr->block_array[i].cnode_cnt;
block_ptr->bp_inx
= block_info_ptr->block_array[i].mp_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,
block_ptr->bp_inx)) {
block_ptr->slurm_part_name
= xstrdup(part.name);
break;
}
}
block_ptr->job_running =
block_info_ptr->block_array[i].job_running;
if (block_ptr->bg_conn_type >= SELECT_SMALL)
block_ptr->size = 0;
list_append(block_list, block_ptr);
}
list_sort(block_list,
(ListCmpF)_sview_block_sort_aval_dec);
return block_list;
}
