Attachment #327 for ticket #360

View | Details | Raw Unified | Return to ticket 360
Collapse All | Expand All




	uint64_t alloc_secs; /* number of cpu seconds allocated */
	uint32_t id;	/* association/wckey ID		*/
	time_t period_start; /* when this record was started */
	uint64_t consumed_energy; /* energy allocated in Joules */
} slurmdb_accounting_rec_t;

typedef struct {

	uint64_t pdown_secs; /* number of cpu seconds planned down */
	time_t period_start; /* when this record was started */
	uint64_t resv_secs; /* number of cpu seconds reserved */
	uint64_t consumed_energy; /* energy allocated in Joules */
} slurmdb_cluster_accounting_rec_t;

typedef struct {

	uint64_t cpu_secs;
	char *parent_acct;
	char *user;
	uint64_t consumed_energy;
} slurmdb_report_assoc_rec_t;

typedef struct {

	uint64_t cpu_secs;
	char *name;
	uid_t uid;
	uint64_t consumed_energy;
} slurmdb_report_user_rec_t;

typedef struct {

	uint64_t cpu_secs;
	char *name;
	List user_list; /* list of slurmdb_report_user_rec_t *'s */
	uint64_t consumed_energy;
} slurmdb_report_cluster_rec_t;

typedef struct {

Lines 2264-2269 extern slurmdb_report_cluster_rec_t *slurmdb_cluster_rec_2_report( Link Here

(-)a/src/common/slurmdb_defs.c (+1 lines)
2264	+ accting->down_secs + accting->idle_secs	2264	+ accting->down_secs + accting->idle_secs
2265	+ accting->resv_secs + accting->pdown_secs;	2265	+ accting->resv_secs + accting->pdown_secs;
2266	slurmdb_report_cluster->cpu_count += accting->cpu_count;	2266	slurmdb_report_cluster->cpu_count += accting->cpu_count;
		2267	slurmdb_report_cluster->consumed_energy += accting->consumed_energy;
2267	}	2268	}
2268	list_iterator_destroy(cluster_itr);	2269	list_iterator_destroy(cluster_itr);
2269		2270




		pack64(object->pdown_secs, buffer);
		pack_time(object->period_start, buffer);
		pack64(object->resv_secs, buffer);
		pack64(object->consumed_energy, buffer);
	}
}


		safe_unpack64(&object_ptr->pdown_secs, buffer);
		safe_unpack_time(&object_ptr->period_start, buffer);
		safe_unpack64(&object_ptr->resv_secs, buffer);
		safe_unpack64(&object_ptr->consumed_energy, buffer);
	}

	return SLURM_SUCCESS;

	pack64(object->alloc_secs, buffer);
	pack32(object->id, buffer);
	pack_time(object->period_start, buffer);
	pack64(object->consumed_energy, buffer);
}

extern int slurmdb_unpack_accounting_rec(void **object, uint16_t rpc_version,

	safe_unpack64(&object_ptr->alloc_secs, buffer);
	safe_unpack32(&object_ptr->id, buffer);
	safe_unpack_time(&object_ptr->period_start, buffer);
	safe_unpack64(&object_ptr->consumed_energy, buffer);

	return SLURM_SUCCESS;


Lines 99-104 static void _process_ua(List user_list, slurmdb_association_rec_t *assoc) Link Here

(-)a/src/db_api/cluster_report_functions.c (+10 lines)
99	while((accting = list_next(itr))) {	99	while((accting = list_next(itr))) {
100	slurmdb_report_user->cpu_secs +=	100	slurmdb_report_user->cpu_secs +=
101	(uint64_t)accting->alloc_secs;	101	(uint64_t)accting->alloc_secs;
		102	slurmdb_report_user->consumed_energy +=
		103	(uint64_t)accting->consumed_energy;
102	}	104	}
103	list_iterator_destroy(itr);	105	list_iterator_destroy(itr);
104	}	106	}
Lines 123-128 static void _process_au(List assoc_list, slurmdb_association_rec_t *assoc) Link Here
123	while((accting = list_next(itr))) {	125	while((accting = list_next(itr))) {
124	slurmdb_report_assoc->cpu_secs +=	126	slurmdb_report_assoc->cpu_secs +=
125	(uint64_t)accting->alloc_secs;	127	(uint64_t)accting->alloc_secs;
		128	slurmdb_report_assoc->consumed_energy +=
		129	(uint64_t)accting->consumed_energy;
126	}	130	}
127	list_iterator_destroy(itr);	131	list_iterator_destroy(itr);
128		132
Lines 158-163 static void _process_uw(List user_list, slurmdb_wckey_rec_t *wckey) Link Here
158	while((accting = list_next(itr))) {	162	while((accting = list_next(itr))) {
159	slurmdb_report_user->cpu_secs +=	163	slurmdb_report_user->cpu_secs +=
160	(uint64_t)accting->alloc_secs;	164	(uint64_t)accting->alloc_secs;
		165	slurmdb_report_user->consumed_energy +=
		166	(uint64_t)accting->consumed_energy;
161	}	167	}
162	list_iterator_destroy(itr);	168	list_iterator_destroy(itr);
163	}	169	}
Lines 200-205 static void _process_wu(List assoc_list, slurmdb_wckey_rec_t *wckey) Link Here
200	(uint64_t)accting->alloc_secs;	206	(uint64_t)accting->alloc_secs;
201	parent_assoc->cpu_secs +=	207	parent_assoc->cpu_secs +=
202	(uint64_t)accting->alloc_secs;	208	(uint64_t)accting->alloc_secs;
		209	slurmdb_report_assoc->consumed_energy +=
		210	(uint64_t)accting->consumed_energy;
		211	parent_assoc->consumed_energy +=
		212	(uint64_t)accting->consumed_energy;
203	}	213	}
204	list_iterator_destroy(itr);	214	list_iterator_destroy(itr);
205	}	215	}

