Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

CoolEmAllMetricsCalculator.java @ 1396

Revision 1396, 13.8 KB checked in by wojtekp, 11 years ago (diff)

Property svn:mime-type set to `text/plain`

Rev	Line
[1299]	1	package simulator.stats;
	2
	3	import java.util.ArrayList;
	4	import java.util.List;
	5
	6	import simulator.stats.implementation.MetricsStats;
	7	import example.energy.coolemall.CoolEmAllTestbedMeasurements;
	8
	9	public class CoolEmAllMetricsCalculator extends AbstractMetricsCalculator{
	10
	11	public CoolEmAllMetricsCalculator (long startTime, long endTime, long timestamp){
	12	super(startTime, endTime, timestamp);
	13	}
	14
	15	public List<MetricsStats> calulateMetrics(){
	16	List<MetricsStats> metrics = new ArrayList<MetricsStats>();
	17	/*for(String resourceTypeName: metricsData.keySet()){
	18	MetricsStats metric = new MetricsStats(resourceTypeName, "energyUsage", metricsData.get(resourceTypeName).getMax());
	19	metrics.add(metric);}
	20	}*/
	21	metrics.add(calculateITComputingEnergyConsumption());
	22	metrics.add(calculateITEnergyConsumption());
	23	metrics.add(calculateNodeGroupFansEnergyConsumption());
	24
	25	metrics.add(calculateRackEnergyConsumption());
	26	metrics.add(calculateDataCenterFansEnergyConsumption());
	27	metrics.add(calculateCoolingDeviceEnergyConsumption());
	28	metrics.add(calculateOtherDevicesEnergyConsumption());
	29
	30	metrics.add(calculateTotalEnergyConsumption());
	31
	32	metrics.add(calculateMeanRackPower());
	33	metrics.add(calculateMeanPower());
	34	metrics.add(calculateMaxRackPower());
	35	metrics.add(calculateMaxPower());
	36
	37	metrics.add(calculatePUE());
	38	metrics.add(calculatePUELevel4());
	39	metrics.add(calculateEnergyWasteRate());
	40
	41	metrics.add(calculateUsefulWork());
	42	metrics.add(calculateProductivity());
	43
	44	return metrics;
	45	}
	46
	47	private MetricsStats calculateTotalEnergyConsumption(){
	48
	49	MetricsStats metric;
	50	try{
	51
	52	double roomPower = 0;
[1396]	53	for(DCwormsAccumulator acc: metricsData.get("Room")){
[1299]	54	roomPower = roomPower + acc.getSum();
	55	}
	56	metric = new MetricsStats("CoolEmAllTestbed", "Total_energy_consumption", roomPower, timestamp, "Wh");
	57	} catch (Exception e){
	58	metric = new MetricsStats("CoolEmAllTestbed", "Total_energy_consumption", -1, timestamp, "Wh");
	59	}
	60	return metric;
	61	}
	62
	63	private MetricsStats calculateITComputingEnergyConsumption(){
	64
	65	MetricsStats metric;
	66	try{
	67	double itComputingPower = 0;
[1396]	68	for(DCwormsAccumulator acc: metricsData.get("Processor")){
[1299]	69	itComputingPower = itComputingPower + acc.getSum();
	70	}
	71	metric = new MetricsStats("CoolEmAllTestbed", "Total_processors_energy_consumption", (itComputingPower), timestamp, "Wh");
	72	} catch (Exception e){
	73	metric = new MetricsStats("CoolEmAllTestbed", "Total_processors_energy_consumption", -1, timestamp, "Wh");
	74	}
	75	return metric;
	76	}
	77
	78	private MetricsStats calculateITEnergyConsumption(){
	79
	80	MetricsStats metric;
	81	try{
	82	double totalSitePower = 0;
[1396]	83	for(DCwormsAccumulator acc: metricsData.get("Rack")){
[1299]	84	totalSitePower = totalSitePower + acc.getSum();
	85	}
	86	double nodeComputingPower = 0;
[1396]	87	for(DCwormsAccumulator acc: metricsData.get("Node")){
[1299]	88	nodeComputingPower = nodeComputingPower+ acc.getSum();
	89	}
	90	double itComputingPower = 0;
[1396]	91	for(DCwormsAccumulator acc: metricsData.get("Processor")){
[1299]	92	itComputingPower = itComputingPower + acc.getSum();
	93	}
	94	double nodeGroupFansPowerConumspion = nodeComputingPower - itComputingPower;
	95	metric = new MetricsStats("CoolEmAllTestbed", "Total_IT_energy_consumption", (totalSitePower * CoolEmAllTestbedMeasurements.POWER_SUPPLY_EFFICIENCY - nodeGroupFansPowerConumspion), timestamp, "Wh");
	96	} catch (Exception e){
	97	metric = new MetricsStats("CoolEmAllTestbed", "Total_IT_energy_consumption", -1, timestamp, "Wh");
	98	}
	99	return metric;
	100	}
	101
	102	private MetricsStats calculateNodeGroupFansEnergyConsumption(){
	103
	104	MetricsStats metric;
	105	try{
	106	double nodeComputingPower = 0;
[1396]	107	for(DCwormsAccumulator acc: metricsData.get("Node")){
[1299]	108	nodeComputingPower = nodeComputingPower+ acc.getSum();
	109	}
	110	double itComputingPower = 0;
[1396]	111	for(DCwormsAccumulator acc: metricsData.get("Processor")){
[1299]	112	itComputingPower = itComputingPower + acc.getSum();
	113	}
	114	double nodeGroupFansPowerConumspion = nodeComputingPower - itComputingPower;
	115	metric = new MetricsStats("CoolEmAllTestbed", "Total_node_group_fans_energy_consumption", nodeGroupFansPowerConumspion, timestamp, "Wh");
	116	} catch (Exception e){
	117	metric = new MetricsStats("CoolEmAllTestbed", "Total_node_group_fans_energy_consumption", -1, timestamp, "Wh");
	118	}
	119	return metric;
	120	}
	121
	122	private MetricsStats calculatePUELevel4(){
	123
	124	MetricsStats metric;
	125	try{
	126
	127	double roomPower = 0;
[1396]	128	for(DCwormsAccumulator acc: metricsData.get("Room")){
[1299]	129	roomPower = roomPower + acc.getSum();
	130	}
	131
	132	double totalSitePower = 0;
[1396]	133	for(DCwormsAccumulator acc: metricsData.get("Rack")){
[1299]	134	totalSitePower = totalSitePower + acc.getSum();
	135	}
	136
	137
	138	double nodeComputingPower = 0;
[1396]	139	for(DCwormsAccumulator acc: metricsData.get("Node")){
[1299]	140	nodeComputingPower = nodeComputingPower+ acc.getSum();
	141	}
	142	double itComputingPower = 0;
[1396]	143	for(DCwormsAccumulator acc: metricsData.get("Processor")){
[1299]	144	itComputingPower = itComputingPower + acc.getSum();
	145	}
	146	double nodeGroupFansPowerConumspion = nodeComputingPower - itComputingPower;
	147
	148	metric = new MetricsStats("CoolEmAllTestbed", "PUE_Level_4", roomPower/(totalSitePower * CoolEmAllTestbedMeasurements.POWER_SUPPLY_EFFICIENCY - nodeGroupFansPowerConumspion), timestamp, "");
	149	} catch (Exception e){
	150	metric = new MetricsStats("CoolEmAllTestbed", "PUE_Level_4", -1, timestamp, "");
	151	}
	152	return metric;
	153	}
	154
	155	private MetricsStats calculatePUE(){
	156
	157	MetricsStats metric;
	158	try{
	159
	160	double roomPower = 0;
[1396]	161	for(DCwormsAccumulator acc: metricsData.get("Room")){
[1299]	162	roomPower = roomPower + acc.getSum();
	163	}
	164
	165	double totalSitePower = 0;
[1396]	166	for(DCwormsAccumulator acc: metricsData.get("Rack")){
[1299]	167	totalSitePower = totalSitePower + acc.getSum();
	168	}
	169
	170
	171	metric = new MetricsStats("CoolEmAllTestbed", "PUE", roomPower/totalSitePower, timestamp, "");
	172	} catch (Exception e){
	173	metric = new MetricsStats("CoolEmAllTestbed", "PUE", -1, timestamp, "");
	174	}
	175	return metric;
	176	}
	177
	178	private MetricsStats calculateUsefulWork(){
	179
	180	MetricsStats metric;
	181	try{
	182	double usefulWork = 0;
	183	for(String key: metricsData.keySet()){
[1331]	184	if(key.contains("UW_")){
[1396]	185	for(DCwormsAccumulator acc: metricsData.get(key)){
[1299]	186	usefulWork= usefulWork + acc.getSum();
	187	}
	188	}
	189	}
	190	metric = new MetricsStats("CoolEmAllTestbed", "Useful_Work", usefulWork, timestamp, "UW units");
	191	} catch (Exception e){
	192	metric = new MetricsStats("CoolEmAllTestbed", "Useful_Work", -1, timestamp, "UW units");
	193	}
	194
	195	return metric;
	196	}
	197
	198	private MetricsStats calculateProductivity(){
	199
	200	MetricsStats metric;
	201	try{
	202	double usefulWork = 0;
	203	for(String key: metricsData.keySet()){
	204	if(key.contains("/")){
[1396]	205	for(DCwormsAccumulator acc: metricsData.get(key)){
[1299]	206	usefulWork= usefulWork + acc.getSum();
	207	}
	208	}
	209	}
	210	double totalSitePower = 0;
[1396]	211	for(DCwormsAccumulator acc: metricsData.get("Rack")){
[1299]	212	totalSitePower = totalSitePower + acc.getSum();
	213	}
	214
	215	metric = new MetricsStats("CoolEmAllTestbed", "Productivity", usefulWork/totalSitePower, timestamp, "UW units/Wh");
	216	} catch (Exception e){
	217	metric = new MetricsStats("CoolEmAllTestbed", "Productivity", -1, timestamp, "UW units/Wh");
	218	}
	219
	220	return metric;
	221	}
	222
	223
	224	private MetricsStats calculateMaxRackPower(){
	225
	226	MetricsStats metric;
	227	try{
	228	double maxPower = 0;
	229
[1396]	230	for(DCwormsAccumulator acc: metricsData.get("Rack_MAX")){
[1299]	231	maxPower = maxPower + acc.getSum();
	232	}
	233
	234	metric = new MetricsStats("CoolEmAllTestbed", "Max_rack_power", maxPower, timestamp, "W");
	235	} catch (Exception e){
	236	metric = new MetricsStats("CoolEmAllTestbed", "Max_rack_power", -1, timestamp, "W");
	237	}
	238
	239	return metric;
	240	}
	241
	242	private MetricsStats calculateMaxPower(){
	243
	244	MetricsStats metric;
	245	try{
	246	double maxPower = 0;
	247
[1396]	248	for(DCwormsAccumulator acc: metricsData.get("Room_MAX")){
[1299]	249	maxPower = maxPower + acc.getSum();
	250	}
	251
	252	metric = new MetricsStats("CoolEmAllTestbed", "Max_power", maxPower, timestamp, "W");
	253	} catch (Exception e){
	254	metric = new MetricsStats("CoolEmAllTestbed", "Max_power", -1, timestamp, "W");
	255	}
	256
	257	return metric;
	258	}
	259
	260	private MetricsStats calculateDataCenterFansEnergyConsumption(){
	261
	262	MetricsStats metric;
	263	try{
	264	double inletsPower = 0;
[1396]	265	for(DCwormsAccumulator acc: metricsData.get("Inlet")){
[1299]	266	inletsPower = inletsPower + acc.getSum();
	267	}
	268
	269	double outletsPower = 0;
[1396]	270	for(DCwormsAccumulator acc: metricsData.get("Outlet")){
[1299]	271	outletsPower = outletsPower + acc.getSum();
	272	}
	273
	274	double nodeComputingPower = 0;
[1396]	275	for(DCwormsAccumulator acc: metricsData.get("Node")){
[1299]	276	nodeComputingPower = nodeComputingPower+ acc.getSum();
	277	}
	278	double itComputingPower = 0;
[1396]	279	for(DCwormsAccumulator acc: metricsData.get("Processor")){
[1299]	280	itComputingPower = itComputingPower + acc.getSum();
	281	}
	282	double nodeGroupFansPowerConumspion = nodeComputingPower - itComputingPower;
	283
	284	metric = new MetricsStats("CoolEmAllTestbed", "Total_data_center_fans_energy_consumption", (inletsPower + outletsPower - nodeGroupFansPowerConumspion), timestamp, "Wh");
	285	} catch (Exception e){
	286	metric = new MetricsStats("CoolEmAllTestbed", "Total_data_center_fans_energy_consumption", -1, timestamp, "Wh");
	287	}
	288	return metric;
	289	}
	290
	291	private MetricsStats calculateRackEnergyConsumption(){
	292
	293	MetricsStats metric;
	294	try{
	295	double roomPower = 0;
[1396]	296	for(DCwormsAccumulator acc: metricsData.get("Rack")){
[1299]	297	roomPower = roomPower + acc.getSum();
	298	}
	299	metric = new MetricsStats("CoolEmAllTestbed", "Total_rack_energy_consumption", roomPower, timestamp, "Wh");
	300	} catch (Exception e){
	301	metric = new MetricsStats("CoolEmAllTestbed", "Total_rack_energy_consumption", -1, timestamp, "Wh");
	302	}
	303	return metric;
	304	}
	305
	306	private MetricsStats calculateCoolingDeviceEnergyConsumption(){
	307
	308	MetricsStats metric;
	309	try{
	310	double coolingDevicePower = 0;
[1396]	311	for(DCwormsAccumulator acc: metricsData.get("CoolingDevice")){
[1299]	312	coolingDevicePower = coolingDevicePower + acc.getSum();
	313	}
	314	metric = new MetricsStats("CoolEmAllTestbed", "Total_cooling_device_energy_consumption", coolingDevicePower, timestamp, "Wh");
	315	} catch (Exception e){
	316	metric = new MetricsStats("CoolEmAllTestbed", "Total_cooling_device_energy_consumption", -1, timestamp, "Wh");
	317	}
	318	return metric;
	319	}
	320
[1331]	321	private MetricsStats calculateDataCenterFansEnergyConsumptionOld(){
	322
	323	MetricsStats metric;
	324	try{
	325
	326	double flowPump = 0;
	327	for(String key: metricsData.keySet()){
	328	if(key.contains("FlowPump")){
[1396]	329	for(DCwormsAccumulator acc: metricsData.get(key)){
[1331]	330	flowPump = flowPump + acc.getSum();
	331	}
	332	}
	333	}
	334
	335	metric = new MetricsStats("CoolEmAllTestbed", "Total_data_center_fans_energy_consumption", (flowPump), timestamp, "Wh");
	336	} catch (Exception e){
	337	metric = new MetricsStats("CoolEmAllTestbed", "Total_data_center_fans_energy_consumption", -1, timestamp, "Wh");
	338	}
	339	return metric;
	340	}
	341
	342
[1299]	343	private MetricsStats calculateOtherDevicesEnergyConsumption(){
	344
	345	MetricsStats metric;
	346	try{
	347	double roomPower = 0;
[1396]	348	for(DCwormsAccumulator acc: metricsData.get("Room")){
[1299]	349	roomPower = roomPower + acc.getSum();
	350	}
	351
	352	double totalSitePower = 0;
[1396]	353	for(DCwormsAccumulator acc: metricsData.get("Rack")){
[1299]	354	totalSitePower = totalSitePower + acc.getSum();
	355	}
	356
	357	double coolingDevicePower = 0;
[1396]	358	for(DCwormsAccumulator acc: metricsData.get("CoolingDevice")){
[1299]	359	coolingDevicePower = coolingDevicePower + acc.getSum();
	360	}
	361
	362	double inletsPower = 0;
[1396]	363	for(DCwormsAccumulator acc: metricsData.get("Inlet")){
[1299]	364	inletsPower = inletsPower + acc.getSum();
	365	}
	366
	367	double outletsPower = 0;
[1396]	368	for(DCwormsAccumulator acc: metricsData.get("Outlet")){
[1299]	369	outletsPower = outletsPower + acc.getSum();
	370	}
	371
	372	double nodeComputingPower = 0;
[1396]	373	for(DCwormsAccumulator acc: metricsData.get("Node")){
[1299]	374	nodeComputingPower = nodeComputingPower+ acc.getSum();
	375	}
	376	double itComputingPower = 0;
[1396]	377	for(DCwormsAccumulator acc: metricsData.get("Processor")){
[1299]	378	itComputingPower = itComputingPower + acc.getSum();
	379	}
	380	double nodeGroupFansPowerConumspion = nodeComputingPower - itComputingPower;
	381
	382	metric = new MetricsStats("CoolEmAllTestbed", "Total_other_devices_energy_consumption", roomPower - (totalSitePower + coolingDevicePower + (inletsPower + outletsPower - nodeGroupFansPowerConumspion)), timestamp, "Wh");
	383	} catch (Exception e){
	384	metric = new MetricsStats("CoolEmAllTestbed", "Total_other_devices_energy_consumption", -1, timestamp, "Wh");
	385	}
	386	return metric;
	387	}
	388
	389
	390	private MetricsStats calculateMeanPower(){
	391
	392	MetricsStats metric;
	393	try{
	394
	395	double roomPower = 0;
[1396]	396	for(DCwormsAccumulator acc: metricsData.get("Room")){
[1299]	397	roomPower = roomPower + acc.getSum();
	398	}
	399	metric = new MetricsStats("CoolEmAllTestbed", "Mean_power", roomPower/((this.endTime - this.startTime)/(SEC_IN_HOUR * MILLI_SEC)), timestamp, "W");
	400	} catch (Exception e){
	401	metric = new MetricsStats("CoolEmAllTestbed", "Mean_power", -1, timestamp, "W");
	402	}
	403	return metric;
	404	}
	405
	406
	407	private MetricsStats calculateMeanRackPower(){
	408
	409	MetricsStats metric;
	410	try{
	411
	412	double roomPower = 0;
[1396]	413	for(DCwormsAccumulator acc: metricsData.get("Rack")){
[1299]	414	roomPower = roomPower + acc.getSum();
	415	}
	416	metric = new MetricsStats("CoolEmAllTestbed", "Mean_rack_power", roomPower/((this.endTime - this.startTime)/(SEC_IN_HOUR * MILLI_SEC)), timestamp, "W");
	417	} catch (Exception e){
	418	metric = new MetricsStats("CoolEmAllTestbed", "Mean_rack_power", -1, timestamp, "W");
	419	}
	420	return metric;
	421	}
	422
	423	private MetricsStats calculateEnergyWasteRate(){
	424
	425	MetricsStats metric;
	426	try{
	427	double itComputingEnergy = 0;
[1331]	428
[1396]	429	for(DCwormsAccumulator acc: metricsData.get("Processor_CALC")){
[1299]	430	itComputingEnergy = itComputingEnergy + acc.getSum();
	431	}
[1331]	432
[1299]	433	double itEnergy = calculateITEnergyConsumption().getValue();
	434
	435	metric = new MetricsStats("CoolEmAllTestbed", "Energy_waste_rate", (1 - itComputingEnergy/itEnergy) * 100, timestamp, "%");
	436	} catch (Exception e){
	437	metric = new MetricsStats("CoolEmAllTestbed", "Energy_waste_rate", -1, timestamp, "%");
	438	}
	439
	440	return metric;
	441	}
	442
	443	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format