/** * print a block request */ extern void print_select_ba_request(select_ba_request_t* ba_request) { int dim; uint32_t cluster_flags = slurmdb_setup_cluster_flags(); uint16_t cluster_dims = slurmdb_setup_cluster_dims(); if (ba_request == NULL){ error("print_ba_request Error, request is NULL"); return; } debug(" ba_request:"); debug(" geometry:\t"); for (dim=0; dim<cluster_dims; dim++){ debug("%d", ba_request->geometry[dim]); } debug(" size:\t%d", ba_request->size); if (cluster_flags & CLUSTER_FLAG_BGQ) { for (dim=0; dim<cluster_dims; dim++) debug(" conn_type:\t%d", ba_request->conn_type[dim]); } else debug(" conn_type:\t%d", ba_request->conn_type[0]); debug(" rotate:\t%d", ba_request->rotate); debug(" elongate:\t%d", ba_request->elongate); }
extern uint16_t slurmdb_setup_cluster_name_dims(void) { if (is_cray_system()) return 1; /* Cray uses 1-dimensional hostlists */ return slurmdb_setup_cluster_dims(); }
/* * verify geometry arguments, must have proper count * returns -1 on error, 0 otherwise */ int verify_geometry(const char *arg, uint16_t *geometry) { char* token, *delimiter = ",x", *next_ptr; int i, rc = 0; char* geometry_tmp = xstrdup(arg); char* original_ptr = geometry_tmp; int dims = slurmdb_setup_cluster_dims(); token = strtok_r(geometry_tmp, delimiter, &next_ptr); for (i=0; i<dims; i++) { if (token == NULL) { error("insufficient dimensions in --geometry"); rc = -1; break; } geometry[i] = (uint16_t)atoi(token); if (geometry[i] == 0 || geometry[i] == (uint16_t)NO_VAL) { error("invalid --geometry argument"); rc = -1; break; } geometry_tmp = next_ptr; token = strtok_r(geometry_tmp, delimiter, &next_ptr); } if (token != NULL) { error("too many dimensions in --geometry"); rc = -1; } if (original_ptr) xfree(original_ptr); return rc; }
extern void select_p_ba_init(node_info_msg_t *node_info_ptr, bool sanity_check) { int i, j, offset; int dims = slurmdb_setup_cluster_dims(); if (select_cray_dim_size[0] == -1) { node_info_t *node_ptr; /* init the rest of the dim sizes. All current (2011) * XT/XE installations have a maximum dimension of 3, * smaller systems deploy a 2D Torus which has no * connectivity in X-dimension. Just incase they * decide to change it where we only get 2 instead of * 3 we will initialize it later. */ for (i = 1; i < dims; i++) select_cray_dim_size[i] = -1; for (i = 0; i < node_info_ptr->record_count; i++) { node_ptr = &(node_info_ptr->node_array[i]); if (!node_ptr->node_addr || (strlen(node_ptr->node_addr) != dims)) continue; for (j = 0; j < dims; j++) { offset = select_char2coord( node_ptr->node_addr[j]); select_cray_dim_size[j] = MAX((offset+1), select_cray_dim_size[j]); } } } /* * Override the generic setup of dim_size made in _setup_cluster_rec() * FIXME: use a better way, e.g. encoding the 3-dim triplet as a * string which gets stored in a database (event_table?) entry. */ if (working_cluster_rec) { xfree(working_cluster_rec->dim_size); working_cluster_rec->dim_size = xmalloc(sizeof(int) * dims); for (j = 0; j < dims; j++) working_cluster_rec->dim_size[j] = select_cray_dim_size[j]; } other_ba_init(node_info_ptr, sanity_check); }
char *print_geometry(const uint16_t *geometry) { int i; char buf[32], *rc = NULL; int dims = slurmdb_setup_cluster_dims(); if ((dims == 0) || !geometry[0] || (geometry[0] == (uint16_t)NO_VAL)) return NULL; for (i=0; i<dims; i++) { if (i > 0) snprintf(buf, sizeof(buf), "x%u", geometry[i]); else snprintf(buf, sizeof(buf), "%u", geometry[i]); xstrcat(rc, buf); } return rc; }
/* * scontrol_update_job - update the slurm job configuration per the supplied * arguments * IN argc - count of arguments * IN argv - list of arguments * RET 0 if no slurm error, errno otherwise. parsing error prints * error message and returns 0 */ extern int scontrol_update_job (int argc, char *argv[]) { bool update_size = false; int i, update_cnt = 0; char *tag, *val; int taglen, vallen; job_desc_msg_t job_msg; slurm_init_job_desc_msg (&job_msg); /* set current user, needed e.g., for AllowGroups checks */ job_msg.user_id = getuid(); for (i=0; i<argc; i++) { tag = argv[i]; val = strchr(argv[i], '='); if (val) { taglen = val - argv[i]; val++; vallen = strlen(val); } else if (strncasecmp(tag, "Nice", MAX(strlen(tag), 2)) == 0){ /* "Nice" is the only tag that might not have an equal sign, so it is handled specially. */ job_msg.nice = NICE_OFFSET + 100; update_cnt++; continue; } else { exit_code = 1; fprintf (stderr, "Invalid input: %s\n", argv[i]); fprintf (stderr, "Request aborted\n"); return -1; } if (strncasecmp(tag, "JobId", MAX(taglen, 3)) == 0) { job_msg.job_id = (uint32_t) strtol(val, (char **) NULL, 10); } else if (strncasecmp(tag, "Comment", MAX(taglen, 3)) == 0) { job_msg.comment = val; update_cnt++; } else if (strncasecmp(tag, "TimeLimit", MAX(taglen, 5)) == 0) { bool incr, decr; uint32_t job_current_time, time_limit; incr = (val[0] == '+'); decr = (val[0] == '-'); if (incr || decr) val++; time_limit = time_str2mins(val); if ((time_limit < 0) && (time_limit != INFINITE)) { error("Invalid TimeLimit value"); exit_code = 1; return 0; } if (incr || decr) { job_current_time = _get_job_time(job_msg. job_id); if (job_current_time == NO_VAL) { exit_code = 1; return 0; } if (incr) { time_limit += job_current_time; } else if (time_limit > job_current_time) { error("TimeLimit decrement larger than" " current time limit (%u > %u)", time_limit, job_current_time); exit_code = 1; return 0; } else { time_limit = job_current_time - time_limit; } } job_msg.time_limit = time_limit; update_cnt++; } else if (strncasecmp(tag, "TimeMin", MAX(taglen, 5)) == 0) { int time_min = time_str2mins(val); if ((time_min < 0) && (time_min != INFINITE)) { error("Invalid TimeMin value"); exit_code = 1; return 0; } job_msg.time_min = time_min; update_cnt++; } else if (strncasecmp(tag, "Priority", MAX(taglen, 2)) == 0) { job_msg.priority = (uint32_t) strtoll(val, (char **) NULL, 10); update_cnt++; } else if (strncasecmp(tag, "Nice", MAX(taglen, 2)) == 0) { int nice; nice = strtoll(val, (char **) NULL, 10); if (abs(nice) > NICE_OFFSET) { error("Invalid nice value, must be between " "-%d and %d", NICE_OFFSET, NICE_OFFSET); exit_code = 1; return 0; } job_msg.nice = NICE_OFFSET + nice; update_cnt++; } else if (strncasecmp(tag, "NumCPUs", MAX(taglen, 6)) == 0) { int min_cpus, max_cpus=0; if (!get_resource_arg_range(val, "NumCPUs", &min_cpus, &max_cpus, false) || (min_cpus <= 0) || (max_cpus && (max_cpus < min_cpus))) { error("Invalid NumCPUs value: %s", val); exit_code = 1; return 0; } job_msg.min_cpus = min_cpus; if (max_cpus) job_msg.max_cpus = max_cpus; update_cnt++; } /* ReqProcs was removed in SLURM version 2.1 */ else if (strncasecmp(tag, "ReqProcs", MAX(taglen, 8)) == 0) { job_msg.num_tasks = (uint32_t) strtol(val, (char **) NULL, 10); update_cnt++; } else if (strncasecmp(tag, "Requeue", MAX(taglen, 4)) == 0) { job_msg.requeue = (uint16_t) strtol(val, (char **) NULL, 10); update_cnt++; } /* ReqNodes was replaced by NumNodes in SLURM version 2.1 */ else if ((strncasecmp(tag, "ReqNodes", MAX(taglen, 8)) == 0) || (strncasecmp(tag, "NumNodes", MAX(taglen, 8)) == 0)) { int min_nodes, max_nodes, rc; if (strcmp(val, "0") == 0) { job_msg.min_nodes = 0; } else if (strcasecmp(val, "ALL") == 0) { job_msg.min_nodes = INFINITE; } else { min_nodes = (int) job_msg.min_nodes; max_nodes = (int) job_msg.max_nodes; rc = get_resource_arg_range( val, "requested node count", &min_nodes, &max_nodes, false); if (!rc) return rc; job_msg.min_nodes = (uint32_t) min_nodes; job_msg.max_nodes = (uint32_t) max_nodes; } update_size = true; update_cnt++; } else if (strncasecmp(tag, "ReqSockets", MAX(taglen, 4)) == 0) { job_msg.sockets_per_node = (uint16_t) strtol(val, (char **) NULL, 10); update_cnt++; } else if (strncasecmp(tag, "ReqCores", MAX(taglen, 4)) == 0) { job_msg.cores_per_socket = (uint16_t) strtol(val, (char **) NULL, 10); update_cnt++; } else if (strncasecmp(tag, "TasksPerNode", MAX(taglen, 2))==0) { job_msg.ntasks_per_node = (uint16_t) strtol(val, (char **) NULL, 10); update_cnt++; } else if (strncasecmp(tag, "ReqThreads", MAX(taglen, 4)) == 0) { job_msg.threads_per_core = (uint16_t) strtol(val, (char **) NULL, 10); update_cnt++; } else if (strncasecmp(tag, "MinCPUsNode", MAX(taglen, 4)) == 0) { job_msg.pn_min_cpus = (uint32_t) strtol(val, (char **) NULL, 10); update_cnt++; } else if (strncasecmp(tag, "MinMemoryNode", MAX(taglen, 10)) == 0) { job_msg.pn_min_memory = (uint32_t) strtol(val, (char **) NULL, 10); update_cnt++; } else if (strncasecmp(tag, "MinMemoryCPU", MAX(taglen, 10)) == 0) { job_msg.pn_min_memory = (uint32_t) strtol(val, (char **) NULL, 10); job_msg.pn_min_memory |= MEM_PER_CPU; update_cnt++; } else if (strncasecmp(tag, "MinTmpDiskNode", MAX(taglen, 5)) == 0) { job_msg.pn_min_tmp_disk = (uint32_t) strtol(val, (char **) NULL, 10); update_cnt++; } else if (strncasecmp(tag, "Partition", MAX(taglen, 2)) == 0) { job_msg.partition = val; update_cnt++; } else if (strncasecmp(tag, "QOS", MAX(taglen, 2)) == 0) { job_msg.qos = val; update_cnt++; } else if (strncasecmp(tag, "ReservationName", MAX(taglen, 3)) == 0) { job_msg.reservation = val; update_cnt++; } else if (strncasecmp(tag, "Name", MAX(taglen, 2)) == 0) { job_msg.name = val; update_cnt++; } else if (strncasecmp(tag, "WCKey", MAX(taglen, 1)) == 0) { job_msg.wckey = val; update_cnt++; } else if (strncasecmp(tag, "Switches", MAX(taglen, 5)) == 0) { char *sep_char; job_msg.req_switch = (uint32_t) strtol(val, &sep_char, 10); update_cnt++; if (sep_char && sep_char[0] == '@') { job_msg.wait4switch = time_str2mins(sep_char+1) * 60; } } else if (strncasecmp(tag, "wait-for-switch", MAX(taglen, 5)) == 0) { job_msg.wait4switch = (uint32_t) strtol(val, (char **) NULL, 10); update_cnt++; } else if (strncasecmp(tag, "Shared", MAX(taglen, 2)) == 0) { if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0) job_msg.shared = 1; else if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0) job_msg.shared = 0; else job_msg.shared = (uint16_t) strtol(val, (char **) NULL, 10); update_cnt++; } else if (strncasecmp(tag, "Contiguous", MAX(taglen, 3)) == 0) { if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0) job_msg.contiguous = 1; else if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0) job_msg.contiguous = 0; else job_msg.contiguous = (uint16_t) strtol(val, (char **) NULL, 10); update_cnt++; } else if (strncasecmp(tag, "ExcNodeList", MAX(taglen, 3)) == 0){ job_msg.exc_nodes = val; update_cnt++; } else if (!strncasecmp(tag, "NodeList", MAX(taglen, 8)) || !strncasecmp(tag, "ReqNodeList", MAX(taglen, 8))) { job_msg.req_nodes = val; update_size = true; update_cnt++; } else if (strncasecmp(tag, "Features", MAX(taglen, 1)) == 0) { job_msg.features = val; update_cnt++; } else if (strncasecmp(tag, "Gres", MAX(taglen, 2)) == 0) { if (!strcasecmp(val, "help") || !strcasecmp(val, "list")) { print_gres_help(); } else { job_msg.gres = val; update_cnt++; } } else if (strncasecmp(tag, "Account", MAX(taglen, 1)) == 0) { job_msg.account = val; update_cnt++; } else if (strncasecmp(tag, "Dependency", MAX(taglen, 1)) == 0) { job_msg.dependency = val; update_cnt++; } else if (strncasecmp(tag, "Geometry", MAX(taglen, 2)) == 0) { char* token, *delimiter = ",x", *next_ptr; int j, rc = 0; int dims = slurmdb_setup_cluster_dims(); uint16_t geo[dims]; char* geometry_tmp = xstrdup(val); char* original_ptr = geometry_tmp; token = strtok_r(geometry_tmp, delimiter, &next_ptr); for (j=0; j<dims; j++) { if (token == NULL) { error("insufficient dimensions in " "Geometry"); rc = -1; break; } geo[j] = (uint16_t) atoi(token); if (geo[j] <= 0) { error("invalid --geometry argument"); rc = -1; break; } geometry_tmp = next_ptr; token = strtok_r(geometry_tmp, delimiter, &next_ptr); } if (token != NULL) { error("too many dimensions in Geometry"); rc = -1; } if (original_ptr) xfree(original_ptr); if (rc != 0) exit_code = 1; else { for (j=0; j<dims; j++) job_msg.geometry[j] = geo[j]; update_cnt++; } } else if (strncasecmp(tag, "Rotate", MAX(taglen, 2)) == 0) { uint16_t rotate; if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0) rotate = 1; else if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0) rotate = 0; else rotate = (uint16_t) strtol(val, (char **) NULL, 10); job_msg.rotate = rotate; update_cnt++; } else if (strncasecmp(tag, "Conn-Type", MAX(taglen, 2)) == 0) { verify_conn_type(val, job_msg.conn_type); if(job_msg.conn_type[0] != (uint16_t)NO_VAL) update_cnt++; } else if (strncasecmp(tag, "Licenses", MAX(taglen, 1)) == 0) { job_msg.licenses = val; update_cnt++; } else if (!strncasecmp(tag, "EligibleTime", MAX(taglen, 2)) || !strncasecmp(tag, "StartTime", MAX(taglen, 2))) { if ((job_msg.begin_time = parse_time(val, 0))) { if (job_msg.begin_time < time(NULL)) job_msg.begin_time = time(NULL); update_cnt++; } } else if (!strncasecmp(tag, "EndTime", MAX(taglen, 2))) { job_msg.end_time = parse_time(val, 0); update_cnt++; } else { exit_code = 1; fprintf (stderr, "Update of this parameter is not " "supported: %s\n", argv[i]); fprintf (stderr, "Request aborted\n"); return 0; } } if (update_cnt == 0) { exit_code = 1; fprintf (stderr, "No changes specified\n"); return 0; } if (slurm_update_job(&job_msg)) return slurm_get_errno (); if (update_size) _update_job_size(job_msg.job_id); return SLURM_SUCCESS; }
int main(int argc, char **argv) { GtkWidget *menubar = NULL; GtkWidget *table = NULL; GtkWidget *combo = NULL; GtkBin *bin = NULL; GtkViewport *view = NULL; int i=0; log_options_t lopts = LOG_OPTS_STDERR_ONLY; if (!getenv("SLURM_BITSTR_LEN")) setenv("SLURM_BITSTR_LEN", "128", 1); /* More array info */ slurm_conf_init(NULL); log_init(argv[0], lopts, SYSLOG_FACILITY_USER, NULL); load_defaults(); cluster_flags = slurmdb_setup_cluster_flags(); cluster_dims = slurmdb_setup_cluster_dims(); _init_pages(); sview_thread_init(NULL); gdk_threads_init(); gdk_threads_enter(); /* Initialize GTK */ gtk_init (&argc, &argv); sview_mutex_new(&sview_mutex); sview_mutex_new(&grid_mutex); sview_cond_new(&grid_cond); /* make sure the system is up */ grid_window = GTK_WIDGET(create_scrolled_window()); bin = GTK_BIN(>K_SCROLLED_WINDOW(grid_window)->container); view = GTK_VIEWPORT(bin->child); bin = GTK_BIN(&view->bin); main_grid_table = GTK_TABLE(bin->child); gtk_table_set_homogeneous(main_grid_table, true); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(grid_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); /* fill in all static info for pages */ /* Make a window */ main_window = gtk_dialog_new(); g_signal_connect(G_OBJECT(main_window), "delete_event", G_CALLBACK(_delete), NULL); gtk_window_set_title(GTK_WINDOW(main_window), "Sview"); gtk_window_set_default_size(GTK_WINDOW(main_window), working_sview_config.main_width, working_sview_config.main_height); gtk_container_set_border_width( GTK_CONTAINER(GTK_DIALOG(main_window)->vbox), 1); /* Create the main notebook, place the position of the tabs */ main_notebook = gtk_notebook_new(); g_signal_connect(G_OBJECT(main_notebook), "switch_page", G_CALLBACK(_page_switched), NULL); table = gtk_table_new(1, 3, false); gtk_table_set_homogeneous(GTK_TABLE(table), false); gtk_container_set_border_width(GTK_CONTAINER(table), 1); /* Create a menu */ menubar = _get_menubar_menu(main_window, main_notebook); gtk_table_attach_defaults(GTK_TABLE(table), menubar, 0, 1, 0, 1); if ((combo = _create_cluster_combo())) { GtkWidget *label = gtk_label_new("Cluster "); gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1, GTK_FILL, GTK_SHRINK, 0, 0); gtk_table_attach(GTK_TABLE(table), combo, 2, 3, 0, 1, GTK_FILL, GTK_SHRINK, 0, 0); } gtk_notebook_popup_enable(GTK_NOTEBOOK(main_notebook)); gtk_notebook_set_scrollable(GTK_NOTEBOOK(main_notebook), true); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(main_notebook), working_sview_config.tab_pos); main_statusbar = gtk_statusbar_new(); gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(main_statusbar), false); /* Pack it all together */ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox), table, false, false, 0); table = gtk_table_new(1, 2, false); gtk_table_attach(GTK_TABLE(table), grid_window, 0, 1, 0, 1, GTK_SHRINK, GTK_EXPAND | GTK_FILL, 0, 0); gtk_table_attach_defaults(GTK_TABLE(table), main_notebook, 1, 2, 0, 1); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox), table, true, true, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox), main_statusbar, false, false, 0); in_process_cursor = gdk_cursor_new(GDK_WATCH); for(i=0; i<PAGE_CNT; i++) { if (main_display_data[i].id == -1) break; create_page(GTK_NOTEBOOK(main_notebook), &main_display_data[i]); } /* tell signal we are done adding */ popup_list = list_create(destroy_popup_info); signal_params_list = list_create(destroy_signal_params); gtk_widget_show_all(main_window); adding = 0; /* apply default settings */ if (!working_sview_config.show_grid) gtk_widget_hide(grid_window); for(i=0; i<PAGE_CNT; i++) { GtkWidget *visible_tab = NULL; if (main_display_data[i].id == -1) break; visible_tab = gtk_notebook_get_nth_page( GTK_NOTEBOOK(main_notebook), i); if (working_sview_config.page_visible[i] || (i == working_sview_config.default_page) || (i == TAB_PAGE)) gtk_widget_show(visible_tab); else gtk_widget_hide(visible_tab); } /* Set the default page. This has to be done after the * gtk_widget_show_all since it, for some reason always sets * 0 to be the default page and will just overwrite this. */ /* Also if we already are set at the current page we need to start up the page thread, so just call the _page_switched function. If we aren't already there, then set the current page which will inturn call the _page_switched. If the pages is already this the signal doesn't happen so handle it here. */ if (gtk_notebook_get_current_page(GTK_NOTEBOOK(main_notebook)) == working_sview_config.default_page) _page_switched(GTK_NOTEBOOK(main_notebook), NULL, working_sview_config.default_page, NULL); else gtk_notebook_set_current_page(GTK_NOTEBOOK(main_notebook), working_sview_config. default_page); /* Finished! */ gtk_main (); gdk_threads_leave(); return 0; }
extern void _change_cluster_main(GtkComboBox *combo, gpointer extra) { GtkTreeModel *model; display_data_t *display_data; GtkTreeIter iter; slurmdb_cluster_rec_t *cluster_rec = NULL; char *tmp, *ui_description; GError *error = NULL; GtkWidget *node_tab = NULL; int rc; bool got_grid = 0; if (!gtk_combo_box_get_active_iter(combo, &iter)) { g_print("nothing selected\n"); return; } model = gtk_combo_box_get_model(combo); if (!model) { g_print("nothing selected\n"); return; } gtk_tree_model_get(model, &iter, 1, &cluster_rec, -1); if (!cluster_rec) { g_print("no cluster_rec pointer here!"); return; } /* From testing it doesn't appear you can get here without a legitimate change, so there isn't a need to check if we are going back to the same cluster we were just at. */ /* if (working_cluster_rec) { */ /* if (!xstrcmp(cluster_rec->name, working_cluster_rec->name)) */ /* return; */ /* } */ /* free old info under last cluster */ slurm_free_block_info_msg(g_block_info_ptr); g_block_info_ptr = NULL; slurm_free_front_end_info_msg(g_front_end_info_ptr); g_front_end_info_ptr = NULL; slurm_free_burst_buffer_info_msg(g_bb_info_ptr); g_bb_info_ptr = NULL; slurm_free_job_info_msg(g_job_info_ptr); g_job_info_ptr = NULL; slurm_free_node_info_msg(g_node_info_ptr); g_node_info_ptr = NULL; slurm_free_partition_info_msg(g_part_info_ptr); g_part_info_ptr = NULL; slurm_free_reservation_info_msg(g_resv_info_ptr); g_resv_info_ptr = NULL; slurm_free_ctl_conf(g_ctl_info_ptr); g_ctl_info_ptr = NULL; slurm_free_job_step_info_response_msg(g_step_info_ptr); g_step_info_ptr = NULL; slurm_free_topo_info_msg(g_topo_info_msg_ptr); g_topo_info_msg_ptr = NULL; /* set up working_cluster_rec */ if (cluster_dims > 1) { /* reset from a multi-dim cluster */ working_sview_config.grid_x_width = default_sview_config.grid_x_width; working_sview_config.grid_hori = default_sview_config.grid_hori; working_sview_config.grid_vert = default_sview_config.grid_vert; } gtk_table_set_col_spacings(main_grid_table, 0); gtk_table_set_row_spacings(main_grid_table, 0); if (!orig_cluster_name) orig_cluster_name = slurm_get_cluster_name(); if (!xstrcmp(cluster_rec->name, orig_cluster_name)) working_cluster_rec = NULL; else working_cluster_rec = cluster_rec; cluster_dims = slurmdb_setup_cluster_dims(); cluster_flags = slurmdb_setup_cluster_flags(); display_data = main_display_data; while (display_data++) { if (display_data->id == -1) break; if (cluster_flags & CLUSTER_FLAG_BG) { switch(display_data->id) { case BLOCK_PAGE: display_data->show = true; break; case NODE_PAGE: display_data->name = "Midplanes"; break; default: break; } } else { switch(display_data->id) { case BLOCK_PAGE: display_data->show = false; break; case NODE_PAGE: display_data->name = "Nodes"; break; default: break; } } } /* set up menu */ ui_description = _get_ui_description(); gtk_ui_manager_remove_ui(g_ui_manager, g_menu_id); if (!(g_menu_id = gtk_ui_manager_add_ui_from_string( g_ui_manager, ui_description, -1, &error))) { xfree(ui_description); g_error("building menus failed: %s", error->message); g_error_free (error); exit (0); } xfree(ui_description); /* make changes for each object */ cluster_change_block(); cluster_change_front_end(); cluster_change_resv(); cluster_change_part(); cluster_change_job(); cluster_change_node(); cluster_change_bb(); /* destroy old stuff */ if (grid_button_list) { FREE_NULL_LIST(grid_button_list); got_grid = 1; } select_g_ba_fini(); /* sorry popups can't survive a cluster change */ if (popup_list) list_flush(popup_list); if (signal_params_list) list_flush(signal_params_list); if (signal_params_list) list_flush(signal_params_list); if (g_switch_nodes_maps) free_switch_nodes_maps(g_switch_nodes_maps); /* change the node tab name if needed */ node_tab = gtk_notebook_get_nth_page( GTK_NOTEBOOK(main_notebook), NODE_PAGE); node_tab = gtk_notebook_get_tab_label(GTK_NOTEBOOK(main_notebook), node_tab); #ifdef GTK2_USE_GET_FOCUS /* ok, now we have a table which we have set up to contain an * event_box which contains the label we are interested. We * setup this label to be the focus child of the table, so all * we have to do is grab that and we are set. */ node_tab = gtk_container_get_focus_child(GTK_CONTAINER(node_tab)); #else /* See above comment. Since gtk_container_get_focus_child * doesn't exist yet we will just traverse the children until * we find the label widget and then break. */ { int i = 0; GList *children = gtk_container_get_children( GTK_CONTAINER(node_tab)); while ((node_tab = g_list_nth_data(children, i++))) { int j = 0; GList *children2 = gtk_container_get_children( GTK_CONTAINER(node_tab)); while ((node_tab = g_list_nth_data(children2, j++))) { if (GTK_IS_LABEL(node_tab)) break; } g_list_free(children2); if (node_tab) break; } g_list_free(children); } #endif if (node_tab) gtk_label_set_text(GTK_LABEL(node_tab), main_display_data[NODE_PAGE].name); /* The name in the visible tabs is easier since it is really just a button with a label on it. */ if (default_sview_config.page_check_widget[NODE_PAGE]) { gtk_button_set_label(GTK_BUTTON(default_sview_config. page_check_widget[NODE_PAGE]), main_display_data[NODE_PAGE].name); } /* reinit */ rc = get_system_stats(main_grid_table); if (rc == SLURM_SUCCESS) { /* It turns out if we didn't have the grid (cluster not responding) before the new grid doesn't get set up correctly. Redoing the system_stats fixes it. There is probably a better way of doing this, but it doesn't happen very often and isn't that bad to handle every once in a while. */ if (!got_grid) { /* I know we just did this before, but it needs to be done again here. */ FREE_NULL_LIST(grid_button_list); get_system_stats(main_grid_table); } refresh_main(NULL, NULL); } tmp = g_strdup_printf("Cluster changed to %s", cluster_rec->name); display_edit_note(tmp); g_free(tmp); }
/* unpack a select job credential from a buffer * OUT jobinfo - the select job credential read * IN buffer - buffer with select credential read from current pointer loc * IN protocol_version - slurm protocol version of client * RET - slurm error code * NOTE: returned value must be freed using free_jobinfo */ extern int unpack_select_jobinfo(select_jobinfo_t **jobinfo_pptr, Buf buffer, uint16_t protocol_version) { int i; uint32_t uint32_tmp; uint16_t mp_cnode_cnt; int dims = slurmdb_setup_cluster_dims(); select_jobinfo_t *jobinfo = xmalloc(sizeof(struct select_jobinfo)); char *bit_char = NULL; *jobinfo_pptr = jobinfo; jobinfo->magic = JOBINFO_MAGIC; if (protocol_version >= SLURM_2_5_PROTOCOL_VERSION) { safe_unpack16(&jobinfo->dim_cnt, buffer); xassert(jobinfo->dim_cnt); dims = jobinfo->dim_cnt; for (i=0; i<dims; i++) { safe_unpack16(&(jobinfo->geometry[i]), buffer); safe_unpack16(&(jobinfo->conn_type[i]), buffer); safe_unpack16(&(jobinfo->start_loc[i]), buffer); } safe_unpack16(&(jobinfo->reboot), buffer); safe_unpack16(&(jobinfo->rotate), buffer); safe_unpack32(&(jobinfo->block_cnode_cnt), buffer); safe_unpack32(&(jobinfo->cnode_cnt), buffer); safe_unpackstr_xmalloc(&(jobinfo->bg_block_id), &uint32_tmp, buffer); safe_unpackstr_xmalloc(&(jobinfo->mp_str), &uint32_tmp, buffer); safe_unpackstr_xmalloc(&(jobinfo->ionode_str), &uint32_tmp, buffer); safe_unpackstr_xmalloc(&(jobinfo->blrtsimage), &uint32_tmp, buffer); safe_unpackstr_xmalloc(&(jobinfo->linuximage), &uint32_tmp, buffer); safe_unpackstr_xmalloc(&(jobinfo->mloaderimage), &uint32_tmp, buffer); safe_unpackstr_xmalloc(&(jobinfo->ramdiskimage), &uint32_tmp, buffer); safe_unpack16(&mp_cnode_cnt, buffer); safe_unpackstr_xmalloc(&bit_char, &uint32_tmp, buffer); if (bit_char) { jobinfo->units_avail = bit_alloc(mp_cnode_cnt); bit_unfmt(jobinfo->units_avail, bit_char); xfree(bit_char); } safe_unpackstr_xmalloc(&bit_char, &uint32_tmp, buffer); if (bit_char) { jobinfo->units_used = bit_alloc(mp_cnode_cnt); bit_unfmt(jobinfo->units_used, bit_char); xfree(bit_char); } } else { error("unpack_select_jobinfo: protocol_version " "%hu not supported", protocol_version); } return SLURM_SUCCESS; unpack_error: free_select_jobinfo(jobinfo); *jobinfo_pptr = NULL; return SLURM_ERROR; }
/* pack a select job credential into a buffer in machine independent form * IN jobinfo - the select job credential to be saved * OUT buffer - buffer with select credential appended * IN protocol_version - slurm protocol version of client * RET - slurm error code */ extern int pack_select_jobinfo(select_jobinfo_t *jobinfo, Buf buffer, uint16_t protocol_version) { int i; int dims = slurmdb_setup_cluster_dims(); if (protocol_version >= SLURM_2_5_PROTOCOL_VERSION) { if (jobinfo) { if (jobinfo->dim_cnt) dims = jobinfo->dim_cnt; else if (bg_recover != NOT_FROM_CONTROLLER) xassert(0); pack16(dims, buffer); /* NOTE: If new elements are added here, make sure to * add equivalant pack of zeros below for NULL * pointer */ for (i=0; i<dims; i++) { pack16(jobinfo->geometry[i], buffer); pack16(jobinfo->conn_type[i], buffer); pack16(jobinfo->start_loc[i], buffer); } pack16(jobinfo->reboot, buffer); pack16(jobinfo->rotate, buffer); pack32(jobinfo->block_cnode_cnt, buffer); pack32(jobinfo->cnode_cnt, buffer); packstr(jobinfo->bg_block_id, buffer); packstr(jobinfo->mp_str, buffer); packstr(jobinfo->ionode_str, buffer); packstr(jobinfo->blrtsimage, buffer); packstr(jobinfo->linuximage, buffer); packstr(jobinfo->mloaderimage, buffer); packstr(jobinfo->ramdiskimage, buffer); if (bg_conf) { pack16(bg_conf->mp_cnode_cnt, buffer); pack_bit_fmt(jobinfo->units_avail, buffer); pack_bit_fmt(jobinfo->units_used, buffer); } else { pack16(0, buffer); packnull(buffer); packnull(buffer); } } else { pack16(dims, buffer); /* pack space for 3 positions for geo * conn_type and start_loc and then, reboot, and rotate */ for (i=0; i<((dims*3)+2); i++) { pack16((uint16_t) 0, buffer); } pack32((uint32_t) 0, buffer); //block_cnode_cnt pack32((uint32_t) 0, buffer); //cnode_cnt packnull(buffer); //bg_block_id packnull(buffer); //nodes packnull(buffer); //ionodes packnull(buffer); //blrts packnull(buffer); //linux packnull(buffer); //mloader packnull(buffer); //ramdisk pack16((uint16_t) 0, buffer); //mp_cnode_cnt packnull(buffer); //units_avail packnull(buffer); //units_used } } else { error("pack_select_jobinfo: protocol_version " "%hu not supported", protocol_version); } return SLURM_SUCCESS; }
/* * parse_command_line, fill in params data structure with data */ extern void parse_command_line(int argc, char *argv[]) { int opt_char; int option_index; int tmp = 0; static struct option long_options[] = { {"commandline", no_argument, 0, 'c'}, {"display", required_argument, 0, 'D'}, {"noheader", no_argument, 0, 'h'}, {"iterate", required_argument, 0, 'i'}, {"ionodes", required_argument, 0, 'I'}, {"cluster", required_argument, 0, 'M'}, {"clusters",required_argument, 0, 'M'}, {"nodes", required_argument, 0, 'n'}, {"quiet", no_argument, 0, 'Q'}, {"resolve", required_argument, 0, 'R'}, {"verbose", no_argument, 0, 'v'}, {"version", no_argument, 0, 'V'}, {"help", no_argument, 0, OPT_LONG_HELP}, {"usage", no_argument, 0, OPT_LONG_USAGE}, {"show_hidden", no_argument, 0, 'H'}, {NULL, 0, 0, 0} }; memset(¶ms, 0, sizeof(params)); while ((opt_char = getopt_long(argc, argv, "cD:hi:I:Hn:M:QR:vV", long_options, &option_index)) != -1) { switch (opt_char) { case '?': fprintf(stderr, "Try \"smap --help\" for more information\n"); exit(1); break; case 'c': params.commandline = TRUE; break; case 'D': if (!strcmp(optarg, "j")) tmp = JOBS; else if (!strcmp(optarg, "s")) tmp = SLURMPART; else if (!strcmp(optarg, "b")) tmp = BGPART; else if (!strcmp(optarg, "c")) tmp = COMMANDS; else if (!strcmp(optarg, "r")) tmp = RESERVATIONS; params.display = tmp; break; case 'h': params.no_header = true; break; case 'H': params.all_flag = true; break; case 'i': params.iterate = atoi(optarg); if (params.iterate <= 0) { error("Error: --iterate=%s", optarg); exit(1); } break; case 'I': /* * confirm valid ionodelist entry (The 128 is * a large number here to avoid having to do a * lot more querying to figure out the correct * pset size. This number should be large enough. */ params.io_bit = bit_alloc(128); if(bit_unfmt(params.io_bit, optarg) == -1) { error("'%s' invalid entry for --ionodes", optarg); exit(1); } break; case 'M': if(params.clusters) list_destroy(params.clusters); if(!(params.clusters = slurmdb_get_info_cluster(optarg))) { error("'%s' invalid entry for --cluster", optarg); exit(1); } working_cluster_rec = list_peek(params.clusters); break; case 'n': /* * confirm valid nodelist entry */ params.hl = hostlist_create(optarg); if (!params.hl) { error("'%s' invalid entry for --nodes", optarg); exit(1); } break; case 'Q': quiet_flag = 1; break; case 'R': params.commandline = TRUE; params.resolve = xstrdup(optarg); break; case 'v': params.verbose++; break; case 'V': print_slurm_version(); exit(0); case OPT_LONG_HELP: _help(); exit(0); case OPT_LONG_USAGE: _usage(); exit(0); } } params.cluster_dims = slurmdb_setup_cluster_dims(); if (params.cluster_dims > 4) fatal("smap is unable to support more than four dimensions"); params.cluster_base = hostlist_get_base(params.cluster_dims); params.cluster_flags = slurmdb_setup_cluster_flags(); }