Lines 256-261 extern List slurmdb_report_user_top_usage(void *db_conn, Link Here

(-)a/src/db_api/user_report_functions.c (+2 lines)
256	while((assoc_acct = list_next(itr3))) {	256	while((assoc_acct = list_next(itr3))) {
257	slurmdb_report_user->cpu_secs +=	257	slurmdb_report_user->cpu_secs +=
258	(uint64_t)assoc_acct->alloc_secs;	258	(uint64_t)assoc_acct->alloc_secs;
		259	slurmdb_report_user->consumed_energy +=
		260	(uint64_t)assoc_acct->consumed_energy;
259	/* slurmdb_report_cluster->cpu_secs += */	261	/* slurmdb_report_cluster->cpu_secs += */
260	/* (uint64_t)assoc_acct->alloc_secs; */	262	/* (uint64_t)assoc_acct->alloc_secs; */
261	}	263	}




		{ "id_assoc", "int not null" },
		{ "time_start", "int unsigned not null" },
		{ "alloc_cpu_secs", "bigint default 0 not null" },
		{ "consumed_energy", "bigint default 0 not null" },
		{ NULL, NULL}
	};


		{ "idle_cpu_secs", "bigint default 0 not null" },
		{ "resv_cpu_secs", "bigint default 0 not null" },
		{ "over_cpu_secs", "bigint default 0 not null" },
		{ "consumed_energy", "bigint default 0 not null" },
		{ NULL, NULL}
	};


		{ "alloc_cpu_secs", "bigint default 0" },
		{ "resv_cpu_secs", "bigint default 0" },
		{ "over_cpu_secs", "bigint default 0" },
		{ "consumed_energy", "bigint default 0 not null" },
		{ NULL, NULL}
	};





		{ "id", "int not null" },
		{ "period_start", "int unsigned not null" },
		{ "alloc_cpu_secs", "bigint default 0" },
		{ "consumed_energy", "bigint default 0 not null" },
		{ NULL, NULL}
	};


		{ "idle_cpu_secs", "bigint default 0" },
		{ "resv_cpu_secs", "bigint default 0" },
		{ "over_cpu_secs", "bigint default 0" },
		{ "consumed_energy", "bigint default 0 not null" },
		{ NULL, NULL}
	};


		{ "alloc_cpu_secs", "bigint default 0" },
		{ "resv_cpu_secs", "bigint default 0" },
		{ "over_cpu_secs", "bigint default 0" },
		{ "consumed_energy", "bigint default 0 not null" },
		{ NULL, NULL}
	};





typedef struct {
	int id;
	uint64_t a_cpu;
	uint64_t energy;
} local_id_usage_t;

typedef struct {

	uint64_t r_cpu;
	time_t start;
	time_t end;
	uint64_t energy;
} local_cluster_usage_t;

typedef struct {

			       "cpu_count, alloc_cpu_secs, "
			       "down_cpu_secs, pdown_cpu_secs, "
			       "idle_cpu_secs, over_cpu_secs, "
			       "resv_cpu_secs, consumed_energy) "
			       "values (%ld, %ld, %ld, %d, "
			       "%"PRIu64", %"PRIu64", %"PRIu64", "
			       "%"PRIu64", %"PRIu64", %"PRIu64", "
			       "%"PRIu64")",
			       cluster_name, cluster_hour_table,
			       now, now,
			       c_usage->start,
			       c_usage->cpu_count,
			       c_usage->a_cpu, c_usage->d_cpu,
			       c_usage->pd_cpu, c_usage->i_cpu,
			       c_usage->o_cpu, c_usage->r_cpu,
			       c_usage->energy);

	/* Spacing out the inserts here instead of doing them
	   all at once in the end proves to be faster.  Just FYI

			   "pdown_cpu_secs=VALUES(pdown_cpu_secs), "
			   "idle_cpu_secs=VALUES(idle_cpu_secs), "
			   "over_cpu_secs=VALUES(over_cpu_secs), "
			   "resv_cpu_secs=VALUES(resv_cpu_secs), "
			   "consumed_energy=VALUES(consumed_energy)",
			   now);
		debug3("%d(%s:%d) query\n%s",
		       mysql_conn->conn, THIS_FILE, __LINE__, query);

	/* char start_char[20], end_char[20]; */

	char *job_req_inx[] = {
		"job.job_db_inx",
		"job.id_job",
		"job.id_assoc",
		"job.id_wckey",
		"job.time_eligible",
		"job.time_start",
		"job.time_end",
		"job.time_suspended",
		"job.cpus_alloc",
		"job.cpus_req",
		"job.id_resv",
		"SUM(step.consumed_energy)"
	};
	char *job_str = NULL;
	enum {

		JOB_REQ_ACPU,
		JOB_REQ_RCPU,
		JOB_REQ_RESVID,
		JOB_REQ_ENERGY,
		JOB_REQ_COUNT
	};


		mysql_free_result(result);

		/* now get the jobs during this time only  */
		query = xstrdup_printf("select %s from \"%s_%s\" as job "
				       "left outer join \"%s_%s\" as step on "
				       "job.job_db_inx=step.job_db_inx "
				       "where (job.time_eligible < %ld && "
				       "(job.time_end >= %ld || "
				       "job.time_end = 0)) and"
				       " (step.id_step>=0) "
				       "group by job.job_db_inx "
				       "order by job.id_assoc, "
				       "job.time_eligible",
				       job_str, cluster_name, job_table,
				       cluster_name, step_table,
				       curr_end, curr_start);

		debug3("%d(%s:%d) query\n%s",

			time_t row_end = slurm_atoul(row[JOB_REQ_END]);
			uint32_t row_acpu = slurm_atoul(row[JOB_REQ_ACPU]);
			uint32_t row_rcpu = slurm_atoul(row[JOB_REQ_RCPU]);
			uint32_t row_energy = slurm_atoul(row[JOB_REQ_ENERGY]);
			int loc_seconds = 0;
			seconds = 0;


			}

			a_usage->a_cpu += seconds * row_acpu;
			a_usage->energy+= row_energy;

			if (!track_wckey)
				goto calc_cluster;

				last_wckeyid = wckey_id;
			}
			w_usage->a_cpu += seconds * row_acpu;
			w_usage->energy+= row_energy;
			/* do the cluster allocated calculation */
		calc_cluster:


				/*      row_acpu); */

				c_usage->a_cpu += seconds * row_acpu;
				c_usage->energy+= row_energy;
			}

			/* now reserved time */

