int
xcpuinfo_abs_to_mac(char* lrange,char** prange)
{
static int total_cores = -1, total_cpus = -1;
bitstr_t* absmap = NULL;
bitstr_t* macmap = NULL;
int icore, ithread;
int absid, macid;
int rc = SLURM_SUCCESS;
if (total_cores == -1) {
total_cores = conf->sockets * conf->cores;
total_cpus = conf->block_map_size;
}
/* allocate bitmap */
absmap = bit_alloc(total_cores);
macmap = bit_alloc(total_cpus);
if (!absmap || !macmap) {
rc = SLURM_ERROR;
goto end_it;
}
/* string to bitmap conversion */
if (bit_unfmt(absmap, lrange)) {
rc = SLURM_ERROR;
goto end_it;
}
/* mapping abstract id to machine id using conf->block_map */
for (icore = 0; icore < total_cores; icore++) {
if (bit_test(absmap, icore)) {
for (ithread = 0; ithread<conf->threads; ithread++) {
absid = icore*conf->threads + ithread;
absid %= total_cpus;
macid = conf->block_map[absid];
macid %= total_cpus;
bit_set(macmap, macid);
}
}
}
/* convert machine cpu bitmap to range string */
*prange = (char*)xmalloc(total_cpus*6);
bit_fmt(*prange, total_cpus*6, macmap);
/* free unused bitmaps */
end_it:
FREE_NULL_BITMAP(absmap);
FREE_NULL_BITMAP(macmap);
if (rc != SLURM_SUCCESS)
info("_abs_to_mac failed");
return rc;
}
/* Set the socket and core counts associated with a set of selected
* nodes of a job_resources data structure based upon slurmctld state.
* (sets cores_per_socket, sockets_per_node, and sock_core_rep_count based
* upon the value of node_bitmap, also creates core_bitmap based upon
* the total number of cores in the allocation). Call this ONLY from
* slurmctld. Example of use:
*
* job_resources_t *job_resrcs_ptr = create_job_resources();
* node_name2bitmap("dummy[2,5,12,16]", true, &(job_res_ptr->node_bitmap));
* rc = build_job_resources(job_resrcs_ptr, node_record_table_ptr,
* slurmctld_conf.fast_schedule);
*/
extern int build_job_resources(job_resources_t *job_resrcs,
void *node_rec_table, uint16_t fast_schedule)
{
int i, bitmap_len;
int core_cnt = 0, sock_inx = -1;
uint32_t cores, socks;
struct node_record *node_ptr, *node_record_table;
if (job_resrcs->node_bitmap == NULL) {
error("build_job_resources: node_bitmap is NULL");
return SLURM_ERROR;
}
node_record_table = (struct node_record *) node_rec_table;
xfree(job_resrcs->sockets_per_node);
xfree(job_resrcs->cores_per_socket);
xfree(job_resrcs->sock_core_rep_count);
job_resrcs->sockets_per_node = xmalloc(sizeof(uint16_t) *
job_resrcs->nhosts);
job_resrcs->cores_per_socket = xmalloc(sizeof(uint16_t) *
job_resrcs->nhosts);
job_resrcs->sock_core_rep_count = xmalloc(sizeof(uint32_t) *
job_resrcs->nhosts);
bitmap_len = bit_size(job_resrcs->node_bitmap);
for (i=0; i<bitmap_len; i++) {
if (!bit_test(job_resrcs->node_bitmap, i))
continue;
node_ptr = node_record_table + i;
if (fast_schedule) {
socks = node_ptr->config_ptr->sockets;
cores = node_ptr->config_ptr->cores;
} else {
socks = node_ptr->sockets;
cores = node_ptr->cores;
}
if ((sock_inx < 0) ||
(socks != job_resrcs->sockets_per_node[sock_inx]) ||
(cores != job_resrcs->cores_per_socket[sock_inx])) {
sock_inx++;
job_resrcs->sockets_per_node[sock_inx] = socks;
job_resrcs->cores_per_socket[sock_inx] = cores;
}
job_resrcs->sock_core_rep_count[sock_inx]++;
core_cnt += (cores * socks);
}
#ifndef HAVE_BG
job_resrcs->core_bitmap = bit_alloc(core_cnt);
job_resrcs->core_bitmap_used = bit_alloc(core_cnt);
if ((job_resrcs->core_bitmap == NULL) ||
(job_resrcs->core_bitmap_used == NULL))
fatal("bit_alloc malloc failure");
#endif
return SLURM_SUCCESS;
}
task_state_t task_state_create (int ntasks)
{
task_state_t ts = xmalloc (sizeof (*ts));
/* ts is zero filled by xmalloc() */
ts->n_tasks = ntasks;
ts->running = bit_alloc (ntasks);
ts->start_failed = bit_alloc (ntasks);
ts->normal_exit = bit_alloc (ntasks);
ts->abnormal_exit = bit_alloc (ntasks);
return (ts);
}
bthid_session_p
session_open(bthid_server_p srv, hid_device_p const d)
{
bthid_session_p s;
assert(srv != NULL);
assert(d != NULL);
if ((s = (bthid_session_p) malloc(sizeof(*s))) == NULL)
return (NULL);
s->srv = srv;
memcpy(&s->bdaddr, &d->bdaddr, sizeof(s->bdaddr));
s->ctrl = -1;
s->intr = -1;
if (d->keyboard) {
/* Open /dev/vkbdctl */
s->vkbd = open("/dev/vkbdctl", O_RDWR);
if (s->vkbd < 0) {
syslog(LOG_ERR, "Could not open /dev/vkbdctl " \
"for %s. %s (%d)", bt_ntoa(&s->bdaddr, NULL),
strerror(errno), errno);
free(s);
return (NULL);
}
} else
s->vkbd = -1;
s->state = CLOSED;
s->keys1 = bit_alloc(kbd_maxkey());
if (s->keys1 == NULL) {
free(s);
return (NULL);
}
s->keys2 = bit_alloc(kbd_maxkey());
if (s->keys2 == NULL) {
free(s->keys1);
free(s);
return (NULL);
}
LIST_INSERT_HEAD(&srv->sessions, s, next);
return (s);
}
/*
* Remove job from full-length core_bitmap
* IN job_resrcs_ptr - resources allocated to a job
* IN/OUT full_bitmap - bitmap of available CPUs, allocate as needed
* IN bits_per_node - bits per node in the full_bitmap
* RET 1 on success, 0 otherwise
*/
extern void remove_job_from_cores(job_resources_t *job_resrcs_ptr,
bitstr_t **full_core_bitmap,
const uint16_t *bits_per_node)
{
int full_node_inx = 0, job_node_cnt;
int job_bit_inx = 0, full_bit_inx = 0, i;
if (!job_resrcs_ptr->core_bitmap)
return;
/* add the job to the row_bitmap */
if (*full_core_bitmap == NULL) {
uint32_t size = 0;
for (i = 0; i < node_record_count; i++)
size += bits_per_node[i];
*full_core_bitmap = bit_alloc(size);
}
job_node_cnt = bit_set_count(job_resrcs_ptr->node_bitmap);
for (full_node_inx = bit_ffs(job_resrcs_ptr->node_bitmap);
job_node_cnt > 0; full_node_inx++) {
if (bit_test(job_resrcs_ptr->node_bitmap, full_node_inx)) {
full_bit_inx = cr_node_cores_offset[full_node_inx];
for (i = 0; i < bits_per_node[full_node_inx]; i++) {
if (!job_resrcs_ptr->whole_node &&
!bit_test(job_resrcs_ptr->core_bitmap,
job_bit_inx + i))
continue;
bit_clear(*full_core_bitmap, full_bit_inx + i);
}
job_bit_inx += bits_per_node[full_node_inx];
job_node_cnt --;
}
}
}
/* given an "avail" node_bitmap, return a corresponding "avail" core_bitmap */
bitstr_t *_make_core_bitmap(bitstr_t *node_map)
{
uint32_t n, c, nodes, size;
uint32_t coff;
int i_first, i_last;
nodes = bit_size(node_map);
size = cr_get_coremap_offset(nodes);
bitstr_t *core_map = bit_alloc(size);
i_first = bit_ffs(node_map);
if (i_first >= 0)
i_last = bit_fls(node_map);
else
i_last = -2;
for (n = i_first, c = 0; n <= i_last; n++) {
if (bit_test(node_map, n)) {
coff = cr_get_coremap_offset(n + 1);
while (c < coff) {
bit_set(core_map, c++);
}
}
}
return core_map;
}
/*
* Initialise the cache for (nblks) of (bsize).
*/
int
bcache_init(u_int nblks, size_t bsize)
{
/* discard any old contents */
if (bcache_data != NULL) {
free(bcache_data);
bcache_data = NULL;
free(bcache_ctl);
}
/* Allocate control structures */
bcache_nblks = nblks;
bcache_blksize = bsize;
bcache_data = malloc(bcache_nblks * bcache_blksize);
bcache_ctl = (struct bcachectl *)malloc(bcache_nblks * sizeof(struct bcachectl));
bcache_miss = bit_alloc((bcache_nblks + 1) / 2);
if ((bcache_data == NULL) || (bcache_ctl == NULL) || (bcache_miss == NULL)) {
if (bcache_miss)
free(bcache_miss);
if (bcache_ctl)
free(bcache_ctl);
if (bcache_data)
free(bcache_data);
bcache_data = NULL;
return(ENOMEM);
}
return(0);
}
int _print_job_job_id(job_info_t * job, int width, bool right, char* suffix)
{
if (job == NULL) { /* Print the Header instead */
_print_str("JOBID", width, right, true);
} else if ((job->array_task_id != NO_VAL) &&
!params.array_flag && IS_JOB_PENDING(job) &&
job->node_inx) {
uint32_t i, max_task_id = 0;
char id[FORMAT_STRING_SIZE], task_str[FORMAT_STRING_SIZE];
bitstr_t *task_bits;
for (i = 1; i <= job->node_inx[0]; i++)
max_task_id = MAX(max_task_id, job->node_inx[i]);
task_bits = bit_alloc(max_task_id + 1);
for (i = 1; i <= job->node_inx[0]; i++)
bit_set(task_bits, job->node_inx[i]);
bit_fmt(task_str, sizeof(task_str), task_bits);
snprintf(id, FORMAT_STRING_SIZE, "%u_[%s]",
job->array_job_id, task_str);
_print_str(id, width, right, true);
bit_free(task_bits);
} else if (job->array_task_id != NO_VAL) {
char id[FORMAT_STRING_SIZE];
snprintf(id, FORMAT_STRING_SIZE, "%u_%u",
job->array_job_id, job->array_task_id);
_print_str(id, width, right, true);
} else {
char id[FORMAT_STRING_SIZE];
snprintf(id, FORMAT_STRING_SIZE, "%u", job->job_id);
_print_str(id, width, right, true);
}
if (suffix)
printf("%s", suffix);
return SLURM_SUCCESS;
}
void task_state_print (task_state_t ts, log_f fn)
{
bitstr_t *unseen;
if (!ts) /* Not built yet */
return;
unseen = bit_alloc (ts->n_tasks);
if (bit_set_count (ts->start_failed)) {
_do_log_msg (ts->start_failed, fn, "failed to start");
bit_or (unseen, ts->start_failed);
}
if (bit_set_count (ts->running)) {
_do_log_msg (ts->running, fn, "running");
bit_or (unseen, ts->running);
}
if (bit_set_count (ts->abnormal_exit)) {
_do_log_msg (ts->abnormal_exit, fn, "exited abnormally");
bit_or (unseen, ts->abnormal_exit);
}
if (bit_set_count (ts->normal_exit)) {
_do_log_msg (ts->normal_exit, fn, "exited");
bit_or (unseen, ts->normal_exit);
}
bit_not (unseen);
if (bit_set_count (unseen))
_do_log_msg (unseen, fn, "unknown");
FREE_NULL_BITMAP(unseen);
}
/*
* Remove job from full-length core_bitmap
* IN job_resrcs_ptr - resources allocated to a job
* IN/OUT full_bitmap - bitmap of available CPUs, allocate as needed
* IN bits_per_node - bits per node in the full_bitmap
* RET 1 on success, 0 otherwise
*/
extern void remove_job_from_cores(job_resources_t *job_resrcs_ptr,
bitstr_t **full_core_bitmap,
const uint16_t *bits_per_node)
{
int full_node_inx = 0;
int job_bit_inx = 0, full_bit_inx = 0, i;
if (!job_resrcs_ptr->core_bitmap)
return;
/* add the job to the row_bitmap */
if (*full_core_bitmap == NULL) {
uint32_t size = 0;
for (i = 0; i < node_record_count; i++)
size += bits_per_node[i];
*full_core_bitmap = bit_alloc(size);
if (!*full_core_bitmap)
fatal("add_job_to_cores: bitmap memory error");
}
for (full_node_inx = 0; full_node_inx < node_record_count;
full_node_inx++) {
if (bit_test(job_resrcs_ptr->node_bitmap, full_node_inx)) {
for (i = 0; i < bits_per_node[full_node_inx]; i++) {
if (!bit_test(job_resrcs_ptr->core_bitmap,
job_bit_inx + i))
continue;
bit_clear(*full_core_bitmap, full_bit_inx + i);
}
job_bit_inx += bits_per_node[full_node_inx];
}
full_bit_inx += bits_per_node[full_node_inx];
}
}
/* Reset the node_bitmap in a job_resources data structure
* This is needed after a restart/reconfiguration since nodes can
* be added or removed from the system resulting in changing in
* the bitmap size or bit positions */
extern int reset_node_bitmap(job_resources_t *job_resrcs_ptr, uint32_t job_id)
{
int i;
if (!job_resrcs_ptr)
return SLURM_SUCCESS;
if (job_resrcs_ptr->node_bitmap)
FREE_NULL_BITMAP(job_resrcs_ptr->node_bitmap);
if (job_resrcs_ptr->nodes &&
(node_name2bitmap(job_resrcs_ptr->nodes, false,
&job_resrcs_ptr->node_bitmap))) {
error("Invalid nodes (%s) for job_id %u",
job_resrcs_ptr->nodes, job_id);
return SLURM_ERROR;
} else if (job_resrcs_ptr->nodes == NULL) {
job_resrcs_ptr->node_bitmap = bit_alloc(node_record_count);
}
i = bit_set_count(job_resrcs_ptr->node_bitmap);
if (job_resrcs_ptr->nhosts != i) {
error("Invalid change in resource allocation node count for "
"job %u, %u to %d", job_id, job_resrcs_ptr->nhosts, i);
return SLURM_ERROR;
}
return SLURM_SUCCESS;
}
/* If slurmctld crashes, the node state that it recovers could differ
* from the actual hardware state (e.g. ResumeProgram failed to complete).
* To address that, when a node that should be powered up for a running
* job is not responding, they try running ResumeProgram again. */
static void _re_wake(void)
{
struct node_record *node_ptr;
bitstr_t *wake_node_bitmap = NULL;
int i;
node_ptr = node_record_table_ptr;
for (i=0; i<node_record_count; i++, node_ptr++) {
if (IS_NODE_ALLOCATED(node_ptr) &&
IS_NODE_NO_RESPOND(node_ptr) &&
!IS_NODE_POWER_SAVE(node_ptr) &&
(bit_test(suspend_node_bitmap, i) == 0) &&
(bit_test(resume_node_bitmap, i) == 0)) {
if (wake_node_bitmap == NULL) {
wake_node_bitmap =
bit_alloc(node_record_count);
}
bit_set(wake_node_bitmap, i);
}
}
if (wake_node_bitmap) {
char *nodes;
nodes = bitmap2node_name(wake_node_bitmap);
if (nodes) {
pid_t pid = _run_prog(resume_prog, nodes, NULL);
info("power_save: pid %d rewaking nodes %s",
(int) pid, nodes);
} else
error("power_save: bitmap2nodename");
xfree(nodes);
FREE_NULL_BITMAP(wake_node_bitmap);
}
}
static void _add_config_feature_inx(List feature_list, char *feature,
int node_inx)
{
node_feature_t *feature_ptr;
ListIterator feature_iter;
bool match = false;
/* If feature already in avail_feature_list, just update the bitmap */
feature_iter = list_iterator_create(feature_list);
while ((feature_ptr = (node_feature_t *) list_next(feature_iter))) {
if (strcmp(feature, feature_ptr->name))
continue;
bit_set(feature_ptr->node_bitmap, node_inx);
match = true;
break;
}
list_iterator_destroy(feature_iter);
if (!match) { /* Need to create new avail_feature_list record */
feature_ptr = xmalloc(sizeof(node_feature_t));
feature_ptr->magic = FEATURE_MAGIC;
feature_ptr->name = xstrdup(feature);
feature_ptr->node_bitmap = bit_alloc(node_record_count);
bit_set(feature_ptr->node_bitmap, node_inx);
list_append(feature_list, feature_ptr);
}
}
/*
* hostlist2bitmap - given a hostlist, build a bitmap representation
* IN hl - hostlist
* IN best_effort - if set don't return an error on invalid node name entries
* OUT bitmap - set to bitmap, may not have all bits set on error
* RET 0 if no error, otherwise EINVAL
*/
extern int hostlist2bitmap (hostlist_t hl, bool best_effort, bitstr_t **bitmap)
{
int rc = SLURM_SUCCESS;
bitstr_t *my_bitmap;
char *name;
hostlist_iterator_t hi;
FREE_NULL_BITMAP(*bitmap);
my_bitmap = (bitstr_t *) bit_alloc (node_record_count);
*bitmap = my_bitmap;
hi = hostlist_iterator_create(hl);
while ((name = hostlist_next(hi)) != NULL) {
struct node_record *node_ptr;
node_ptr = _find_node_record(name, best_effort, true);
if (node_ptr) {
bit_set (my_bitmap, (bitoff_t) (node_ptr -
node_record_table_ptr));
} else {
error ("hostlist2bitmap: invalid node specified %s",
name);
if (!best_effort)
rc = EINVAL;
}
free (name);
}
hostlist_iterator_destroy(hi);
return rc;
}
/*
* Given a pack group and task count, return a task_state structure
* Free memory using task_state_destroy()
*/
extern task_state_t task_state_create(uint32_t job_id, uint32_t step_id,
uint32_t pack_group, int ntasks)
{
task_state_t ts = xmalloc(sizeof(*ts));
/* ts is zero filled by xmalloc() */
ts->job_id = job_id;
ts->step_id = step_id;
ts->pack_group = pack_group;
ts->n_tasks = ntasks;
ts->running = bit_alloc(ntasks);
ts->start_failed = bit_alloc(ntasks);
ts->normal_exit = bit_alloc(ntasks);
ts->abnormal_exit = bit_alloc(ntasks);
return ts;
}
static node_subgrp_t *_create_subgrp(List subgrp_list, enum node_states state,
uint16_t size)
{
node_subgrp_t *subgrp = xmalloc(sizeof(node_subgrp_t));
subgrp->state = state;
subgrp->bitmap = bit_alloc(size);
list_append(subgrp_list, subgrp);
return subgrp;
}
/*
* Initialize our volume bitmap data structures
*/
int BitMapCheckBegin(SGlobPtr g)
{
Boolean isHFSPlus;
if (gBitMapInited)
return (0);
isHFSPlus = VolumeObjectIsHFSPlus( );
gFullBitmapSegment = (UInt32 *)malloc(kBytesPerSegment);
memset((void *)gFullBitmapSegment, 0xff, kBytesPerSegment);
gEmptyBitmapSegment = (UInt32 *)malloc(kBytesPerSegment);
memset((void *)gEmptyBitmapSegment, 0x00, kBytesPerSegment);
gTotalBits = g->calculatedVCB->vcbTotalBlocks;
gTotalSegments = (gTotalBits / kBitsPerSegment);
if (gTotalBits % kBitsPerSegment)
++gTotalSegments;
gFullSegmentList = bit_alloc(gTotalSegments);
bit_nclear(gFullSegmentList, 0, gTotalSegments - 1);
BMS_InitTree();
gBitMapInited = 1;
gBitsMarked = 0;
if (isHFSPlus) {
UInt16 alignBits;
/*
* Allocate the VolumeHeader in the volume bitmap.
* Since the VH is the 3rd sector in we may need to
* add some alignment allocation blocks before it.
*/
if (g->calculatedVCB->vcbBlockSize == 512)
alignBits = 2;
else if (g->calculatedVCB->vcbBlockSize == 1024)
alignBits = 1;
else
alignBits = 0;
(void) CaptureBitmapBits(0, 1 + alignBits);
if (g->calculatedVCB->vcbBlockSize == 512)
alignBits = 1;
else
alignBits = 0;
(void) CaptureBitmapBits(gTotalBits - 1 - alignBits, 1 + alignBits);
}
return (0);
}
/* Reset tabs to default, eight spaces apart. */
void
screen_reset_tabs(struct screen *s)
{
u_int i;
free(s->tabs);
if ((s->tabs = bit_alloc(screen_size_x(s))) == NULL)
fatal("bit_alloc failed");
for (i = 8; i < screen_size_x(s); i += 8)
bit_set(s->tabs, i);
}
/* Configure reserved ports.
* Call with mpi_params==NULL to free memory */
extern int reserve_port_config(char *mpi_params)
{
char *tmp_e=NULL, *tmp_p=NULL;
int i, p_min, p_max;
if (mpi_params)
tmp_p = strstr(mpi_params, "ports=");
if (tmp_p == NULL) {
if (port_resv_table) {
info("Clearing port reservations");
for (i=0; i<port_resv_cnt; i++)
FREE_NULL_BITMAP(port_resv_table[i]);
xfree(port_resv_table);
port_resv_cnt = 0;
port_resv_min = port_resv_max = 0;
}
return SLURM_SUCCESS;
}
tmp_p += 6;
p_min = strtol(tmp_p, &tmp_e, 10);
if ((p_min < 1) || (tmp_e[0] != '-')) {
info("invalid MpiParams: %s", mpi_params);
return SLURM_ERROR;
}
tmp_e++;
p_max = strtol(tmp_e, NULL, 10);
if (p_max < p_min) {
info("invalid MpiParams: %s", mpi_params);
return SLURM_ERROR;
}
if ((p_min == port_resv_min) && (p_max == port_resv_max)) {
_dump_resv_port_info();
return SLURM_SUCCESS; /* No change */
}
port_resv_min = p_min;
port_resv_max = p_max;
port_resv_cnt = p_max - p_min + 1;
debug("Ports available for reservation %u-%u",
port_resv_min, port_resv_max);
xfree(port_resv_table);
port_resv_table = xmalloc(sizeof(bitstr_t *) * port_resv_cnt);
for (i=0; i<port_resv_cnt; i++)
port_resv_table[i] = bit_alloc(node_record_count);
_make_all_resv();
_dump_resv_port_info();
return SLURM_SUCCESS;
}
int slurm_job_cpus_allocated_str_on_node_id(char *cpus,
size_t cpus_len,
job_resources_t *job_resrcs_ptr,
int node_id)
{
uint32_t threads = 1;
int inx = 0;
bitstr_t *cpu_bitmap;
int j, k, bit_inx, bit_reps, hi;
if (!job_resrcs_ptr || node_id < 0)
slurm_seterrno_ret(EINVAL);
/* find index in and first bit index in sock_core_rep_count[]
* for this node id */
bit_inx = 0;
hi = node_id + 1; /* change from 0-origin to 1-origin */
for (inx = 0; hi; inx++) {
if (hi > job_resrcs_ptr->sock_core_rep_count[inx]) {
bit_inx += job_resrcs_ptr->sockets_per_node[inx] *
job_resrcs_ptr->cores_per_socket[inx] *
job_resrcs_ptr->sock_core_rep_count[inx];
hi -= job_resrcs_ptr->sock_core_rep_count[inx];
} else {
bit_inx += job_resrcs_ptr->sockets_per_node[inx] *
job_resrcs_ptr->cores_per_socket[inx] *
(hi - 1);
break;
}
}
bit_reps = job_resrcs_ptr->sockets_per_node[inx] *
job_resrcs_ptr->cores_per_socket[inx];
/* get the number of threads per core on this node
*/
if (job_node_ptr)
threads = job_node_ptr->node_array[node_id].threads;
cpu_bitmap = bit_alloc(bit_reps * threads);
for (j = 0; j < bit_reps; j++) {
if (bit_test(job_resrcs_ptr->core_bitmap, bit_inx)){
for (k = 0; k < threads; k++)
bit_set(cpu_bitmap,
(j * threads) + k);
}
bit_inx++;
}
bit_fmt(cpus, cpus_len, cpu_bitmap);
FREE_NULL_BITMAP(cpu_bitmap);
return SLURM_SUCCESS;
}
/* power_job_reboot - Reboot compute nodes for a job from the head node */
extern int power_job_reboot(struct job_record *job_ptr)
{
int rc = SLURM_SUCCESS;
int i, i_first, i_last;
struct node_record *node_ptr;
bitstr_t *wake_node_bitmap = NULL;
time_t now = time(NULL);
char *nodes, *features = NULL;
wake_node_bitmap = bit_alloc(node_record_count);
i_first = bit_ffs(job_ptr->node_bitmap);
i_last = bit_fls(job_ptr->node_bitmap);
for (i = i_first; i <= i_last; i++) {
if (!bit_test(job_ptr->node_bitmap, i))
continue;
node_ptr = node_record_table_ptr + i;
resume_cnt++;
resume_cnt_f++;
node_ptr->node_state &= (~NODE_STATE_POWER_SAVE);
node_ptr->node_state |= NODE_STATE_POWER_UP;
node_ptr->node_state |= NODE_STATE_NO_RESPOND;
bit_clear(power_node_bitmap, i);
bit_clear(avail_node_bitmap, i);
node_ptr->last_response = now + resume_timeout;
bit_set(wake_node_bitmap, i);
bit_set(resume_node_bitmap, i);
}
nodes = bitmap2node_name(wake_node_bitmap);
if (nodes) {
#if _DEBUG
info("power_save: reboot nodes %s", nodes);
#else
verbose("power_save: reboot nodes %s", nodes);
#endif
if (job_ptr->details && job_ptr->details->features)
features = xlate_features(job_ptr->details->features);
_run_prog(resume_prog, nodes, features);
xfree(features);
} else {
error("power_save: bitmap2nodename");
rc = SLURM_ERROR;
}
xfree(nodes);
FREE_NULL_BITMAP(wake_node_bitmap);
last_node_update = now;
return rc;
}
int slurm_job_cpus_allocated_str_on_node_id(char *cpus,
size_t cpus_len,
job_resources_t *job_resrcs_ptr,
int node_id)
{
int start_node = -1; /* start with -1 less so the array reps
* lines up correctly */
uint32_t threads = 1;
int inx = 0;
bitstr_t *cpu_bitmap;
int j, k, bit_inx, bit_reps;
if (!job_resrcs_ptr || node_id < 0)
slurm_seterrno_ret(EINVAL);
/* find index in sock_core_rep_count[] for this node id
*/
do {
start_node += job_resrcs_ptr->sock_core_rep_count[inx];
inx++;
} while (start_node < node_id);
/* back to previous index since inx is always one step further
* after previous loop
*/
inx--;
bit_reps = job_resrcs_ptr->sockets_per_node[inx] *
job_resrcs_ptr->cores_per_socket[inx];
/* get the number of threads per core on this node
*/
if (job_node_ptr)
threads = job_node_ptr->node_array[node_id].threads;
bit_inx = 0;
cpu_bitmap = bit_alloc(bit_reps * threads);
for (j = 0; j < bit_reps; j++) {
if (bit_test(job_resrcs_ptr->core_bitmap, bit_inx)){
for (k = 0; k < threads; k++)
bit_set(cpu_bitmap,
(j * threads) + k);
}
bit_inx++;
}
bit_fmt(cpus, cpus_len, cpu_bitmap);
FREE_NULL_BITMAP(cpu_bitmap);
return SLURM_SUCCESS;
}
static void _state_read_buf(Buf buffer)
{
uint16_t protocol_version = (uint16_t) NO_VAL;
uint32_t min_port, max_port;
int i;
/* Validate state version */
safe_unpack16(&protocol_version, buffer);
debug3("Version in switch_cray header is %u", protocol_version);
if (protocol_version < SLURM_MIN_PROTOCOL_VERSION) {
error("******************************************************");
error("Can't recover switch/cray state, incompatible version");
error("******************************************************");
return;
}
if (protocol_version >= SLURM_14_11_PROTOCOL_VERSION) {
safe_unpack32(&min_port, buffer);
safe_unpack32(&max_port, buffer);
safe_unpack32(&last_alloc_port, buffer);
unpack_bit_str(&port_resv, buffer);
} else if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
uint8_t port_set = 0;
safe_unpack32(&min_port, buffer);
safe_unpack32(&max_port, buffer);
safe_unpack32(&last_alloc_port, buffer);
port_resv = bit_alloc(PORT_CNT);
for (i = 0; i < PORT_CNT; i++) {
safe_unpack8(&port_set, buffer);
if (port_set)
bit_set(port_resv, i);
}
}
if ((min_port != MIN_PORT) || (max_port != MAX_PORT)) {
error("******************************************************");
error("Can not recover switch/cray state");
error("Changed MIN_PORT (%u != %u) and/or MAX_PORT (%u != %u)",
min_port, MIN_PORT, max_port, MAX_PORT);
error("******************************************************");
return;
}
return;
unpack_error:
CRAY_ERR("unpack error");
return;
}
/* Return a bitmap the size of the machine in cores. On a Bluegene
* system it will return a bitmap in cnodes. */
extern bitstr_t *cr_create_cluster_core_bitmap(int core_mult)
{
/* DEF_TIMERS; */
/* START_TIMER; */
bitstr_t *core_bitmap;
static int cnt = 0;
if (!cnt) {
cnt = cr_get_coremap_offset(node_record_count);
if (core_mult)
cnt *= core_mult;
}
core_bitmap = bit_alloc(cnt);
/* END_TIMER; */
/* info("creating of core bitmap of %d took %s", cnt, TIME_STR); */
return core_bitmap;
}
/*
* _node_name2bitmap - given a node name regular expression, build a bitmap
* representation, any invalid hostnames are added to a hostlist
* IN node_names - set of node namess
* OUT bitmap - set to bitmap, may not have all bits set on error
* IN/OUT invalid_hostlist - hostlist of invalid host names, initialize to NULL
* RET 0 if no error, otherwise EINVAL
* NOTE: call FREE_NULL_BITMAP(bitmap) and hostlist_destroy(invalid_hostlist)
* to free memory when variables are no longer required
*/
static int _node_name2bitmap(char *node_names, bitstr_t **bitmap,
hostlist_t *invalid_hostlist)
{
char *this_node_name;
bitstr_t *my_bitmap;
hostlist_t host_list;
my_bitmap = (bitstr_t *) bit_alloc(node_record_count);
*bitmap = my_bitmap;
if (node_names == NULL) {
error("_node_name2bitmap: node_names is NULL");
return EINVAL;
}
if ( (host_list = hostlist_create(node_names)) == NULL) {
/* likely a badly formatted hostlist */
error("_node_name2bitmap: hostlist_create(%s) error",
node_names);
return EINVAL;
}
while ( (this_node_name = hostlist_shift(host_list)) ) {
struct node_record *node_ptr;
node_ptr = find_node_record(this_node_name);
if (node_ptr) {
bit_set(my_bitmap,
(bitoff_t) (node_ptr - node_record_table_ptr));
} else {
debug2("_node_name2bitmap: invalid node specified %s",
this_node_name);
if (*invalid_hostlist) {
hostlist_push_host(*invalid_hostlist,
this_node_name);
} else {
*invalid_hostlist =
hostlist_create(this_node_name);
}
}
free (this_node_name);
}
hostlist_destroy(host_list);
return SLURM_SUCCESS;
}
/* Return a copy of core_bitmap only for the specific node */
extern bitstr_t * copy_job_resources_node(job_resources_t *job_resrcs_ptr,
uint32_t node_id)
{
int i, bit_inx = 0, core_cnt = 0;
bitstr_t *core_bitmap;
xassert(job_resrcs_ptr);
for (i = 0; i < job_resrcs_ptr->nhosts; i++) {
if (job_resrcs_ptr->sock_core_rep_count[i] <= node_id) {
bit_inx += job_resrcs_ptr->sockets_per_node[i] *
job_resrcs_ptr->cores_per_socket[i] *
job_resrcs_ptr->sock_core_rep_count[i];
node_id -= job_resrcs_ptr->sock_core_rep_count[i];
} else {
bit_inx += job_resrcs_ptr->sockets_per_node[i] *
job_resrcs_ptr->cores_per_socket[i] *
node_id;
core_cnt = job_resrcs_ptr->sockets_per_node[i] *
job_resrcs_ptr->cores_per_socket[i];
break;
}
}
if (core_cnt < 1) {
error("copy_job_resources_node: core_cnt=0");
return NULL;
}
i = bit_size(job_resrcs_ptr->core_bitmap);
if ((bit_inx + core_cnt) > i) {
error("copy_job_resources_node: offset > bitmap size "
"(%d >= %d)", (bit_inx + core_cnt), i);
return NULL;
}
core_bitmap = bit_alloc(core_cnt);
if (!core_bitmap)
fatal("copy_job_resources_node: bit_alloc(%d): %m", core_cnt);
for (i = 0; i < core_cnt; i++) {
if (bit_test(job_resrcs_ptr->core_bitmap, bit_inx++))
bit_set(core_bitmap, i);
}
return core_bitmap;
}
/*
* node_name2bitmap - given a node name regular expression, build a bitmap
* representation
* IN node_names - list of nodes
* IN best_effort - if set don't return an error on invalid node name entries
* OUT bitmap - set to bitmap, may not have all bits set on error
* RET 0 if no error, otherwise EINVAL
* NOTE: call FREE_NULL_BITMAP() to free bitmap memory when no longer required
*/
extern int node_name2bitmap (char *node_names, bool best_effort,
bitstr_t **bitmap)
{
int rc = SLURM_SUCCESS;
char *this_node_name;
bitstr_t *my_bitmap;
hostlist_t host_list;
my_bitmap = (bitstr_t *) bit_alloc (node_record_count);
if (my_bitmap == NULL)
fatal("bit_alloc malloc failure");
*bitmap = my_bitmap;
if (node_names == NULL) {
info("node_name2bitmap: node_names is NULL");
return rc;
}
if ( (host_list = hostlist_create (node_names)) == NULL) {
/* likely a badly formatted hostlist */
error ("hostlist_create on %s error:", node_names);
if (!best_effort)
rc = EINVAL;
return rc;
}
while ( (this_node_name = hostlist_shift (host_list)) ) {
struct node_record *node_ptr;
node_ptr = find_node_record (this_node_name);
if (node_ptr) {
bit_set (my_bitmap, (bitoff_t) (node_ptr -
node_record_table_ptr));
} else {
error ("node_name2bitmap: invalid node specified %s",
this_node_name);
if (!best_effort)
rc = EINVAL;
}
free (this_node_name);
}
hostlist_destroy (host_list);
return rc;
}
/* Convert an array of task IDs into a string.
* RET: the string, caller must xfree() this value
* NOTE: the taskids array is not necessarily in numeric order,
* so we use existing bitmap functions to format */
static char *_task_array_to_string(int ntasks, uint32_t taskids[])
{
bitstr_t *tasks_bitmap = NULL;
char *str;
int i;
tasks_bitmap = bit_alloc(local_srun_job->ntasks);
if (!tasks_bitmap) {
error("bit_alloc: memory allocation failure");
exit(error_exit);
}
for (i=0; i<ntasks; i++)
bit_set(tasks_bitmap, taskids[i]);
str = xmalloc(2048);
bit_fmt(str, 2048, tasks_bitmap);
FREE_NULL_BITMAP(tasks_bitmap);
return str;
}
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;
}
/*
* _lllp_map_abstract_mask
*
* Map one abstract block mask to a physical machine mask
*
* IN - mask to map
* OUT - mapped mask (storage allocated in this routine)
*/
static bitstr_t *_lllp_map_abstract_mask(bitstr_t *bitmask)
{
int i, bit;
int num_bits = bit_size(bitmask);
bitstr_t *newmask = NULL;
newmask = (bitstr_t *) bit_alloc(num_bits);
/* remap to physical machine */
for (i = 0; i < num_bits; i++) {
if (bit_test(bitmask,i)) {
bit = BLOCK_MAP(i);
if (bit < bit_size(newmask))
bit_set(newmask, bit);
else
error("%s: can't go from %d -> %d since we "
"only have %"BITSTR_FMT" bits",
__func__, i, bit, bit_size(newmask));
}
}
return newmask;
}
