Attachment #22414 for ticket #11323





#define XCC_FLAG_NONE 0x00000000
#define XCC_FLAG_FAKE 0x00000001
/* Match cmd_rq[] response expectations */
#define XCC_SD650_RESPONSE_LEN 16

/*
 * These variables are required by the generic plugin interface.  If they


        debug3("ipmi_cmd_raw: %s", ipmi_ctx_errormsg(ipmi_ctx));

	if (rs_len != XCC_SD650_RESPONSE_LEN) {
		error("Invalid ipmi response length for XCC raw command: %d bytes, expected %d",
		      rs_len, XCC_SD650_RESPONSE_LEN);
		return NULL;
	}

- 
--
.../xcc/acct_gather_energy_xcc.c              | 33 +++++++++++--------
1 file changed, 20 insertions(+), 13 deletions(-)




	return xcc_reading;
}

static void _sd650_update_node_energy(xcc_raw_single_data_t *xcc_raw)
 * _thread_update_node_energy calls _read_ipmi_values and updates all values
 * for node consumption
 */
static int _thread_update_node_energy(void)
{
	xcc_raw_single_data_t *xcc_raw;
	static uint16_t overflows = 0; /* Number of overflows of the counter */
        int elapsed = 0;
	static uint64_t first_consumed_energy = 0;

	xcc_raw = _read_ipmi_values();

	if (!xcc_raw) {
		error("%s could not read XCC ipmi values", __func__);
		return SLURM_ERROR;
	}

	if (!xcc_energy.poll_time) {
		/*
		 * First number from the slurmd.  We will figure out the usage

		 __func__, xcc_energy.current_watts,
		 xcc_energy.base_consumed_energy, xcc_energy.consumed_energy,
		 elapsed, first_consumed_energy, xcc_energy.ave_watts);
}

/*
 * _thread_update_node_energy calls _read_ipmi_values and updates all values
 * for node consumption
 */
static int _thread_update_node_energy(void)
{
	xcc_raw_single_data_t *xcc_raw;

	xcc_raw = _read_ipmi_values();

	if (!xcc_raw) {
		error("%s could not read XCC ipmi values", __func__);
		return SLURM_ERROR;
	}

	_sd650_update_node_energy(xcc_raw);

	return SLURM_SUCCESS;
}

- 
for raw data
--
.../xcc/acct_gather_energy_xcc.c              | 37 +++++++++++++++++--
1 file changed, 33 insertions(+), 4 deletions(-)

Lines 85-90 slurmd_conf_t *conf = NULL; Link Here

(-)a/src/plugins/acct_gather_energy/xcc/acct_gather_energy_xcc.c (-6 / +33 lines)
85	#define XCC_FLAG_FAKE 0x00000001	85	#define XCC_FLAG_FAKE 0x00000001
86	/* Match cmd_rq[] response expectations */	86	/* Match cmd_rq[] response expectations */
87	#define XCC_SD650_RESPONSE_LEN 16	87	#define XCC_SD650_RESPONSE_LEN 16
		88	#define XCC_SD650V2_RESPONSE_LEN 40
88		89
89	/*	90	/*
90	* These variables are required by the generic plugin interface. If they	91	* These variables are required by the generic plugin interface. If they
Lines 210-220 typedef struct slurm_ipmi_conf { Link Here
210	uint32_t workaround_flags;	211	uint32_t workaround_flags;
211	} slurm_ipmi_conf_t;	212	} slurm_ipmi_conf_t;
212		213
		214	typedef enum xcc_version {
		215	XCC_SD650_VERSION = 0,
		216	XCC_SD650V2_VERSION
		217	} xcc_version_t;
		218
213	/* Struct to store the raw single data command reading */	219	/* Struct to store the raw single data command reading */
214	typedef struct xcc_raw_single_data {	220	typedef struct xcc_raw_single_data {
		221	xcc_version_t version;
215	uint16_t fifo_inx;	222	uint16_t fifo_inx;
216	uint32_t j;	223	uint32_t j;
217	uint16_t mj;	224	uint16_t mj;
		225	uint32_t w;
		226	uint16_t mw;
218	uint16_t ms;	227	uint16_t ms;
219	uint32_t s;	228	uint32_t s;
220	} xcc_raw_single_data_t;	229	} xcc_raw_single_data_t;
Lines 443-451 static xcc_raw_single_data_t *_read_ipmi_values(void) Link Here
443		452
444	debug3("ipmi_cmd_raw: %s", ipmi_ctx_errormsg(ipmi_ctx));	453	debug3("ipmi_cmd_raw: %s", ipmi_ctx_errormsg(ipmi_ctx));
445		454
446	if (rs_len != XCC_SD650_RESPONSE_LEN) {	455	if ((rs_len != XCC_SD650_RESPONSE_LEN) &&
447	error("Invalid ipmi response length for XCC raw command: %d bytes, expected %d",	456	(rs_len != XCC_SD650V2_RESPONSE_LEN)) {
448	rs_len, XCC_SD650_RESPONSE_LEN);	457	error("Invalid ipmi response length for XCC raw command: %d bytes, expected %d or %d",
		458	rs_len, XCC_SD650_RESPONSE_LEN, XCC_SD650V2_RESPONSE_LEN);
449	return NULL;	459	return NULL;
450	}	460	}
451		461
Lines 460-478 static xcc_raw_single_data_t *_read_ipmi_values(void) Link Here
460	fake_inited = true;	470	fake_inited = true;
461	}	471	}
462		472
		473	xcc_reading->version = XCC_SD650_VERSION;