/* 			     a_usage->a_cpu); */
			if (query) {
				xstrfmtcat(query,
					   ", (%ld, %ld, %d, %ld, %"PRIu64",%"PRIu64")",
					   now, now,
					   a_usage->id, curr_start,
					   a_usage->a_cpu, a_usage->energy);
			} else {
				xstrfmtcat(query,
					   "insert into \"%s_%s\" "
					   "(creation_time, "
					   "mod_time, id_assoc, time_start, "
					   "alloc_cpu_secs, consumed_energy) values "
					   "(%ld, %ld, %d, %ld, %"PRIu64",%"PRIu64")",
					   cluster_name, assoc_hour_table,
					   now, now,
					   a_usage->id, curr_start,
					   a_usage->a_cpu, a_usage->energy);
			}
		}
		if (query) {
			xstrfmtcat(query,
				   " on duplicate key update "
				   "mod_time=%ld, "
				   "alloc_cpu_secs=VALUES(alloc_cpu_secs), "
				   "consumed_energy=VALUES(consumed_energy);",
				   now);

			debug3("%d(%s:%d) query\n%s",

/* 			     w_usage->a_cpu); */
			if (query) {
				xstrfmtcat(query,
					   ", (%ld, %ld, %d, %ld, "
					   "%"PRIu64", %"PRIu64")",
					   now, now,
					   w_usage->id, curr_start,
					   w_usage->a_cpu, w_usage->energy);
			} else {
				xstrfmtcat(query,
					   "insert into \"%s_%s\" "
					   "(creation_time, "
					   "mod_time, id_wckey, time_start, "
					   "alloc_cpu_secs, consumed_energy) "
					   "values "
					   "(%ld, %ld, %d, %ld, "
					   "%"PRIu64", %"PRIu64")",
					   cluster_name, wckey_hour_table,
					   now, now,
					   w_usage->id, curr_start,
					   w_usage->a_cpu, w_usage->energy);
			}
		}
		if (query) {
			xstrfmtcat(query,
				   " on duplicate key update "
				   "mod_time=%ld, "
				   "alloc_cpu_secs=VALUES(alloc_cpu_secs), "
				   "consumed_energy=VALUES(consumed_energy);",
				   now);

			debug3("%d(%s:%d) query\n%s",

		query = xstrdup_printf(
			"insert into \"%s_%s\" (creation_time, mod_time, "
			"id_assoc, "
			"time_start, alloc_cpu_secs, consumed_energy) select %ld, %ld, "
			"id_assoc, "
			"%ld, @ASUM:=SUM(alloc_cpu_secs), @ESUM:=SUM(consumed_energy) "
			"from \"%s_%s\" where "
			"(time_start < %ld && time_start >= %ld) "
			"group by id_assoc on duplicate key update "
			"mod_time=%ld, alloc_cpu_secs=@ASUM, consumed_energy=@ESUM;",
			cluster_name, assoc_day_table, now, now, curr_start,
			cluster_name, assoc_hour_table,
			curr_end, curr_start, now);

			   "insert into \"%s_%s\" (creation_time, "
			   "mod_time, time_start, cpu_count, "
			   "alloc_cpu_secs, down_cpu_secs, pdown_cpu_secs, "
			   "idle_cpu_secs, over_cpu_secs, resv_cpu_secs, consumed_energy) "
			   "select %ld, %ld, "
			   "%ld, @CPU:=MAX(cpu_count), "
			   "@ASUM:=SUM(alloc_cpu_secs), "

			   "@PDSUM:=SUM(pdown_cpu_secs), "
			   "@ISUM:=SUM(idle_cpu_secs), "
			   "@OSUM:=SUM(over_cpu_secs), "
			   "@RSUM:=SUM(resv_cpu_secs), "
			   "@ESUM:=SUM(consumed_energy) from \"%s_%s\" where "
			   "(time_start < %ld && time_start >= %ld) "
			   "group by deleted "
			   "on duplicate key update "
			   "mod_time=%ld, cpu_count=@CPU, "
			   "alloc_cpu_secs=@ASUM, down_cpu_secs=@DSUM, "
			   "pdown_cpu_secs=@PDSUM, idle_cpu_secs=@ISUM, "
			   "over_cpu_secs=@OSUM, resv_cpu_secs=@RSUM, "
			   "consumed_energy=@ESUM;",
			   cluster_name, cluster_day_table,
			   now, now, curr_start,
			   cluster_name, cluster_hour_table,

			xstrfmtcat(query,
				   "insert into \"%s_%s\" (creation_time, "
				   "mod_time, id_wckey, time_start, "
				   "alloc_cpu_secs, consumed_energy) select %ld, %ld, "
				   "id_wckey, %ld, @ASUM:=SUM(alloc_cpu_secs), "
				   "@ESUM:=SUM(consumed_energy) "
				   "from \"%s_%s\" where (time_start < %ld && "
				   "time_start >= %ld) "
				   "group by id_wckey on duplicate key update "
				   "mod_time=%ld, alloc_cpu_secs=@ASUM, "
				   "consumed_energy=@ESUM;",
				   cluster_name, wckey_day_table,
				   now, now, curr_start,
				   cluster_name, wckey_hour_table,

		query = xstrdup_printf(
			"insert into \"%s_%s\" (creation_time, "
			"mod_time, id_assoc, "
			"time_start, alloc_cpu_secs, consumed_energy) select "
			"%ld, %ld, id_assoc, "
			"%ld, @ASUM:=SUM(alloc_cpu_secs), @ESUM:=SUM(consumed_energy) "
			"from \"%s_%s\" where "
			"(time_start < %ld && time_start >= %ld) "
			"group by id_assoc on duplicate key update "
			"mod_time=%ld, alloc_cpu_secs=@ASUM, consumed_energy=@ESUM;",
			cluster_name, assoc_month_table, now, now, curr_start,
			cluster_name, assoc_day_table,
			curr_end, curr_start, now);

			   "insert into \"%s_%s\" (creation_time, "
			   "mod_time, time_start, cpu_count, "
			   "alloc_cpu_secs, down_cpu_secs, pdown_cpu_secs, "
			   "idle_cpu_secs, over_cpu_secs, resv_cpu_secs, consumed_energy) "
			   "select %ld, %ld, "
			   "%ld, @CPU:=MAX(cpu_count), "
			   "@ASUM:=SUM(alloc_cpu_secs), "

			   "@PDSUM:=SUM(pdown_cpu_secs), "
			   "@ISUM:=SUM(idle_cpu_secs), "
			   "@OSUM:=SUM(over_cpu_secs), "
			   "@RSUM:=SUM(resv_cpu_secs), "
			   "@ESUM:=SUM(consumed_energy) from \"%s_%s\" where "
			   "(time_start < %ld && time_start >= %ld) "
			   "group by deleted "
			   "on duplicate key update "
			   "mod_time=%ld, cpu_count=@CPU, "
			   "alloc_cpu_secs=@ASUM, down_cpu_secs=@DSUM, "
			   "pdown_cpu_secs=@PDSUM, idle_cpu_secs=@ISUM, "
			   "over_cpu_secs=@OSUM, resv_cpu_secs=@RSUM, "
			   "consumed_energy=@ESUM;",
			   cluster_name, cluster_month_table,
			   now, now, curr_start,
			   cluster_name, cluster_day_table,

			xstrfmtcat(query,
				   "insert into \"%s_%s\" "
				   "(creation_time, mod_time, "
				   "id_wckey, time_start, alloc_cpu_secs, consumed_energy) "
				   "select %ld, %ld, id_wckey, %ld, "
				   "@ASUM:=SUM(alloc_cpu_secs), @ESUM:=SUM(consumed_energy) "
				   "from \"%s_%s\" where (time_start < %ld && "
				   "time_start >= %ld) "
				   "group by id_wckey on duplicate key update "
				   "mod_time=%ld, alloc_cpu_secs=@ASUM, consumed_energy=@ESUM;",
				   cluster_name, wckey_month_table,
				   now, now, curr_start,
				   cluster_name, wckey_day_table,




		"resv_cpu_secs",
		"over_cpu_secs",
		"cpu_count",
		"time_start",
		"consumed_energy"
	};

	enum {

		CLUSTER_OCPU,
		CLUSTER_CPU_COUNT,
		CLUSTER_START,
		CLUSTER_ENERGY,
		CLUSTER_COUNT
	};


	xfree(tmp);
	debug4("%d(%s:%d) query\n%s",
	       mysql_conn->conn, THIS_FILE, __LINE__, query);

	if (!(result = mysql_db_query_ret(
		      mysql_conn, query, 0))) {
		xfree(query);

		accounting_rec->resv_secs = slurm_atoull(row[CLUSTER_RCPU]);
		accounting_rec->cpu_count = slurm_atoul(row[CLUSTER_CPU_COUNT]);
		accounting_rec->period_start = slurm_atoul(row[CLUSTER_START]);
		accounting_rec->consumed_energy = slurm_atoull(row[CLUSTER_ENERGY]);
		list_append(cluster_rec->accounting_list, accounting_rec);
	}
	mysql_free_result(result);

	return rc;
}


		USAGE_ID,
		USAGE_START,
		USAGE_ACPU,
		USAGE_ENERGY,
		USAGE_COUNT
	};


		char *temp_usage[] = {
			"t3.id_assoc",
			"t1.time_start",
			"t1.alloc_cpu_secs",
			"t1.consumed_energy",
		};
		usage_req_inx = temp_usage;


		char *temp_usage[] = {
			"id_wckey",
			"time_start",
			"alloc_cpu_secs",
			"consumed_energy"
		};
		usage_req_inx = temp_usage;


		accounting_rec->id = slurm_atoul(row[USAGE_ID]);
		accounting_rec->period_start = slurm_atoul(row[USAGE_START]);
		accounting_rec->alloc_secs = slurm_atoull(row[USAGE_ACPU]);
		accounting_rec->consumed_energy = slurm_atoull(row[USAGE_ENERGY]);
		list_append(usage_list, accounting_rec);
	}
	mysql_free_result(result);

		USAGE_ID,
		USAGE_START,
		USAGE_ACPU,
		USAGE_COUNT,
		USAGE_ENERGY
	};

	switch (type) {

		accounting_rec->id = slurm_atoul(row[USAGE_ID]);
		accounting_rec->period_start = slurm_atoul(row[USAGE_START]);
		accounting_rec->alloc_secs = slurm_atoull(row[USAGE_ACPU]);
		accounting_rec->consumed_energy = slurm_atoull(row[USAGE_ENERGY]);
		list_append((*my_list), accounting_rec);
	}
	mysql_free_result(result);

