/* updates the burst buffer record on sview */ static void _update_bb_record(sview_bb_info_t *sview_bb_info_ptr, GtkTreeStore *treestore) { char tmp_create_time[40]; char tmp_size[20], tmp_user_id[60], bb_name_id[32]; char *tmp_state, *tmp_user_name; burst_buffer_resv_t *bb_ptr = sview_bb_info_ptr->bb_ptr; if (bb_ptr->name) { strncpy(bb_name_id, bb_ptr->name, sizeof(bb_name_id)); } else if (bb_ptr->array_task_id == NO_VAL) { convert_num_unit(bb_ptr->job_id, bb_name_id, sizeof(bb_name_id), UNIT_NONE, working_sview_config.convert_flags); } else { snprintf(bb_name_id, sizeof(bb_name_id), "%u_%u(%u)", bb_ptr->array_job_id, bb_ptr->array_task_id, bb_ptr->job_id); } if (bb_ptr->create_time) { slurm_make_time_str((time_t *)&bb_ptr->create_time, tmp_create_time, sizeof(tmp_create_time)); } else { time_t now = time(NULL); slurm_make_time_str(&now, tmp_create_time, sizeof(tmp_create_time)); } _get_size_str(tmp_size, sizeof(tmp_size), bb_ptr->size); tmp_state = bb_state_string(bb_ptr->state); tmp_user_name = uid_to_string(bb_ptr->user_id); snprintf(tmp_user_id, sizeof(tmp_user_id), "%s(%u)", tmp_user_name, bb_ptr->user_id); xfree(tmp_user_name); /* Combining these records provides a slight performance improvement */ gtk_tree_store_set(treestore, &sview_bb_info_ptr->iter_ptr, SORTID_COLOR, sview_colors[sview_bb_info_ptr->color_inx], SORTID_COLOR_INX, sview_bb_info_ptr->color_inx, SORTID_PLUGIN, sview_bb_info_ptr->plugin, SORTID_ACCOUNT, bb_ptr->account, SORTID_CREATE_TIME, tmp_create_time, SORTID_NAME, bb_name_id, SORTID_PARTITION, bb_ptr->partition, SORTID_POOL, bb_ptr->pool, SORTID_QOS, bb_ptr->qos, SORTID_SIZE, tmp_size, SORTID_STATE, tmp_state, SORTID_UPDATED, 1, SORTID_USERID, tmp_user_id, -1); return; }
static void _print_burst_buffer_resv(FILE *out, burst_buffer_resv_t* burst_buffer_ptr, int one_liner, bool verbose) { char sz_buf[32], time_buf[64], tmp_line[512]; char *out_buf = NULL; /****** Line 1 ******/ if (burst_buffer_ptr->job_id && (burst_buffer_ptr->array_task_id == NO_VAL)) { snprintf(tmp_line, sizeof(tmp_line), " JobID=%u ", burst_buffer_ptr->job_id); } else if (burst_buffer_ptr->job_id) { snprintf(tmp_line, sizeof(tmp_line), " JobID=%u_%u(%u) ", burst_buffer_ptr->array_job_id, burst_buffer_ptr->array_task_id, burst_buffer_ptr->job_id); } else { snprintf(tmp_line, sizeof(tmp_line), " Name=%s ", burst_buffer_ptr->name); } xstrcat(out_buf, tmp_line); _get_size_str(sz_buf, sizeof(sz_buf), burst_buffer_ptr->size); if (burst_buffer_ptr->create_time) { slurm_make_time_str(&burst_buffer_ptr->create_time, time_buf, sizeof(time_buf)); } else { time_t now = time(NULL); slurm_make_time_str(&now, time_buf, sizeof(time_buf)); } if (verbose) { snprintf(tmp_line, sizeof(tmp_line), "Account=%s CreateTime=%s Partition=%s Pool=%s QOS=%s " "Size=%s State=%s UserID=%s(%u)", burst_buffer_ptr->account, time_buf, burst_buffer_ptr->partition, burst_buffer_ptr->pool, burst_buffer_ptr->qos, sz_buf, bb_state_string(burst_buffer_ptr->state), uid_to_string(burst_buffer_ptr->user_id), burst_buffer_ptr->user_id); } else { snprintf(tmp_line, sizeof(tmp_line), "CreateTime=%s Pool=%s Size=%s State=%s UserID=%s(%u)", time_buf, burst_buffer_ptr->pool, sz_buf, bb_state_string(burst_buffer_ptr->state), uid_to_string(burst_buffer_ptr->user_id), burst_buffer_ptr->user_id); } xstrcat(out_buf, tmp_line); xstrcat(out_buf, "\n"); fprintf(out, "%s", out_buf); xfree(out_buf); }
/* Log recousrces to be allocated to a pending job */ static void _dump_job_sched(struct job_record *job_ptr, time_t end_time, bitstr_t *avail_bitmap) { char begin_buf[32], end_buf[32], *node_list; slurm_make_time_str(&job_ptr->start_time, begin_buf, sizeof(begin_buf)); slurm_make_time_str(&end_time, end_buf, sizeof(end_buf)); node_list = bitmap2node_name(avail_bitmap); info("Job %u to start at %s, end at %s on %s", job_ptr->job_id, begin_buf, end_buf, node_list); xfree(node_list); }
/* * slurm_print_slurmd_status - output the contents of slurmd status * message as loaded using slurm_load_slurmd_status * IN out - file to write to * IN slurmd_status_ptr - slurmd status pointer */ void slurm_print_slurmd_status (FILE* out, slurmd_status_t * slurmd_status_ptr) { char time_str[32]; if (slurmd_status_ptr == NULL ) return ; fprintf(out, "Active Steps = %s\n", slurmd_status_ptr->step_list); fprintf(out, "Actual CPUs = %u\n", slurmd_status_ptr->actual_cpus); fprintf(out, "Actual Boards = %u\n", slurmd_status_ptr->actual_boards); fprintf(out, "Actual sockets = %u\n", slurmd_status_ptr->actual_sockets); fprintf(out, "Actual cores = %u\n", slurmd_status_ptr->actual_cores); fprintf(out, "Actual threads per core = %u\n", slurmd_status_ptr->actual_threads); fprintf(out, "Actual real memory = %u MB\n", slurmd_status_ptr->actual_real_mem); fprintf(out, "Actual temp disk space = %u MB\n", slurmd_status_ptr->actual_tmp_disk); slurm_make_time_str ((time_t *)&slurmd_status_ptr->booted, time_str, sizeof(time_str)); fprintf(out, "Boot time = %s\n", time_str); fprintf(out, "Hostname = %s\n", slurmd_status_ptr->hostname); if (slurmd_status_ptr->last_slurmctld_msg) { slurm_make_time_str ((time_t *) &slurmd_status_ptr->last_slurmctld_msg, time_str, sizeof(time_str)); fprintf(out, "Last slurmctld msg time = %s\n", time_str); } else fprintf(out, "Last slurmctld msg time = NONE\n"); fprintf(out, "Slurmd PID = %u\n", slurmd_status_ptr->pid); fprintf(out, "Slurmd Debug = %u\n", slurmd_status_ptr->slurmd_debug); fprintf(out, "Slurmd Logfile = %s\n", slurmd_status_ptr->slurmd_logfile); fprintf(out, "Version = %s\n", slurmd_status_ptr->version); return; }
/* * slurm_sprint_reservation_info - output information about a specific Slurm * reservation based upon message as loaded using slurm_load_reservations * IN resv_ptr - an individual reservation information record pointer * IN one_liner - print as a single line if true * RET out - char * containing formatted output (must be freed after call) * NULL is returned on failure. */ char *slurm_sprint_reservation_info ( reserve_info_t * resv_ptr, int one_liner ) { char tmp1[32], tmp2[32], tmp3[32], *flag_str = NULL; char tmp_line[MAXHOSTRANGELEN]; char *out = NULL; uint32_t duration; /****** Line 1 ******/ slurm_make_time_str(&resv_ptr->start_time, tmp1, sizeof(tmp1)); slurm_make_time_str(&resv_ptr->end_time, tmp2, sizeof(tmp2)); duration = difftime(resv_ptr->end_time, resv_ptr->start_time); secs2time_str(duration, tmp3, sizeof(tmp3)); snprintf(tmp_line, sizeof(tmp_line), "ReservationName=%s StartTime=%s EndTime=%s Duration=%s", resv_ptr->name, tmp1, tmp2, tmp3); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 2 ******/ flag_str = reservation_flags_string(resv_ptr->flags); snprintf(tmp_line, sizeof(tmp_line), "Nodes=%s NodeCnt=%u Features=%s PartitionName=%s Flags=%s", resv_ptr->node_list, resv_ptr->node_cnt, resv_ptr->features, resv_ptr->partition, flag_str); xfree(flag_str); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 3 ******/ snprintf(tmp_line, sizeof(tmp_line), "Users=%s Accounts=%s Licenses=%s", resv_ptr->users, resv_ptr->accounts, resv_ptr->licenses); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, "\n"); else xstrcat(out, "\n\n"); return out; }
/* * slurm_job_will_run - determine if a job would execute immediately if * submitted now * IN job_desc_msg - description of resource allocation request * RET 0 on success, otherwise return -1 and set errno to indicate the error */ int slurm_job_will_run(job_desc_msg_t *req) { will_run_response_msg_t *will_run_resp = NULL; char buf[64], local_hostname[64]; int rc; uint32_t cluster_flags = slurmdb_setup_cluster_flags(); char *type = "processors"; char *cluster_name = NULL; void *ptr = NULL; if ((req->alloc_node == NULL) && (gethostname_short(local_hostname, sizeof(local_hostname)) == 0)) { req->alloc_node = local_hostname; } if (working_cluster_rec) cluster_name = working_cluster_rec->name; else cluster_name = slurmctld_conf.cluster_name; if (!slurm_load_federation(&ptr) && cluster_in_federation(ptr, cluster_name)) rc = _fed_job_will_run(req, &will_run_resp, ptr); else rc = slurm_job_will_run2(req, &will_run_resp); if ((rc == 0) && will_run_resp) { if (cluster_flags & CLUSTER_FLAG_BG) type = "cnodes"; slurm_make_time_str(&will_run_resp->start_time, buf, sizeof(buf)); info("Job %u to start at %s using %u %s on %s", will_run_resp->job_id, buf, will_run_resp->proc_cnt, type, will_run_resp->node_list); if (will_run_resp->preemptee_job_id) { ListIterator itr; uint32_t *job_id_ptr; char *job_list = NULL, *sep = ""; itr = list_iterator_create(will_run_resp-> preemptee_job_id); while ((job_id_ptr = list_next(itr))) { if (job_list) sep = ","; xstrfmtcat(job_list, "%s%u", sep, *job_id_ptr); } list_iterator_destroy(itr); info(" Preempts: %s", job_list); xfree(job_list); } slurm_free_will_run_response_msg(will_run_resp); } if (req->alloc_node == local_hostname) req->alloc_node = NULL; if (ptr) slurm_destroy_federation_rec(ptr); return rc; }
/* * slurm_print_ctl_conf - output the contents of slurm control configuration * message as loaded using slurm_load_ctl_conf * IN out - file to write to * IN slurm_ctl_conf_ptr - slurm control configuration pointer */ void slurm_print_ctl_conf ( FILE* out, slurm_ctl_conf_info_msg_t * slurm_ctl_conf_ptr ) { char time_str[32], tmp_str[128]; void *ret_list = NULL; char *select_title = ""; uint32_t cluster_flags = slurmdb_setup_cluster_flags(); if (cluster_flags & CLUSTER_FLAG_BGL) select_title = "\nBluegene/L configuration\n"; else if (cluster_flags & CLUSTER_FLAG_BGP) select_title = "\nBluegene/P configuration\n"; else if (cluster_flags & CLUSTER_FLAG_BGQ) select_title = "\nBluegene/Q configuration\n"; if ( slurm_ctl_conf_ptr == NULL ) return ; slurm_make_time_str((time_t *)&slurm_ctl_conf_ptr->last_update, time_str, sizeof(time_str)); snprintf(tmp_str, sizeof(tmp_str), "Configuration data as of %s\n", time_str); ret_list = slurm_ctl_conf_2_key_pairs(slurm_ctl_conf_ptr); if (ret_list) { slurm_print_key_pairs(out, ret_list, tmp_str); list_destroy((List)ret_list); } slurm_print_key_pairs(out, slurm_ctl_conf_ptr->select_conf_key_pairs, select_title); }
static void _print_slurm_config(void) { time_t now = time(NULL); char tmp_str[128], *user_name = NULL; slurm_make_time_str(&now, tmp_str, sizeof(tmp_str)); printf("Configuration data as of %s\n", tmp_str); printf("AccountingStorageBackupHost = %s\n", acct_storage_backup_host); printf("AccountingStorageHost = %s\n", acct_storage_host); printf("AccountingStorageLoc = %s\n", acct_storage_loc); printf("AccountingStoragePass = %s\n", acct_storage_pass); printf("AccountingStoragePort = %u\n", acct_storage_port); printf("AccountingStorageType = %s\n", acct_storage_type); printf("AccountingStorageUser = %s\n", acct_storage_user); printf("AuthType = %s\n", auth_type); printf("MessageTimeout = %u sec\n", msg_timeout); printf("PluginDir = %s\n", plugin_dir); private_data_string(private_data, tmp_str, sizeof(tmp_str)); printf("PrivateData = %s\n", tmp_str); user_name = uid_to_string(slurm_user_id); printf("SlurmUserId = %s(%u)\n", user_name, slurm_user_id); xfree(user_name); printf("SLURM_CONF = %s\n", default_slurm_config_file); printf("SLURM_VERSION = %s\n", SLURM_VERSION_STRING); printf("TrackWCKey = %u\n", track_wckey); }
extern uint16_t scontrol_get_job_state(uint32_t job_id) { job_info_msg_t * job_buffer_ptr = NULL; int error_code = SLURM_SUCCESS, i; job_info_t *job_ptr = NULL; error_code = scontrol_load_job(&job_buffer_ptr, job_id); if (error_code) { exit_code = 1; if (quiet_flag == -1) slurm_perror ("slurm_load_job error"); return (uint16_t) NO_VAL; } if (quiet_flag == -1) { char time_str[32]; slurm_make_time_str((time_t *)&job_buffer_ptr->last_update, time_str, sizeof(time_str)); printf("last_update_time=%s, records=%d\n", time_str, job_buffer_ptr->record_count); } job_ptr = job_buffer_ptr->job_array ; for (i = 0; i < job_buffer_ptr->record_count; i++) { if (job_ptr->job_id == job_id) return job_ptr->job_state; } if (quiet_flag == -1) printf("Could not find job %u", job_id); return (uint16_t) NO_VAL; }
static void _update_resv_record(sview_resv_info_t *sview_resv_info_ptr, GtkTreeStore *treestore) { char tmp_duration[40], tmp_end[40], tmp_nodes[40], tmp_start[40]; char *tmp_flags; reserve_info_t *resv_ptr = sview_resv_info_ptr->resv_ptr; secs2time_str((uint32_t)difftime(resv_ptr->end_time, resv_ptr->start_time), tmp_duration, sizeof(tmp_duration)); slurm_make_time_str((time_t *)&resv_ptr->end_time, tmp_end, sizeof(tmp_end)); tmp_flags = reservation_flags_string(resv_ptr->flags); convert_num_unit((float)resv_ptr->node_cnt, tmp_nodes, sizeof(tmp_nodes), UNIT_NONE); slurm_make_time_str((time_t *)&resv_ptr->start_time, tmp_start, sizeof(tmp_start)); /* Combining these records provides a slight performance improvement */ gtk_tree_store_set(treestore, &sview_resv_info_ptr->iter_ptr, SORTID_ACCOUNTS, resv_ptr->accounts, SORTID_COLOR, sview_colors[sview_resv_info_ptr->color_inx], SORTID_COLOR_INX, sview_resv_info_ptr->color_inx, SORTID_DURATION, tmp_duration, SORTID_FEATURES, resv_ptr->features, SORTID_FLAGS, tmp_flags, SORTID_LICENSES, resv_ptr->licenses, SORTID_NAME, resv_ptr->name, SORTID_NODE_CNT, tmp_nodes, SORTID_NODE_INX, resv_ptr->node_inx, SORTID_NODELIST, resv_ptr->node_list, SORTID_PARTITION, resv_ptr->partition, SORTID_TIME_START, tmp_start, SORTID_TIME_END, tmp_end, SORTID_UPDATED, 1, SORTID_USERS, resv_ptr->users, -1); xfree(tmp_flags); return; }
/* * scontrol_print_node_list - print information about the supplied node list * (or regular expression) * IN node_list - print information about the supplied node list * (or regular expression) */ extern void scontrol_print_node_list (char *node_list) { node_info_msg_t *node_info_ptr = NULL; hostlist_t host_list; int error_code; uint16_t show_flags = 0; char *this_node_name; if (all_flag) show_flags |= SHOW_ALL; if (detail_flag) show_flags |= SHOW_DETAIL; error_code = scontrol_load_nodes(&node_info_ptr, show_flags); if (error_code) { exit_code = 1; if (quiet_flag != 1) slurm_perror ("slurm_load_node error"); return; } if (quiet_flag == -1) { char time_str[32]; slurm_make_time_str ((time_t *)&node_info_ptr->last_update, time_str, sizeof(time_str)); printf ("last_update_time=%s, records=%d\n", time_str, node_info_ptr->record_count); } if (node_list == NULL) { scontrol_print_node (NULL, node_info_ptr); } else { if ((host_list = hostlist_create (node_list))) { while ((this_node_name = hostlist_shift (host_list))) { scontrol_print_node(this_node_name, node_info_ptr); free(this_node_name); } hostlist_destroy(host_list); } else { exit_code = 1; if (quiet_flag != 1) { if (errno == EINVAL) { fprintf(stderr, "unable to parse node list %s\n", node_list); } else if (errno == ERANGE) { fprintf(stderr, "too many nodes in supplied range %s\n", node_list); } else perror("error parsing node list"); } } } return; }
/* * scontrol_print_job - print the specified job's information * IN job_id - job's id or NULL to print information about all jobs */ extern void scontrol_print_job (char * job_id_str) { int error_code = SLURM_SUCCESS, i, print_cnt = 0; uint32_t job_id = 0; uint16_t array_id = (uint16_t) NO_VAL; job_info_msg_t * job_buffer_ptr = NULL; job_info_t *job_ptr = NULL; char *end_ptr = NULL; if (job_id_str) { job_id = (uint32_t) strtol (job_id_str, &end_ptr, 10); if (end_ptr[0] == '_') array_id = strtol( end_ptr + 1, &end_ptr, 10 ); } error_code = scontrol_load_job(&job_buffer_ptr, job_id); if (error_code) { exit_code = 1; if (quiet_flag != 1) slurm_perror ("slurm_load_jobs error"); return; } if (quiet_flag == -1) { char time_str[32]; slurm_make_time_str ((time_t *)&job_buffer_ptr->last_update, time_str, sizeof(time_str)); printf ("last_update_time=%s, records=%d\n", time_str, job_buffer_ptr->record_count); } job_ptr = job_buffer_ptr->job_array ; for (i = 0, job_ptr = job_buffer_ptr->job_array; i < job_buffer_ptr->record_count; i++, job_ptr++) { if ((array_id != (uint16_t) NO_VAL) && (array_id != job_ptr->array_task_id)) continue; slurm_print_job_info(stdout, job_ptr, one_liner); print_cnt++; } if (print_cnt == 0) { if (job_id_str) { exit_code = 1; if (quiet_flag != 1) { if (array_id == (uint16_t) NO_VAL) { printf("Job %u not found\n", job_id); } else { printf("Job %u_%u not found\n", job_id, array_id); } } } else if (quiet_flag != 1) printf ("No jobs in the system\n"); } }
static void _handle_timeout(srun_timeout_msg_t *timeout_msg) { time_t now = time(NULL); char time_str[24]; if (now < timeout_msg->timeout) { slurm_make_time_str(&timeout_msg->timeout, time_str, sizeof(time_str)); debug("step %u.%u will timeout at %s", timeout_msg->job_id, timeout_msg->step_id, time_str); return; } slurm_make_time_str(&now, time_str, sizeof(time_str)); error("*** STEP %u.%u CANCELLED AT %s DUE TO TIME LIMIT ***", timeout_msg->job_id, timeout_msg->step_id, time_str); launch_p_fwd_signal(SIGKILL); return; }
int _print_time(time_t t, int level, int width, bool right) { if (t) { char time_str[32]; slurm_make_time_str(&t, time_str, sizeof(time_str)); _print_str(time_str, width, right, true); } else _print_str("N/A", width, right, true); return SLURM_SUCCESS; }
static void _layout_conf_ctl(GtkTreeStore *treestore, slurm_ctl_conf_info_msg_t *slurm_ctl_conf_ptr) { char temp_str[128]; int update = 0; GtkTreeIter iter; ListIterator itr = NULL; config_key_pair_t *key_pair; List ret_list = NULL; char *select_title = ""; if (cluster_flags & CLUSTER_FLAG_BGL) select_title = "Bluegene/L configuration"; else if (cluster_flags & CLUSTER_FLAG_BGP) select_title = "Bluegene/P configuration"; else if (cluster_flags & CLUSTER_FLAG_BGQ) select_title = "Bluegene/Q configuration"; if (!slurm_ctl_conf_ptr) return; slurm_make_time_str((time_t *)&slurm_ctl_conf_ptr->last_update, temp_str, sizeof(temp_str)); add_display_treestore_line_with_font( update, treestore, &iter, "Configuration data as of", temp_str, "bold"); ret_list = slurm_ctl_conf_2_key_pairs(slurm_ctl_conf_ptr); if (ret_list) { itr = list_iterator_create(ret_list); while ((key_pair = list_next(itr))) { add_display_treestore_line(update, treestore, &iter, key_pair->name, key_pair->value); } list_iterator_destroy(itr); list_destroy(ret_list); } if (!slurm_ctl_conf_ptr->select_conf_key_pairs) return; add_display_treestore_line(update, treestore, &iter, "", NULL); add_display_treestore_line_with_font(update, treestore, &iter, select_title, NULL, "bold"); itr = list_iterator_create( (List)slurm_ctl_conf_ptr->select_conf_key_pairs); while ((key_pair = list_next(itr))) { add_display_treestore_line(update, treestore, &iter, key_pair->name, key_pair->value); } list_iterator_destroy(itr); }
/* Log resource allocate table */ static void _dump_node_space_table(node_space_map_t *node_space_ptr) { int i = 0; char begin_buf[32], end_buf[32], *node_list; info("========================================="); while (1) { slurm_make_time_str(&node_space_ptr[i].begin_time, begin_buf, sizeof(begin_buf)); slurm_make_time_str(&node_space_ptr[i].end_time, end_buf, sizeof(end_buf)); node_list = bitmap2node_name(node_space_ptr[i].avail_bitmap); info("Begin:%s End:%s Nodes:%s", begin_buf, end_buf, node_list); xfree(node_list); if ((i = node_space_ptr[i].next) == 0) break; } info("========================================="); }
static void *_monitor(void *arg) { stepd_step_rec_t *job = (stepd_step_rec_t *)arg; struct timespec ts = {0, 0}; int rc; debug2("step_terminate_monitor will run for %d secs", timeout); ts.tv_sec = time(NULL) + 1 + timeout; slurm_mutex_lock(&lock); if (stop_flag) goto done; rc = pthread_cond_timedwait(&cond, &lock, &ts); if (rc == ETIMEDOUT) { char entity[24], time_str[24]; time_t now = time(NULL); int rc; _call_external_program(job); if (job->stepid == SLURM_BATCH_SCRIPT) { snprintf(entity, sizeof(entity), "JOB %u", job->jobid); } else if (job->stepid == SLURM_EXTERN_CONT) { snprintf(entity, sizeof(entity), "EXTERN STEP FOR %u", job->jobid); } else { snprintf(entity, sizeof(entity), "STEP %u.%u", job->jobid, job->stepid); } slurm_make_time_str(&now, time_str, sizeof(time_str)); if (job->state < SLURMSTEPD_STEP_RUNNING) { error("*** %s STEPD TERMINATED ON %s AT %s DUE TO JOB NOT RUNNING ***", entity, job->node_name, time_str); rc = ESLURMD_JOB_NOTRUNNING; } else { error("*** %s STEPD TERMINATED ON %s AT %s DUE TO JOB NOT ENDING WITH SIGNALS ***", entity, job->node_name, time_str); rc = ESLURMD_KILL_TASK_FAILED; } exit(stepd_cleanup(NULL, job, NULL, NULL, rc, 0)); } else if (rc != 0) { error("Error waiting on condition in _monitor: %m"); } done: slurm_mutex_unlock(&lock); debug2("step_terminate_monitor is stopping"); return NULL; }
static void _print_reservation(reserve_info_t *resv_ptr, int width) { char format[64], tmp1[32], tmp2[32], tmp3[32]; char *state = "INACTIVE"; uint32_t duration; time_t now = time(NULL); slurm_make_time_str(&resv_ptr->start_time, tmp1, sizeof(tmp1)); slurm_make_time_str(&resv_ptr->end_time, tmp2, sizeof(tmp2)); duration = difftime(resv_ptr->end_time, resv_ptr->start_time); secs2time_str(duration, tmp3, sizeof(tmp3)); if ((resv_ptr->start_time <= now) && (resv_ptr->end_time >= now)) state = "ACTIVE"; snprintf(format, sizeof(format), "%%-%ds %%8s %%19s %%19s %%11s %%s\n", width); printf(format, resv_ptr->name, state, tmp1, tmp2, tmp3, resv_ptr->node_list); return; }
static void _dump_job_test(struct job_record *job_ptr, bitstr_t *avail_bitmap, time_t start_time) { char begin_buf[32], *node_list; if (start_time == 0) strcpy(begin_buf, "NOW"); else slurm_make_time_str(&start_time, begin_buf, sizeof(begin_buf)); node_list = bitmap2node_name(avail_bitmap); info("Test job %u at %s on %s", job_ptr->job_id, begin_buf, node_list); xfree(node_list); }
/* * slurm_job_will_run - determine if a job would execute immediately if * submitted now * IN job_desc_msg - description of resource allocation request * RET 0 on success, otherwise return -1 and set errno to indicate the error */ int slurm_job_will_run (job_desc_msg_t *req) { will_run_response_msg_t *will_run_resp = NULL; char buf[64]; bool host_set = false; int rc; uint32_t cluster_flags = slurmdb_setup_cluster_flags(); char *type = "processors"; if ((req->alloc_node == NULL) && (gethostname_short(buf, sizeof(buf)) == 0)) { req->alloc_node = buf; host_set = true; } rc = slurm_job_will_run2(req, &will_run_resp); if ((rc == 0) && will_run_resp) { if (cluster_flags & CLUSTER_FLAG_BG) type = "cnodes"; slurm_make_time_str(&will_run_resp->start_time, buf, sizeof(buf)); info("Job %u to start at %s using %u %s" " on %s", will_run_resp->job_id, buf, will_run_resp->proc_cnt, type, will_run_resp->node_list); if (will_run_resp->preemptee_job_id) { ListIterator itr; uint32_t *job_id_ptr; char *job_list = NULL, *sep = ""; itr = list_iterator_create(will_run_resp-> preemptee_job_id); while ((job_id_ptr = list_next(itr))) { if (job_list) sep = ","; xstrfmtcat(job_list, "%s%u", sep, *job_id_ptr); } list_iterator_destroy(itr); info(" Preempts: %s", job_list); xfree(job_list); } slurm_free_will_run_response_msg(will_run_resp); } if (host_set) req->alloc_node = NULL; return rc; }
/* * slurm_print_job_info_msg - output information about all Slurm * jobs based upon message as loaded using slurm_load_jobs * IN out - file to write to * IN job_info_msg_ptr - job information message pointer * IN one_liner - print as a single line if true */ extern void slurm_print_job_info_msg ( FILE* out, job_info_msg_t *jinfo, int one_liner ) { int i; job_info_t *job_ptr = jinfo->job_array; char time_str[32]; slurm_make_time_str ((time_t *)&jinfo->last_update, time_str, sizeof(time_str)); fprintf( out, "Job data as of %s, record count %d\n", time_str, jinfo->record_count); for (i = 0; i < jinfo->record_count; i++) slurm_print_job_info(out, &job_ptr[i], one_liner); }
/* * slurm_print_block_info_msg - output information about all Bluegene * blocks based upon message as loaded using slurm_load_block * IN out - file to write to * IN info_ptr - block information message pointer * IN one_liner - print as a single line if true */ void slurm_print_block_info_msg( FILE *out, block_info_msg_t *info_ptr, int one_liner) { int i ; block_info_t * block_ptr = info_ptr->block_array; char time_str[32]; slurm_make_time_str ((time_t *)&info_ptr->last_update, time_str, sizeof(time_str)); fprintf( out, "Bluegene Block data as of %s, record count %d\n", time_str, info_ptr->record_count); for (i = 0; i < info_ptr->record_count; i++) slurm_print_block_info(out, & block_ptr[i], one_liner); }
extern void print_fields_date(print_field_t *field, time_t value, int last) { int abs_len = abs(field->len); char temp_char[abs_len+1]; slurm_make_time_str(&value, (char *)temp_char, sizeof(temp_char)); if (print_fields_parsable_print == PRINT_FIELDS_PARSABLE_NO_ENDING && last) printf("%s", temp_char); else if (print_fields_parsable_print) printf("%s|", temp_char); else if (field->len == abs_len) printf("%*.*s ", abs_len, abs_len, temp_char); else printf("%-*.*s ", abs_len, abs_len, temp_char); }
/* * slurm_print_partition_info_msg - output information about all Slurm * partitions based upon message as loaded using slurm_load_partitions * IN out - file to write to * IN part_info_ptr - partitions information message pointer * IN one_liner - print as a single line if true */ void slurm_print_partition_info_msg ( FILE* out, partition_info_msg_t * part_info_ptr, int one_liner ) { int i ; partition_info_t * part_ptr = part_info_ptr->partition_array ; char time_str[32]; slurm_make_time_str ((time_t *)&part_info_ptr->last_update, time_str, sizeof(time_str)); fprintf( out, "Partition data as of %s, record count %d\n", time_str, part_info_ptr->record_count); for (i = 0; i < part_info_ptr->record_count; i++) { slurm_print_partition_info ( out, & part_ptr[i], one_liner ) ; } }
int _print_timestamp(sinfo_data_t * sinfo_data, int width, bool right_justify, char *suffix) { if (sinfo_data && sinfo_data->reason_time) { char time_str[32]; slurm_make_time_str(&sinfo_data->reason_time, time_str, sizeof(time_str)); _print_str(time_str, width, right_justify, true); } else if (sinfo_data) _print_str("Unknown", width, right_justify, true); else _print_str("TIMESTAMP", width, right_justify, true); if (suffix) printf("%s", suffix); return SLURM_SUCCESS; }
/* * slurm_print_reservation_info_msg - output information about all Slurm * reservations based upon message as loaded using slurm_load_reservation * IN out - file to write to * IN resv_info_ptr - reservation information message pointer * IN one_liner - print as a single line if true */ void slurm_print_reservation_info_msg ( FILE* out, reserve_info_msg_t * resv_info_ptr, int one_liner ) { int i ; reserve_info_t * resv_ptr = resv_info_ptr->reservation_array ; char time_str[32]; slurm_make_time_str( (time_t *)&resv_info_ptr->last_update, time_str, sizeof(time_str)); fprintf( out, "Reservation data as of %s, record count %d\n", time_str, resv_info_ptr->record_count); for (i = 0; i < resv_info_ptr->record_count; i++) { slurm_print_reservation_info ( out, & resv_ptr[i], one_liner ); } }
/* * scontrol_print_block - print the specified block's information * IN block_name - NULL to print information about all block */ extern void scontrol_print_block (char *block_name) { int error_code, i, print_cnt = 0; block_info_msg_t *block_info_ptr = NULL; block_info_t *block_ptr = NULL; error_code = scontrol_load_block(&block_info_ptr); if (error_code) { exit_code = 1; if (quiet_flag != 1) slurm_perror ("slurm_load_block error"); return; } if (quiet_flag == -1) { char time_str[32]; slurm_make_time_str( (time_t *)&block_info_ptr->last_update, time_str, sizeof(time_str)); printf ("last_update_time=%s, records=%d\n", time_str, block_info_ptr->record_count); } block_ptr = block_info_ptr->block_array; for (i = 0; i < block_info_ptr->record_count; i++) { if (block_name && xstrcmp(block_name, block_ptr[i].bg_block_id)) continue; print_cnt++; slurm_print_block_info( stdout, &block_ptr[i], one_liner); if (block_name) break; } if (print_cnt == 0) { if (block_name) { exit_code = 1; if (quiet_flag != 1) printf ("Block %s not found\n", block_name); } else if (quiet_flag != 1) printf ("No blocks in the system\n"); } }
/* * scontrol_print_part - print the specified partition's information * IN partition_name - NULL to print information about all partition */ extern void scontrol_print_part (char *partition_name) { int error_code, i, print_cnt = 0; partition_info_msg_t *part_info_ptr = NULL; partition_info_t *part_ptr = NULL; error_code = scontrol_load_partitions(&part_info_ptr); if (error_code) { exit_code = 1; if (quiet_flag != 1) slurm_perror ("slurm_load_partitions error"); return; } if (quiet_flag == -1) { char time_str[32]; slurm_make_time_str ((time_t *)&part_info_ptr->last_update, time_str, sizeof(time_str)); printf ("last_update_time=%s, records=%d\n", time_str, part_info_ptr->record_count); } part_ptr = part_info_ptr->partition_array; for (i = 0; i < part_info_ptr->record_count; i++) { if (partition_name && strcmp (partition_name, part_ptr[i].name) != 0) continue; print_cnt++; slurm_print_partition_info (stdout, & part_ptr[i], one_liner ) ; if (partition_name) break; } if (print_cnt == 0) { if (partition_name) { exit_code = 1; if (quiet_flag != 1) printf ("Partition %s not found\n", partition_name); } else if (quiet_flag != 1) printf ("No partitions in the system\n"); } }
/* * slurm_print_node_info_msg - output information about all Slurm nodes * based upon message as loaded using slurm_load_node * IN out - file to write to * IN node_info_msg_ptr - node information message pointer * IN one_liner - print as a single line if true */ void slurm_print_node_info_msg ( FILE * out, node_info_msg_t * node_info_msg_ptr, int one_liner ) { int i; node_info_t * node_ptr = node_info_msg_ptr -> node_array ; char time_str[32]; slurm_make_time_str ((time_t *)&node_info_msg_ptr->last_update, time_str, sizeof(time_str)); fprintf( out, "Node data as of %s, record count %d\n", time_str, node_info_msg_ptr->record_count); for (i = 0; i < node_info_msg_ptr-> record_count; i++) { slurm_print_node_table ( out, & node_ptr[i], one_liner ) ; } }
/* * slurm_print_job_step_info_msg - output information about all Slurm * job steps based upon message as loaded using slurm_get_job_steps * IN out - file to write to * IN job_step_info_msg_ptr - job step information message pointer * IN one_liner - print as a single line if true */ void slurm_print_job_step_info_msg ( FILE* out, job_step_info_response_msg_t * job_step_info_msg_ptr, int one_liner ) { int i; job_step_info_t *job_step_ptr = job_step_info_msg_ptr->job_steps ; char time_str[32]; slurm_make_time_str ((time_t *)&job_step_info_msg_ptr->last_update, time_str, sizeof(time_str)); fprintf( out, "Job step data as of %s, record count %d\n", time_str, job_step_info_msg_ptr->job_step_count); for (i = 0; i < job_step_info_msg_ptr-> job_step_count; i++) { slurm_print_job_step_info ( out, & job_step_ptr[i], one_liner ) ; } }