463	xcc_reading->fifo_inx = 0;	474	xcc_reading->fifo_inx = 0;
464	// Fake metric j	475	// Fake metric j
465	xcc_reading->j = fake_past_read + 550 + rand() % 200;	476	xcc_reading->j = fake_past_read + 550 + rand() % 200;
466	fake_past_read = xcc_reading->j;	477	fake_past_read = xcc_reading->j;
467	xcc_reading->mj = 0;	478	xcc_reading->mj = 0;
		479	xcc_reading->w = 0;
		480	xcc_reading->mw = 0;
468	xcc_reading->s = time(NULL); //Fake metric timestamp	481	xcc_reading->s = time(NULL); //Fake metric timestamp
469	xcc_reading->ms = 0;	482	xcc_reading->ms = 0;
470	} else {	483	} else if (rs_len == XCC_SD650_RESPONSE_LEN) {
		484	xcc_reading->version = XCC_SD650_VERSION;
		485	xcc_reading->w = 0;
		486	xcc_reading->mw = 0;
471	memcpy(&xcc_reading->fifo_inx, buf_rs+2, 2);	487	memcpy(&xcc_reading->fifo_inx, buf_rs+2, 2);
472	memcpy(&xcc_reading->j, buf_rs+4, 4);	488	memcpy(&xcc_reading->j, buf_rs+4, 4);
473	memcpy(&xcc_reading->mj, buf_rs+8, 2);	489	memcpy(&xcc_reading->mj, buf_rs+8, 2);
474	memcpy(&xcc_reading->s, buf_rs+10, 4);	490	memcpy(&xcc_reading->s, buf_rs+10, 4);
475	memcpy(&xcc_reading->ms, buf_rs+14, 2);	491	memcpy(&xcc_reading->ms, buf_rs+14, 2);
		492	} else {
		493	int count;
		494
		495	xcc_reading->version = XCC_SD650V2_VERSION;
		496	xcc_reading->fifo_inx = 0;
		497	xcc_reading->j = 0;
		498	xcc_reading->mj = 0;
		499	memcpy(&count, buf_rs+2, 2);
		500	memcpy(&xcc_reading->w, buf_rs+4, 4);
		501	xcc_reading->w /= count;
		502	memcpy(&xcc_reading->mw, buf_rs+8, 2);
		503	memcpy(&xcc_reading->s, buf_rs+34, 4);
		504	memcpy(&xcc_reading->ms, buf_rs+38, 2);
476	}	505	}
477		506
478	return xcc_reading;	507	return xcc_reading;
479	-
480	new raw format	508	new raw format
481	--
482	.../xcc/acct_gather_energy_xcc.c \| 64 ++++++++++++++++++-	509	.../xcc/acct_gather_energy_xcc.c \| 64 ++++++++++++++++++-
483	1 file changed, 62 insertions(+), 2 deletions(-)	510	1 file changed, 62 insertions(+), 2 deletions(-)




		 elapsed, first_consumed_energy, xcc_energy.ave_watts);
}