Lines 56-61 enum { Link Here

(-)a/src/sreport/cluster_reports.c (-2 / +37 lines)
56	PRINT_CLUSTER_USER_PROPER,	56	PRINT_CLUSTER_USER_PROPER,
57	PRINT_CLUSTER_AMOUNT_USED,	57	PRINT_CLUSTER_AMOUNT_USED,
58	PRINT_CLUSTER_WCKEY,	58	PRINT_CLUSTER_WCKEY,
		59	PRINT_CLUSTER_ENERGY,
59	};	60	};
60		61
61	typedef enum {	62	typedef enum {
Lines 507-512 static int _setup_print_fields_list(List format_list) Link Here
507	else	508	else
508	field->len = 15;	509	field->len = 15;
509	field->print_routine = print_fields_str;	510	field->print_routine = print_fields_str;
		511	} else if (!strncasecmp("Energy", object, MAX(command_len, 1))) {
		512	field->type = PRINT_CLUSTER_ENERGY;
		513	field->name = xstrdup("Energy");
		514	field->len = 10;
		515	field->print_routine = print_fields_int;
510	} else {	516	} else {
511	exit_code=1;	517	exit_code=1;
512	fprintf(stderr, " Unknown field '%s'\n", object);	518	fprintf(stderr, " Unknown field '%s'\n", object);
Lines 608-614 extern int cluster_account_by_user(int argc, char *argv[]) Link Here
608		614
609	if (!list_count(format_list))	615	if (!list_count(format_list))
610	slurm_addto_char_list(format_list,	616	slurm_addto_char_list(format_list,
611	"Cluster,Ac,Login,Proper,Used");	617	"Cluster,Ac,Login,Proper,Used,Energy");
612		618
613	_setup_print_fields_list(format_list);	619	_setup_print_fields_list(format_list);
614	list_destroy(format_list);	620	list_destroy(format_list);
Lines 739-744 extern int cluster_account_by_user(int argc, char *argv[]) Link Here
739	slurmdb_report_cluster->cpu_secs,	745	slurmdb_report_cluster->cpu_secs,
740	(curr_inx == field_count));	746	(curr_inx == field_count));
741	break;	747	break;
		748	case PRINT_CLUSTER_ENERGY:
		749	field->print_routine(
		750	field,
		751	slurmdb_report_assoc->consumed_energy,
		752	slurmdb_report_cluster->consumed_energy,
		753	(curr_inx == field_count));
		754	break;
