/* Load current node table information into *node_buffer_pptr */
extern int
scontrol_load_nodes (node_info_msg_t ** node_buffer_pptr, uint16_t show_flags)
{
int error_code;
static int last_show_flags = 0xffff;
node_info_msg_t *node_info_ptr = NULL;
if (old_node_info_ptr) {
if (last_show_flags != show_flags)
old_node_info_ptr->last_update = (time_t) 0;
error_code = slurm_load_node (old_node_info_ptr->last_update,
&node_info_ptr, show_flags);
if (error_code == SLURM_SUCCESS)
slurm_free_node_info_msg (old_node_info_ptr);
else if (slurm_get_errno () == SLURM_NO_CHANGE_IN_DATA) {
node_info_ptr = old_node_info_ptr;
error_code = SLURM_SUCCESS;
if (quiet_flag == -1)
printf ("slurm_load_node no change in data\n");
}
}
else
error_code = slurm_load_node ((time_t) NULL, &node_info_ptr,
show_flags);
if (error_code == SLURM_SUCCESS) {
old_node_info_ptr = node_info_ptr;
last_show_flags = show_flags;
*node_buffer_pptr = node_info_ptr;
}
return error_code;
}
/* This set of functions loads/free node information so that we can map a job's
* core bitmap to it's CPU IDs based upon the thread count on each node. */
static void _load_node_info(void)
{
slurm_mutex_lock(&job_node_info_lock);
if (!job_node_ptr)
(void) slurm_load_node((time_t) NULL, &job_node_ptr, 0);
slurm_mutex_unlock(&job_node_info_lock);
}
// Get bar summaries for cluster nodes
void ClusterMenu::get_lines() {
// First we set the time of this update
last_update = std::chrono::steady_clock::now();
// Call SLURM API to write node information to pointer
// Free pointer memory first if it has been previously set
if (node_info_buffer_ptr != NULL) {
slurm_free_node_info_msg(node_info_buffer_ptr);
}
slurm_load_node ((time_t) NULL, &node_info_buffer_ptr, SHOW_ALL);
// Create a NodeContainer struct and populate with node information
node_container.populate_nodes_from_slurm(node_info_buffer_ptr);
// Call API function, pass job_info_ptr as reference (double pointer); flags must be SHOW_DETAIL to get job allocations
// Free pointer memory first if it has been previously set
if (job_info_buffer_ptr != NULL) {
slurm_free_job_info_msg(job_info_buffer_ptr);
}
slurm_load_jobs((time_t) NULL, &job_info_buffer_ptr, SHOW_DETAIL);
// Populate nodes with job allocations
node_container.populate_job_allocations_from_slurm(job_info_buffer_ptr);
// Get line content
lines = node_container.get_node_bar_summary(32);
// Record largest line for later use in horizontal scrolling
get_longest_line();
}
bitstr_t *get_requested_node_bitmap(void)
{
static bitstr_t *bitmap = NULL;
static node_info_msg_t *old_node_ptr = NULL, *new_node_ptr;
int error_code;
int i = 0;
node_info_t *node_ptr = NULL;
if (!params.hl)
return NULL;
if (old_node_ptr) {
error_code = slurm_load_node(old_node_ptr->last_update,
&new_node_ptr, SHOW_ALL);
if (error_code == SLURM_SUCCESS)
slurm_free_node_info_msg(old_node_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA)
return bitmap;
} else {
error_code = slurm_load_node((time_t) NULL, &new_node_ptr,
SHOW_ALL);
}
if (bitmap)
FREE_NULL_BITMAP(bitmap);
if (error_code) {
slurm_perror("slurm_load_node");
return NULL;
}
old_node_ptr = new_node_ptr;
bitmap = bit_alloc(old_node_ptr->record_count);
for (i = 0; i < old_node_ptr->record_count; i++) {
node_ptr = &(old_node_ptr->node_array[i]);
if (hostlist_find(params.hl, node_ptr->name) != -1)
bit_set(bitmap, i);
}
return bitmap;
}
/* Return the maximum number of processors for any node in the cluster */
static int _max_cpus_per_node(void)
{
int error_code, max_cpus = 1;
node_info_msg_t *node_info_ptr = NULL;
error_code = slurm_load_node ((time_t) NULL, &node_info_ptr,
params.all_flag);
if (error_code == SLURM_SUCCESS) {
int i;
node_info_t *node_ptr = node_info_ptr->node_array;
for (i=0; i<node_info_ptr->record_count; i++) {
max_cpus = MAX(max_cpus, node_ptr[i].cpus);
}
slurm_free_node_info_msg (node_info_ptr);
}
return max_cpus;
}
int main() {
// Initialise container for all node information
NodeContainer node_container;
// Declare a pointer to which the SLURM API writes node information
node_info_msg_t * node_info_buffer_ptr = NULL;
// Call SLURM API to write node information to pointer
slurm_load_node((time_t) NULL, &node_info_buffer_ptr, SHOW_ALL);
// Create a NodeContainer struct and populate with node information
node_container.populate_nodes_from_slurm(node_info_buffer_ptr);
// Declare a pointer to which the SLURM API writes job information
job_info_msg_t * job_info_buffer_ptr = NULL;
// Call API function, pass job_info_ptr as reference (double pointer); flags must be SHOW_DETAIL to get job allocations
slurm_load_jobs((time_t) NULL, &job_info_buffer_ptr, SHOW_DETAIL);
// Populate nodes with job allocations
node_container.populate_job_allocations_from_slurm(job_info_buffer_ptr);
// Get lines for output
std::vector<std::string> lines = node_container.get_node_bar_summary(32);
// Print output
for (std::vector<std::string>::iterator it = lines.begin(); it != lines.end(); ++it) {
printf("%s\n", it->c_str());
}
// Clean up and nicely deallocated memory for SLURM pointers
slurm_free_node_info_msg(node_info_buffer_ptr);
slurm_free_job_info_msg(job_info_buffer_ptr);
}
int main()
{
//===========================================================================================
// Declarations
//===========================================================================================
int i,j;
int i2,j2;
job_info_msg_t *job_ptr;
partition_info_msg_t *prt_ptr = NULL;
node_info_msg_t *node_ptr = NULL;
int err = SLURM_SUCCESS;
err = slurm_load_partitions((time_t) NULL, &prt_ptr, 0);
err = slurm_load_node((time_t) NULL, &node_ptr, 0);
err = slurm_load_jobs((time_t) NULL, &job_ptr, 0);
Linked_List_Node* job_llist;
struct json_object *partition = json_object_new_object();
struct json_object *node = json_object_new_object();
//===========================================================================================
// Filling hash tables
//===========================================================================================
j2 = 0;
i2 = 0;
//fill node_job hash
if (job_ptr->record_count > 0) {
for (i = 0; i < job_ptr->record_count; i++) {
j2=0;
while( job_ptr->job_array[i].node_inx[j2] >= 0){
i2 = 0;
for(i2 = job_ptr->job_array[i].node_inx[j2];i2 <= job_ptr->job_array[i].node_inx[j2+1];i2++) {
node_job_put(node_ptr->node_array[i2].name,job_ptr -> job_array[i]);
}
j2+=2;
}
}
}
//============================================================================================
// Creating Output in Json
//============================================================================================
// create json
int total_node_unknown = 0;
int total_node_down = 0;
int total_node_idle = 0;
int total_node_allocated = 0;
int current_node_unknown;
int current_node_down;
int current_node_idle;
int current_node_allocated;
int current_job_running;
int current_job_waiting;
int current_job_stopped;
if(prt_ptr -> record_count > 0){
for (i = 0; i < prt_ptr->record_count; i++) {
current_node_unknown = 0;
current_node_down = 0;
current_node_idle = 0;
current_node_allocated = 0;
current_job_running = 0;
current_job_waiting = 0;
current_job_stopped = 0;
int j2=0;
while( prt_ptr->partition_array[i].node_inx[j2] >= 0){
int i2 = 0;
for(i2 = prt_ptr->partition_array[i].node_inx[j2];i2 <= prt_ptr->partition_array[i].node_inx[j2+1];i2++) {
if(node_ptr->node_array[i2].node_state == 5 || node_ptr->node_array[i2].node_state == 3){ total_node_allocated++; current_node_allocated++;}
else if(node_ptr->node_array[i2].node_state == 1){ total_node_down++; current_node_down++;}
else if(node_ptr->node_array[i2].node_state == 2 || node_ptr->node_array[i2].node_state == 6){ total_node_idle++; current_node_idle++;}
else { total_node_unknown++; current_node_unknown++;}
job_llist = node_job_get(node_ptr->node_array[i2].name); //get job name
while( job_llist != NULL){
if(job_llist->value_job.job_state == 2 || job_llist->value_job.job_state == 8 || job_llist->value_job.job_state == 0) current_job_waiting++;
else if(job_llist->value_job.job_state == 1) current_job_running++;
else current_job_stopped++;
job_llist = job_llist->next;
}
}
j2+=2;
}
json_object_object_add(node, "Allocated", json_object_new_int(current_node_allocated));
json_object_object_add(node, "Down", json_object_new_int(current_node_down));
json_object_object_add(node, "Idle", json_object_new_int(current_node_idle));
json_object_object_add(node, "Unknown", json_object_new_int(current_node_unknown));
json_object_object_add(node, "Running", json_object_new_int(current_job_running));
json_object_object_add(node, "Wating", json_object_new_int(current_job_waiting));
json_object_object_add(node, "Stopped", json_object_new_int(current_job_stopped));
json_object_object_add(partition, prt_ptr->partition_array[i].name , node);
}
}
node = json_object_new_object();
json_object_object_add(node, "Unknown", json_object_new_int(total_node_unknown));
json_object_object_add(node, "Down", json_object_new_int(total_node_down));
json_object_object_add(node, "Idle", json_object_new_int(total_node_idle));
json_object_object_add(node, "Allocated", json_object_new_int(total_node_allocated));
json_object_object_add(partition, "General", node);
printf("Content-type: text/html\n\n%s",json_object_to_json_string(partition));
slurm_free_partition_info_msg(prt_ptr);
slurm_free_node_info_msg(node_ptr);
return 1;
}
int main(int argc, char **argv)
{
log_options_t opts = LOG_OPTS_STDERR_ONLY;
node_info_msg_t *node_info_ptr = NULL;
node_info_msg_t *new_node_ptr = NULL;
int error_code;
int height = 40;
int width = 100;
int startx = 0;
int starty = 0;
int end = 0;
int i;
int rc;
slurm_conf_init(NULL);
log_init(xbasename(argv[0]), opts, SYSLOG_FACILITY_DAEMON, NULL);
parse_command_line(argc, argv);
if (params.verbose) {
opts.stderr_level += params.verbose;
log_alter(opts, SYSLOG_FACILITY_USER, NULL);
}
if (params.cluster_dims == 4) {
min_screen_width = 92;
} else if (params.cluster_dims == 3)
min_screen_width = 92;
/* no need for this if you are resolving */
while (slurm_load_node((time_t) NULL,
&new_node_ptr, SHOW_ALL)) {
if (params.resolve || (params.display == COMMANDS)) {
new_node_ptr = NULL;
break; /* just continue */
}
error_code = slurm_get_errno();
printf("slurm_load_node: %s\n",
slurm_strerror(error_code));
if (params.iterate == 0)
exit(1);
sleep(10); /* keep trying to reconnect */
}
select_g_ba_init(new_node_ptr, 0);
if (dim_size == NULL) {
dim_size = get_cluster_dims(new_node_ptr);
if ((dim_size == NULL) || (dim_size[0] < 1))
fatal("Invalid system dimensions");
}
_init_colors();
if (params.resolve) {
char *ret_str = resolve_mp(params.resolve, new_node_ptr);
if (ret_str) {
printf("%s", ret_str);
xfree(ret_str);
}
_smap_exit(0); /* Calls exit(), no return */
}
if (!params.commandline) {
int check_width = min_screen_width;
initscr();
init_grid(new_node_ptr, COLS);
signal(SIGWINCH, (void (*)(int))_resize_handler);
if (params.cluster_dims == 4) {
height = dim_size[2] * dim_size[3] + dim_size[2] + 3;
width = (dim_size[1] + dim_size[3] + 1) * dim_size[0]
+ 2;
check_width += width;
} else if (params.cluster_dims == 3) {
height = dim_size[1] * dim_size[2] + dim_size[1] + 3;
width = dim_size[0] + dim_size[2] + 3;
check_width += width;
} else {
height = 10;
width = COLS;
}
if ((COLS < check_width) || (LINES < height)) {
endwin();
error("Screen is too small make sure the screen "
"is at least %dx%d\n"
"Right now it is %dx%d\n",
check_width,
height,
COLS,
LINES);
_smap_exit(1); /* Calls exit(), no return */
}
raw();
keypad(stdscr, true);
noecho();
cbreak();
curs_set(0);
nodelay(stdscr, true);
start_color();
_set_pairs();
grid_win = newwin(height, width, starty, startx);
max_display = (getmaxy(grid_win) - 1) * (getmaxx(grid_win) - 1);
if (params.cluster_dims == 4) {
startx = width;
width = COLS - width - 2;
height = LINES;
} else if (params.cluster_dims == 3) {
startx = width;
width = COLS - width - 2;
height = LINES;
} else {
startx = 0;
starty = height;
height = LINES - height;
}
text_win = newwin(height, width, starty, startx);
}
while (!end) {
if (!params.commandline) {
_get_option();
redraw:
clear_window(text_win);
clear_window(grid_win);
move(0, 0);
update_grid(new_node_ptr);
main_xcord = 1;
main_ycord = 1;
}
if (!params.no_header)
print_date();
clear_grid();
switch (params.display) {
case JOBS:
get_job();
break;
case RESERVATIONS:
get_reservation();
break;
case SLURMPART:
get_slurm_part();
break;
case COMMANDS:
#ifdef HAVE_BG
wclear(text_win);
get_command();
#else
error("Must be on a real BG SYSTEM to "
"run this command");
if (!params.commandline)
endwin();
_smap_exit(1); /* Calls exit(), no return */
#endif
break;
case BGPART:
if (params.cluster_flags & CLUSTER_FLAG_BG)
get_bg_part();
else {
error("Must be on a BG SYSTEM to "
"run this command");
if (!params.commandline)
endwin();
_smap_exit(1); /* Calls exit(), no return */
}
break;
}
if (!params.commandline) {
box(text_win, 0, 0);
wnoutrefresh(text_win);
print_grid();
box(grid_win, 0, 0);
wnoutrefresh(grid_win);
doupdate();
node_info_ptr = new_node_ptr;
if (node_info_ptr) {
error_code = slurm_load_node(
node_info_ptr->last_update,
&new_node_ptr, SHOW_ALL);
if (error_code == SLURM_SUCCESS)
slurm_free_node_info_msg(
node_info_ptr);
else if (slurm_get_errno()
== SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_node_ptr = node_info_ptr;
}
} else {
error_code = slurm_load_node(
(time_t) NULL,
&new_node_ptr, SHOW_ALL);
}
if (error_code && (quiet_flag != 1)) {
if (!params.commandline) {
mvwprintw(
text_win,
main_ycord,
1,
"slurm_load_node: %s",
slurm_strerror(
slurm_get_errno()));
main_ycord++;
} else {
printf("slurm_load_node: %s",
slurm_strerror(
slurm_get_errno()));
}
}
}
if (params.iterate) {
for (i = 0; i < params.iterate; i++) {
sleep(1);
if (!params.commandline) {
if ((rc = _get_option()) == 1)
goto redraw;
else if (resize_screen) {
resize_screen = 0;
goto redraw;
}
}
}
} else
break;
}
if (!params.commandline) {
nodelay(stdscr, false);
getch();
endwin();
}
_smap_exit(0); /* Calls exit(), no return */
exit(0); /* Redundant, but eliminates compiler warning */
}
/*
* _query_server - download the current server state
* part_pptr IN/OUT - partition information message
* node_pptr IN/OUT - node information message
* block_pptr IN/OUT - BlueGene block data
* reserv_pptr IN/OUT - reservation information message
* clear_old IN - If set, then always replace old data, needed when going
* between clusters.
* RET zero or error code
*/
static int
_query_server(partition_info_msg_t ** part_pptr,
node_info_msg_t ** node_pptr,
block_info_msg_t ** block_pptr,
reserve_info_msg_t ** reserv_pptr,
bool clear_old)
{
static partition_info_msg_t *old_part_ptr = NULL, *new_part_ptr;
static node_info_msg_t *old_node_ptr = NULL, *new_node_ptr;
static block_info_msg_t *old_bg_ptr = NULL, *new_bg_ptr;
static reserve_info_msg_t *old_resv_ptr = NULL, *new_resv_ptr;
int error_code;
uint16_t show_flags = 0;
int cc;
node_info_t *node_ptr;
if (params.all_flag)
show_flags |= SHOW_ALL;
if (old_part_ptr) {
if (clear_old)
old_part_ptr->last_update = 0;
error_code = slurm_load_partitions(old_part_ptr->last_update,
&new_part_ptr, show_flags);
if (error_code == SLURM_SUCCESS)
slurm_free_partition_info_msg(old_part_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_part_ptr = old_part_ptr;
}
} else {
error_code = slurm_load_partitions((time_t) NULL, &new_part_ptr,
show_flags);
}
if (error_code) {
slurm_perror("slurm_load_partitions");
return error_code;
}
old_part_ptr = new_part_ptr;
*part_pptr = new_part_ptr;
if (old_node_ptr) {
if (clear_old)
old_node_ptr->last_update = 0;
if (params.node_name_single) {
error_code = slurm_load_node_single(&new_node_ptr,
params.nodes,
show_flags);
} else {
error_code = slurm_load_node(old_node_ptr->last_update,
&new_node_ptr, show_flags);
}
if (error_code == SLURM_SUCCESS)
slurm_free_node_info_msg(old_node_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_node_ptr = old_node_ptr;
}
} else if (params.node_name_single) {
error_code = slurm_load_node_single(&new_node_ptr, params.nodes,
show_flags);
} else {
error_code = slurm_load_node((time_t) NULL, &new_node_ptr,
show_flags);
}
if (error_code) {
slurm_perror("slurm_load_node");
return error_code;
}
old_node_ptr = new_node_ptr;
*node_pptr = new_node_ptr;
/* Set the node state as NODE_STATE_MIXED. */
for (cc = 0; cc < new_node_ptr->record_count; cc++) {
node_ptr = &(new_node_ptr->node_array[cc]);
if (IS_NODE_DRAIN(node_ptr)) {
/* don't worry about mixed since the
* whole node is being drained. */
} else {
uint16_t alloc_cpus = 0, err_cpus = 0, idle_cpus;
int single_node_cpus =
(node_ptr->cpus / g_node_scaling);
select_g_select_nodeinfo_get(node_ptr->select_nodeinfo,
SELECT_NODEDATA_SUBCNT,
NODE_STATE_ALLOCATED,
&alloc_cpus);
if (params.cluster_flags & CLUSTER_FLAG_BG) {
if (!alloc_cpus &&
(IS_NODE_ALLOCATED(node_ptr) ||
IS_NODE_COMPLETING(node_ptr)))
alloc_cpus = node_ptr->cpus;
else
alloc_cpus *= single_node_cpus;
}
idle_cpus = node_ptr->cpus - alloc_cpus;
select_g_select_nodeinfo_get(node_ptr->select_nodeinfo,
SELECT_NODEDATA_SUBCNT,
NODE_STATE_ERROR,
&err_cpus);
if (params.cluster_flags & CLUSTER_FLAG_BG)
err_cpus *= single_node_cpus;
idle_cpus -= err_cpus;
if ((alloc_cpus && err_cpus) ||
(idle_cpus && (idle_cpus != node_ptr->cpus))) {
node_ptr->node_state &= NODE_STATE_FLAGS;
node_ptr->node_state |= NODE_STATE_MIXED;
}
}
}
if (old_resv_ptr) {
if (clear_old)
old_resv_ptr->last_update = 0;
error_code = slurm_load_reservations(old_resv_ptr->last_update,
&new_resv_ptr);
if (error_code == SLURM_SUCCESS)
slurm_free_reservation_info_msg(old_resv_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_resv_ptr = old_resv_ptr;
}
} else {
error_code = slurm_load_reservations((time_t) NULL,
&new_resv_ptr);
}
if (error_code) {
slurm_perror("slurm_load_reservations");
return error_code;
}
old_resv_ptr = new_resv_ptr;
*reserv_pptr = new_resv_ptr;
if (!params.bg_flag)
return SLURM_SUCCESS;
if (params.cluster_flags & CLUSTER_FLAG_BG) {
if (old_bg_ptr) {
if (clear_old)
old_bg_ptr->last_update = 0;
error_code = slurm_load_block_info(
old_bg_ptr->last_update,
&new_bg_ptr, show_flags);
if (error_code == SLURM_SUCCESS)
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_block_info((time_t) NULL,
&new_bg_ptr,
show_flags);
}
}
if (error_code) {
slurm_perror("slurm_load_block");
return error_code;
}
old_bg_ptr = new_bg_ptr;
*block_pptr = new_bg_ptr;
return SLURM_SUCCESS;
}
/* This set of functions loads/free node information so that we can map a job's
* core bitmap to it's CPU IDs based upon the thread count on each node. */
static void _load_node_info(void)
{
if (!job_node_ptr)
(void) slurm_load_node((time_t) NULL, &job_node_ptr, 0);
}
/*
* _query_server - download the current server state
* part_pptr IN/OUT - partition information message
* node_pptr IN/OUT - node information message
* block_pptr IN/OUT - BlueGene block data
* reserv_pptr IN/OUT - reservation information message
* clear_old IN - If set, then always replace old data, needed when going
* between clusters.
* RET zero or error code
*/
static int
_query_server(partition_info_msg_t ** part_pptr,
node_info_msg_t ** node_pptr,
block_info_msg_t ** block_pptr,
reserve_info_msg_t ** reserv_pptr,
bool clear_old)
{
static partition_info_msg_t *old_part_ptr = NULL, *new_part_ptr;
static node_info_msg_t *old_node_ptr = NULL, *new_node_ptr;
static block_info_msg_t *old_bg_ptr = NULL, *new_bg_ptr;
static reserve_info_msg_t *old_resv_ptr = NULL, *new_resv_ptr;
int error_code;
uint16_t show_flags = 0;
if (params.all_flag)
show_flags |= SHOW_ALL;
if (old_part_ptr) {
if (clear_old)
old_part_ptr->last_update = 0;
error_code = slurm_load_partitions(old_part_ptr->last_update,
&new_part_ptr, show_flags);
if (error_code == SLURM_SUCCESS)
slurm_free_partition_info_msg(old_part_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_part_ptr = old_part_ptr;
}
} else {
error_code = slurm_load_partitions((time_t) NULL, &new_part_ptr,
show_flags);
}
if (error_code) {
slurm_perror("slurm_load_partitions");
return error_code;
}
old_part_ptr = new_part_ptr;
*part_pptr = new_part_ptr;
if (old_node_ptr) {
if (clear_old)
old_node_ptr->last_update = 0;
if (params.node_name_single) {
error_code = slurm_load_node_single(&new_node_ptr,
params.nodes,
show_flags);
} else {
error_code = slurm_load_node(old_node_ptr->last_update,
&new_node_ptr, show_flags);
}
if (error_code == SLURM_SUCCESS)
slurm_free_node_info_msg(old_node_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_node_ptr = old_node_ptr;
}
} else if (params.node_name_single) {
error_code = slurm_load_node_single(&new_node_ptr, params.nodes,
show_flags);
} else {
error_code = slurm_load_node((time_t) NULL, &new_node_ptr,
show_flags);
}
if (error_code) {
slurm_perror("slurm_load_node");
return error_code;
}
old_node_ptr = new_node_ptr;
*node_pptr = new_node_ptr;
if (old_resv_ptr) {
if (clear_old)
old_resv_ptr->last_update = 0;
error_code = slurm_load_reservations(old_resv_ptr->last_update,
&new_resv_ptr);
if (error_code == SLURM_SUCCESS)
slurm_free_reservation_info_msg(old_resv_ptr);
else if (slurm_get_errno() == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_resv_ptr = old_resv_ptr;
}
} else {
error_code = slurm_load_reservations((time_t) NULL,
&new_resv_ptr);
}
if (error_code) {
slurm_perror("slurm_load_reservations");
return error_code;
}
old_resv_ptr = new_resv_ptr;
*reserv_pptr = new_resv_ptr;
if (!params.bg_flag)
return SLURM_SUCCESS;
if (params.cluster_flags & CLUSTER_FLAG_BG) {
if (old_bg_ptr) {
if (clear_old)
old_bg_ptr->last_update = 0;
error_code = slurm_load_block_info(
old_bg_ptr->last_update,
&new_bg_ptr, show_flags);
if (error_code == SLURM_SUCCESS)
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_block_info((time_t) NULL,
&new_bg_ptr,
show_flags);
}
}
if (error_code) {
slurm_perror("slurm_load_block");
return error_code;
}
old_bg_ptr = new_bg_ptr;
*block_pptr = new_bg_ptr;
return SLURM_SUCCESS;
}
int
get_batch_queues(bridge_batch_manager_t* p_batch_manager,
bridge_batch_queue_t** p_p_batch_queues,
int* p_batch_queues_nb, char* batch_queue_name)
{
int fstatus=-1;
int i,j;
int queue_nb=0;
int stored_queue_nb=0;
bridge_batch_queue_t* bn;
partition_info_msg_t* ppim;
partition_info_t* ppi;
job_info_msg_t* pjim;
job_info_t* pji;
node_info_msg_t* pnim;
node_info_t* pni;
/* get slurm partition infos */
if (slurm_load_partitions(0,&ppim,SHOW_ALL) != 0) {
DEBUG3_LOGGER("unable to get slurm partitions infos");
ppim=NULL;
goto exit;
}
/* get nodes status */
if(slurm_load_node(0,&pnim,SHOW_ALL)) {
DEBUG3_LOGGER("unable to get nodes informations");
slurm_free_partition_info_msg(ppim);
pnim=NULL;
goto exit;
}
/* get slurm job infos */
if (slurm_load_jobs(0,&pjim,SHOW_ALL) != 0) {
DEBUG3_LOGGER("unable to get allocations informations");
slurm_free_partition_info_msg(ppim);
slurm_free_node_info_msg(pnim);
goto exit;
}
/* build/initialize storage structures */
queue_nb = ppim->record_count;
if (*p_p_batch_queues != NULL) {
if (*p_batch_queues_nb < queue_nb)
queue_nb=*p_batch_queues_nb;
}
else {
*p_p_batch_queues = (bridge_batch_queue_t*)
malloc(queue_nb*(sizeof(bridge_batch_queue_t)+1));
if (*p_p_batch_queues == NULL) {
*p_batch_queues_nb = 0;
queue_nb = *p_batch_queues_nb;
}
else {
*p_batch_queues_nb = queue_nb;
}
}
stored_queue_nb=0;
/* fill queue structures */
for (i=0; i<ppim->record_count && stored_queue_nb<queue_nb; i++) {
/* get partition pointer */
ppi=ppim->partition_array+i;
if (ppi->name == NULL)
continue;
/* queue name filter */
if (batch_queue_name != NULL &&
strcmp(batch_queue_name,ppi->name) != 0)
continue;
bn = &(*p_p_batch_queues)[stored_queue_nb];
/* put default values */
init_batch_queue(p_batch_manager,bn);
/* queue Name */
bn->name=strdup(ppi->name);
bn->default_queue = (uint32_t) ( ppi->flags | PART_FLAG_DEFAULT);
bn->priority = (uint32_t) ppi->priority;
/* queue activity */
if(ppi->state_up == PARTITION_UP) {
bn->activity = BRIDGE_BATCH_QUEUE_ACTIVITY_ACTIVE ;
bn->state = BRIDGE_BATCH_QUEUE_STATE_OPENED ;
} else if (ppi->state_up == PARTITION_DRAIN) {
bn->activity = BRIDGE_BATCH_QUEUE_ACTIVITY_ACTIVE ;
bn->state = BRIDGE_BATCH_QUEUE_STATE_CLOSED ;
} else if (ppi->state_up == PARTITION_DOWN) {
bn->activity = BRIDGE_BATCH_QUEUE_ACTIVITY_INACTIVE ;
bn->state = BRIDGE_BATCH_QUEUE_STATE_OPENED ;
} else if (ppi->state_up == PARTITION_INACTIVE) {
bn->activity = BRIDGE_BATCH_QUEUE_ACTIVITY_INACTIVE ;
bn->state = BRIDGE_BATCH_QUEUE_STATE_CLOSED ;
} else {
bn->activity = BRIDGE_BATCH_QUEUE_ACTIVITY_UNKNOWN ;
bn->state = BRIDGE_BATCH_QUEUE_STATE_UNKNOWN ;
}
/* max times */
if ( ppi->max_time != INFINITE )
bn->seq_time_max = (uint32_t) ppi->max_time * 60 ;
else
bn->seq_time_max = NO_LIMIT;
bn->par_time_max = bn->seq_time_max ;
/* slurm */
for ( j=0 ; j < pjim->record_count ; j++ ) {
pji=pjim->job_array+j;
if ( strcmp(pji->partition,ppi->name) != 0 )
continue;
switch ( pji->job_state & JOB_STATE_BASE ) {
case JOB_PENDING :
bn->jobs_nb++;
bn->pending_jobs_nb++;
break;
case JOB_RUNNING :
bn->jobs_nb++;
bn->running_jobs_nb++;
break;
case JOB_SUSPENDED :
bn->jobs_nb++;
bn->syssuspended_jobs_nb++;
break;
}
}
/* Slurm does not provide information about Min and Max cpus per
* partition. So we use the following method :
*
* if partition->name ~= /.*_seq/ min=max=1
* otherwise, calculate it using MinNodes, MaxNodes and nodes
* informations
*/
int done = 0 ;
char * p;
p = rindex(ppi->name,'_');
if ( p != NULL ) {
if ( strcmp(p+1,"seq") == 0 ) {
done = 1;
bn->par_cores_nb_min = 1;
bn->par_cores_nb_max = 1;
}
}
if ( ! done ) {
/* use partition nodes information to build the min and max */
/* number of cores (only min and max nodes number are provided */
/* by slurm so we have to build this information) */
uint32_t max_cpus_per_node=0;
uint32_t min_cpus_per_node=-1;
bridge_nodelist_t list1,list2;
bridge_nodelist_init(&list1,NULL,0);
bridge_nodelist_add_nodes(&list1,ppi->nodes);
for ( j=0 ; j < pnim->record_count ; j++ ) {
pni=pnim->node_array+j;
bridge_nodelist_init(&list2,NULL,0);
bridge_nodelist_add_nodes(&list2,pni->name);
if(bridge_nodelist_intersects(&list1,&list2)==0) {
bridge_nodelist_free_contents(&list2);
continue;
}
if ( pni->cpus > max_cpus_per_node )
max_cpus_per_node = pni->cpus ;
if ( pni->cpus < min_cpus_per_node )
min_cpus_per_node = pni->cpus ;
bridge_nodelist_free_contents(&list2);
}
bridge_nodelist_free_contents(&list1);
if ( max_cpus_per_node > 0 && ppi->max_nodes != INFINITE )
bn->par_cores_nb_max = max_cpus_per_node * ppi->max_nodes ;
if ( min_cpus_per_node < (uint32_t) -1 && ppi->min_nodes > 1 )
bn->par_cores_nb_min = min_cpus_per_node * ppi->min_nodes ;
}
stored_queue_nb++;
}
fstatus=0;
/* free slurm informations */
slurm_free_job_info_msg(pjim);
slurm_free_node_info_msg(pnim);
slurm_free_partition_info_msg(ppim);
if(stored_queue_nb<queue_nb) {
*p_p_batch_queues=(bridge_batch_queue_t*)
realloc(*p_p_batch_queues,
stored_queue_nb*(sizeof(bridge_batch_queue_t)+1));
if(*p_p_batch_queues==NULL)
*p_batch_queues_nb=0;
else
*p_batch_queues_nb=stored_queue_nb;
}
exit:
return fstatus;
}
int main(int argc, char *argv[])
{
log_options_t opts = LOG_OPTS_STDERR_ONLY;
node_info_msg_t *node_info_ptr = NULL;
node_info_msg_t *new_node_ptr = NULL;
int error_code;
int height = 40;
int width = 100;
int startx = 0;
int starty = 0;
int end = 0;
int i;
int rc;
int mapset = 0;
log_init(xbasename(argv[0]), opts, SYSLOG_FACILITY_DAEMON, NULL);
parse_command_line(argc, argv);
if (params.verbose) {
opts.stderr_level += params.verbose;
log_alter(opts, SYSLOG_FACILITY_USER, NULL);
}
if (params.cluster_dims == 4) {
min_screen_width = 92;
} else if (params.cluster_dims == 3)
min_screen_width = 92;
while (slurm_load_node((time_t) NULL, &new_node_ptr, SHOW_ALL)) {
error_code = slurm_get_errno();
printf("slurm_load_node: %s\n", slurm_strerror(error_code));
if (params.display == COMMANDS) {
new_node_ptr = NULL;
break; /* just continue */
}
if (params.iterate == 0)
_smap_exit(1); /* Calls exit(), no return */
sleep(10); /* keep trying to reconnect */
}
_init_colors();
select_g_ba_init(new_node_ptr, 0);
init_grid(new_node_ptr);
if (params.resolve) {
#if defined HAVE_BG_FILES && defined HAVE_BG_L_P
#if 1
error("this doesn't work in the current 2.3 code. FIXME");
#else
if (!have_db2) {
printf("Required libraries can not be found "
"to access the Bluegene system.\nPlease "
"set your LD_LIBRARY_PATH correctly to "
"point to them.\n");
goto part_fini;
}
if (!mapset)
mapset = 1;
if (params.resolve[0] != 'R') {
i = strlen(params.resolve);
i -= 3;
if (i < 0) {
printf("No real block was entered\n");
goto part_fini;
}
char *rack_mid = find_bp_rack_mid(params.resolve+i);
if (rack_mid) {
printf("X=%c Y=%c Z=%c resolves to %s\n",
params.resolve[0+i],
params.resolve[1+i],
params.resolve[2+i],
rack_mid);
} else {
printf("X=%c Y=%c Z=%c has no resolve\n",
params.resolve[0+i],
params.resolve[1+i],
params.resolve[2+i]);
}
} else {
uint16_t *coord = find_bp_loc(params.resolve);
if (coord) {
printf("%s resolves to X=%d Y=%d Z=%d\n",
params.resolve,
coord[0], coord[1], coord[2]);
} else {
printf("%s has no resolve.\n",
params.resolve);
}
}
part_fini:
#endif
#else
printf("Must be physically on a BlueGene system for support "
"of resolve option.\n");
#endif
_smap_exit(0); /* Calls exit(), no return */
}
if (!params.commandline) {
int check_width = min_screen_width;
signal(SIGWINCH, (void (*)(int))_resize_handler);
initscr();
if (params.cluster_dims == 4) {
height = dim_size[2] * dim_size[3] + dim_size[2] + 3;
width = (dim_size[1] + dim_size[3] + 1) * dim_size[0]
+ 2;
check_width += width;
} else if (params.cluster_dims == 3) {
height = dim_size[1] * dim_size[2] + dim_size[1] + 3;
width = dim_size[0] + dim_size[2] + 3;
check_width += width;
} else {
height = 10;
width = COLS;
}
if ((COLS < check_width) || (LINES < height)) {
endwin();
error("Screen is too small make sure the screen "
"is at least %dx%d\n"
"Right now it is %dx%d\n",
check_width,
height,
COLS,
LINES);
_smap_exit(1); /* Calls exit(), no return */
}
raw();
keypad(stdscr, TRUE);
noecho();
cbreak();
curs_set(0);
nodelay(stdscr, TRUE);
start_color();
_set_pairs();
grid_win = newwin(height, width, starty, startx);
max_display = grid_win->_maxy * grid_win->_maxx;
if (params.cluster_dims == 4) {
startx = width;
COLS -= 2;
width = COLS - width;
height = LINES;
} else if (params.cluster_dims == 3) {
startx = width;
COLS -= 2;
width = COLS - width;
height = LINES;
} else {
startx = 0;
starty = height;
height = LINES - height;
}
text_win = newwin(height, width, starty, startx);
}
while (!end) {
if (!params.commandline) {
_get_option();
redraw:
clear_window(text_win);
clear_window(grid_win);
move(0, 0);
main_xcord = 1;
main_ycord = 1;
}
if (!params.no_header)
print_date();
clear_grid();
switch (params.display) {
case JOBS:
get_job();
break;
case RESERVATIONS:
get_reservation();
break;
case SLURMPART:
get_slurm_part();
break;
case COMMANDS:
if (params.cluster_flags & CLUSTER_FLAG_BG) {
if (!mapset) {
mapset = 1;
wclear(text_win);
}
get_command();
} else {
error("Must be on a BG SYSTEM to "
"run this command");
if (!params.commandline)
endwin();
_smap_exit(1); /* Calls exit(), no return */
}
break;
case BGPART:
if (params.cluster_flags & CLUSTER_FLAG_BG)
get_bg_part();
else {
error("Must be on a BG SYSTEM to "
"run this command");
if (!params.commandline)
endwin();
_smap_exit(1); /* Calls exit(), no return */
}
break;
}
if (!params.commandline) {
box(text_win, 0, 0);
wnoutrefresh(text_win);
print_grid();
box(grid_win, 0, 0);
wnoutrefresh(grid_win);
doupdate();
node_info_ptr = new_node_ptr;
if (node_info_ptr) {
error_code = slurm_load_node(
node_info_ptr->last_update,
&new_node_ptr, SHOW_ALL);
if (error_code == SLURM_SUCCESS)
slurm_free_node_info_msg(
node_info_ptr);
else if (slurm_get_errno()
== SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_SUCCESS;
new_node_ptr = node_info_ptr;
}
} else {
error_code = slurm_load_node(
(time_t) NULL,
&new_node_ptr, SHOW_ALL);
}
if (error_code && (quiet_flag != 1)) {
if (!params.commandline) {
mvwprintw(
text_win,
main_ycord,
1,
"slurm_load_node: %s",
slurm_strerror(
slurm_get_errno()));
main_ycord++;
} else {
printf("slurm_load_node: %s",
slurm_strerror(
slurm_get_errno()));
}
}
}
if (params.iterate) {
for (i = 0; i < params.iterate; i++) {
sleep(1);
if (!params.commandline) {
if ((rc = _get_option()) == 1)
goto redraw;
else if (resize_screen) {
resize_screen = 0;
goto redraw;
}
}
}
} else
break;
}
if (!params.commandline) {
nodelay(stdscr, FALSE);
getch();
endwin();
}
_smap_exit(0); /* Calls exit(), no return */
exit(0); /* Redundant, but eliminates compiler warning */
}
