/* * get info from the storage * IN: slurmdb_wckey_cond_t * * RET: List of slurmdb_wckey_rec_t * * note List needs to be freed with slurm_list_destroy() when called */ extern List slurmdb_wckeys_get(void *db_conn, slurmdb_wckey_cond_t *wckey_cond) { if (db_api_uid == -1) db_api_uid = getuid(); return acct_storage_g_get_wckeys(db_conn, db_api_uid, wckey_cond); }
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; 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; char *tmp = NULL; individual = 1; itr = list_iterator_create(job_list); while((job = list_next(itr))) { if (!job->elapsed || !job->alloc_cpus) continue; tmp = xstrdup_printf("%u", job->alloc_cpus); while((group = list_next(group_itr))) { if (!strcmp(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_association_cond_t assoc_cond; memset(&assoc_cond, 0, sizeof(slurmdb_association_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)) { if (job_cond->acct_list) list_destroy(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_associations(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_association_rec_t *assoc = (slurmdb_association_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_association_rec_t *assoc2 = (slurmdb_association_rec_t *)object2; char name[200]; if (!wckey_type) { if (strcmp(assoc->cluster, wckey2->cluster)) continue; cluster = assoc->cluster; snprintf(name, sizeof(name), "%s:%s", assoc->acct, wckey2->name); } else { if (strcmp(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 (!strcmp(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 (!strcmp(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 strcmp 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 (!strcmp(mywckey, job->wckey)) break; } } else if (!strcmp(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 total_secs = 0; if ((job->alloc_cpus < job_group->min_size) || (job->alloc_cpus > job_group->max_size)) continue; list_append(job_group->jobs, job); job_group->count++; acct_group->count++; cluster_group->count++; total_secs = (uint64_t)job->elapsed * (uint64_t)job->alloc_cpus; job_group->cpu_secs += total_secs; acct_group->cpu_secs += total_secs; cluster_group->cpu_secs += total_secs; } 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: if (object_list) list_destroy(object_list); if (object2_list) list_destroy(object2_list); if (destroy_job_cond) slurmdb_destroy_job_cond(job_cond); if (destroy_grouping_list && grouping_list) list_destroy(grouping_list); if (exit_code) { if (cluster_list) { list_destroy(cluster_list); cluster_list = NULL; } } return cluster_list; }
static List _process_util_by_report(void *db_conn, char *calling_name, void *cond, cluster_report_t type) { ListIterator itr = NULL; ListIterator type_itr = NULL; slurmdb_cluster_cond_t cluster_cond; List type_list = NULL; List cluster_list = NULL; List first_list = NULL; slurmdb_cluster_rec_t *cluster = NULL; slurmdb_report_cluster_rec_t *slurmdb_report_cluster = NULL; time_t start_time, end_time; int exit_code = 0; uid_t my_uid = getuid(); List ret_list = list_create(slurmdb_destroy_report_cluster_rec); slurmdb_init_cluster_cond(&cluster_cond, 0); cluster_cond.with_deleted = 1; cluster_cond.with_usage = 1; if ((type == CLUSTER_REPORT_UA) || (type == CLUSTER_REPORT_AU)) { start_time = ((slurmdb_assoc_cond_t *)cond)->usage_start; end_time = ((slurmdb_assoc_cond_t *)cond)->usage_end; cluster_cond.cluster_list = ((slurmdb_assoc_cond_t *)cond)->cluster_list; } else if ((type == CLUSTER_REPORT_UW) || (type == CLUSTER_REPORT_WU)) { start_time = ((slurmdb_wckey_cond_t *)cond)->usage_start; end_time = ((slurmdb_wckey_cond_t *)cond)->usage_end; cluster_cond.cluster_list = ((slurmdb_wckey_cond_t *)cond)->cluster_list; } else { error("unknown report type %d", type); return NULL; } /* This needs to be done on some systems to make sure cluster_cond isn't messed. This has happened on some 64 bit machines and this is here to be on the safe side. */ slurmdb_report_set_start_end_time(&start_time, &end_time); cluster_cond.usage_end = end_time; cluster_cond.usage_start = start_time; cluster_list = acct_storage_g_get_clusters( db_conn, my_uid, &cluster_cond); if (!cluster_list) { exit_code=1; fprintf(stderr, "%s: Problem with cluster query.\n", calling_name); goto end_it; } if ((type == CLUSTER_REPORT_UA) || (type == CLUSTER_REPORT_AU)) { ((slurmdb_assoc_cond_t *)cond)->usage_start = start_time; ((slurmdb_assoc_cond_t *)cond)->usage_end = end_time; type_list = acct_storage_g_get_assocs( db_conn, my_uid, cond); } else if ((type == CLUSTER_REPORT_UW) || (type == CLUSTER_REPORT_WU)) { ((slurmdb_wckey_cond_t *)cond)->usage_start = start_time; ((slurmdb_wckey_cond_t *)cond)->usage_end = end_time; type_list = acct_storage_g_get_wckeys( db_conn, my_uid, cond); } if (!type_list) { exit_code=1; fprintf(stderr, "%s: Problem with get query.\n", calling_name); goto end_it; } if ((type == CLUSTER_REPORT_UA) || (type == CLUSTER_REPORT_AU)) { first_list = type_list; type_list = slurmdb_get_hierarchical_sorted_assoc_list( first_list, true); } /* set up the structures for easy retrieval later */ itr = list_iterator_create(cluster_list); type_itr = list_iterator_create(type_list); while((cluster = list_next(itr))) { /* check to see if this cluster is around during the time we are looking at */ if (!cluster->accounting_list || !list_count(cluster->accounting_list)) continue; slurmdb_report_cluster = slurmdb_cluster_rec_2_report(cluster); list_append(ret_list, slurmdb_report_cluster); if ((type == CLUSTER_REPORT_UA) || (type == CLUSTER_REPORT_UW)) slurmdb_report_cluster->user_list = list_create(slurmdb_destroy_report_user_rec); else if ((type == CLUSTER_REPORT_AU) || (type == CLUSTER_REPORT_WU)) slurmdb_report_cluster->assoc_list = list_create(slurmdb_destroy_report_assoc_rec); if ((type == CLUSTER_REPORT_UA) || (type == CLUSTER_REPORT_AU)) _process_assoc_type(type_itr, slurmdb_report_cluster, cluster->name, type); else if ((type == CLUSTER_REPORT_UW) || (type == CLUSTER_REPORT_WU)) _process_wckey_type(type_itr, slurmdb_report_cluster, cluster->name, type); list_iterator_reset(type_itr); } list_iterator_destroy(type_itr); list_iterator_destroy(itr); end_it: FREE_NULL_LIST(type_list); FREE_NULL_LIST(first_list); FREE_NULL_LIST(cluster_list); if (exit_code) FREE_NULL_LIST(ret_list); return ret_list; }
/* * get info from the storage * IN: slurmdb_wckey_cond_t * * RET: List of slurmdb_wckey_rec_t * * note List needs to be freed with slurm_list_destroy() when called */ extern List slurmdb_wckeys_get(void *db_conn, slurmdb_wckey_cond_t *wckey_cond) { return acct_storage_g_get_wckeys(db_conn, getuid(), wckey_cond); }