742	default:	755	default:
743	field->print_routine(	756	field->print_routine(
744	field, NULL,	757	field, NULL,
Lines 794-800 extern int cluster_user_by_account(int argc, char *argv[]) Link Here
794		807
795	if (!list_count(format_list))	808	if (!list_count(format_list))
796	slurm_addto_char_list(format_list,	809	slurm_addto_char_list(format_list,
797	"Cluster,Login,Proper,Ac,Used");	810	"Cluster,Login,Proper,Ac,Used,Energy");
798		811
799	_setup_print_fields_list(format_list);	812	_setup_print_fields_list(format_list);
800	list_destroy(format_list);	813	list_destroy(format_list);
Lines 893-898 extern int cluster_user_by_account(int argc, char *argv[]) Link Here
893	slurmdb_report_cluster->cpu_secs,	906	slurmdb_report_cluster->cpu_secs,
894	(curr_inx == field_count));	907	(curr_inx == field_count));
895	break;	908	break;
		909	case PRINT_CLUSTER_ENERGY:
		910	field->print_routine(
		911	field,
		912	slurmdb_report_user->consumed_energy,
		913	slurmdb_report_cluster->consumed_energy,
		914	(curr_inx == field_count));
		915	break;
896	default:	916	default:
897	field->print_routine(	917	field->print_routine(
898	field, NULL,	918	field, NULL,
Lines 1047-1052 extern int cluster_user_by_wckey(int argc, char *argv[]) Link Here
1047	slurmdb_report_cluster->cpu_secs,	1067	slurmdb_report_cluster->cpu_secs,
1048	(curr_inx == field_count));	1068	(curr_inx == field_count));
1049	break;	1069	break;
		1070	case PRINT_CLUSTER_ENERGY:
		1071	field->print_routine(
		1072	field,
		1073	slurmdb_report_user->consumed_energy,
		1074	slurmdb_report_cluster->consumed_energy,
		1075	(curr_inx == field_count));
		1076	break;
		1077
1050	default:	1078	default:
1051	field->print_routine(	1079	field->print_routine(
1052	field, NULL,	1080	field, NULL,
Lines 1137-1142 extern int cluster_utilization(int argc, char *argv[]) Link Here
1137	total_acct.resv_secs += accting->resv_secs;	1165	total_acct.resv_secs += accting->resv_secs;
1138	total_acct.over_secs += accting->over_secs;	1166	total_acct.over_secs += accting->over_secs;
1139	total_acct.cpu_count += accting->cpu_count;	1167	total_acct.cpu_count += accting->cpu_count;
		1168	total_acct.consumed_energy += accting->consumed_energy;
1140	}	1169	}
1141	list_iterator_destroy(itr3);	1170	list_iterator_destroy(itr3);
1142		1171
Lines 1204-1209 extern int cluster_utilization(int argc, char *argv[]) Link Here
1204	(curr_inx ==	1233	(curr_inx ==
1205	field_count));	1234	field_count));
1206	break;	1235	break;
		1236	case PRINT_CLUSTER_ENERGY:
		1237	field->print_routine(field,
		1238	total_acct.consumed_energy,
		1239	(curr_inx ==
		1240	field_count));
		1241	break;
