extern void get_slurm_part(void)
{
int error_code, i, j, recs, count = 0;
static partition_info_msg_t *part_info_ptr = NULL;
static partition_info_msg_t *new_part_ptr = NULL;
partition_info_t part;
uint16_t show_flags = 0;
bitstr_t *nodes_req = NULL;
static uint16_t last_flags = 0;
if (params.all_flag)
show_flags |= SHOW_ALL;
if (part_info_ptr) {
if (show_flags != last_flags)
part_info_ptr->last_update = 0;
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);
}
last_flags = 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 (!params.no_header)
_print_header_part();
if (new_part_ptr)
recs = new_part_ptr->record_count;
else
recs = 0;
if (!params.commandline)
if ((recs - text_line_cnt) < (getmaxy(text_win) - 4))
text_line_cnt--;
if (params.hl)
nodes_req = get_requested_node_bitmap();
for (i = 0; i < recs; i++) {
part = new_part_ptr->partition_array[i];
if (nodes_req) {
int overlap = 0;
bitstr_t *loc_bitmap = bit_alloc(bit_size(nodes_req));
inx2bitstr(loc_bitmap, part.node_inx);
overlap = bit_overlap(loc_bitmap, nodes_req);
FREE_NULL_BITMAP(loc_bitmap);
if (!overlap)
continue;
}
j = 0;
while (part.node_inx[j] >= 0) {
set_grid_inx(part.node_inx[j],
part.node_inx[j + 1], count);
j += 2;
}
if (!params.commandline) {
if (i >= text_line_cnt) {
part.flags = (int) letters[count%62];
wattron(text_win,
COLOR_PAIR(colors[count%6]));
_print_text_part(&part, NULL);
wattroff(text_win,
COLOR_PAIR(colors[count%6]));
}
} else {
part.flags = (int) letters[count%62];
_print_text_part(&part, NULL);
}
count++;
}
if (params.commandline && params.iterate)
printf("\n");
part_info_ptr = new_part_ptr;
return;
}
extern void get_reservation(void)
{
int error_code = -1, active, i, recs;
reserve_info_t resv;
time_t now = time(NULL);
static int printed_resv = 0;
static int count = 0;
static reserve_info_msg_t *resv_info_ptr = NULL, *new_resv_ptr = NULL;
bitstr_t *nodes_req = NULL;
if (resv_info_ptr) {
error_code = slurm_load_reservations(resv_info_ptr->last_update,
&new_resv_ptr);
if (error_code == SLURM_SUCCESS)
slurm_free_reservation_info_msg(resv_info_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_resv_ptr = resv_info_ptr;
}
} else
error_code = slurm_load_reservations((time_t) NULL,
&new_resv_ptr);
if (error_code) {
if (quiet_flag != 1) {
if (!params.commandline) {
mvwprintw(text_win,
main_ycord, 1,
"slurm_load_reservations: %s",
slurm_strerror(slurm_get_errno()));
main_ycord++;
} else {
printf("slurm_load_reservations: %s\n",
slurm_strerror(slurm_get_errno()));
}
}
}
if (!params.no_header)
_print_header_resv();
if (new_resv_ptr)
recs = new_resv_ptr->record_count;
else
recs = 0;
if (!params.commandline) {
if ((text_line_cnt + printed_resv) > count)
text_line_cnt--;
}
printed_resv = 0;
count = 0;
if (params.hl)
nodes_req = get_requested_node_bitmap();
for (i = 0; i < recs; i++) {
resv = new_resv_ptr->reservation_array[i];
if (nodes_req) {
int overlap = 0;
bitstr_t *loc_bitmap = bit_alloc(bit_size(nodes_req));
inx2bitstr(loc_bitmap, resv.node_inx);
overlap = bit_overlap(loc_bitmap, nodes_req);
FREE_NULL_BITMAP(loc_bitmap);
if (!overlap)
continue;
}
if ((resv.start_time <= now) && (resv.end_time >= now))
active = 1;
else
active = 0;
if (active && (resv.node_inx[0] != -1)) {
int j = 0;
resv.node_cnt = 0;
while (resv.node_inx[j] >= 0) {
resv.node_cnt +=
(resv.node_inx[j + 1] + 1) -
resv.node_inx[j];
set_grid_inx(resv.node_inx[j],
resv.node_inx[j + 1],
count);
j += 2;
}
}
if (resv.node_inx[0] != -1) {
if (!params.commandline) {
if ((count >= text_line_cnt) &&
(printed_resv < (text_win->_maxy-3))) {
resv.flags = (int)letters[count%62];
wattron(text_win,
COLOR_PAIR(colors[count%6]));
_print_text_resv(&resv);
wattroff(text_win,
COLOR_PAIR(colors[count%6]));
printed_resv++;
}
} else {
/* put the letter code into "flags" field */
resv.flags = (int)letters[count%62];
_print_text_resv(&resv);
}
count++;
}
if (count == 128)
count = 0;
}
if (params.commandline && params.iterate)
printf("\n");
if (!params.commandline)
main_ycord++;
resv_info_ptr = new_resv_ptr;
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;
}
extern void get_job(void)
{
int error_code = -1, i, recs;
static int printed_jobs = 0;
static int count = 0;
static job_info_msg_t *job_info_ptr = NULL, *new_job_ptr = NULL;
job_info_t *job_ptr = NULL;
uint16_t show_flags = 0;
bitstr_t *nodes_req = NULL;
static uint16_t last_flags = 0;
if (params.all_flag)
show_flags |= SHOW_ALL;
if (job_info_ptr) {
if (show_flags != last_flags)
job_info_ptr->last_update = 0;
error_code = slurm_load_jobs(job_info_ptr->last_update,
&new_job_ptr, show_flags);
if (error_code == SLURM_SUCCESS)
slurm_free_job_info_msg(job_info_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_job_ptr = job_info_ptr;
}
} else
error_code = slurm_load_jobs((time_t) NULL, &new_job_ptr,
show_flags);
last_flags = show_flags;
if (error_code) {
if (quiet_flag != 1) {
if (!params.commandline) {
mvwprintw(text_win,
main_ycord, 1,
"slurm_load_jobs: %s",
slurm_strerror(slurm_get_errno()));
main_ycord++;
} else {
printf("slurm_load_jobs: %s\n",
slurm_strerror(slurm_get_errno()));
}
}
}
if (!params.no_header)
_print_header_job();
if (new_job_ptr)
recs = new_job_ptr->record_count;
else
recs = 0;
if (!params.commandline)
if ((text_line_cnt+printed_jobs) > count)
text_line_cnt--;
printed_jobs = 0;
count = 0;
if (params.hl)
nodes_req = get_requested_node_bitmap();
for (i = 0; i < recs; i++) {
job_ptr = &(new_job_ptr->job_array[i]);
if (!IS_JOB_PENDING(job_ptr) && !IS_JOB_RUNNING(job_ptr) &&
!IS_JOB_SUSPENDED(job_ptr) && !IS_JOB_COMPLETING(job_ptr))
continue; /* job has completed */
if (nodes_req) {
int overlap = 0;
bitstr_t *loc_bitmap = bit_alloc(bit_size(nodes_req));
inx2bitstr(loc_bitmap, job_ptr->node_inx);
overlap = bit_overlap(loc_bitmap, nodes_req);
FREE_NULL_BITMAP(loc_bitmap);
if (!overlap)
continue;
}
if (job_ptr->node_inx[0] != -1) {
int j = 0;
job_ptr->num_nodes = 0;
while (job_ptr->node_inx[j] >= 0) {
job_ptr->num_nodes +=
(job_ptr->node_inx[j + 1] + 1) -
job_ptr->node_inx[j];
set_grid_inx(job_ptr->node_inx[j],
job_ptr->node_inx[j + 1], count);
j += 2;
}
if (!params.commandline) {
if ((count >= text_line_cnt) &&
(printed_jobs < (getmaxy(text_win) - 4))) {
job_ptr->num_cpus =
(int)letters[count%62];
wattron(text_win,
COLOR_PAIR(colors[count%6]));
_print_text_job(job_ptr);
wattroff(text_win,
COLOR_PAIR(colors[count%6]));
printed_jobs++;
}
} else {
job_ptr->num_cpus = (int)letters[count%62];
_print_text_job(job_ptr);
}
count++;
}
if (count == 128)
count = 0;
}
for (i = 0; i < recs; i++) {
job_ptr = &(new_job_ptr->job_array[i]);
if (!IS_JOB_PENDING(job_ptr))
continue; /* job has completed */
if (!params.commandline) {
if ((count>=text_line_cnt) &&
(printed_jobs < (getmaxy(text_win) - 4))) {
xfree(job_ptr->nodes);
job_ptr->nodes = xstrdup("waiting...");
job_ptr->num_cpus = (int) letters[count%62];
wattron(text_win,
COLOR_PAIR(colors[count%6]));
_print_text_job(job_ptr);
wattroff(text_win,
COLOR_PAIR(colors[count%6]));
printed_jobs++;
}
} else {
xfree(job_ptr->nodes);
job_ptr->nodes = xstrdup("waiting...");
job_ptr->num_cpus = (int) letters[count%62];
_print_text_job(job_ptr);
printed_jobs++;
}
count++;
if (count == 128)
count = 0;
}
if (params.commandline && params.iterate)
printf("\n");
if (!params.commandline)
main_ycord++;
job_info_ptr = new_job_ptr;
return;
}
