static int _change_state_bps(char *com, int state)
{
char *host;
int i = 0;
uint16_t pos[params.cluster_dims];
char letter = '.';
bool used = false;
char *c_state = "up";
hostlist_t hl = NULL;
int rc = 1;
if (state == NODE_STATE_DOWN) {
letter = '#';
used = true;
c_state = "down";
}
while (com[i] && (com[i] != '[') &&
((com[i] < '0') || (com[i] > '9')) &&
((com[i] < 'A') || (com[i] > 'Z')))
i++;
if (com[i] == '\0') {
memset(error_string, 0, 255);
sprintf(error_string,
"You didn't specify any nodes to make %s. "
"in statement '%s'",
c_state, com);
return 0;
}
if (!(hl = hostlist_create(com+i))) {
memset(error_string, 0, 255);
sprintf(error_string, "Bad hostlist given '%s'", com+i);
return 0;
}
while ((host = hostlist_shift(hl))) {
ba_mp_t *ba_mp;
smap_node_t *smap_node;
for (i = 0; i < params.cluster_dims; i++)
pos[i] = select_char2coord(host[i]);
if (!(ba_mp = bg_configure_coord2ba_mp(pos))) {
memset(error_string, 0, 255);
sprintf(error_string, "Bad host given '%s'", host);
rc = 0;
break;
}
bg_configure_ba_update_mp_state(ba_mp, state);
smap_node = smap_system_ptr->grid[ba_mp->index];
smap_node->color = 0;
smap_node->letter = letter;
smap_node->used = used;
free(host);
}
hostlist_destroy(hl);
return rc;
}
static int _make_nodelist(char *nodes, List nodelist)
{
int i, j = 0;
int start[params.cluster_dims];
int end[params.cluster_dims];
if (!nodelist)
nodelist = list_create(_nodelist_del);
memset(start, params.cluster_dims, sizeof(int));
memset(end, params.cluster_dims, sizeof(int));
while (nodes[j] != '\0') {
int mid = j + params.cluster_dims + 1;
int fin = mid + params.cluster_dims + 1;
if (((nodes[j] == '[') || (nodes[j] == ',')) &&
((nodes[mid] == 'x') || (nodes[mid] == '-')) &&
((nodes[fin] == ']') || (nodes[fin] == ','))) {
j++; /* Skip leading '[' or ',' */
for (i = 0; i < params.cluster_dims; i++, j++)
start[i] = select_char2coord(nodes[j]);
j++; /* Skip middle 'x' or '-' */
for (i = 0; i < params.cluster_dims; i++, j++)
end[i] = select_char2coord(nodes[j]);
_addto_nodelist(nodelist, start, end);
if (nodes[j] != ',')
break;
j--;
} else if (((nodes[j] >= '0') && (nodes[j] <= '9')) ||
((nodes[j] >= 'A') && (nodes[j] <= 'Z'))) {
for (i = 0; i < params.cluster_dims; i++, j++)
start[i] = select_char2coord(nodes[j]);
_addto_nodelist(nodelist, start, start);
if (nodes[j] != ',')
break;
j--;
}
j++;
}
return 1;
}
static void _marknodes(db2_block_info_t *block_ptr, int count)
{
int i, j = 0;
int start[params.cluster_dims];
int end[params.cluster_dims];
char *nodes = block_ptr->mp_str;
block_ptr->letter_num = count;
while (nodes[j] != '\0') {
int mid = j + params.cluster_dims + 1;
int fin = mid + params.cluster_dims + 1;
if (((nodes[j] == '[') || (nodes[j] == ',')) &&
((nodes[mid] == 'x') || (nodes[mid] == '-')) &&
((nodes[fin] == ']') || (nodes[fin] == ','))) {
j++; /* Skip leading '[' or ',' */
for (i = 0; i < params.cluster_dims; i++, j++)
start[i] = select_char2coord(nodes[j]);
j++; /* Skip middle 'x' or '-' */
for (i = 0; i < params.cluster_dims; i++, j++)
end[i] = select_char2coord(nodes[j]);
if (block_ptr->state != BG_BLOCK_FREE) {
block_ptr->size += set_grid_bg(
start, end, count, 1);
} else {
block_ptr->size += set_grid_bg(
start, end, count, 0);
}
if (nodes[j] != ',')
break;
} else if (((nodes[j] >= '0') && (nodes[j] <= '9')) ||
((nodes[j] >= 'A') && (nodes[j] <= 'Z'))) {
for (i = 0; i < params.cluster_dims; i++, j++)
start[i] = select_char2coord(nodes[j]);
block_ptr->size += set_grid_bg(start, start, count, 1);
if (nodes[j] != ',')
break;
} else
j++;
}
}
extern void select_p_ba_init(node_info_msg_t *node_info_ptr, bool sanity_check)
{
int i, j, offset;
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 < SYSTEM_DIMENSIONS; 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) != SYSTEM_DIMENSIONS))
continue;
for (j = 0; j < SYSTEM_DIMENSIONS; 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) *
SYSTEM_DIMENSIONS);
for (j = 0; j < SYSTEM_DIMENSIONS; j++)
working_cluster_rec->dim_size[j] =
select_cray_dim_size[j];
}
other_ba_init(node_info_ptr, sanity_check);
}
/* Add a button for a given node. If node_ptr == NULL then fill in any gaps
* in the grid just for a clean look. Always call with node_ptr == NULL for
* the last call in the sequence. */
static int _add_button_to_list(node_info_t *node_ptr,
button_processor_t *button_processor)
{
static bool *node_exists = NULL;
static int node_exists_cnt = 1;
grid_button_t *grid_button = button_processor->grid_button;
int *dim_size = NULL, i, coord_x = 0, coord_y = 0;
int len = 0, len_a = 0;
if (cluster_dims > 1) {
dim_size = _get_cluster_dims();
if (dim_size == NULL) {
g_error("Could not read dim_size\n");
return SLURM_ERROR;
}
if ((dim_size[0] < 1) || (cluster_dims < 1)) {
g_error("Invalid dim_size %d or cluster_dims %d\n",
dim_size[0], cluster_dims);
return SLURM_ERROR;
}
/* Translate a 3D or 4D space into a 2D space to the extent
* possible. */
if (node_exists == NULL) {
node_exists_cnt = 1;
for (i = 0; i < cluster_dims; i++)
node_exists_cnt *= dim_size[i];
node_exists = xmalloc(sizeof(bool) * node_exists_cnt);
}
if (node_ptr) {
len = strlen(node_ptr->name);
if (len < cluster_dims) {
g_error("bad node name %s\n", node_ptr->name);
return SLURM_ERROR;
}
if (cluster_flags & CLUSTER_FLAG_CRAY_A) {
len_a = strlen(node_ptr->node_addr);
if (len_a < cluster_dims) {
g_error("bad node addr %s\n",
node_ptr->node_addr);
return SLURM_ERROR;
}
}
}
}
if (cluster_dims == 3) {
int x, y, z;
if (node_ptr) {
if (cluster_flags & CLUSTER_FLAG_CRAY_A) {
x = select_char2coord(
node_ptr->node_addr[len_a-3]);
y = select_char2coord(
node_ptr->node_addr[len_a-2]);
z = select_char2coord(
node_ptr->node_addr[len_a-1]);
} else {
x = select_char2coord(node_ptr->name[len-3]);
y = select_char2coord(node_ptr->name[len-2]);
z = select_char2coord(node_ptr->name[len-1]);
}
i = (x * dim_size[1] + y) * dim_size[2] + z;
node_exists[i] = true;
_calc_coord_3d(x, y, z,
button_processor->default_y_offset,
&coord_x, &coord_y, dim_size);
} else {
for (x = 0; x < dim_size[0]; x++) {
for (y = 0; y < dim_size[1]; y++) {
for (z = 0; z < dim_size[2]; z++) {
i = (x * dim_size[1] + y) *
dim_size[2] + z;
if (node_exists[i])
continue;
_calc_coord_3d(x, y, z,
button_processor->
default_y_offset,
&coord_x, &coord_y,
dim_size);
_build_empty_node(
coord_x, coord_y,
button_processor);
}
}
}
xfree(node_exists);
return SLURM_SUCCESS;
}
}
if (node_ptr == NULL)
return SLURM_SUCCESS;
if (cluster_dims > 1) {
(*button_processor->coord_x) = coord_x;
(*button_processor->coord_y) = coord_y;
#if 0
g_print("%s %d:%d\n", node_ptr->name, coord_x, coord_y);
#endif
}
if (!grid_button) {
grid_button = xmalloc(sizeof(grid_button_t));
grid_button->color_inx = MAKE_INIT;
grid_button->inx = (*button_processor->inx);
grid_button->table = button_processor->table;
grid_button->table_x = (*button_processor->coord_x);
grid_button->table_y = (*button_processor->coord_y);
grid_button->button = gtk_button_new();
grid_button->node_name = xstrdup(node_ptr->name);
gtk_widget_set_size_request(grid_button->button,
working_sview_config.button_size,
working_sview_config.button_size);
_add_button_signals(grid_button);
list_append(button_processor->button_list, grid_button);
gtk_table_attach(button_processor->table, grid_button->button,
(*button_processor->coord_x),
((*button_processor->coord_x)+1),
(*button_processor->coord_y),
((*button_processor->coord_y)+1),
GTK_SHRINK, GTK_SHRINK,
1, 1);
} else {
grid_button->table_x = (*button_processor->coord_x);
grid_button->table_y = (*button_processor->coord_y);
gtk_container_child_set(
GTK_CONTAINER(button_processor->table),
grid_button->button,
"left-attach", (*button_processor->coord_x),
"right-attach", ((*button_processor->coord_x)+1),
"top-attach", (*button_processor->coord_y),
"bottom-attach", ((*button_processor->coord_y)+1),
NULL);
}
/* gtk_container_add(GTK_CONTAINER(grid_button->frame), */
/* grid_button->button); */
/* gtk_frame_set_shadow_type(GTK_FRAME(grid_button->frame), */
/* GTK_SHADOW_ETCHED_OUT); */
if (cluster_dims < 3) {
/* On linear systems we just up the x_coord until we hit the
* side of the table and then increment the coord_y. We add
* space between each tenth row. */
(*button_processor->coord_x)++;
if (button_processor->force_row_break) {
(*button_processor->coord_x) = 0;
(*button_processor->coord_y)++;
gtk_table_set_row_spacing(
button_processor->table,
(*button_processor->coord_y)-1,
working_sview_config.gap_size);
return SLURM_SUCCESS;
}
if ((*button_processor->coord_x)
== working_sview_config.grid_x_width) {
(*button_processor->coord_x) = 0;
(*button_processor->coord_y)++;
if (!((*button_processor->coord_y)
% working_sview_config.grid_vert))
gtk_table_set_row_spacing(
button_processor->table,
(*button_processor->coord_y)-1,
working_sview_config.gap_size);
}
if ((*button_processor->coord_y) == button_processor->table_y)
return SLURM_SUCCESS;
if ((*button_processor->coord_x) &&
!((*button_processor->coord_x)
% working_sview_config.grid_hori))
gtk_table_set_col_spacing(
button_processor->table,
(*button_processor->coord_x)-1,
working_sview_config.gap_size);
}
return SLURM_SUCCESS;
}
/* fill in a previously allocated select job credential
* IN/OUT jobinfo - updated select job credential
* IN data_type - type of data to enter into job credential
* IN data - the data to enter into job credential
*/
extern int set_select_jobinfo(select_jobinfo_t *jobinfo,
enum select_jobdata_type data_type, void *data)
{
int i, rc = SLURM_SUCCESS;
uint16_t *uint16 = (uint16_t *) data;
uint32_t *uint32 = (uint32_t *) data;
uid_t *uid = (uid_t *)data;
char *tmp_char = (char *) data;
bg_record_t *bg_record = (bg_record_t *) data;
uint32_t new_size;
xassert(jobinfo);
if (jobinfo->magic != JOBINFO_MAGIC) {
error("set_select_jobinfo: jobinfo magic bad");
return SLURM_ERROR;
}
if (!jobinfo->dim_cnt)
jobinfo->dim_cnt = SYSTEM_DIMENSIONS;
switch (data_type) {
case SELECT_JOBDATA_DIM_CNT:
jobinfo->dim_cnt = *uint16;
break;
case SELECT_JOBDATA_GEOMETRY:
new_size = 1;
for (i=0; i<jobinfo->dim_cnt; i++) {
jobinfo->geometry[i] = uint16[i];
new_size *= uint16[i];
/* Make sure the conn type is correct with the
* new count (if Geometry is requested it
* can't be small) */
jobinfo->conn_type[i] = SELECT_NAV;
}
break;
case SELECT_JOBDATA_REBOOT:
jobinfo->reboot = *uint16;
break;
case SELECT_JOBDATA_ROTATE:
jobinfo->rotate = *uint16;
break;
case SELECT_JOBDATA_CONN_TYPE:
for (i=0; i<jobinfo->dim_cnt; i++)
jobinfo->conn_type[i] = uint16[i];
break;
case SELECT_JOBDATA_BLOCK_ID:
/* we xfree() any preset value to avoid a memory leak */
xfree(jobinfo->bg_block_id);
jobinfo->bg_block_id = xstrdup(tmp_char);
break;
case SELECT_JOBDATA_BLOCK_NODE_CNT:
jobinfo->block_cnode_cnt = *uint32;
break;
case SELECT_JOBDATA_BLOCK_PTR:
jobinfo->bg_record = bg_record;
xfree(jobinfo->bg_block_id);
if (bg_record) {
jobinfo->bg_block_id = xstrdup(bg_record->bg_block_id);
jobinfo->block_cnode_cnt = bg_record->cnode_cnt;
} else {
jobinfo->bg_block_id = xstrdup("unassigned");
jobinfo->block_cnode_cnt = 0;
}
break;
case SELECT_JOBDATA_NODES:
xfree(jobinfo->mp_str);
jobinfo->mp_str = xstrdup(tmp_char);
break;
case SELECT_JOBDATA_IONODES:
xfree(jobinfo->ionode_str);
if (tmp_char) {
#ifdef HAVE_BGQ
jobinfo->dim_cnt = 5;
for (i=0; i<jobinfo->dim_cnt; i++) {
jobinfo->start_loc[i] =
select_char2coord(tmp_char[i]);
}
#else
jobinfo->dim_cnt = SYSTEM_DIMENSIONS;
#endif
jobinfo->ionode_str = xstrdup(tmp_char);
} else
jobinfo->dim_cnt = SYSTEM_DIMENSIONS;
break;
case SELECT_JOBDATA_NODE_CNT:
jobinfo->cnode_cnt = *uint32;
/* Make sure the conn type is correct with the new count */
if (bg_conf->sub_mp_sys
|| (jobinfo->cnode_cnt < bg_conf->mp_cnode_cnt)) {
if (jobinfo->conn_type[0] < SELECT_SMALL)
jobinfo->conn_type[0] = SELECT_SMALL;
} else if (jobinfo->conn_type[0] >= SELECT_SMALL) {
for (i=0; i<SYSTEM_DIMENSIONS; i++)
jobinfo->conn_type[i] = SELECT_NAV;
}
break;
case SELECT_JOBDATA_ALTERED:
jobinfo->altered = *uint16;
break;
case SELECT_JOBDATA_BLRTS_IMAGE:
/* we xfree() any preset value to avoid a memory leak */
xfree(jobinfo->blrtsimage);
jobinfo->blrtsimage = xstrdup(tmp_char);
break;
case SELECT_JOBDATA_LINUX_IMAGE:
/* we xfree() any preset value to avoid a memory leak */
xfree(jobinfo->linuximage);
jobinfo->linuximage = xstrdup(tmp_char);
break;
case SELECT_JOBDATA_MLOADER_IMAGE:
/* we xfree() any preset value to avoid a memory leak */
xfree(jobinfo->mloaderimage);
jobinfo->mloaderimage = xstrdup(tmp_char);
break;
case SELECT_JOBDATA_RAMDISK_IMAGE:
/* we xfree() any preset value to avoid a memory leak */
xfree(jobinfo->ramdiskimage);
jobinfo->ramdiskimage = xstrdup(tmp_char);
break;
case SELECT_JOBDATA_START_LOC:
for (i=0; i<jobinfo->dim_cnt; i++)
jobinfo->start_loc[i] = uint16[i];
break;
case SELECT_JOBDATA_USER_NAME:
xfree(jobinfo->user_name);
jobinfo->user_name = uid_to_string(*uid);
break;
default:
debug("set_select_jobinfo: data_type %d invalid",
data_type);
}
return rc;
}
extern bg_record_t *create_small_record(bg_record_t *bg_record,
bitstr_t *ionodes, int size)
{
bg_record_t *found_record = NULL;
ba_mp_t *new_ba_mp = NULL;
ba_mp_t *ba_mp = NULL;
found_record = (bg_record_t*) xmalloc(sizeof(bg_record_t));
found_record->magic = BLOCK_MAGIC;
/* This will be a list containing jobs running on this
block */
if (bg_conf->sub_blocks)
found_record->job_list = list_create(NULL);
found_record->job_running = NO_JOB_RUNNING;
#ifdef HAVE_BGL
found_record->node_use = SELECT_COPROCESSOR_MODE;
found_record->blrtsimage = xstrdup(bg_record->blrtsimage);
#endif
#ifdef HAVE_BG_L_P
found_record->linuximage = xstrdup(bg_record->linuximage);
found_record->ramdiskimage = xstrdup(bg_record->ramdiskimage);
#endif
found_record->mloaderimage = xstrdup(bg_record->mloaderimage);
if (bg_record->conn_type[0] >= SELECT_SMALL)
found_record->conn_type[0] = bg_record->conn_type[0];
else
found_record->conn_type[0] = SELECT_SMALL;
xassert(bg_conf->cpu_ratio);
found_record->cpu_cnt = bg_conf->cpu_ratio * size;
found_record->cnode_cnt = size;
found_record->ionode_bitmap = bit_copy(ionodes);
ba_set_ionode_str(found_record);
found_record->ba_mp_list = list_create(destroy_ba_mp);
slurm_mutex_lock(&ba_system_mutex);
if (bg_record->ba_mp_list)
ba_mp = list_peek(bg_record->ba_mp_list);
if (!ba_mp) {
if (bg_record->mp_str) {
int j = 0, dim;
char *nodes = bg_record->mp_str;
uint16_t coords[SYSTEM_DIMENSIONS];
while (nodes[j] != '\0') {
if ((nodes[j] >= '0' && nodes[j] <= '9')
|| (nodes[j] >= 'A' && nodes[j] <= 'Z')) {
break;
}
j++;
}
if (nodes[j] && ((strlen(nodes)
- (j + SYSTEM_DIMENSIONS)) >= 0)) {
for (dim = 0; dim < SYSTEM_DIMENSIONS;
dim++, j++)
coords[dim] = select_char2coord(
nodes[j]);
ba_mp = coord2ba_mp(coords);
}
error("you gave me a list with no ba_mps using %s",
ba_mp->coord_str);
} else {
ba_mp = coord2ba_mp(found_record->start);
error("you gave me a record with no ba_mps "
"and no nodes either using %s",
ba_mp->coord_str);
}
}
xassert(ba_mp);
new_ba_mp = ba_copy_mp(ba_mp);
slurm_mutex_unlock(&ba_system_mutex);
/* We need to have this node wrapped in Q to handle
wires correctly when creating around the midplane.
*/
ba_setup_mp(new_ba_mp, false, true);
new_ba_mp->used = BA_MP_USED_TRUE;
/* Create these now so we can deal with error cnodes if/when
they happen. Since this is the easiest place to figure it
out for blocks that don't use the entire block */
if ((new_ba_mp->cnode_bitmap =
ba_create_ba_mp_cnode_bitmap(found_record))) {
new_ba_mp->cnode_err_bitmap = bit_alloc(bg_conf->mp_cnode_cnt);
new_ba_mp->cnode_usable_bitmap =
bit_copy(new_ba_mp->cnode_bitmap);
}
list_append(found_record->ba_mp_list, new_ba_mp);
found_record->mp_count = 1;
found_record->mp_str = xstrdup_printf(
"%s%s",
bg_conf->slurm_node_prefix, new_ba_mp->coord_str);
process_nodes(found_record, false);
/* Force small blocks to always be non-full system blocks.
* This really only plays a part on sub-midplane systems. */
found_record->full_block = 0;
if (bg_conf->slurm_debug_flags & DEBUG_FLAG_BG_PICK)
info("made small block of %s[%s]",
found_record->mp_str, found_record->ionode_str);
return found_record;
}
/* Build the smap_system_ptr structure from the node records */
extern void init_grid(node_info_msg_t *node_info_ptr, int cols)
{
int i, j, len;
int default_y_offset = 0;
smap_node_t *smap_node;
smap_system_ptr = xmalloc(sizeof(smap_system_t));
if (!node_info_ptr) {
if (params.display != COMMANDS)
return;
#ifdef HAVE_BG
uint16_t coords[params.cluster_dims];
smap_system_ptr->node_cnt = 1;
for (i=0; i<params.cluster_dims; i++)
smap_system_ptr->node_cnt *= dim_size[i];
smap_system_ptr->grid = xmalloc(sizeof(smap_node_t *) *
smap_system_ptr->node_cnt);
/* We need to make sure we set up the wires if we
don't have a node_info_ptr.
*/
bg_configure_ba_setup_wires();
_internal_setup_grid(0, coords);
#endif
} else {
smap_system_ptr->grid = xmalloc(sizeof(smap_node_t *) *
node_info_ptr->record_count);
for (i = 0; i < node_info_ptr->record_count; i++) {
node_info_t *node_ptr = &node_info_ptr->node_array[i];
if ((node_ptr->name == NULL) ||
(node_ptr->name[0] == '\0'))
continue;
smap_node = xmalloc(sizeof(smap_node_t));
len = strlen(node_ptr->name);
if (params.cluster_dims == 1) {
smap_node->coord = xmalloc(sizeof(uint16_t));
j = len - 1;
while ((node_ptr->name[j] >= '0') &&
(node_ptr->name[j] <= '9')) {
smap_node->coord[0] *= 10;
smap_node->coord[0] +=
node_ptr->name[j] - '0';
j++;
}
} else if (params.cluster_flags & CLUSTER_FLAG_CRAY) {
int len_a, len_h;
len_a = strlen(node_ptr->node_addr);
len_h = strlen(node_ptr->node_hostname);
if (len_a < params.cluster_dims) {
printf("Invalid node addr %s\n",
node_ptr->node_addr);
xfree(smap_node);
continue;
}
if (len_h < 1) {
printf("Invalid node hostname %s\n",
node_ptr->node_hostname);
xfree(smap_node);
continue;
}
smap_node->coord = xmalloc(sizeof(uint16_t) *
params.cluster_dims);
len_a -= params.cluster_dims;
for (j = 0; j < params.cluster_dims; j++) {
smap_node->coord[j] = select_char2coord(
node_ptr->node_addr[len_a+j]);
}
} else {
len -= params.cluster_dims;
if (len < 0) {
printf("Invalid node name: %s.\n",
node_ptr->name);
xfree(smap_node);
continue;
}
smap_node->coord = xmalloc(sizeof(uint16_t) *
params.cluster_dims);
for (j = 0; j < params.cluster_dims; j++) {
smap_node->coord[j] = select_char2coord(
node_ptr->name[len+j]);
}
}
smap_node->index = i;
smap_node->state = node_ptr->node_state;
smap_system_ptr->grid[i] = smap_node;
smap_system_ptr->node_cnt++;
}
}
if (params.cluster_dims == 3) {
default_y_offset = (dim_size[2] * dim_size[1]) +
(dim_size[1] - dim_size[2]);
} else if (params.cluster_dims == 4) {
default_y_offset = (dim_size[3] * dim_size[2]) +
(dim_size[2] - dim_size[3]);
}
if (cols == 0)
cols = 80;
for (i = 0; i < smap_system_ptr->node_cnt; i++) {
smap_node = smap_system_ptr->grid[i];
if (!smap_node) /* Null node name */
continue;
if (params.cluster_dims == 1) {
smap_node->grid_xcord = (i % cols) + 1;
smap_node->grid_ycord = (i / cols) + 1;
} else if (params.cluster_dims == 2) {
smap_node->grid_xcord = smap_node->coord[0] + 1;
smap_node->grid_ycord =
dim_size[1] - smap_node->coord[1];
} else if (params.cluster_dims == 3) {
_calc_coord_3d(smap_node->coord[0], smap_node->coord[1],
smap_node->coord[2],
default_y_offset,
&smap_node->grid_xcord,
&smap_node->grid_ycord, dim_size);
} else if (params.cluster_dims == 4) {
_calc_coord_4d(smap_node->coord[0], smap_node->coord[1],
smap_node->coord[2], smap_node->coord[3],
default_y_offset,
&smap_node->grid_xcord,
&smap_node->grid_ycord, dim_size);
}
}
}
static int _add_bg_record(select_ba_request_t *blockreq, List allocated_blocks)
{
int rc = 1;
#ifdef HAVE_BG
char *nodes = NULL, *host;
int diff = 0;
int largest_diff = -1;
uint16_t start[params.cluster_dims];
uint16_t end[params.cluster_dims];
uint16_t best_start[params.cluster_dims];
int i, j = 0;
hostlist_t hl = NULL;
bitstr_t *mark_bitmap = NULL;
char tmp_char[params.cluster_dims+1],
tmp_char2[params.cluster_dims+1];
memset(tmp_char, 0, sizeof(tmp_char));
memset(tmp_char2, 0, sizeof(tmp_char2));
for (i = 0; i < params.cluster_dims; i++) {
best_start[0] = 0;
blockreq->geometry[i] = 0;
end[i] = (int16_t)-1;
}
nodes = blockreq->save_name;
if (!nodes)
return SLURM_SUCCESS;
while (nodes[j] && (nodes[j] != '[') &&
((nodes[j] < '0') || (nodes[j] > '9')) &&
((nodes[j] < 'A') || (nodes[j] > 'Z')))
j++;
if (nodes[j] == '\0') {
snprintf(error_string, sizeof(error_string),
"This block '%s' for some reason didn't contain "
"any midplanes.",
nodes);
rc = 0;
goto fini;
}
if (!(hl = hostlist_create(nodes+j))) {
snprintf(error_string, sizeof(error_string),
"Bad hostlist given '%s'", nodes+j);
rc = 0;
goto fini;
}
/* figure out the geo and the size */
mark_bitmap = bit_alloc(smap_system_ptr->node_cnt);
while ((host = hostlist_shift(hl))) {
ba_mp_t *ba_mp;
uint16_t pos[params.cluster_dims];
for (i = 0; i < params.cluster_dims; i++)
pos[i] = select_char2coord(host[i]);
free(host);
if (!(ba_mp = bg_configure_coord2ba_mp(pos))) {
memset(error_string, 0, 255);
sprintf(error_string, "Bad host given '%s'", host);
rc = 0;
break;
}
bit_set(mark_bitmap, ba_mp->index);
for (i = 0; i < params.cluster_dims; i++) {
if (ba_mp->coord[i] > (int16_t)end[i]) {
blockreq->geometry[i]++;
end[i] = ba_mp->coord[i];
}
}
}
hostlist_destroy(hl);
if (!rc)
goto fini;
/* figure out the start pos */
while (nodes[j] != '\0') {
int mid = j + params.cluster_dims + 1;
int fin = mid + params.cluster_dims + 1;
if (((nodes[j] == '[') || (nodes[j] == ',')) &&
((nodes[mid] == 'x') || (nodes[mid] == '-')) &&
((nodes[fin] == ']') || (nodes[fin] == ','))) {
j++; /* Skip leading '[' or ',' */
for (i = 0; i < params.cluster_dims; i++, j++)
start[i] = select_char2coord(nodes[j]);
j++; /* Skip middle 'x' or '-' */
for (i = 0; i < params.cluster_dims; i++, j++)
end[i] = select_char2coord(nodes[j]);
diff = end[0] - start[0];
} else if (((nodes[j] >= '0') && (nodes[j] <= '9')) ||
((nodes[j] >= 'A') && (nodes[j] <= 'Z'))) {
for (i = 0; i < params.cluster_dims; i++, j++)
start[i] = select_char2coord(nodes[j]);
diff = 0;
} else {
j++;
continue;
}
if (diff > largest_diff) {
largest_diff = diff;
memcpy(best_start, start, sizeof(best_start));
}
if (nodes[j] != ',')
break;
}
if (largest_diff == -1) {
snprintf(error_string, sizeof(error_string),
"No hostnames given here");
goto fini;
}
memcpy(blockreq->start, best_start, sizeof(blockreq->start));
if(!_full_request(blockreq, mark_bitmap, allocated_blocks))
destroy_select_ba_request(blockreq);
fini:
FREE_NULL_BITMAP(mark_bitmap);
#endif
return rc;
}
extern void process_nodes(bg_record_t *bg_record, bool startup)
{
int j=0;
int diff=0;
int largest_diff=-1;
uint16_t best_start[SYSTEM_DIMENSIONS];
uint16_t start[SYSTEM_DIMENSIONS];
uint16_t end[SYSTEM_DIMENSIONS];
bool start_set=0;
ListIterator itr;
ba_mp_t* ba_mp = NULL;
int dim;
static char tmp_char[SYSTEM_DIMENSIONS+1],
tmp_char2[SYSTEM_DIMENSIONS+1];
static int *cluster_dims = NULL;
if (!cluster_dims) {
/* do some initing that only needs to happen once. */
cluster_dims = select_g_ba_get_dims();
memset(tmp_char, 0, sizeof(tmp_char));
memset(tmp_char2, 0, sizeof(tmp_char2));
}
if (!bg_record->ba_mp_list || !list_count(bg_record->ba_mp_list)) {
char *nodes = bg_record->mp_str;
if (!bg_record->ba_mp_list)
bg_record->ba_mp_list = list_create(destroy_ba_mp);
memset(&best_start, 0, sizeof(best_start));
//bg_record->mp_count = 0;
if ((bg_record->conn_type[0] >= SELECT_SMALL) && (!startup))
error("process_nodes: "
"We shouldn't be here there could be some "
"badness if we use this logic %s",
bg_record->mp_str);
while (nodes[j] != '\0') {
int mid = j + SYSTEM_DIMENSIONS + 1;
int fin = mid + SYSTEM_DIMENSIONS + 1;
if (((nodes[j] == '[') || (nodes[j] == ',')) &&
((nodes[mid] == 'x') || (nodes[mid] == '-')) &&
((nodes[fin] == ']') || (nodes[fin] == ','))) {
j++; /* Skip leading '[' or ',' */
for (dim = 0; dim < SYSTEM_DIMENSIONS;
dim++, j++)
start[dim] = select_char2coord(
nodes[j]);
j++; /* Skip middle 'x' or '-' */
for (dim = 0; dim < SYSTEM_DIMENSIONS;
dim++, j++)
end[dim] = select_char2coord(nodes[j]);
diff = end[0]-start[0];
_addto_mp_list(bg_record, start, end);
} else if ((nodes[j] >= '0'&& nodes[j] <= '9')
|| (nodes[j] >= 'A' && nodes[j] <= 'Z')) {
for (dim = 0; dim < SYSTEM_DIMENSIONS;
dim++, j++)
start[dim] = select_char2coord(
nodes[j]);
diff = 0;
_addto_mp_list(bg_record, start, start);
} else {
j++;
continue;
}
if (diff > largest_diff) {
largest_diff = diff;
memcpy(best_start, start, sizeof(best_start));
if (bg_conf->slurm_debug_level
>= LOG_LEVEL_DEBUG3) {
for (dim = 0;
dim < SYSTEM_DIMENSIONS;
dim++)
tmp_char[dim] = alpha_num[
best_start[dim]];
debug3("process_nodes: start is now %s",
tmp_char);
}
}
if (bg_record->mp_str[j] != ',')
break;
}
if (largest_diff == -1)
fatal("No hostnames given here");
memcpy(bg_record->start, best_start, sizeof(bg_record->start));
start_set = 1;
if (bg_conf->slurm_debug_level >= LOG_LEVEL_DEBUG3) {
for (dim = 0; dim < SYSTEM_DIMENSIONS; dim++) {
tmp_char[dim] = alpha_num[best_start[dim]];
tmp_char2[dim] =
alpha_num[bg_record->start[dim]];
}
debug3("process_nodes: start is %s %s",
tmp_char, tmp_char2);
}
}
memset(bg_record->geo, 0, sizeof(bg_record->geo));
for (dim = 0; dim < SYSTEM_DIMENSIONS; dim++) {
end[dim] = (int16_t)-1;
if (!start_set)
bg_record->start[dim] = HOSTLIST_BASE;
}
list_sort(bg_record->ba_mp_list, (ListCmpF) _ba_mp_cmpf_inc);
bg_record->mp_count = 0;
itr = list_iterator_create(bg_record->ba_mp_list);
while ((ba_mp = list_next(itr))) {
if (!ba_mp->used)
continue;
bg_record->mp_count++;
debug3("process_nodes: %s is included in this block",
ba_mp->coord_str);
for (dim = 0; dim < SYSTEM_DIMENSIONS; dim++) {
if (ba_mp->coord[dim] > (int16_t)end[dim]) {
bg_record->geo[dim]++;
end[dim] = ba_mp->coord[dim];
}
if (!start_set && (ba_mp->coord[dim] <
(int16_t)bg_record->start[dim]))
bg_record->start[dim] = ba_mp->coord[dim];
}
}
list_iterator_destroy(itr);
if (bg_conf->slurm_debug_level >= LOG_LEVEL_DEBUG3) {
for (dim = 0; dim < SYSTEM_DIMENSIONS; dim++) {
tmp_char[dim] = alpha_num[bg_record->geo[dim]];
tmp_char2[dim] = alpha_num[bg_record->start[dim]];
}
debug3("process_nodes: geo = %s mp count is %d start is %s",
tmp_char, bg_record->mp_count, tmp_char2);
}
/* This check is for sub midplane systems to figure out what
the largest block can be.
*/
for (dim = 0; dim < SYSTEM_DIMENSIONS; dim++) {
if (cluster_dims[dim] > 1)
break;
}
if (dim < SYSTEM_DIMENSIONS) {
/* means we have more than 1 base partition */
for (dim = 0; dim < SYSTEM_DIMENSIONS; dim++) {
if (bg_record->geo[dim] != cluster_dims[dim])
break;
}
if (dim == SYSTEM_DIMENSIONS)
bg_record->full_block = 1;
} else if (bg_record->cnode_cnt == bg_conf->mp_cnode_cnt)
bg_record->full_block = 1;
FREE_NULL_BITMAP(bg_record->mp_bitmap);
if (node_name2bitmap(bg_record->mp_str,
false,
&bg_record->mp_bitmap)) {
fatal("process_nodes: Unable to convert nodes %s to bitmap",
bg_record->mp_str);
}
return;
}