1207	case PRINT_CLUSTER_TOTAL:	1242	case PRINT_CLUSTER_TOTAL:
1208	field->print_routine(field,	1243	field->print_routine(field,
1209	total_reported,	1244	total_reported,

Lines 46-51 enum { Link Here

(-)a/src/sreport/user_reports.c (-1 / +13 lines)
46	PRINT_USER_LOGIN,	46	PRINT_USER_LOGIN,
47	PRINT_USER_PROPER,	47	PRINT_USER_PROPER,
48	PRINT_USER_USED,	48	PRINT_USER_USED,
		49	PRINT_USER_ENERGY,
49	};	50	};
50		51
51	static List print_fields_list = NULL; /* types are of print_field_t */	52	static List print_fields_list = NULL; /* types are of print_field_t */
Lines 221-226 static int _setup_print_fields_list(List format_list) Link Here
221	else	222	else
222	field->len = 10;	223	field->len = 10;
223	field->print_routine = slurmdb_report_print_time;	224	field->print_routine = slurmdb_report_print_time;
		225	}else if (!strncasecmp("Energy", object, MAX(command_len, 1))) {
		226	field->type = PRINT_USER_ENERGY;
		227	field->name = xstrdup("Energy");
		228	field->len = 10;
		229	field->print_routine = print_fields_int;
224	} else {	230	} else {
225	exit_code=1;	231	exit_code=1;
226	fprintf(stderr, " Unknown field '%s'\n", object);	232	fprintf(stderr, " Unknown field '%s'\n", object);
Lines 261-267 extern int user_top(int argc, char *argv[]) Link Here
261	_set_cond(&i, argc, argv, user_cond, format_list);	267	_set_cond(&i, argc, argv, user_cond, format_list);
262		268
263	if (!list_count(format_list))	269	if (!list_count(format_list))
264	slurm_addto_char_list(format_list, "Cl,L,P,A,U");	270	slurm_addto_char_list(format_list, "Cl,L,P,A,U,Energy");
265		271
266	_setup_print_fields_list(format_list);	272	_setup_print_fields_list(format_list);
267	list_destroy(format_list);	273	list_destroy(format_list);
Lines 369-374 extern int user_top(int argc, char *argv[]) Link Here
369	slurmdb_report_cluster->cpu_secs,	375	slurmdb_report_cluster->cpu_secs,
370	(curr_inx == field_count));	376	(curr_inx == field_count));
371	break;	377	break;
		378	case PRINT_USER_ENERGY:
		379	field->print_routine(
		380	field,
		381	slurmdb_report_user->consumed_energy,
		382	(curr_inx ==field_count));
		383	break;
