static int _cluster_get_jobs(mysql_conn_t *mysql_conn,
slurmdb_user_rec_t *user,
slurmdb_job_cond_t *job_cond,
char *cluster_name,
char *job_fields, char *step_fields,
char *sent_extra,
bool is_admin, int only_pending, List sent_list)
{
char *query = NULL;
char *extra = xstrdup(sent_extra);
uint16_t private_data = slurm_get_private_data();
slurmdb_selected_step_t *selected_step = NULL;
MYSQL_RES *result = NULL, *step_result = NULL;
MYSQL_ROW row, step_row;
slurmdb_job_rec_t *job = NULL;
slurmdb_step_rec_t *step = NULL;
time_t now = time(NULL);
List job_list = list_create(slurmdb_destroy_job_rec);
ListIterator itr = NULL, itr2 = NULL;
List local_cluster_list = NULL;
int set = 0;
char *prefix="t2";
int rc = SLURM_SUCCESS;
int last_id = -1, curr_id = -1;
local_cluster_t *curr_cluster = NULL;
/* This is here to make sure we are looking at only this user
* if this flag is set. We also include any accounts they may be
* coordinator of.
*/
if (!is_admin && (private_data & PRIVATE_DATA_JOBS)) {
query = xstrdup_printf("select lft from \"%s_%s\" "
"where user='******'",
cluster_name, assoc_table, user->name);
if (user->coord_accts) {
slurmdb_coord_rec_t *coord = NULL;
itr = list_iterator_create(user->coord_accts);
while ((coord = list_next(itr))) {
xstrfmtcat(query, " || acct='%s'",
coord->name);
}
list_iterator_destroy(itr);
}
if (debug_flags & DEBUG_FLAG_DB_JOB)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(extra);
xfree(query);
rc = SLURM_ERROR;
goto end_it;
}
xfree(query);
set = 0;
while ((row = mysql_fetch_row(result))) {
if (set) {
xstrfmtcat(extra,
" || (%s between %s.lft and %s.rgt)",
row[0], prefix, prefix);
} else {
set = 1;
if (extra)
xstrfmtcat(extra,
" && ((%s between %s.lft "
"and %s.rgt)",
row[0], prefix,
prefix);
else
xstrfmtcat(extra,
" where ((%s between %s.lft "
"and %s.rgt)",
row[0], prefix,
prefix);
}
}
mysql_free_result(result);
if (set)
xstrcat(extra, ")");
else {
xfree(extra);
debug("User %s has no assocations, and is not admin, "
"so not returning any jobs.", user->name);
/* This user has no valid associations, so
* they will not have any jobs. */
goto end_it;
}
}
setup_job_cluster_cond_limits(mysql_conn, job_cond,
cluster_name, &extra);
query = xstrdup_printf("select %s from \"%s_%s\" as t1 "
"left join \"%s_%s\" as t2 "
"on t1.id_assoc=t2.id_assoc "
"left join \"%s_%s\" as t3 "
"on t1.id_resv=t3.id_resv && "
"((t1.time_start && "
"(t3.time_start < t1.time_start && "
"(t3.time_end >= t1.time_start || "
"t3.time_end = 0))) || "
"((t3.time_start < t1.time_submit && "
"(t3.time_end >= t1.time_submit || "
"t3.time_end = 0)) || "
"(t3.time_start > t1.time_submit)))",
job_fields, cluster_name, job_table,
cluster_name, assoc_table,
cluster_name, resv_table);
if (extra) {
xstrcat(query, extra);
xfree(extra);
}
/* Here we want to order them this way in such a way so it is
easy to look for duplicates, it is also easy to sort the
resized jobs.
*/
xstrcat(query, " group by id_job, time_submit desc");
if (debug_flags & DEBUG_FLAG_DB_JOB)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(mysql_conn, query, 0))) {
xfree(query);
rc = SLURM_ERROR;
goto end_it;
}
xfree(query);
/* Here we set up environment to check used nodes of jobs.
Since we store the bitmap of the entire cluster we can use
that to set up a hostlist and set up the bitmap to make
things work. This should go before the setup of conds
since we could update the start/end time.
*/
if (job_cond && job_cond->used_nodes) {
local_cluster_list = setup_cluster_list_with_inx(
mysql_conn, job_cond, (void **)&curr_cluster);
if (!local_cluster_list) {
rc = SLURM_ERROR;
goto end_it;
}
}
while ((row = mysql_fetch_row(result))) {
char *id = row[JOB_REQ_ID];
bool job_ended = 0;
int start = slurm_atoul(row[JOB_REQ_START]);
curr_id = slurm_atoul(row[JOB_REQ_JOBID]);
if (job_cond && !job_cond->duplicates
&& (curr_id == last_id)
&& (slurm_atoul(row[JOB_REQ_STATE]) != JOB_RESIZING))
continue;
/* check the bitmap to see if this is one of the jobs
we are looking for */
/* Use start time instead of submit time because node
* indexes are determined at start time and not submit. */
if (!good_nodes_from_inx(local_cluster_list,
(void **)&curr_cluster,
row[JOB_REQ_NODE_INX], start)) {
last_id = curr_id;
continue;
}
job = slurmdb_create_job_rec();
job->state = slurm_atoul(row[JOB_REQ_STATE]);
if (curr_id == last_id)
/* put in reverse so we order by the submit getting
larger which it is given to us in reverse
order from the database */
list_prepend(job_list, job);
else
list_append(job_list, job);
last_id = curr_id;
if (row[JOB_REQ_GRES_ALLOC])
job->alloc_gres = xstrdup(row[JOB_REQ_GRES_ALLOC]);
else
job->alloc_gres = xstrdup("");
job->alloc_nodes = slurm_atoul(row[JOB_REQ_ALLOC_NODES]);
job->associd = slurm_atoul(row[JOB_REQ_ASSOCID]);
job->array_job_id = slurm_atoul(row[JOB_REQ_ARRAYJOBID]);
job->array_task_id = slurm_atoul(row[JOB_REQ_ARRAYTASKID]);
job->resvid = slurm_atoul(row[JOB_REQ_RESVID]);
/* This shouldn't happen with new jobs, but older jobs
* could of been added without a start and so the
* array_task_id would be 0 instead of it's real value */
if (!job->array_job_id && !job->array_task_id)
job->array_task_id = NO_VAL;
if (row[JOB_REQ_RESV_NAME] && row[JOB_REQ_RESV_NAME][0])
job->resv_name = xstrdup(row[JOB_REQ_RESV_NAME]);
job->cluster = xstrdup(cluster_name);
/* we want a blank wckey if the name is null */
if (row[JOB_REQ_WCKEY])
job->wckey = xstrdup(row[JOB_REQ_WCKEY]);
else
job->wckey = xstrdup("");
job->wckeyid = slurm_atoul(row[JOB_REQ_WCKEYID]);
if (row[JOB_REQ_USER_NAME])
job->user = xstrdup(row[JOB_REQ_USER_NAME]);
else
job->uid = slurm_atoul(row[JOB_REQ_UID]);
if (row[JOB_REQ_LFT])
job->lft = slurm_atoul(row[JOB_REQ_LFT]);
if (row[JOB_REQ_ACCOUNT] && row[JOB_REQ_ACCOUNT][0])
job->account = xstrdup(row[JOB_REQ_ACCOUNT]);
else if (row[JOB_REQ_ACCOUNT1] && row[JOB_REQ_ACCOUNT1][0])
job->account = xstrdup(row[JOB_REQ_ACCOUNT1]);
if (row[JOB_REQ_ARRAY_STR] && row[JOB_REQ_ARRAY_STR][0])
job->array_task_str = xstrdup(row[JOB_REQ_ARRAY_STR]);
if (row[JOB_REQ_ARRAY_MAX])
job->array_max_tasks =
slurm_atoul(row[JOB_REQ_ARRAY_MAX]);
if (row[JOB_REQ_BLOCKID])
job->blockid = xstrdup(row[JOB_REQ_BLOCKID]);
job->eligible = slurm_atoul(row[JOB_REQ_ELIGIBLE]);
job->submit = slurm_atoul(row[JOB_REQ_SUBMIT]);
job->start = start;
job->end = slurm_atoul(row[JOB_REQ_END]);
job->timelimit = slurm_atoul(row[JOB_REQ_TIMELIMIT]);
/* since the job->end could be set later end it here */
if (job->end) {
job_ended = 1;
if (!job->start || (job->start > job->end))
job->start = job->end;
}
if (job_cond && !job_cond->without_usage_truncation
&& job_cond->usage_start) {
if (job->start && (job->start < job_cond->usage_start))
job->start = job_cond->usage_start;
if (!job->end || job->end > job_cond->usage_end)
job->end = job_cond->usage_end;
if (!job->start)
job->start = job->end;
job->elapsed = job->end - job->start;
if (row[JOB_REQ_SUSPENDED]) {
MYSQL_RES *result2 = NULL;
MYSQL_ROW row2;
/* get the suspended time for this job */
query = xstrdup_printf(
"select time_start, time_end from "
"\"%s_%s\" where "
"(time_start < %ld && (time_end >= %ld "
"|| time_end = 0)) && job_db_inx=%s "
"order by time_start",
cluster_name, suspend_table,
job_cond->usage_end,
job_cond->usage_start,
id);
debug4("%d(%s:%d) query\n%s",
mysql_conn->conn, THIS_FILE,
__LINE__, query);
if (!(result2 = mysql_db_query_ret(
mysql_conn,
query, 0))) {
FREE_NULL_LIST(job_list);
job_list = NULL;
break;
}
xfree(query);
while ((row2 = mysql_fetch_row(result2))) {
time_t local_start =
slurm_atoul(row2[0]);
time_t local_end =
slurm_atoul(row2[1]);
if (!local_start)
continue;
if (job->start > local_start)
local_start = job->start;
if (job->end < local_end)
local_end = job->end;
if ((local_end - local_start) < 1)
continue;
job->elapsed -=
(local_end - local_start);
job->suspended +=
(local_end - local_start);
}
mysql_free_result(result2);
}
} else {
job->suspended = slurm_atoul(row[JOB_REQ_SUSPENDED]);
/* fix the suspended number to be correct */
if (job->state == JOB_SUSPENDED)
job->suspended = now - job->suspended;
if (!job->start) {
job->elapsed = 0;
} else if (!job->end) {
job->elapsed = now - job->start;
} else {
job->elapsed = job->end - job->start;
}
job->elapsed -= job->suspended;
}
if ((int)job->elapsed < 0)
job->elapsed = 0;
job->jobid = curr_id;
job->jobname = xstrdup(row[JOB_REQ_NAME]);
job->gid = slurm_atoul(row[JOB_REQ_GID]);
job->exitcode = slurm_atoul(row[JOB_REQ_EXIT_CODE]);
job->derived_ec = slurm_atoul(row[JOB_REQ_DERIVED_EC]);
job->derived_es = xstrdup(row[JOB_REQ_DERIVED_ES]);
if (row[JOB_REQ_PARTITION])
job->partition = xstrdup(row[JOB_REQ_PARTITION]);
if (row[JOB_REQ_NODELIST])
job->nodes = xstrdup(row[JOB_REQ_NODELIST]);
if (!job->nodes || !xstrcmp(job->nodes, "(null)")) {
xfree(job->nodes);
job->nodes = xstrdup("(unknown)");
}
job->track_steps = slurm_atoul(row[JOB_REQ_TRACKSTEPS]);
job->priority = slurm_atoul(row[JOB_REQ_PRIORITY]);
job->req_cpus = slurm_atoul(row[JOB_REQ_REQ_CPUS]);
if (row[JOB_REQ_GRES_REQ])
job->req_gres = xstrdup(row[JOB_REQ_GRES_REQ]);
else
job->req_gres = xstrdup("");
job->req_mem = slurm_atoul(row[JOB_REQ_REQ_MEM]);
job->requid = slurm_atoul(row[JOB_REQ_KILL_REQUID]);
job->qosid = slurm_atoul(row[JOB_REQ_QOS]);
job->show_full = 1;
if (row[JOB_REQ_TRESA])
job->tres_alloc_str = xstrdup(row[JOB_REQ_TRESA]);
if (row[JOB_REQ_TRESR])
job->tres_req_str = xstrdup(row[JOB_REQ_TRESR]);
if (only_pending || (job_cond && job_cond->without_steps))
goto skip_steps;
if (job_cond && job_cond->step_list
&& list_count(job_cond->step_list)) {
set = 0;
itr = list_iterator_create(job_cond->step_list);
while ((selected_step = list_next(itr))) {
if ((selected_step->jobid != job->jobid) &&
(selected_step->jobid !=
job->array_job_id)) {
continue;
} else if ((selected_step->array_task_id !=
INFINITE) &&
(selected_step->array_task_id !=
job->array_task_id))
continue;
else if (selected_step->stepid == NO_VAL) {
job->show_full = 1;
break;
} else if (selected_step->stepid == INFINITE)
selected_step->stepid =
SLURM_BATCH_SCRIPT;
if (set)
xstrcat(extra, " || ");
else
xstrcat(extra, " && (");
/* The stepid could be -2 so use %d not %u */
xstrfmtcat(extra, "t1.id_step=%d",
selected_step->stepid);
set = 1;
job->show_full = 0;
/* Set it back just in case we are
looking at a job array.
*/
if (selected_step->stepid == SLURM_BATCH_SCRIPT)
selected_step->stepid = INFINITE;
}
list_iterator_destroy(itr);
if (set)
xstrcat(extra, ")");
}
query = xstrdup_printf("select %s from \"%s_%s\" as t1 "
"where t1.job_db_inx=%s",
step_fields, cluster_name,
step_table, id);
if (extra) {
xstrcat(query, extra);
xfree(extra);
}
if (debug_flags & DEBUG_FLAG_DB_STEP)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
if (!(step_result = mysql_db_query_ret(
mysql_conn, query, 0))) {
xfree(query);
rc = SLURM_ERROR;
goto end_it;
}
xfree(query);
/* Querying the steps in the fashion was faster than
doing only 1 query and then matching the steps up
later with the job.
*/
while ((step_row = mysql_fetch_row(step_result))) {
/* check the bitmap to see if this is one of the steps
we are looking for */
if (!good_nodes_from_inx(local_cluster_list,
(void **)&curr_cluster,
step_row[STEP_REQ_NODE_INX],
start))
continue;
step = slurmdb_create_step_rec();
step->tot_cpu_sec = 0;
step->tot_cpu_usec = 0;
step->job_ptr = job;
if (!job->first_step_ptr)
job->first_step_ptr = step;
list_append(job->steps, step);
step->stepid = slurm_atoul(step_row[STEP_REQ_STEPID]);
/* info("got step %u.%u", */
/* job->header.jobnum, step->stepnum); */
step->state = slurm_atoul(step_row[STEP_REQ_STATE]);
step->exitcode =
slurm_atoul(step_row[STEP_REQ_EXIT_CODE]);
step->nnodes = slurm_atoul(step_row[STEP_REQ_NODES]);
step->ntasks = slurm_atoul(step_row[STEP_REQ_TASKS]);
step->task_dist =
slurm_atoul(step_row[STEP_REQ_TASKDIST]);
step->start = slurm_atoul(step_row[STEP_REQ_START]);
step->end = slurm_atoul(step_row[STEP_REQ_END]);
/* if the job has ended end the step also */
if (!step->end && job_ended) {
step->end = job->end;
step->state = job->state;
}
if (job_cond && !job_cond->without_usage_truncation
&& job_cond->usage_start) {
if (step->start
&& (step->start < job_cond->usage_start))
step->start = job_cond->usage_start;
if (!step->start && step->end)
step->start = step->end;
if (!step->end
|| (step->end > job_cond->usage_end))
step->end = job_cond->usage_end;
}
/* figure this out by start stop */
step->suspended =
slurm_atoul(step_row[STEP_REQ_SUSPENDED]);
if (!step->start) {
step->elapsed = 0;
} else if (!step->end) {
step->elapsed = now - step->start;
} else {
step->elapsed = step->end - step->start;
}
step->elapsed -= step->suspended;
if ((int)step->elapsed < 0)
step->elapsed = 0;
step->req_cpufreq_min = slurm_atoul(
step_row[STEP_REQ_REQ_CPUFREQ_MIN]);
step->req_cpufreq_max = slurm_atoul(
step_row[STEP_REQ_REQ_CPUFREQ_MAX]);
step->req_cpufreq_gov = slurm_atoul(
step_row[STEP_REQ_REQ_CPUFREQ_GOV]);
step->stepname = xstrdup(step_row[STEP_REQ_NAME]);
step->nodes = xstrdup(step_row[STEP_REQ_NODELIST]);
step->requid =
slurm_atoul(step_row[STEP_REQ_KILL_REQUID]);
step->stats.cpu_min = slurm_atoul(
step_row[STEP_REQ_MIN_CPU]);
if (step->stats.cpu_min != NO_VAL) {
step->user_cpu_sec = slurm_atoul(
step_row[STEP_REQ_USER_SEC]);
step->user_cpu_usec = slurm_atoul(
step_row[STEP_REQ_USER_USEC]);
step->sys_cpu_sec =
slurm_atoul(step_row[STEP_REQ_SYS_SEC]);
step->sys_cpu_usec = slurm_atoul(
step_row[STEP_REQ_SYS_USEC]);
step->tot_cpu_sec +=
step->user_cpu_sec + step->sys_cpu_sec;
step->tot_cpu_usec += step->user_cpu_usec +
step->sys_cpu_usec;
step->stats.disk_read_max =
atof(step_row[STEP_REQ_MAX_DISK_READ]);
step->stats.disk_read_max_taskid = slurm_atoul(
step_row[STEP_REQ_MAX_DISK_READ_TASK]);
step->stats.disk_read_ave =
atof(step_row[STEP_REQ_AVE_DISK_READ]);
step->stats.disk_write_max =
atof(step_row[STEP_REQ_MAX_DISK_WRITE]);
step->stats.disk_write_max_taskid = slurm_atoul(
step_row[STEP_REQ_MAX_DISK_WRITE_TASK]);
step->stats.disk_write_ave =
atof(step_row[STEP_REQ_AVE_DISK_WRITE]);
step->stats.vsize_max = slurm_atoul(
step_row[STEP_REQ_MAX_VSIZE]);
step->stats.vsize_max_taskid = slurm_atoul(
step_row[STEP_REQ_MAX_VSIZE_TASK]);
step->stats.vsize_ave =
atof(step_row[STEP_REQ_AVE_VSIZE]);
step->stats.rss_max =
slurm_atoul(step_row[STEP_REQ_MAX_RSS]);
step->stats.rss_max_taskid = slurm_atoul(
step_row[STEP_REQ_MAX_RSS_TASK]);
step->stats.rss_ave =
atof(step_row[STEP_REQ_AVE_RSS]);
step->stats.pages_max = slurm_atoul(
step_row[STEP_REQ_MAX_PAGES]);
step->stats.pages_max_taskid = slurm_atoul(
step_row[STEP_REQ_MAX_PAGES_TASK]);
step->stats.pages_ave =
atof(step_row[STEP_REQ_AVE_PAGES]);
step->stats.cpu_min_taskid = slurm_atoul(
step_row[STEP_REQ_MIN_CPU_TASK]);
step->stats.cpu_ave =
atof(step_row[STEP_REQ_AVE_CPU]);
step->stats.act_cpufreq =
atof(step_row[STEP_REQ_ACT_CPUFREQ]);
step->stats.consumed_energy = atof(
step_row[STEP_REQ_CONSUMED_ENERGY]);
step->stats.vsize_max_nodeid = slurm_atoul(
step_row[STEP_REQ_MAX_VSIZE_NODE]);
step->stats.rss_max_nodeid = slurm_atoul(
step_row[STEP_REQ_MAX_RSS_NODE]);
step->stats.pages_max_nodeid = slurm_atoul(
step_row[STEP_REQ_MAX_PAGES_NODE]);
step->stats.cpu_min_nodeid = slurm_atoul(
step_row[STEP_REQ_MIN_CPU_NODE]);
}
if (step_row[STEP_REQ_TRES])
step->tres_alloc_str =
xstrdup(step_row[STEP_REQ_TRES]);
}
mysql_free_result(step_result);
if (!job->track_steps) {
uint64_t j_cpus, s_cpus;
/* If we don't have track_steps we want to see
if we have multiple steps. If we only have
1 step check the job name against the step
name in most all cases it will be
different. If it is different print out
the step separate. It could also be a single
step/allocation where the job was allocated more than
the step requested (eg. CR_Socket).
*/
if (list_count(job->steps) > 1)
job->track_steps = 1;
else if (step &&
(xstrcmp(step->stepname, job->jobname) ||
(((j_cpus = slurmdb_find_tres_count_in_string(
job->tres_alloc_str, TRES_CPU))
!= INFINITE64) &&
((s_cpus = slurmdb_find_tres_count_in_string(
step->tres_alloc_str, TRES_CPU))
!= INFINITE64) &&
j_cpus != s_cpus)))
job->track_steps = 1;
}
skip_steps:
/* need to reset here to make the above test valid */
step = NULL;
}
mysql_free_result(result);
end_it:
if (itr2)
list_iterator_destroy(itr2);
FREE_NULL_LIST(local_cluster_list);
if (rc == SLURM_SUCCESS)
list_transfer(sent_list, job_list);
FREE_NULL_LIST(job_list);
return rc;
}
/* FIXME: This only works for CPUS now */
static List _process_grouped_report(
void *db_conn, slurmdb_job_cond_t *job_cond, List grouping_list,
bool flat_view, bool wckey_type, bool both)
{
int exit_code = 0;
void *object = NULL, *object2 = NULL;
ListIterator itr = NULL, itr2 = NULL;
ListIterator cluster_itr = NULL;
ListIterator local_itr = NULL;
ListIterator acct_itr = NULL;
ListIterator group_itr = NULL;
slurmdb_job_rec_t *job = NULL;
slurmdb_report_cluster_grouping_t *cluster_group = NULL;
slurmdb_report_acct_grouping_t *acct_group = NULL;
slurmdb_report_job_grouping_t *job_group = NULL;
List job_list = NULL;
List cluster_list = NULL;
List object_list = NULL, object2_list = NULL;
List tmp_acct_list = NULL;
bool destroy_job_cond = 0;
bool destroy_grouping_list = 0;
bool individual = 0;
uint32_t tres_id = TRES_CPU;
uid_t my_uid = getuid();
/* we don't want to actually query by accounts in the jobs
here since we may be looking for sub accounts of a specific
account.
*/
if (!job_cond) {
destroy_job_cond = 1;
job_cond = xmalloc(sizeof(slurmdb_job_cond_t));
}
if (!grouping_list) {
destroy_grouping_list = 1;
grouping_list = list_create(slurm_destroy_char);
slurm_addto_char_list(grouping_list, "50,250,500,1000");
}
tmp_acct_list = job_cond->acct_list;
job_cond->acct_list = NULL;
job_list = jobacct_storage_g_get_jobs_cond(db_conn, my_uid, job_cond);
job_cond->acct_list = tmp_acct_list;
tmp_acct_list = NULL;
if (!job_list) {
exit_code=1;
fprintf(stderr, " Problem with job query.\n");
goto end_it;
}
group_itr = list_iterator_create(grouping_list);
/* make a group for each job size we find. */
if (!list_count(grouping_list)) {
char *group = NULL;
individual = 1;
itr = list_iterator_create(job_list);
while ((job = list_next(itr))) {
char *tmp = NULL;
uint64_t count;
if (!job->elapsed)
continue;
if ((count = slurmdb_find_tres_count_in_string(
job->tres_alloc_str, tres_id))
== INFINITE64)
continue;
tmp = xstrdup_printf("%"PRIu64, count);
while ((group = list_next(group_itr))) {
if (!xstrcmp(group, tmp)) {
break;
}
}
if (!group)
list_append(grouping_list, tmp);
else
xfree(tmp);
list_iterator_reset(group_itr);
}
list_iterator_destroy(itr);
list_sort(grouping_list, (ListCmpF)_sort_group_asc);
}
cluster_list = list_create(slurmdb_destroy_report_cluster_grouping);
cluster_itr = list_iterator_create(cluster_list);
if (flat_view)
goto no_objects;
if (!wckey_type || both) {
slurmdb_assoc_cond_t assoc_cond;
memset(&assoc_cond, 0, sizeof(slurmdb_assoc_cond_t));
assoc_cond.id_list = job_cond->associd_list;
assoc_cond.cluster_list = job_cond->cluster_list;
/* don't limit associations to having the partition_list */
//assoc_cond.partition_list = job_cond->partition_list;
if (!job_cond->acct_list || !list_count(job_cond->acct_list)) {
FREE_NULL_LIST(job_cond->acct_list);
job_cond->acct_list = list_create(NULL);
list_append(job_cond->acct_list, "root");
}
assoc_cond.parent_acct_list = job_cond->acct_list;
object_list = acct_storage_g_get_assocs(db_conn, my_uid,
&assoc_cond);
}
if (wckey_type || both) {
slurmdb_wckey_cond_t wckey_cond;
memset(&wckey_cond, 0, sizeof(slurmdb_wckey_cond_t));
wckey_cond.name_list = job_cond->wckey_list;
wckey_cond.cluster_list = job_cond->cluster_list;
object2_list = acct_storage_g_get_wckeys(db_conn, my_uid,
&wckey_cond);
if (!object_list) {
object_list = object2_list;
object2_list = NULL;
}
}
if (!object_list) {
debug2(" No join list given.\n");
goto no_objects;
}
itr = list_iterator_create(object_list);
if (object2_list)
itr2 = list_iterator_create(object2_list);
while ((object = list_next(itr))) {
char *cluster = NULL;
slurmdb_wckey_rec_t *wckey = (slurmdb_wckey_rec_t *)object;
slurmdb_assoc_rec_t *assoc =
(slurmdb_assoc_rec_t *)object;
if (!itr2) {
char *name = NULL;
if (wckey_type) {
cluster = wckey->cluster;
name = wckey->name;
} else {
cluster = assoc->cluster;
name = assoc->acct;
}
_check_create_grouping(cluster_list, group_itr,
cluster, name, object,
individual, wckey_type);
continue;
}
while ((object2 = list_next(itr2))) {
slurmdb_wckey_rec_t *wckey2 =
(slurmdb_wckey_rec_t *)object2;
slurmdb_assoc_rec_t *assoc2 =
(slurmdb_assoc_rec_t *)object2;
char name[200];
if (!wckey_type) {
if (xstrcmp(assoc->cluster, wckey2->cluster))
continue;
cluster = assoc->cluster;
snprintf(name, sizeof(name), "%s:%s",
assoc->acct, wckey2->name);
} else {
if (xstrcmp(wckey->cluster, assoc2->cluster))
continue;
cluster = wckey->cluster;
snprintf(name, sizeof(name), "%s:%s",
wckey2->name, assoc->acct);
}
_check_create_grouping(cluster_list, group_itr,
cluster, name, object,
individual, wckey_type);
}
list_iterator_reset(itr2);
}
list_iterator_destroy(itr);
if (itr2)
list_iterator_destroy(itr2);
no_objects:
itr = list_iterator_create(job_list);
while((job = list_next(itr))) {
char *local_cluster = "UNKNOWN";
char tmp_acct[200];
if (!job->elapsed) {
/* here we don't care about jobs that didn't
* really run here */
continue;
}
if (job->cluster)
local_cluster = job->cluster;
if (!wckey_type) {
if (both && job->wckey) {
snprintf(tmp_acct, sizeof(tmp_acct),
"%s:%s",
job->account,
job->wckey);
} else {
snprintf(tmp_acct, sizeof(tmp_acct),
"%s", job->account);
}
} else {
if (both && job->account) {
snprintf(tmp_acct, sizeof(tmp_acct),
"%s:%s",
job->wckey,
job->account);
} else {
snprintf(tmp_acct, sizeof(tmp_acct),
"%s", job->wckey);
}
}
list_iterator_reset(cluster_itr);
while((cluster_group = list_next(cluster_itr))) {
if (!xstrcmp(local_cluster, cluster_group->cluster))
break;
}
if (!cluster_group) {
/* here we are only looking for groups that
* were added with the associations above
*/
if (!flat_view)
continue;
cluster_group = xmalloc(
sizeof(slurmdb_report_cluster_grouping_t));
cluster_group->cluster = xstrdup(local_cluster);
cluster_group->acct_list = list_create(
slurmdb_destroy_report_acct_grouping);
list_append(cluster_list, cluster_group);
}
acct_itr = list_iterator_create(cluster_group->acct_list);
while((acct_group = list_next(acct_itr))) {
if (wckey_type) {
if (!xstrcmp(tmp_acct, acct_group->acct))
break;
continue;
}
if (!flat_view
&& (acct_group->lft != (uint32_t)NO_VAL)
&& (job->lft != (uint32_t)NO_VAL)) {
/* keep separate since we don't want
* to so a xstrcmp if we don't have to
*/
if (job->lft > acct_group->lft
&& job->lft < acct_group->rgt) {
char *mywckey;
if (!both)
break;
mywckey = strstr(acct_group->acct, ":");
mywckey++;
if (!job->wckey && !mywckey)
break;
else if (!mywckey || !job->wckey)
continue;
else if (!xstrcmp(mywckey, job->wckey))
break;
}
} else if (!xstrcmp(acct_group->acct, tmp_acct))
break;
}
list_iterator_destroy(acct_itr);
if (!acct_group) {
char *group = NULL;
uint32_t last_size = 0;
/* here we are only looking for groups that
* were added with the associations above
*/
if (!flat_view)
continue;
acct_group = xmalloc(
sizeof(slurmdb_report_acct_grouping_t));
acct_group->acct = xstrdup(tmp_acct);
acct_group->groups = list_create(
slurmdb_destroy_report_job_grouping);
list_append(cluster_group->acct_list, acct_group);
while((group = list_next(group_itr))) {
job_group = xmalloc(
sizeof(slurmdb_report_job_grouping_t));
job_group->jobs = list_create(NULL);
if (!individual)
job_group->min_size = last_size;
last_size = atoi(group);
if (!individual)
job_group->max_size = last_size-1;
else
job_group->min_size =
job_group->max_size = last_size;
list_append(acct_group->groups, job_group);
}
if (last_size && !individual) {
job_group = xmalloc(
sizeof(slurmdb_report_job_grouping_t));
job_group->jobs = list_create(NULL);
job_group->min_size = last_size;
if (individual)
job_group->max_size =
job_group->min_size;
else
job_group->max_size = INFINITE;
list_append(acct_group->groups, job_group);
}
list_iterator_reset(group_itr);
}
local_itr = list_iterator_create(acct_group->groups);
while ((job_group = list_next(local_itr))) {
uint64_t count;
if (((count = slurmdb_find_tres_count_in_string(
job->tres_alloc_str, tres_id))
== INFINITE64) ||
(count < job_group->min_size) ||
(count > job_group->max_size))
continue;
list_append(job_group->jobs, job);
job_group->count++;
acct_group->count++;
cluster_group->count++;
slurmdb_transfer_tres_time(
&job_group->tres_list, job->tres_alloc_str,
job->elapsed);
slurmdb_transfer_tres_time(
&acct_group->tres_list, job->tres_alloc_str,
job->elapsed);
slurmdb_transfer_tres_time(
&cluster_group->tres_list, job->tres_alloc_str,
job->elapsed);
}
list_iterator_destroy(local_itr);
}
list_iterator_destroy(itr);
list_iterator_destroy(group_itr);
list_iterator_reset(cluster_itr);
while ((cluster_group = list_next(cluster_itr))) {
ListIterator acct_itr;
if (!cluster_group->count) {
list_delete_item(cluster_itr);
continue;
}
acct_itr = list_iterator_create(cluster_group->acct_list);
while ((acct_group = list_next(acct_itr))) {
if (!acct_group->count) {
list_delete_item(acct_itr);
continue;
}
}
list_iterator_destroy(acct_itr);
}
list_iterator_destroy(cluster_itr);
end_it:
FREE_NULL_LIST(object_list);
FREE_NULL_LIST(object2_list);
if (destroy_job_cond)
slurmdb_destroy_job_cond(job_cond);
if (destroy_grouping_list)
FREE_NULL_LIST(grouping_list);
if (exit_code) {
FREE_NULL_LIST(cluster_list);
}
return cluster_list;
}
void print_fields(slurmdb_step_rec_t *step)
{
// print_field_t *field = NULL;
// int curr_inx = 1;
// char outbuf[FORMAT_STRING_SIZE];
list_iterator_reset(print_fields_itr);
while ((field = list_next(print_fields_itr))) {
char *tmp_char = NULL;
uint64_t tmp_uint64 = NO_VAL64;
memset(&outbuf, 0, sizeof(outbuf));
switch(field->type) {
case PRINT_AVECPU:
tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.tres_usage_in_ave, TRES_CPU);
if (tmp_uint64 != NO_VAL64) {
tmp_uint64 /= CPU_TIME_ADJ;
tmp_char = _elapsed_time((long)tmp_uint64, 0);
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_ACT_CPUFREQ:
convert_num_unit2((double)step->stats.act_cpufreq,
outbuf, sizeof(outbuf), UNIT_KILO,
NO_VAL, 1000, params.convert_flags &
(~CONVERT_NUM_UNIT_EXACT));
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_CONSUMED_ENERGY:
if (!fuzzy_equal(step->stats.consumed_energy,
NO_VAL64)) {
convert_num_unit2((double)
step->stats.consumed_energy,
outbuf, sizeof(outbuf),
UNIT_NONE, NO_VAL, 1000,
params.convert_flags &
(~CONVERT_NUM_UNIT_EXACT));
}
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_CONSUMED_ENERGY_RAW:
field->print_routine(field,
step->stats.consumed_energy,
(curr_inx == field_count));
break;
case PRINT_AVEDISKREAD:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.tres_usage_in_ave,
TRES_FS_DISK)) == INFINITE64)
tmp_uint64 = NO_VAL64;
if (tmp_uint64 != NO_VAL64)
_print_small_double(outbuf, sizeof(outbuf),
(double)tmp_uint64,
UNIT_NONE);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_AVEDISKWRITE:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.tres_usage_out_ave,
TRES_FS_DISK)) == INFINITE64)
tmp_uint64 = NO_VAL64;
if (tmp_uint64 != NO_VAL64)
_print_small_double(outbuf, sizeof(outbuf),
(double)tmp_uint64,
UNIT_NONE);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_AVEPAGES:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.tres_usage_in_ave,
TRES_PAGES)) == INFINITE64)
tmp_uint64 = NO_VAL64;
if (tmp_uint64 != NO_VAL64)
convert_num_unit((double)tmp_uint64, outbuf,
sizeof(outbuf), UNIT_NONE, NO_VAL,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_AVERSS:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.tres_usage_in_ave,
TRES_MEM)) == INFINITE64)
tmp_uint64 = NO_VAL64;
if (tmp_uint64 != NO_VAL64)
convert_num_unit((double)tmp_uint64, outbuf,
sizeof(outbuf), UNIT_NONE, NO_VAL,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_AVEVSIZE:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.tres_usage_in_ave,
TRES_VMEM)) == INFINITE64)
tmp_uint64 = NO_VAL64;
if (tmp_uint64 != NO_VAL64)
convert_num_unit((double)tmp_uint64, outbuf,
sizeof(outbuf), UNIT_NONE, NO_VAL,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_JOBID:
if (step->stepid == SLURM_BATCH_SCRIPT)
snprintf(outbuf, sizeof(outbuf), "%u.batch",
step->job_ptr->jobid);
else if (step->stepid == SLURM_EXTERN_CONT)
snprintf(outbuf, sizeof(outbuf), "%u.extern",
step->job_ptr->jobid);
else
snprintf(outbuf, sizeof(outbuf), "%u.%u",
step->job_ptr->jobid,
step->stepid);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXDISKREAD:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.tres_usage_in_max,
TRES_FS_DISK)) == INFINITE64)
tmp_uint64 = NO_VAL64;
if (tmp_uint64 != NO_VAL64)
_print_small_double(outbuf, sizeof(outbuf),
(double)tmp_uint64,
UNIT_NONE);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXDISKREADNODE:
tmp_char = find_hostname(
slurmdb_find_tres_count_in_string(
step->stats.
tres_usage_in_max_nodeid,
TRES_FS_DISK),
step->nodes);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MAXDISKREADTASK:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.
tres_usage_in_max_taskid,
TRES_FS_DISK)) == INFINITE64)
tmp_uint64 = NO_VAL64;
field->print_routine(field,
tmp_uint64,
(curr_inx == field_count));
break;
case PRINT_MAXDISKWRITE:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.tres_usage_out_max,
TRES_FS_DISK)) == INFINITE64)
tmp_uint64 = NO_VAL64;
if (tmp_uint64 != NO_VAL64)
_print_small_double(outbuf, sizeof(outbuf),
(double)tmp_uint64,
UNIT_NONE);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXDISKWRITENODE:
tmp_char = find_hostname(
slurmdb_find_tres_count_in_string(
step->stats.
tres_usage_out_max_nodeid,
TRES_FS_DISK),
step->nodes);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MAXDISKWRITETASK:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.
tres_usage_out_max_taskid,
TRES_FS_DISK)) == INFINITE64)
tmp_uint64 = NO_VAL64;
field->print_routine(field,
tmp_uint64,
(curr_inx == field_count));
break;
case PRINT_MAXPAGES:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.tres_usage_in_max,
TRES_PAGES)) == INFINITE64)
tmp_uint64 = NO_VAL64;
if (tmp_uint64 != NO_VAL64)
convert_num_unit((double)tmp_uint64, outbuf,
sizeof(outbuf), UNIT_NONE, NO_VAL,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXPAGESNODE:
tmp_char = find_hostname(
slurmdb_find_tres_count_in_string(
step->stats.
tres_usage_out_max_nodeid,
TRES_PAGES),
step->nodes);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MAXPAGESTASK:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.
tres_usage_in_max_taskid,
TRES_PAGES)) == INFINITE64)
tmp_uint64 = NO_VAL64;
field->print_routine(field,
tmp_uint64,
(curr_inx == field_count));
break;
case PRINT_MAXRSS:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.tres_usage_in_max,
TRES_MEM)) == INFINITE64)
tmp_uint64 = NO_VAL64;
if (tmp_uint64 != NO_VAL64)
convert_num_unit((double)tmp_uint64, outbuf,
sizeof(outbuf), UNIT_NONE, NO_VAL,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXRSSNODE:
tmp_char = find_hostname(
slurmdb_find_tres_count_in_string(
step->stats.
tres_usage_in_max_nodeid,
TRES_MEM),
step->nodes);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MAXRSSTASK:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.
tres_usage_in_max_taskid,
TRES_MEM)) == INFINITE64)
tmp_uint64 = NO_VAL64;
field->print_routine(field,
tmp_uint64,
(curr_inx == field_count));
break;
case PRINT_MAXVSIZE:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.tres_usage_in_max,
TRES_VMEM)) == INFINITE64)
tmp_uint64 = NO_VAL64;
if (tmp_uint64 != NO_VAL64)
convert_num_unit((double)tmp_uint64, outbuf,
sizeof(outbuf), UNIT_NONE, NO_VAL,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXVSIZENODE:
tmp_char = find_hostname(
slurmdb_find_tres_count_in_string(
step->stats.
tres_usage_in_max_nodeid,
TRES_VMEM),
step->nodes);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MAXVSIZETASK:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.
tres_usage_in_max_taskid,
TRES_VMEM)) == INFINITE64)
tmp_uint64 = NO_VAL64;
field->print_routine(field,
tmp_uint64,
(curr_inx == field_count));
break;
case PRINT_MINCPU:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.tres_usage_in_min,
TRES_CPU)) == INFINITE64)
tmp_uint64 = NO_VAL64;
if (tmp_uint64 != NO_VAL64) {
tmp_uint64 /= CPU_TIME_ADJ;
tmp_char = _elapsed_time((long)tmp_uint64, 0);
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MINCPUNODE:
tmp_char = find_hostname(
slurmdb_find_tres_count_in_string(
step->stats.
tres_usage_in_min_nodeid,
TRES_CPU),
step->nodes);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MINCPUTASK:
if ((tmp_uint64 = slurmdb_find_tres_count_in_string(
step->stats.
tres_usage_in_min_taskid,
TRES_CPU)) == INFINITE64)
tmp_uint64 = NO_VAL64;
field->print_routine(field,
tmp_uint64,
(curr_inx == field_count));
break;
case PRINT_TRESUIA:
_print_tres_field(step->stats.tres_usage_in_ave,
NULL, 1);
break;
case PRINT_TRESUIM:
_print_tres_field(step->stats.tres_usage_in_max,
NULL, 1);
break;
case PRINT_TRESUIMN:
_print_tres_field(step->stats.tres_usage_in_max_nodeid,
step->nodes, 0);
break;
case PRINT_TRESUIMT:
_print_tres_field(step->stats.tres_usage_in_max_taskid,
NULL, 0);
break;
case PRINT_TRESUIMI:
_print_tres_field(step->stats.tres_usage_in_min,
NULL, 1);
break;
case PRINT_TRESUIMIN:
_print_tres_field(step->stats.tres_usage_in_min_nodeid,
step->nodes, 0);
break;
case PRINT_TRESUIMIT:
_print_tres_field(step->stats.tres_usage_in_min_taskid,
NULL, 0);
break;
case PRINT_TRESUIT:
_print_tres_field(step->stats.tres_usage_in_tot,
NULL, 1);
break;
case PRINT_TRESUOA:
_print_tres_field(step->stats.tres_usage_out_ave,
NULL, 1);
break;
case PRINT_TRESUOM:
_print_tres_field(step->stats.tres_usage_out_max,
NULL, 1);
break;
case PRINT_TRESUOMN:
_print_tres_field(step->stats.tres_usage_out_max_nodeid,
step->nodes, 0);
break;
case PRINT_TRESUOMT:
_print_tres_field(step->stats.tres_usage_out_max_taskid,
NULL, 0);
break;
case PRINT_TRESUOMI:
_print_tres_field(step->stats.tres_usage_out_min,
NULL, 1);
break;
case PRINT_TRESUOMIN:
_print_tres_field(step->stats.tres_usage_out_min_nodeid,
step->nodes, 0);
break;
case PRINT_TRESUOMIT:
_print_tres_field(step->stats.tres_usage_out_min_taskid,
NULL, 0);
break;
case PRINT_TRESUOT:
_print_tres_field(step->stats.tres_usage_out_tot,
NULL, 1);
break;
case PRINT_NODELIST:
field->print_routine(field,
step->nodes,
(curr_inx == field_count));
break;
case PRINT_NTASKS:
field->print_routine(field,
step->ntasks,
(curr_inx == field_count));
break;
case PRINT_PIDS:
field->print_routine(field,
step->pid_str,
(curr_inx == field_count));
break;
case PRINT_REQ_CPUFREQ_MIN:
cpu_freq_to_string(outbuf, sizeof(outbuf),
step->req_cpufreq_min);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_REQ_CPUFREQ_MAX:
cpu_freq_to_string(outbuf, sizeof(outbuf),
step->req_cpufreq_max);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_REQ_CPUFREQ_GOV:
cpu_freq_to_string(outbuf, sizeof(outbuf),
step->req_cpufreq_gov);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
default:
break;
}
curr_inx++;
}
printf("\n");
}
void print_fields(type_t type, void *object)
{
if (!object) {
fatal ("Job or step record is NULL");
return;
}
slurmdb_job_rec_t *job = (slurmdb_job_rec_t *)object;
slurmdb_step_rec_t *step = (slurmdb_step_rec_t *)object;
jobcomp_job_rec_t *job_comp = (jobcomp_job_rec_t *)object;
print_field_t *field = NULL;
int curr_inx = 1;
struct passwd *pw = NULL;
struct group *gr = NULL;
char outbuf[FORMAT_STRING_SIZE];
bool got_stats = false;
int cpu_tres_rec_count = 0;
int step_cpu_tres_rec_count = 0;
switch(type) {
case JOB:
step = NULL;
if (!job->track_steps)
step = (slurmdb_step_rec_t *)job->first_step_ptr;
/* set this to avoid printing out info for things that
don't mean anything. Like an allocation that never
ran anything.
*/
if (!step)
job->track_steps = 1;
else
step_cpu_tres_rec_count =
slurmdb_find_tres_count_in_string(
step->tres_alloc_str, TRES_CPU);
if (job->stats.cpu_min != NO_VAL)
got_stats = true;
job_comp = NULL;
cpu_tres_rec_count = slurmdb_find_tres_count_in_string(
(job->tres_alloc_str && job->tres_alloc_str[0]) ?
job->tres_alloc_str : job->tres_req_str,
TRES_CPU);
break;
case JOBSTEP:
job = step->job_ptr;
if (step->stats.cpu_min != NO_VAL)
got_stats = true;
if ((step_cpu_tres_rec_count =
slurmdb_find_tres_count_in_string(
step->tres_alloc_str, TRES_CPU)) == INFINITE64)
step_cpu_tres_rec_count =
slurmdb_find_tres_count_in_string(
(job->tres_alloc_str &&
job->tres_alloc_str[0]) ?
job->tres_alloc_str : job->tres_req_str,
TRES_CPU);
job_comp = NULL;
break;
case JOBCOMP:
job = NULL;
step = NULL;
break;
default:
break;
}
if ((uint64_t)cpu_tres_rec_count == INFINITE64)
cpu_tres_rec_count = 0;
if ((uint64_t)step_cpu_tres_rec_count == INFINITE64)
step_cpu_tres_rec_count = 0;
list_iterator_reset(print_fields_itr);
while((field = list_next(print_fields_itr))) {
char *tmp_char = NULL, id[FORMAT_STRING_SIZE];
int tmp_int = NO_VAL, tmp_int2 = NO_VAL;
double tmp_dub = (double)NO_VAL; /* don't use NO_VAL64
unless we can
confirm the values
coming in are
NO_VAL64 */
uint32_t tmp_uint32 = NO_VAL;
uint64_t tmp_uint64 = NO_VAL64;
memset(&outbuf, 0, sizeof(outbuf));
switch(field->type) {
case PRINT_ALLOC_CPUS:
switch(type) {
case JOB:
tmp_int = cpu_tres_rec_count;
// we want to use the step info
if (!step)
break;
case JOBSTEP:
tmp_int = step_cpu_tres_rec_count;
break;
case JOBCOMP:
default:
tmp_int = job_comp->proc_cnt;
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_ALLOC_GRES:
switch(type) {
case JOB:
tmp_char = job->alloc_gres;
break;
case JOBSTEP:
tmp_char = step->job_ptr->alloc_gres;
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_ALLOC_NODES:
switch(type) {
case JOB:
tmp_int = job->alloc_nodes;
tmp_char = job->tres_alloc_str;
break;
case JOBSTEP:
tmp_int = step->nnodes;
tmp_char = step->tres_alloc_str;
break;
case JOBCOMP:
tmp_int = job_comp->node_cnt;
break;
default:
break;
}
if (!tmp_int && tmp_char) {
if ((tmp_uint64 =
slurmdb_find_tres_count_in_string(
tmp_char, TRES_NODE))
!= INFINITE64)
tmp_int = tmp_uint64;
}
convert_num_unit((double)tmp_int, outbuf,
sizeof(outbuf), UNIT_NONE, NO_VAL,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_ACCOUNT:
switch(type) {
case JOB:
tmp_char = job->account;
break;
case JOBSTEP:
tmp_char = step->job_ptr->account;
break;
case JOBCOMP:
default:
tmp_char = "n/a";
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_ACT_CPUFREQ:
if (got_stats) {
switch (type) {
case JOB:
if (!job->track_steps)
tmp_dub =
step->stats.act_cpufreq;
break;
case JOBSTEP:
tmp_dub = step->stats.act_cpufreq;
break;
default:
break;
}
}
if (!fuzzy_equal(tmp_dub, NO_VAL))
convert_num_unit2((double)tmp_dub, outbuf,
sizeof(outbuf), UNIT_KILO,
params.units, 1000,
params.convert_flags &
(~CONVERT_NUM_UNIT_EXACT));
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_ASSOCID:
switch(type) {
case JOB:
tmp_int = job->associd;
break;
case JOBSTEP:
tmp_int = step->job_ptr->associd;
break;
case JOBCOMP:
default:
tmp_int = NO_VAL;
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_AVECPU:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->stats.cpu_ave;
break;
case JOBSTEP:
tmp_dub = step->stats.cpu_ave;
break;
case JOBCOMP:
default:
break;
}
}
if (!fuzzy_equal(tmp_dub, NO_VAL))
tmp_char = _elapsed_time((long)tmp_dub, 0);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_AVEDISKREAD:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->
stats.disk_read_ave;
break;
case JOBSTEP:
tmp_dub = step->stats.disk_read_ave;
break;
case JOBCOMP:
default:
break;
}
}
_print_small_double(outbuf, sizeof(outbuf),
tmp_dub, UNIT_MEGA);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_AVEDISKWRITE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->
stats.disk_write_ave;
break;
case JOBSTEP:
tmp_dub = step->stats.disk_write_ave;
break;
case JOBCOMP:
default:
break;
}
}
_print_small_double(outbuf, sizeof(outbuf),
tmp_dub, UNIT_MEGA);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_AVEPAGES:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->stats.pages_ave;
break;
case JOBSTEP:
tmp_dub = step->stats.pages_ave;
break;
case JOBCOMP:
default:
break;
}
}
if (!fuzzy_equal(tmp_dub, NO_VAL))
convert_num_unit((double)tmp_dub, outbuf,
sizeof(outbuf), UNIT_KILO,
params.units,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_AVERSS:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->stats.rss_ave;
break;
case JOBSTEP:
tmp_dub = step->stats.rss_ave;
break;
case JOBCOMP:
default:
break;
}
}
if (!fuzzy_equal(tmp_dub, NO_VAL))
convert_num_unit((double)tmp_dub, outbuf,
sizeof(outbuf), UNIT_KILO,
params.units,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_AVEVSIZE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->stats.vsize_ave;
break;
case JOBSTEP:
tmp_dub = step->stats.vsize_ave;
break;
case JOBCOMP:
default:
break;
}
}
if (!fuzzy_equal(tmp_dub, NO_VAL))
convert_num_unit((double)tmp_dub, outbuf,
sizeof(outbuf), UNIT_KILO,
params.units,
params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_BLOCKID:
switch(type) {
case JOB:
tmp_char = job->blockid;
break;
case JOBSTEP:
break;
case JOBCOMP:
tmp_char = job_comp->blockid;
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_CLUSTER:
switch(type) {
case JOB:
tmp_char = job->cluster;
break;
case JOBSTEP:
tmp_char = step->job_ptr->cluster;
break;
case JOBCOMP:
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_COMMENT:
switch(type) {
case JOB:
tmp_char = job->derived_es;
break;
case JOBSTEP:
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_CONSUMED_ENERGY:
if (got_stats) {
switch (type) {
case JOB:
if (!job->track_steps)
tmp_dub = step->
stats.consumed_energy;
break;
case JOBSTEP:
tmp_dub = step->stats.consumed_energy;
break;
default:
break;
}
}
if (!fuzzy_equal(tmp_dub, NO_VAL))
convert_num_unit2((double)tmp_dub, outbuf,
sizeof(outbuf), UNIT_NONE,
params.units, 1000,
params.convert_flags &
(~CONVERT_NUM_UNIT_EXACT));
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_CONSUMED_ENERGY_RAW:
if (got_stats) {
switch (type) {
case JOB:
if (!job->track_steps)
tmp_dub = step->
stats.consumed_energy;
break;
case JOBSTEP:
tmp_dub = step->stats.consumed_energy;
break;
default:
break;
}
}
field->print_routine(field,
tmp_dub,
(curr_inx == field_count));
break;
case PRINT_CPU_TIME:
switch(type) {
case JOB:
tmp_uint64 = (uint64_t)job->elapsed
* (uint64_t)cpu_tres_rec_count;
break;
case JOBSTEP:
tmp_uint64 = (uint64_t)step->elapsed
* (uint64_t)step_cpu_tres_rec_count;
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_uint64,
(curr_inx == field_count));
break;
case PRINT_CPU_TIME_RAW:
switch(type) {
case JOB:
tmp_uint64 = (uint64_t)job->elapsed
* (uint64_t)cpu_tres_rec_count;
break;
case JOBSTEP:
tmp_uint64 = (uint64_t)step->elapsed
* (uint64_t)step_cpu_tres_rec_count;
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_uint64,
(curr_inx == field_count));
break;
case PRINT_DERIVED_EC:
tmp_int2 = 0;
switch(type) {
case JOB:
tmp_int = job->derived_ec;
if (tmp_int == NO_VAL)
tmp_int = 0;
if (WIFSIGNALED(tmp_int))
tmp_int2 = WTERMSIG(tmp_int);
snprintf(outbuf, sizeof(outbuf), "%d:%d",
WEXITSTATUS(tmp_int), tmp_int2);
break;
case JOBSTEP:
case JOBCOMP:
default:
outbuf[0] = '\0';
break;
}
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_ELAPSED:
switch(type) {
case JOB:
tmp_int = job->elapsed;
break;
case JOBSTEP:
tmp_int = step->elapsed;
break;
case JOBCOMP:
tmp_int = job_comp->elapsed_time;
break;
default:
tmp_int = NO_VAL;
break;
}
field->print_routine(field,
(uint64_t)tmp_int,
(curr_inx == field_count));
break;
case PRINT_ELIGIBLE:
switch(type) {
case JOB:
tmp_int = job->eligible;
break;
case JOBSTEP:
tmp_int = step->start;
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_END:
switch(type) {
case JOB:
tmp_int = job->end;
break;
case JOBSTEP:
tmp_int = step->end;
break;
case JOBCOMP:
tmp_int = parse_time(job_comp->end_time, 1);
break;
default:
tmp_int = NO_VAL;
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_EXITCODE:
tmp_int = 0;
tmp_int2 = 0;
switch(type) {
case JOB:
tmp_int = job->exitcode;
break;
case JOBSTEP:
tmp_int = step->exitcode;
break;
case JOBCOMP:
default:
break;
}
if (tmp_int != NO_VAL) {
if (WIFSIGNALED(tmp_int))
tmp_int2 = WTERMSIG(tmp_int);
tmp_int = WEXITSTATUS(tmp_int);
if (tmp_int >= 128)
tmp_int -= 128;
}
snprintf(outbuf, sizeof(outbuf), "%d:%d",
tmp_int, tmp_int2);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_GID:
switch(type) {
case JOB:
tmp_int = job->gid;
break;
case JOBSTEP:
tmp_int = NO_VAL;
break;
case JOBCOMP:
tmp_int = job_comp->gid;
break;
default:
tmp_int = NO_VAL;
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_GROUP:
switch(type) {
case JOB:
tmp_int = job->gid;
break;
case JOBSTEP:
tmp_int = NO_VAL;
break;
case JOBCOMP:
tmp_int = job_comp->gid;
break;
default:
tmp_int = NO_VAL;
break;
}
tmp_char = NULL;
if ((gr=getgrgid(tmp_int)))
tmp_char=gr->gr_name;
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_JOBID:
if (type == JOBSTEP)
job = step->job_ptr;
if (job) {
if (job->array_task_str) {
_xlate_task_str(job);
snprintf(id, FORMAT_STRING_SIZE,
"%u_[%s]",
job->array_job_id,
job->array_task_str);
} else if (job->array_task_id != NO_VAL)
snprintf(id, FORMAT_STRING_SIZE,
"%u_%u",
job->array_job_id,
job->array_task_id);
else
snprintf(id, FORMAT_STRING_SIZE,
"%u",
job->jobid);
}
switch (type) {
case JOB:
tmp_char = xstrdup(id);
break;
case JOBSTEP:
if (step->stepid == SLURM_BATCH_SCRIPT) {
tmp_char = xstrdup_printf(
"%s.batch", id);
} else if (step->stepid == SLURM_EXTERN_CONT) {
tmp_char = xstrdup_printf(
"%s.extern", id);
} else {
tmp_char = xstrdup_printf(
"%s.%u",
id, step->stepid);
}
break;
case JOBCOMP:
tmp_char = xstrdup_printf("%u",
job_comp->jobid);
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_JOBIDRAW:
switch (type) {
case JOB:
tmp_char = xstrdup_printf("%u", job->jobid);
break;
case JOBSTEP:
if (step->stepid == SLURM_BATCH_SCRIPT) {
tmp_char = xstrdup_printf(
"%u.batch",
step->job_ptr->jobid);
} else if (step->stepid == SLURM_EXTERN_CONT) {
tmp_char = xstrdup_printf(
"%u.extern",
step->job_ptr->jobid);
} else {
tmp_char = xstrdup_printf(
"%u.%u",
step->job_ptr->jobid,
step->stepid);
}
break;
case JOBCOMP:
tmp_char = xstrdup_printf("%u",
job_comp->jobid);
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_JOBNAME:
switch(type) {
case JOB:
tmp_char = job->jobname;
break;
case JOBSTEP:
tmp_char = step->stepname;
break;
case JOBCOMP:
tmp_char = job_comp->jobname;
break;
default:
tmp_char = NULL;
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_LAYOUT:
switch(type) {
case JOB:
/* below really should be step. It is
not a typo */
if (!job->track_steps)
tmp_char = slurm_step_layout_type_name(
step->task_dist);
break;
case JOBSTEP:
tmp_char = slurm_step_layout_type_name(
step->task_dist);
break;
case JOBCOMP:
break;
default:
tmp_char = NULL;
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_MAXDISKREAD:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->
stats.disk_read_max;
break;
case JOBSTEP:
tmp_dub = step->stats.disk_read_max;
break;
case JOBCOMP:
default:
break;
}
}
_print_small_double(outbuf, sizeof(outbuf),
tmp_dub, UNIT_MEGA);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXDISKREADNODE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_char = find_hostname(
job->stats.
disk_read_max_nodeid,
job->nodes);
break;
case JOBSTEP:
tmp_char = find_hostname(
step->stats.
disk_read_max_nodeid,
step->nodes);
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MAXDISKREADTASK:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint32 =
job->stats.
disk_read_max_taskid;
break;
case JOBSTEP:
tmp_uint32 = step->stats.
disk_read_max_taskid;
break;
case JOBCOMP:
default:
tmp_uint32 = NO_VAL;
break;
}
}
if (tmp_uint32 == (uint32_t)NO_VAL)
tmp_uint32 = NO_VAL;
field->print_routine(field,
tmp_uint32,
(curr_inx == field_count));
break;
case PRINT_MAXDISKWRITE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->stats.
disk_write_max;
break;
case JOBSTEP:
tmp_dub = step->stats.disk_write_max;
break;
case JOBCOMP:
default:
break;
}
}
_print_small_double(outbuf, sizeof(outbuf),
tmp_dub, UNIT_MEGA);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXDISKWRITENODE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_char = find_hostname(
job->stats.
disk_write_max_nodeid,
job->nodes);
break;
case JOBSTEP:
tmp_char = find_hostname(
step->stats.
disk_write_max_nodeid,
step->nodes);
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MAXDISKWRITETASK:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint32 =
job->stats.
disk_write_max_taskid;
break;
case JOBSTEP:
tmp_uint32 = step->stats.
disk_write_max_taskid;
break;
case JOBCOMP:
default:
tmp_uint32 = NO_VAL;
break;
}
if (tmp_uint32 == (uint32_t)NO_VAL)
tmp_uint32 = NO_VAL;
}
field->print_routine(field,
tmp_uint32,
(curr_inx == field_count));
break;
case PRINT_MAXPAGES:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint64 =
job->stats.pages_max;
break;
case JOBSTEP:
tmp_uint64 = step->stats.pages_max;
break;
case JOBCOMP:
default:
break;
}
if (tmp_uint64 != (uint64_t)NO_VAL64)
convert_num_unit(
(double)tmp_uint64,
outbuf, sizeof(outbuf),
UNIT_KILO, params.units,
params.convert_flags);
}
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXPAGESNODE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_char = find_hostname(
job->stats.
pages_max_nodeid,
job->nodes);
break;
case JOBSTEP:
tmp_char = find_hostname(
step->stats.pages_max_nodeid,
step->nodes);
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MAXPAGESTASK:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint32 =
job->stats.
pages_max_taskid;
break;
case JOBSTEP:
tmp_uint32 = step->stats.
pages_max_taskid;
break;
case JOBCOMP:
default:
tmp_uint32 = NO_VAL;
break;
}
if (tmp_uint32 == (uint32_t)NO_VAL)
tmp_uint32 = NO_VAL;
}
field->print_routine(field,
tmp_uint32,
(curr_inx == field_count));
break;
case PRINT_MAXRSS:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint64 = job->stats.rss_max;
break;
case JOBSTEP:
tmp_uint64 = step->stats.rss_max;
break;
case JOBCOMP:
default:
break;
}
if (tmp_uint64 != (uint64_t)NO_VAL64)
convert_num_unit(
(double)tmp_uint64,
outbuf, sizeof(outbuf),
UNIT_KILO, params.units,
params.convert_flags);
}
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXRSSNODE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_char = find_hostname(
job->stats.
rss_max_nodeid,
job->nodes);
break;
case JOBSTEP:
tmp_char = find_hostname(
step->stats.rss_max_nodeid,
step->nodes);
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MAXRSSTASK:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint32 = job->stats.
rss_max_taskid;
break;
case JOBSTEP:
tmp_uint32 = step->stats.rss_max_taskid;
break;
case JOBCOMP:
default:
tmp_uint32 = NO_VAL;
break;
}
if (tmp_uint32 == (uint32_t)NO_VAL)
tmp_uint32 = NO_VAL;
}
field->print_routine(field,
tmp_uint32,
(curr_inx == field_count));
break;
case PRINT_MAXVSIZE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint64 = job->stats.
vsize_max;
break;
case JOBSTEP:
tmp_uint64 = step->stats.vsize_max;
break;
case JOBCOMP:
default:
tmp_uint64 = (uint64_t)NO_VAL64;
break;
}
if (tmp_uint64 != (uint64_t)NO_VAL64)
convert_num_unit(
(double)tmp_uint64,
outbuf, sizeof(outbuf),
UNIT_KILO, params.units,
params.convert_flags);
}
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_MAXVSIZENODE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_char = find_hostname(
job->stats.
vsize_max_nodeid,
job->nodes);
break;
case JOBSTEP:
tmp_char = find_hostname(
step->stats.vsize_max_nodeid,
step->nodes);
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MAXVSIZETASK:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint32 =
job->stats.
vsize_max_taskid;
break;
case JOBSTEP:
tmp_uint32 = step->stats.
vsize_max_taskid;
break;
case JOBCOMP:
default:
tmp_uint32 = NO_VAL;
break;
}
if (tmp_uint32 == (uint32_t)NO_VAL)
tmp_uint32 = NO_VAL;
}
field->print_routine(field,
tmp_uint32,
(curr_inx == field_count));
break;
case PRINT_MINCPU:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_dub = job->stats.cpu_min;
break;
case JOBSTEP:
tmp_dub = step->stats.cpu_min;
break;
case JOBCOMP:
default:
break;
}
if (!fuzzy_equal(tmp_dub, NO_VAL))
tmp_char = _elapsed_time(
(long)tmp_dub, 0);
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MINCPUNODE:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_char = find_hostname(
job->stats.
cpu_min_nodeid,
job->nodes);
break;
case JOBSTEP:
tmp_char = find_hostname(
step->stats.cpu_min_nodeid,
step->nodes);
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_MINCPUTASK:
if (got_stats) {
switch(type) {
case JOB:
if (!job->track_steps)
tmp_uint32 = job->stats.
cpu_min_taskid;
break;
case JOBSTEP:
tmp_uint32 = step->stats.cpu_min_taskid;
break;
case JOBCOMP:
default:
tmp_uint32 = NO_VAL;
break;
}
if (tmp_uint32 == (uint32_t)NO_VAL)
tmp_uint32 = NO_VAL;
}
field->print_routine(field,
tmp_uint32,
(curr_inx == field_count));
break;
case PRINT_NODELIST:
switch(type) {
case JOB:
tmp_char = job->nodes;
break;
case JOBSTEP:
tmp_char = step->nodes;
break;
case JOBCOMP:
tmp_char = job_comp->nodelist;
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_NNODES:
switch(type) {
case JOB:
tmp_int = job->alloc_nodes;
tmp_char = (job->tres_alloc_str &&
job->tres_alloc_str[0])
? job->tres_alloc_str :
job->tres_req_str;
break;
case JOBSTEP:
tmp_int = step->nnodes;
tmp_char = step->tres_alloc_str;
break;
case JOBCOMP:
tmp_int = job_comp->node_cnt;
break;
default:
break;
}
if (!tmp_int && tmp_char) {
if ((tmp_uint64 =
slurmdb_find_tres_count_in_string(
tmp_char, TRES_NODE))
!= INFINITE64)
tmp_int = tmp_uint64;
}
convert_num_unit((double)tmp_int, outbuf,
sizeof(outbuf), UNIT_NONE,
params.units, params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_NTASKS:
switch(type) {
case JOB:
if (!job->track_steps && !step)
tmp_int = cpu_tres_rec_count;
// we want to use the step info
if (!step)
break;
case JOBSTEP:
tmp_int = step->ntasks;
break;
case JOBCOMP:
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_PRIO:
switch(type) {
case JOB:
tmp_int = job->priority;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_PARTITION:
switch(type) {
case JOB:
tmp_char = job->partition;
break;
case JOBSTEP:
break;
case JOBCOMP:
tmp_char = job_comp->partition;
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_QOS:
switch(type) {
case JOB:
tmp_int = job->qosid;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
if (!g_qos_list) {
slurmdb_qos_cond_t qos_cond;
memset(&qos_cond, 0,
sizeof(slurmdb_qos_cond_t));
qos_cond.with_deleted = 1;
g_qos_list = slurmdb_qos_get(
acct_db_conn, &qos_cond);
}
tmp_char = _find_qos_name_from_list(g_qos_list,
tmp_int);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_QOSRAW:
switch(type) {
case JOB:
tmp_int = job->qosid;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_REQ_CPUFREQ_MIN:
switch (type) {
case JOB:
if (!job->track_steps && !step)
tmp_dub = NO_VAL;
// we want to use the step info
if (!step)
break;
case JOBSTEP:
tmp_dub = step->req_cpufreq_min;
break;
default:
break;
}
cpu_freq_to_string(outbuf, sizeof(outbuf), tmp_dub);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_REQ_CPUFREQ_MAX:
switch (type) {
case JOB:
if (!job->track_steps && !step)
tmp_dub = NO_VAL;
// we want to use the step info
if (!step)
break;
case JOBSTEP:
tmp_dub = step->req_cpufreq_max;
break;
default:
break;
}
cpu_freq_to_string(outbuf, sizeof(outbuf), tmp_dub);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_REQ_CPUFREQ_GOV:
switch (type) {
case JOB:
if (!job->track_steps && !step)
tmp_dub = NO_VAL;
// we want to use the step info
if (!step)
break;
case JOBSTEP:
tmp_dub = step->req_cpufreq_gov;
break;
default:
break;
}
cpu_freq_to_string(outbuf, sizeof(outbuf), tmp_dub);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_REQ_CPUS:
switch(type) {
case JOB:
tmp_int = job->req_cpus;
break;
case JOBSTEP:
tmp_int = step_cpu_tres_rec_count;
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_REQ_GRES:
switch(type) {
case JOB:
tmp_char = job->req_gres;
break;
case JOBSTEP:
tmp_char = step->job_ptr->req_gres;
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_REQ_MEM:
switch(type) {
case JOB:
tmp_uint32 = job->req_mem;
break;
case JOBSTEP:
tmp_uint32 = step->job_ptr->req_mem;
break;
case JOBCOMP:
default:
tmp_uint32 = NO_VAL;
break;
}
if (tmp_uint32 != (uint32_t)NO_VAL) {
bool per_cpu = false;
if (tmp_uint32 & MEM_PER_CPU) {
tmp_uint32 &= (~MEM_PER_CPU);
per_cpu = true;
}
convert_num_unit((double)tmp_uint32,
outbuf, sizeof(outbuf),
UNIT_MEGA, params.units,
params.convert_flags);
if (per_cpu)
sprintf(outbuf+strlen(outbuf), "c");
else
sprintf(outbuf+strlen(outbuf), "n");
}
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_REQ_NODES:
switch(type) {
case JOB:
tmp_int = 0;
tmp_char = job->tres_req_str;
break;
case JOBSTEP:
tmp_int = step->nnodes;
tmp_char = step->tres_alloc_str;
break;
case JOBCOMP:
tmp_int = job_comp->node_cnt;
break;
default:
break;
}
if (!tmp_int && tmp_char) {
if ((tmp_uint64 =
slurmdb_find_tres_count_in_string(
tmp_char, TRES_NODE))
!= INFINITE64)
tmp_int = tmp_uint64;
}
convert_num_unit((double)tmp_int, outbuf,
sizeof(outbuf), UNIT_NONE,
params.units, params.convert_flags);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_RESERVATION:
switch(type) {
case JOB:
if (job->resv_name) {
tmp_char = job->resv_name;
} else {
tmp_char = NULL;
}
break;
case JOBSTEP:
tmp_char = NULL;
break;
case JOBCOMP:
tmp_char = NULL;
break;
default:
tmp_char = NULL;
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_RESERVATION_ID:
switch(type) {
case JOB:
if (job->resvid)
tmp_uint32 = job->resvid;
else
tmp_uint32 = NO_VAL;
break;
case JOBSTEP:
tmp_uint32 = NO_VAL;
break;
case JOBCOMP:
tmp_uint32 = NO_VAL;
break;
default:
tmp_uint32 = NO_VAL;
break;
}
if (tmp_uint32 == (uint32_t)NO_VAL)
tmp_uint32 = NO_VAL;
field->print_routine(field,
tmp_uint32,
(curr_inx == field_count));
break;
case PRINT_RESV:
switch(type) {
case JOB:
if (job->start)
tmp_int = job->start - job->eligible;
else
tmp_int = time(NULL) - job->eligible;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
(uint64_t)tmp_int,
(curr_inx == field_count));
break;
case PRINT_RESV_CPU:
switch(type) {
case JOB:
if (job->start)
tmp_int = (job->start - job->eligible)
* job->req_cpus;
else
tmp_int = (time(NULL) - job->eligible)
* job->req_cpus;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
(uint64_t)tmp_int,
(curr_inx == field_count));
break;
case PRINT_RESV_CPU_RAW:
switch(type) {
case JOB:
if (job->start)
tmp_int = (job->start - job->eligible)
* job->req_cpus;
else
tmp_int = (time(NULL) - job->eligible)
* job->req_cpus;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_START:
switch(type) {
case JOB:
tmp_int = job->start;
break;
case JOBSTEP:
tmp_int = step->start;
break;
case JOBCOMP:
tmp_int = parse_time(job_comp->start_time, 1);
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_STATE:
switch(type) {
case JOB:
tmp_int = job->state;
tmp_int2 = job->requid;
break;
case JOBSTEP:
tmp_int = step->state;
tmp_int2 = step->requid;
break;
case JOBCOMP:
tmp_char = job_comp->state;
break;
default:
break;
}
if (((tmp_int & JOB_STATE_BASE) == JOB_CANCELLED) &&
(tmp_int2 != -1))
snprintf(outbuf, FORMAT_STRING_SIZE,
"%s by %d",
job_state_string(tmp_int),
tmp_int2);
else if (tmp_int != NO_VAL)
snprintf(outbuf, FORMAT_STRING_SIZE,
"%s",
job_state_string(tmp_int));
else if (tmp_char)
snprintf(outbuf, FORMAT_STRING_SIZE,
"%s",
tmp_char);
field->print_routine(field,
outbuf,
(curr_inx == field_count));
break;
case PRINT_SUBMIT:
switch(type) {
case JOB:
tmp_int = job->submit;
break;
case JOBSTEP:
tmp_int = step->start;
break;
case JOBCOMP:
tmp_int = parse_time(job_comp->start_time, 1);
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_SUSPENDED:
switch(type) {
case JOB:
tmp_int = job->suspended;
break;
case JOBSTEP:
tmp_int = step->suspended;
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
(uint64_t)tmp_int,
(curr_inx == field_count));
break;
case PRINT_SYSTEMCPU:
if (got_stats) {
switch(type) {
case JOB:
tmp_int = job->sys_cpu_sec;
tmp_int2 = job->sys_cpu_usec;
break;
case JOBSTEP:
tmp_int = step->sys_cpu_sec;
tmp_int2 = step->sys_cpu_usec;
break;
case JOBCOMP:
default:
break;
}
tmp_char = _elapsed_time(tmp_int, tmp_int2);
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_TIMELIMIT:
switch(type) {
case JOB:
if (job->timelimit == INFINITE)
tmp_char = "UNLIMITED";
else if (job->timelimit == NO_VAL)
tmp_char = "Partition_Limit";
else if (job->timelimit) {
char tmp1[128];
mins2time_str(job->timelimit,
tmp1, sizeof(tmp1));
tmp_char = tmp1;
}
break;
case JOBSTEP:
break;
case JOBCOMP:
tmp_char = job_comp->timelimit;
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_TOTALCPU:
switch(type) {
case JOB:
tmp_int = job->tot_cpu_sec;
tmp_int2 = job->tot_cpu_usec;
break;
case JOBSTEP:
tmp_int = step->tot_cpu_sec;
tmp_int2 = step->tot_cpu_usec;
break;
case JOBCOMP:
break;
default:
break;
}
tmp_char = _elapsed_time(tmp_int, tmp_int2);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_TRESA:
switch(type) {
case JOB:
tmp_char = job->tres_alloc_str;
break;
case JOBSTEP:
tmp_char = step->tres_alloc_str;
break;
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
if (!g_tres_list) {
slurmdb_tres_cond_t tres_cond;
memset(&tres_cond, 0,
sizeof(slurmdb_tres_cond_t));
tres_cond.with_deleted = 1;
g_tres_list = slurmdb_tres_get(
acct_db_conn, &tres_cond);
}
tmp_char = slurmdb_make_tres_string_from_simple(
tmp_char, g_tres_list, params.units,
params.convert_flags);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_TRESR:
switch(type) {
case JOB:
tmp_char = job->tres_req_str;
break;
case JOBSTEP:
case JOBCOMP:
default:
tmp_char = NULL;
break;
}
if (!g_tres_list) {
slurmdb_tres_cond_t tres_cond;
memset(&tres_cond, 0,
sizeof(slurmdb_tres_cond_t));
tres_cond.with_deleted = 1;
g_tres_list = slurmdb_tres_get(
acct_db_conn, &tres_cond);
}
tmp_char = slurmdb_make_tres_string_from_simple(
tmp_char, g_tres_list, params.units,
params.convert_flags);
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_UID:
switch(type) {
case JOB:
if (job->user) {
if ((pw=getpwnam(job->user)))
tmp_int = pw->pw_uid;
} else
tmp_int = job->uid;
break;
case JOBSTEP:
break;
case JOBCOMP:
tmp_int = job_comp->uid;
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
case PRINT_USER:
switch(type) {
case JOB:
if (job->user)
tmp_char = job->user;
else if (job->uid != -1) {
if ((pw=getpwuid(job->uid)))
tmp_char = pw->pw_name;
}
break;
case JOBSTEP:
break;
case JOBCOMP:
tmp_char = job_comp->uid_name;
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_USERCPU:
if (got_stats) {
switch(type) {
case JOB:
tmp_int = job->user_cpu_sec;
tmp_int2 = job->user_cpu_usec;
break;
case JOBSTEP:
tmp_int = step->user_cpu_sec;
tmp_int2 = step->user_cpu_usec;
break;
case JOBCOMP:
default:
break;
}
tmp_char = _elapsed_time(tmp_int, tmp_int2);
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
xfree(tmp_char);
break;
case PRINT_WCKEY:
switch(type) {
case JOB:
tmp_char = job->wckey;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_char,
(curr_inx == field_count));
break;
case PRINT_WCKEYID:
switch(type) {
case JOB:
tmp_int = job->wckeyid;
break;
case JOBSTEP:
break;
case JOBCOMP:
break;
default:
break;
}
field->print_routine(field,
tmp_int,
(curr_inx == field_count));
break;
default:
break;
}
curr_inx++;
}
printf("\n");
}
extern int as_mysql_step_start(mysql_conn_t *mysql_conn,
struct step_record *step_ptr)
{
int tasks = 0, nodes = 0, task_dist = 0;
int rc=SLURM_SUCCESS;
char node_list[BUFFER_SIZE];
char *node_inx = NULL, *step_name = NULL;
time_t start_time, submit_time;
char *query = NULL;
if (!step_ptr->job_ptr->db_index
&& ((!step_ptr->job_ptr->details
|| !step_ptr->job_ptr->details->submit_time)
&& !step_ptr->job_ptr->resize_time)) {
error("as_mysql_step_start: "
"Not inputing this job, it has no submit time.");
return SLURM_ERROR;
}
if (step_ptr->job_ptr->resize_time) {
submit_time = start_time = step_ptr->job_ptr->resize_time;
if (step_ptr->start_time > submit_time)
start_time = step_ptr->start_time;
} else {
start_time = step_ptr->start_time;
submit_time = step_ptr->job_ptr->details->submit_time;
}
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return ESLURM_DB_CONNECTION;
if (slurmdbd_conf) {
if (step_ptr->job_ptr->details)
tasks = step_ptr->job_ptr->details->num_tasks;
else
tasks = step_ptr->cpu_count;
snprintf(node_list, BUFFER_SIZE, "%s",
step_ptr->job_ptr->nodes);
nodes = step_ptr->step_layout->node_cnt;
task_dist = step_ptr->step_layout->task_dist;
node_inx = step_ptr->network;
} else if (step_ptr->step_id == SLURM_BATCH_SCRIPT) {
char temp_bit[BUF_SIZE];
if (step_ptr->step_node_bitmap) {
node_inx = bit_fmt(temp_bit, sizeof(temp_bit),
step_ptr->step_node_bitmap);
}
/* We overload gres with the node name of where the
script was running.
*/
snprintf(node_list, BUFFER_SIZE, "%s", step_ptr->gres);
nodes = tasks = 1;
if (!step_ptr->tres_alloc_str)
xstrfmtcat(step_ptr->tres_alloc_str,
"%s%u=%u,%u=%u",
step_ptr->tres_alloc_str ? "," : "",
TRES_CPU, 1,
TRES_NODE, 1);
} else {
char *ionodes = NULL, *temp_nodes = NULL;
char temp_bit[BUF_SIZE];
if (step_ptr->step_node_bitmap) {
node_inx = bit_fmt(temp_bit, sizeof(temp_bit),
step_ptr->step_node_bitmap);
}
#ifdef HAVE_BG_L_P
/* Only L and P use this code */
if (step_ptr->job_ptr->details)
tasks = step_ptr->job_ptr->details->min_cpus;
else
tasks = step_ptr->job_ptr->cpu_cnt;
select_g_select_jobinfo_get(step_ptr->job_ptr->select_jobinfo,
SELECT_JOBDATA_NODE_CNT,
&nodes);
temp_nodes = step_ptr->job_ptr->nodes;
#else
if (!step_ptr->step_layout
|| !step_ptr->step_layout->task_cnt) {
if (step_ptr->cpu_count)
tasks = step_ptr->cpu_count;
else {
if ((tasks = slurmdb_find_tres_count_in_string(
step_ptr->tres_alloc_str,
TRES_CPU)) == INFINITE64) {
if ((tasks =
slurmdb_find_tres_count_in_string(
step_ptr->job_ptr->
tres_alloc_str,
TRES_CPU)) == INFINITE64)
tasks = step_ptr->job_ptr->
total_nodes;
}
}
nodes = step_ptr->job_ptr->total_nodes;
temp_nodes = step_ptr->job_ptr->nodes;
} else {
tasks = step_ptr->step_layout->task_cnt;
#ifdef HAVE_BGQ
select_g_select_jobinfo_get(step_ptr->select_jobinfo,
SELECT_JOBDATA_NODE_CNT,
&nodes);
#else
nodes = step_ptr->step_layout->node_cnt;
#endif
task_dist = step_ptr->step_layout->task_dist;
temp_nodes = step_ptr->step_layout->node_list;
}
#endif
select_g_select_jobinfo_get(step_ptr->select_jobinfo,
SELECT_JOBDATA_IONODES,
&ionodes);
if (ionodes) {
snprintf(node_list, BUFFER_SIZE, "%s[%s]",
temp_nodes, ionodes);
xfree(ionodes);
} else
snprintf(node_list, BUFFER_SIZE, "%s", temp_nodes);
}
if (!step_ptr->job_ptr->db_index) {
if (!(step_ptr->job_ptr->db_index =
_get_db_index(mysql_conn,
submit_time,
step_ptr->job_ptr->job_id,
step_ptr->job_ptr->assoc_id))) {
/* If we get an error with this just fall
* through to avoid an infinite loop
*/
if (as_mysql_job_start(mysql_conn, step_ptr->job_ptr)
== SLURM_ERROR) {
error("couldn't add job %u at step start",
step_ptr->job_ptr->job_id);
return SLURM_SUCCESS;
}
}
}
step_name = slurm_add_slash_to_quotes(step_ptr->name);
/* we want to print a -1 for the requid so leave it a
%d */
/* The stepid could be -2 so use %d not %u */
query = xstrdup_printf(
"insert into \"%s_%s\" (job_db_inx, id_step, time_start, "
"step_name, state, tres_alloc, "
"nodes_alloc, task_cnt, nodelist, node_inx, "
"task_dist, req_cpufreq, req_cpufreq_min, req_cpufreq_gov) "
"values (%d, %d, %d, '%s', %d, '%s', %d, %d, "
"'%s', '%s', %d, %u, %u, %u) "
"on duplicate key update "
"nodes_alloc=%d, task_cnt=%d, time_end=0, state=%d, "
"nodelist='%s', node_inx='%s', task_dist=%d, "
"req_cpufreq=%u, req_cpufreq_min=%u, req_cpufreq_gov=%u,"
"tres_alloc='%s';",
mysql_conn->cluster_name, step_table,
step_ptr->job_ptr->db_index,
step_ptr->step_id,
(int)start_time, step_name,
JOB_RUNNING, step_ptr->tres_alloc_str,
nodes, tasks, node_list, node_inx, task_dist,
step_ptr->cpu_freq_max, step_ptr->cpu_freq_min,
step_ptr->cpu_freq_gov, nodes, tasks, JOB_RUNNING,
node_list, node_inx, task_dist, step_ptr->cpu_freq_max,
step_ptr->cpu_freq_min, step_ptr->cpu_freq_gov,
step_ptr->tres_alloc_str);
if (debug_flags & DEBUG_FLAG_DB_STEP)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
xfree(step_name);
return rc;
}
extern int as_mysql_step_complete(mysql_conn_t *mysql_conn,
struct step_record *step_ptr)
{
time_t now;
uint16_t comp_status;
int tasks = 0;
struct jobacctinfo *jobacct = (struct jobacctinfo *)step_ptr->jobacct;
char *query = NULL;
int rc = SLURM_SUCCESS;
uint32_t exit_code = 0;
time_t submit_time;
if (!step_ptr->job_ptr->db_index
&& ((!step_ptr->job_ptr->details
|| !step_ptr->job_ptr->details->submit_time)
&& !step_ptr->job_ptr->resize_time)) {
error("as_mysql_step_complete: "
"Not inputing this job, it has no submit time.");
return SLURM_ERROR;
}
if (step_ptr->job_ptr->resize_time)
submit_time = step_ptr->job_ptr->resize_time;
else
submit_time = step_ptr->job_ptr->details->submit_time;
if (check_connection(mysql_conn) != SLURM_SUCCESS)
return ESLURM_DB_CONNECTION;
if (slurmdbd_conf) {
now = step_ptr->job_ptr->end_time;
if (step_ptr->job_ptr->details)
tasks = step_ptr->job_ptr->details->num_tasks;
else
tasks = step_ptr->cpu_count;
} else if (step_ptr->step_id == SLURM_BATCH_SCRIPT) {
now = time(NULL);
tasks = 1;
} else {
now = time(NULL);
#ifdef HAVE_BG_L_P
/* Only L and P use this code */
tasks = step_ptr->job_ptr->details->min_cpus;
#else
if (!step_ptr->step_layout
|| !step_ptr->step_layout->task_cnt) {
if (step_ptr->cpu_count)
tasks = step_ptr->cpu_count;
else {
if ((tasks = slurmdb_find_tres_count_in_string(
step_ptr->tres_alloc_str,
TRES_CPU)) == INFINITE64) {
if ((tasks =
slurmdb_find_tres_count_in_string(
step_ptr->job_ptr->
tres_alloc_str,
TRES_CPU)) == INFINITE64)
tasks = step_ptr->job_ptr->
total_nodes;
}
}
} else
tasks = step_ptr->step_layout->task_cnt;
#endif
}
exit_code = step_ptr->exit_code;
comp_status = step_ptr->state & JOB_STATE_BASE;
if (comp_status < JOB_COMPLETE) {
if (WIFSIGNALED(exit_code)) {
comp_status = JOB_CANCELLED;
} else if (exit_code)
comp_status = JOB_FAILED;
else {
step_ptr->requid = -1;
comp_status = JOB_COMPLETE;
}
}
if (!step_ptr->job_ptr->db_index) {
if (!(step_ptr->job_ptr->db_index =
_get_db_index(mysql_conn,
submit_time,
step_ptr->job_ptr->job_id,
step_ptr->job_ptr->assoc_id))) {
/* If we get an error with this just fall
* through to avoid an infinite loop
*/
if (as_mysql_job_start(mysql_conn, step_ptr->job_ptr)
== SLURM_ERROR) {
error("couldn't add job %u "
"at step completion",
step_ptr->job_ptr->job_id);
return SLURM_SUCCESS;
}
}
}
/* The stepid could be -2 so use %d not %u */
query = xstrdup_printf(
"update \"%s_%s\" set time_end=%d, state=%u, "
"kill_requid=%d, exit_code=%d",
mysql_conn->cluster_name, step_table, (int)now,
comp_status,
step_ptr->requid,
exit_code);
if (jobacct) {
double ave_vsize = NO_VAL, ave_rss = NO_VAL, ave_pages = NO_VAL;
double ave_disk_read = (double)NO_VAL;
double ave_disk_write = (double)NO_VAL;
double ave_cpu = (double)NO_VAL;
/* figure out the ave of the totals sent */
if (tasks > 0) {
ave_vsize = (double)jobacct->tot_vsize;
ave_vsize /= (double)tasks;
ave_rss = (double)jobacct->tot_rss;
ave_rss /= (double)tasks;
ave_pages = (double)jobacct->tot_pages;
ave_pages /= (double)tasks;
ave_cpu = (double)jobacct->tot_cpu;
ave_cpu /= (double)tasks;
ave_disk_read = (double)jobacct->tot_disk_read;
ave_disk_read /= (double)tasks;
ave_disk_write = (double)jobacct->tot_disk_write;
ave_disk_write /= (double)tasks;
}
xstrfmtcat(query,
", user_sec=%u, user_usec=%u, "
"sys_sec=%u, sys_usec=%u, "
"max_disk_read=%f, max_disk_read_task=%u, "
"max_disk_read_node=%u, ave_disk_read=%f, "
"max_disk_write=%f, max_disk_write_task=%u, "
"max_disk_write_node=%u, ave_disk_write=%f, "
"max_vsize=%"PRIu64", max_vsize_task=%u, "
"max_vsize_node=%u, ave_vsize=%f, "
"max_rss=%"PRIu64", max_rss_task=%u, "
"max_rss_node=%u, ave_rss=%f, "
"max_pages=%"PRIu64", max_pages_task=%u, "
"max_pages_node=%u, ave_pages=%f, "
"min_cpu=%u, min_cpu_task=%u, "
"min_cpu_node=%u, ave_cpu=%f, "
"act_cpufreq=%u, consumed_energy=%"PRIu64"",
/* user seconds */
jobacct->user_cpu_sec,
/* user microseconds */
jobacct->user_cpu_usec,
/* system seconds */
jobacct->sys_cpu_sec,
/* system microsecs */
jobacct->sys_cpu_usec,
/* max disk_read */
jobacct->max_disk_read,
/* max disk_read task */
jobacct->max_disk_read_id.taskid,
/* max disk_read node */
jobacct->max_disk_read_id.nodeid,
/* ave disk_read */
ave_disk_read,
/* max disk_write */
jobacct->max_disk_write,
/* max disk_write task */
jobacct->max_disk_write_id.taskid,
/* max disk_write node */
jobacct->max_disk_write_id.nodeid,
/* ave disk_write */
ave_disk_write,
jobacct->max_vsize, /* max vsize */
jobacct->max_vsize_id.taskid, /* max vsize task */
jobacct->max_vsize_id.nodeid, /* max vsize node */
ave_vsize, /* ave vsize */
jobacct->max_rss, /* max vsize */
jobacct->max_rss_id.taskid, /* max rss task */
jobacct->max_rss_id.nodeid, /* max rss node */
ave_rss, /* ave rss */
jobacct->max_pages, /* max pages */
jobacct->max_pages_id.taskid, /* max pages task */
jobacct->max_pages_id.nodeid, /* max pages node */
ave_pages, /* ave pages */
jobacct->min_cpu, /* min cpu */
jobacct->min_cpu_id.taskid, /* min cpu task */
jobacct->min_cpu_id.nodeid, /* min cpu node */
ave_cpu, /* ave cpu */
jobacct->act_cpufreq,
jobacct->energy.consumed_energy);
}
xstrfmtcat(query,
" where job_db_inx=%d and id_step=%d",
step_ptr->job_ptr->db_index, step_ptr->step_id);
if (debug_flags & DEBUG_FLAG_DB_STEP)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
return rc;
}