static void _sd650v2_update_node_energy(xcc_raw_single_data_t *xcc_raw)
{
	static uint64_t readings = 0;
	int elapsed = 0;

	if (!xcc_energy.poll_time) {
		/* First number from the slurmd. */
		xcc_energy.consumed_energy = 0;
		xcc_energy.base_consumed_energy = 0;
		xcc_energy.previous_consumed_energy = 0;
		xcc_energy.ave_watts = xcc_raw->w;
		xcc_energy.current_watts = xcc_raw->w;
		readings++;
	} else {
		elapsed = xcc_raw->s - xcc_energy.poll_time;
		if (elapsed) {
			xcc_energy.previous_consumed_energy =
						xcc_energy.consumed_energy;

			/*
			 * We have no clue about the watt variation inbetween
			 * the sampling interval. Best effort: mean value.
			 */
			xcc_energy.consumed_energy +=
			round((double)elapsed * 0.5 *
			      (double)(xcc_energy.current_watts + xcc_raw->w));

			xcc_energy.base_consumed_energy =
					xcc_energy.consumed_energy -
					xcc_energy.previous_consumed_energy;

			xcc_energy.current_watts = xcc_raw->w;
			/* ave_watts is used as TresUsageOutAve (AvePower) */
			xcc_energy.ave_watts =
					((xcc_energy.ave_watts * readings) +
					 xcc_energy.current_watts) /
					 (readings + 1);
			readings++;
		}
	}

	xcc_energy.poll_time = xcc_raw->s;

	xfree(xcc_raw);

	log_flag(ENERGY, "%s: XCC current_watts: %u consumed energy last interval: %"PRIu64"(current reading %"PRIu64") Joules, elapsed time: %u Seconds, ave watts: %u",
		 __func__, xcc_energy.current_watts,
		 xcc_energy.base_consumed_energy, xcc_energy.consumed_energy,
		 elapsed, xcc_energy.ave_watts);
}

/*
 * _thread_update_node_energy calls _read_ipmi_values and updates all values
 * for node consumption

		return SLURM_ERROR;
	}

	switch(xcc_raw->version) {
	case  XCC_SD650_VERSION:
		_sd650_update_node_energy(xcc_raw);
		break;
	case XCC_SD650V2_VERSION:
		_sd650v2_update_node_energy(xcc_raw);
		break;
	default:
		error("Unimplemented energy calculation for returned data");
		return SLURM_ERROR;
	}
	return SLURM_SUCCESS;
}

- 

Return to ticket 11323

Lines 589-594 static void _sd650_update_node_energy(xcc_raw_single_data_t *xcc_raw) Link Here

(-)a/src/plugins/acct_gather_energy/xcc/acct_gather_energy_xcc.c (-3 / +62 lines)
589	elapsed, first_consumed_energy, xcc_energy.ave_watts);	589	elapsed, first_consumed_energy, xcc_energy.ave_watts);
590	}	590	}
591		591
		592	static void _sd650v2_update_node_energy(xcc_raw_single_data_t *xcc_raw)
		593	{
		594	static uint64_t readings = 0;
		595	int elapsed = 0;
		596
		597	if (!xcc_energy.poll_time) {
		598	/* First number from the slurmd. */
		599	xcc_energy.consumed_energy = 0;
		600	xcc_energy.base_consumed_energy = 0;
		601	xcc_energy.previous_consumed_energy = 0;
		602	xcc_energy.ave_watts = xcc_raw->w;
		603	xcc_energy.current_watts = xcc_raw->w;
		604	readings++;
		605	} else {
		606	elapsed = xcc_raw->s - xcc_energy.poll_time;
		607	if (elapsed) {
		608	xcc_energy.previous_consumed_energy =
		609	xcc_energy.consumed_energy;
		610
		611	/*
		612	* We have no clue about the watt variation inbetween
		613	* the sampling interval. Best effort: mean value.
		614	*/
		615	xcc_energy.consumed_energy +=
		616	round((double)elapsed * 0.5 *
		617	(double)(xcc_energy.current_watts + xcc_raw->w));
		618
		619	xcc_energy.base_consumed_energy =
		620	xcc_energy.consumed_energy -
		621	xcc_energy.previous_consumed_energy;
		622
		623	xcc_energy.current_watts = xcc_raw->w;
		624	/* ave_watts is used as TresUsageOutAve (AvePower) */
		625	xcc_energy.ave_watts =
		626	((xcc_energy.ave_watts * readings) +
		627	xcc_energy.current_watts) /
		628	(readings + 1);
		629	readings++;
		630	}
		631	}
		632
		633	xcc_energy.poll_time = xcc_raw->s;
		634
		635	xfree(xcc_raw);
		636
		637	log_flag(ENERGY, "%s: XCC current_watts: %u consumed energy last interval: %"PRIu64"(current reading %"PRIu64") Joules, elapsed time: %u Seconds, ave watts: %u",
		638	__func__, xcc_energy.current_watts,
		639	xcc_energy.base_consumed_energy, xcc_energy.consumed_energy,
		640	elapsed, xcc_energy.ave_watts);
		641	}
		642