372	default:	384	default:
373	field->print_routine(	385	field->print_routine(
374	field, NULL,	386	field, NULL,

Return to ticket 360

Lines 336-341 typedef struct { Link Here

(-)a/slurm/slurmdb.h (+5 lines)
336	uint64_t alloc_secs; /* number of cpu seconds allocated */	336	uint64_t alloc_secs; /* number of cpu seconds allocated */
337	uint32_t id; /* association/wckey ID */	337	uint32_t id; /* association/wckey ID */
338	time_t period_start; /* when this record was started */	338	time_t period_start; /* when this record was started */
		339	uint64_t consumed_energy; /* energy allocated in Joules */
339	} slurmdb_accounting_rec_t;	340	} slurmdb_accounting_rec_t;
340		341
341	typedef struct {	342	typedef struct {
Lines 497-502 typedef struct { Link Here
497	uint64_t pdown_secs; /* number of cpu seconds planned down */	498	uint64_t pdown_secs; /* number of cpu seconds planned down */
498	time_t period_start; /* when this record was started */	499	time_t period_start; /* when this record was started */
499	uint64_t resv_secs; /* number of cpu seconds reserved */	500	uint64_t resv_secs; /* number of cpu seconds reserved */
		501	uint64_t consumed_energy; /* energy allocated in Joules */
500	} slurmdb_cluster_accounting_rec_t;	502	} slurmdb_cluster_accounting_rec_t;
501		503
502	typedef struct {	504	typedef struct {
Lines 851-856 typedef struct { Link Here
851	uint64_t cpu_secs;	853	uint64_t cpu_secs;
852	char *parent_acct;	854	char *parent_acct;
853	char *user;	855	char *user;
		856	uint64_t consumed_energy;
854	} slurmdb_report_assoc_rec_t;	857	} slurmdb_report_assoc_rec_t;
855		858
856	typedef struct {	859	typedef struct {
Lines 860-865 typedef struct { Link Here
860	uint64_t cpu_secs;	863	uint64_t cpu_secs;
861	char *name;	864	char *name;
862	uid_t uid;	865	uid_t uid;
		866	uint64_t consumed_energy;
863	} slurmdb_report_user_rec_t;	867	} slurmdb_report_user_rec_t;
864		868
865	typedef struct {	869	typedef struct {
Lines 868-873 typedef struct { Link Here
868	uint64_t cpu_secs;	872	uint64_t cpu_secs;
869	char *name;	873	char *name;
870	List user_list; /* list of slurmdb_report_user_rec_t 's /	874	List user_list; /* list of slurmdb_report_user_rec_t 's /
		875	uint64_t consumed_energy;
871	} slurmdb_report_cluster_rec_t;	876	} slurmdb_report_cluster_rec_t;
872		877
873	typedef struct {	878	typedef struct {

Lines 885-890 extern int create_cluster_tables(mysql_conn_t mysql_conn, char cluster_name) Link Here

(-)a/src/plugins/accounting_storage/mysql/accounting_storage_mysql.c (+3 lines)
885	{ "id_assoc", "int not null" },	885	{ "id_assoc", "int not null" },
886	{ "time_start", "int unsigned not null" },	886	{ "time_start", "int unsigned not null" },
887	{ "alloc_cpu_secs", "bigint default 0 not null" },	887	{ "alloc_cpu_secs", "bigint default 0 not null" },
		888	{ "consumed_energy", "bigint default 0 not null" },
888	{ NULL, NULL}	889	{ NULL, NULL}
889	};	890	};
890		891
Lines 900-905 extern int create_cluster_tables(mysql_conn_t mysql_conn, char cluster_name) Link Here
900	{ "idle_cpu_secs", "bigint default 0 not null" },	901	{ "idle_cpu_secs", "bigint default 0 not null" },
901	{ "resv_cpu_secs", "bigint default 0 not null" },	902	{ "resv_cpu_secs", "bigint default 0 not null" },
902	{ "over_cpu_secs", "bigint default 0 not null" },	903	{ "over_cpu_secs", "bigint default 0 not null" },
		904	{ "consumed_energy", "bigint default 0 not null" },
903	{ NULL, NULL}	905	{ NULL, NULL}
904	};	906	};
905		907
Lines 1056-1061 extern int create_cluster_tables(mysql_conn_t mysql_conn, char cluster_name) Link Here
1056	{ "alloc_cpu_secs", "bigint default 0" },	1058	{ "alloc_cpu_secs", "bigint default 0" },
1057	{ "resv_cpu_secs", "bigint default 0" },	1059	{ "resv_cpu_secs", "bigint default 0" },
1058	{ "over_cpu_secs", "bigint default 0" },	1060	{ "over_cpu_secs", "bigint default 0" },
		1061	{ "consumed_energy", "bigint default 0 not null" },
1059	{ NULL, NULL}	1062	{ NULL, NULL}
1060	};	1063	};
1061		1064

Lines 750-755 extern void slurmdb_pack_cluster_accounting_rec(void *in, uint16_t rpc_version, Link Here

(-)a/src/common/slurmdb_pack.c (+4 lines)
750	pack64(object->pdown_secs, buffer);	750	pack64(object->pdown_secs, buffer);
751	pack_time(object->period_start, buffer);	751	pack_time(object->period_start, buffer);
752	pack64(object->resv_secs, buffer);	752	pack64(object->resv_secs, buffer);
		753	pack64(object->consumed_energy, buffer);
753	}	754	}
754	}	755	}
755		756
Lines 771-776 extern int slurmdb_unpack_cluster_accounting_rec(void **object, Link Here
771	safe_unpack64(&object_ptr->pdown_secs, buffer);	772	safe_unpack64(&object_ptr->pdown_secs, buffer);
772	safe_unpack_time(&object_ptr->period_start, buffer);	773	safe_unpack_time(&object_ptr->period_start, buffer);
773	safe_unpack64(&object_ptr->resv_secs, buffer);	774	safe_unpack64(&object_ptr->resv_secs, buffer);
		775	safe_unpack64(&object_ptr->consumed_energy, buffer);
774	}	776	}
775		777
776	return SLURM_SUCCESS;	778	return SLURM_SUCCESS;
Lines 991-996 extern void slurmdb_pack_accounting_rec(void *in, uint16_t rpc_version, Link Here
991	pack64(object->alloc_secs, buffer);	993	pack64(object->alloc_secs, buffer);
992	pack32(object->id, buffer);	994	pack32(object->id, buffer);
993	pack_time(object->period_start, buffer);	995	pack_time(object->period_start, buffer);
		996	pack64(object->consumed_energy, buffer);
994	}	997	}
995		998
996	extern int slurmdb_unpack_accounting_rec(void **object, uint16_t rpc_version,	999	extern int slurmdb_unpack_accounting_rec(void **object, uint16_t rpc_version,
Lines 1004-1009 extern int slurmdb_unpack_accounting_rec(void **object, uint16_t rpc_version, Link Here
1004	safe_unpack64(&object_ptr->alloc_secs, buffer);	1007	safe_unpack64(&object_ptr->alloc_secs, buffer);
1005	safe_unpack32(&object_ptr->id, buffer);	1008	safe_unpack32(&object_ptr->id, buffer);
1006	safe_unpack_time(&object_ptr->period_start, buffer);	1009	safe_unpack_time(&object_ptr->period_start, buffer);
		1010	safe_unpack64(&object_ptr->consumed_energy, buffer);
1007		1011
1008	return SLURM_SUCCESS;	1012	return SLURM_SUCCESS;
1009		1013

Lines 602-607 extern int as_mysql_convert_tables(mysql_conn_t *mysql_conn) Link Here

(-)a/src/plugins/accounting_storage/mysql/as_mysql_convert.c (+3 lines)
602	{ "id", "int not null" },	602	{ "id", "int not null" },
603	{ "period_start", "int unsigned not null" },	603	{ "period_start", "int unsigned not null" },
604	{ "alloc_cpu_secs", "bigint default 0" },	604	{ "alloc_cpu_secs", "bigint default 0" },
		605	{ "consumed_energy", "bigint default 0 not null" },
605	{ NULL, NULL}	606	{ NULL, NULL}
606	};	607	};
607		608
Lines 618-623 extern int as_mysql_convert_tables(mysql_conn_t *mysql_conn) Link Here
618	{ "idle_cpu_secs", "bigint default 0" },	619	{ "idle_cpu_secs", "bigint default 0" },
619	{ "resv_cpu_secs", "bigint default 0" },	620	{ "resv_cpu_secs", "bigint default 0" },
620	{ "over_cpu_secs", "bigint default 0" },	621	{ "over_cpu_secs", "bigint default 0" },
		622	{ "consumed_energy", "bigint default 0 not null" },
621	{ NULL, NULL}	623	{ NULL, NULL}
622	};	624	};
623		625
Lines 771-776 extern int as_mysql_convert_tables(mysql_conn_t *mysql_conn) Link Here
771	{ "alloc_cpu_secs", "bigint default 0" },	773	{ "alloc_cpu_secs", "bigint default 0" },
772	{ "resv_cpu_secs", "bigint default 0" },	774	{ "resv_cpu_secs", "bigint default 0" },
773	{ "over_cpu_secs", "bigint default 0" },	775	{ "over_cpu_secs", "bigint default 0" },
		776	{ "consumed_energy", "bigint default 0 not null" },
774	{ NULL, NULL}	777	{ NULL, NULL}
775	};	778	};
776		779

Lines 425-431 static int _get_cluster_usage(mysql_conn_t *mysql_conn, uid_t uid, Link Here

(-)a/src/plugins/accounting_storage/mysql/as_mysql_usage.c (-5 / +14 lines)
425	"resv_cpu_secs",	425	"resv_cpu_secs",
426	"over_cpu_secs",	426	"over_cpu_secs",
427	"cpu_count",	427	"cpu_count",
428	"time_start"	428	"time_start",
		429	"consumed_energy"
429	};	430	};
430		431
431	enum {	432	enum {
Lines 437-442 static int _get_cluster_usage(mysql_conn_t *mysql_conn, uid_t uid, Link Here
437	CLUSTER_OCPU,	438	CLUSTER_OCPU,
438	CLUSTER_CPU_COUNT,	439	CLUSTER_CPU_COUNT,
439	CLUSTER_START,	440	CLUSTER_START,
		441	CLUSTER_ENERGY,
440	CLUSTER_COUNT	442	CLUSTER_COUNT
441	};	443	};
442		444
Lines 465-470 static int _get_cluster_usage(mysql_conn_t *mysql_conn, uid_t uid, Link Here
465	xfree(tmp);	467	xfree(tmp);
466	debug4("%d(%s:%d) query\n%s",	468	debug4("%d(%s:%d) query\n%s",
467	mysql_conn->conn, THIS_FILE, __LINE__, query);	469	mysql_conn->conn, THIS_FILE, __LINE__, query);
		470
468	if (!(result = mysql_db_query_ret(	471	if (!(result = mysql_db_query_ret(
469	mysql_conn, query, 0))) {	472	mysql_conn, query, 0))) {
470	xfree(query);	473	xfree(query);
Lines 487-496 static int _get_cluster_usage(mysql_conn_t *mysql_conn, uid_t uid, Link Here
487	accounting_rec->resv_secs = slurm_atoull(row[CLUSTER_RCPU]);	490	accounting_rec->resv_secs = slurm_atoull(row[CLUSTER_RCPU]);
488	accounting_rec->cpu_count = slurm_atoul(row[CLUSTER_CPU_COUNT]);	491	accounting_rec->cpu_count = slurm_atoul(row[CLUSTER_CPU_COUNT]);
489	accounting_rec->period_start = slurm_atoul(row[CLUSTER_START]);	492	accounting_rec->period_start = slurm_atoul(row[CLUSTER_START]);
		493	accounting_rec->consumed_energy = slurm_atoull(row[CLUSTER_ENERGY]);
490	list_append(cluster_rec->accounting_list, accounting_rec);	494	list_append(cluster_rec->accounting_list, accounting_rec);
491	}	495	}
492	mysql_free_result(result);	496	mysql_free_result(result);
493
494	return rc;	497	return rc;
495	}	498	}
496		499
Lines 526-531 extern int get_usage_for_list(mysql_conn_t *mysql_conn, Link Here
526	USAGE_ID,	529	USAGE_ID,
527	USAGE_START,	530	USAGE_START,
528	USAGE_ACPU,	531	USAGE_ACPU,
		532	USAGE_ENERGY,
529	USAGE_COUNT	533	USAGE_COUNT
530	};	534	};
531		535
Lines 544-550 extern int get_usage_for_list(mysql_conn_t *mysql_conn, Link Here
544	char *temp_usage[] = {	548	char *temp_usage[] = {
545	"t3.id_assoc",	549	"t3.id_assoc",
546	"t1.time_start",	550	"t1.time_start",
547	"t1.alloc_cpu_secs"	551	"t1.alloc_cpu_secs",
		552	"t1.consumed_energy",
548	};	553	};
549	usage_req_inx = temp_usage;	554	usage_req_inx = temp_usage;
550		555
Lines 566-572 extern int get_usage_for_list(mysql_conn_t *mysql_conn, Link Here
566	char *temp_usage[] = {	571	char *temp_usage[] = {
567	"id_wckey",	572	"id_wckey",
568	"time_start",	573	"time_start",
569	"alloc_cpu_secs"	574	"alloc_cpu_secs",
		575	"consumed_energy"
570	};	576	};
571	usage_req_inx = temp_usage;	577	usage_req_inx = temp_usage;
572		578
Lines 648-653 extern int get_usage_for_list(mysql_conn_t *mysql_conn, Link Here
648	accounting_rec->id = slurm_atoul(row[USAGE_ID]);	654	accounting_rec->id = slurm_atoul(row[USAGE_ID]);
649	accounting_rec->period_start = slurm_atoul(row[USAGE_START]);	655	accounting_rec->period_start = slurm_atoul(row[USAGE_START]);
650	accounting_rec->alloc_secs = slurm_atoull(row[USAGE_ACPU]);	656	accounting_rec->alloc_secs = slurm_atoull(row[USAGE_ACPU]);
		657	accounting_rec->consumed_energy = slurm_atoull(row[USAGE_ENERGY]);
651	list_append(usage_list, accounting_rec);	658	list_append(usage_list, accounting_rec);
652	}	659	}
653	mysql_free_result(result);	660	mysql_free_result(result);
Lines 740-746 extern int as_mysql_get_usage(mysql_conn_t *mysql_conn, uid_t uid, Link Here
740	USAGE_ID,	747	USAGE_ID,
741	USAGE_START,	748	USAGE_START,
742	USAGE_ACPU,	749	USAGE_ACPU,
743	USAGE_COUNT	750	USAGE_COUNT,
		751	USAGE_ENERGY
744	};	752	};
745		753
746	switch (type) {	754	switch (type) {
Lines 902-907 is_user: Link Here
902	accounting_rec->id = slurm_atoul(row[USAGE_ID]);	910	accounting_rec->id = slurm_atoul(row[USAGE_ID]);
903	accounting_rec->period_start = slurm_atoul(row[USAGE_START]);	911	accounting_rec->period_start = slurm_atoul(row[USAGE_START]);
904	accounting_rec->alloc_secs = slurm_atoull(row[USAGE_ACPU]);	912	accounting_rec->alloc_secs = slurm_atoull(row[USAGE_ACPU]);
		913	accounting_rec->consumed_energy = slurm_atoull(row[USAGE_ENERGY]);
905	list_append((*my_list), accounting_rec);	914	list_append((*my_list), accounting_rec);
906	}	915	}
907	mysql_free_result(result);	916	mysql_free_result(result);