592	/*	643	/*
593	* _thread_update_node_energy calls _read_ipmi_values and updates all values	644	* _thread_update_node_energy calls _read_ipmi_values and updates all values
594	* for node consumption	645	* for node consumption
Lines 604-611 static int _thread_update_node_energy(void) Link Here
604	return SLURM_ERROR;	655	return SLURM_ERROR;
605	}	656	}
606		657
607	_sd650_update_node_energy(xcc_raw);	658	switch(xcc_raw->version) {
608		659	case XCC_SD650_VERSION:
		660	_sd650_update_node_energy(xcc_raw);
		661	break;
		662	case XCC_SD650V2_VERSION:
		663	_sd650v2_update_node_energy(xcc_raw);
		664	break;
		665	default:
		666	error("Unimplemented energy calculation for returned data");
		667	return SLURM_ERROR;
		668	}
609	return SLURM_SUCCESS;	669	return SLURM_SUCCESS;
610	}	670	}
611		671
612	-

Lines 83-89 slurmd_conf_t *conf = NULL; Link Here

(-)a/src/plugins/acct_gather_energy/xcc/acct_gather_energy_xcc.c (-6 / +5 lines)
83		83
84	#define XCC_FLAG_NONE 0x00000000	84	#define XCC_FLAG_NONE 0x00000000
85	#define XCC_FLAG_FAKE 0x00000001	85	#define XCC_FLAG_FAKE 0x00000001
86	#define XCC_EXPECTED_RSPLEN 16 /* Must match cmd_rq[] response expectations */	86	/* Match cmd_rq[] response expectations */
		87	#define XCC_SD650_RESPONSE_LEN 16
87		88
88	/*	89	/*
89	* These variables are required by the generic plugin interface. If they	90	* These variables are required by the generic plugin interface. If they
Lines 442-450 static xcc_raw_single_data_t *_read_ipmi_values(void) Link Here
442		443
443	debug3("ipmi_cmd_raw: %s", ipmi_ctx_errormsg(ipmi_ctx));	444	debug3("ipmi_cmd_raw: %s", ipmi_ctx_errormsg(ipmi_ctx));
444		445
445	if (rs_len != XCC_EXPECTED_RSPLEN) {	446	if (rs_len != XCC_SD650_RESPONSE_LEN) {
446	error("Invalid ipmi response length for XCC raw command: "	447	error("Invalid ipmi response length for XCC raw command: %d bytes, expected %d",
447	"%d bytes, expected %d", rs_len, XCC_EXPECTED_RSPLEN);	448	rs_len, XCC_SD650_RESPONSE_LEN);
448	return NULL;	449	return NULL;
449	}	450	}
450		451
451	-
452	--
453	.../xcc/acct_gather_energy_xcc.c \| 33 +++++++++++--------	452	.../xcc/acct_gather_energy_xcc.c \| 33 +++++++++++--------
454	1 file changed, 20 insertions(+), 13 deletions(-)	453	1 file changed, 20 insertions(+), 13 deletions(-)