Changeset 1299 for DCWoRMS/branches/coolemall/src/simulator/stats/MetricsCalculator.java

Timestamp:

03/19/14 18:22:27 (11 years ago)

Author:

wojtekp

Message:

 

File:

• DCWoRMS/branches/coolemall/src/simulator/stats/MetricsCalculator.java (modified) (1 diff)

DCWoRMS/branches/coolemall/src/simulator/stats/MetricsCalculator.java

@@ -1 +1 @@
 package simulator.stats;
 
-import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 import simulator.stats.implementation.MetricsStats;
-import example.energy.coolemall.CoolEmAllTestbedMeasurements;
 
-public class MetricsCalculator {
+public interface MetricsCalculator {
         
-        protected static final double MILLI_SEC = 1000;
-        protected static final double SEC_IN_HOUR = 3600;
+        public List<MetricsStats> calulateMetrics();
         
-        protected Map<String, List<GSSAccumulator>> metricsData = new HashMap<String, List<GSSAccumulator>>();
-        protected long timestamp;
-        protected long startTime;
-        protected long endTime;
-
-        public List<MetricsStats> calulateMetrics(long timestamp){
-                this.timestamp = timestamp;
-                List<MetricsStats> metrics = new ArrayList<MetricsStats>();
-                /*for(String resourceTypeName: metricsData.keySet()){
-                        MetricsStats metric = new MetricsStats(resourceTypeName, "energyUsage", metricsData.get(resourceTypeName).getMax());
-                        metrics.add(metric);}
-                }*/
-                metrics.add(calculateITComputingEnergyConsumption());
-                metrics.add(calculateITEnergyConsumption());
-                metrics.add(calculateNodeGroupFansEnergyConsumption());
-                
-                metrics.add(calculateRackEnergyConsumption());
-                metrics.add(calculateDataCenterFansEnergyConsumption());
-                metrics.add(calculateCoolingDeviceEnergyConsumption());
-                metrics.add(calculateOtherDevicesEnergyConsumption());
-                
-                metrics.add(calculateTotalEnergyConsumption());
-                
-                metrics.add(calculateMeanRackPower());
-                metrics.add(calculateMeanPower());
-                metrics.add(calculateMaxRackPower());
-                metrics.add(calculateMaxPower());
-                
-                metrics.add(calculatePUE());
-                metrics.add(calculatePUELevel4());
-                metrics.add(calculateEnergyWasteRate());
-                
-                metrics.add(calculateUsefulWork());
-                metrics.add(calculateProductivity());
-
-                return metrics;
-        }
+        public void addMetricsData(String resourceTypeName, GSSAccumulator resourceEnergyAccumulator);
         
-        public void addMetricsData(String resourceTypeName, GSSAccumulator resourceEnergyAccumulator){
-                List<GSSAccumulator> resourceEnergyAccumulatorList = metricsData.get(resourceTypeName);
-                if(resourceEnergyAccumulatorList == null){
-                        resourceEnergyAccumulatorList = new ArrayList<GSSAccumulator>();
-                }
-                resourceEnergyAccumulatorList.add(resourceEnergyAccumulator);
-                metricsData.put(resourceTypeName, resourceEnergyAccumulatorList);
-        }
+        public Map<String, List<GSSAccumulator>> getMetricsData();
         
-        public Map<String, List<GSSAccumulator>> getMetricsData(){
-                return metricsData;
-        }
-        
-        private MetricsStats calculateTotalEnergyConsumption(){
-                
-                MetricsStats metric;
-                try{
-                        
-                        double roomPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Room")){
-                                roomPower = roomPower + acc.getSum();
-                        }
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_energy_consumption", roomPower, timestamp, "Wh");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_energy_consumption", -1, timestamp, "Wh");
-                }
-                return metric;
-        }
-        
-        private MetricsStats calculateITComputingEnergyConsumption(){
-                
-                MetricsStats metric;
-                try{
-                        double itComputingPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Processor")){
-                                itComputingPower = itComputingPower + acc.getSum();
-                        }
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_processors_energy_consumption", (itComputingPower), timestamp, "Wh");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_processors_energy_consumption", -1, timestamp, "Wh");
-                }
-                return metric;
-        }
-        
-        private MetricsStats calculateITEnergyConsumption(){
-                
-                MetricsStats metric;
-                try{
-                        double totalSitePower = 0; 
-                        for(GSSAccumulator acc: metricsData.get("Rack")){
-                                totalSitePower = totalSitePower + acc.getSum();
-                        }
-                        double nodeComputingPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Node")){
-                                nodeComputingPower = nodeComputingPower+ acc.getSum();
-                        }
-                        double itComputingPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Processor")){
-                                itComputingPower = itComputingPower + acc.getSum();
-                        }
-                        double fanPowerConumspion = nodeComputingPower - itComputingPower;
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_IT_energy_consumption", (totalSitePower * CoolEmAllTestbedMeasurements.POWER_SUPPLY_EFFICIENCY - fanPowerConumspion), timestamp, "Wh");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_IT_energy_consumption", -1, timestamp, "Wh");
-                }
-                return metric;
-        }
-        
-        private MetricsStats calculateNodeGroupFansEnergyConsumption(){
-                
-                MetricsStats metric;
-                try{
-                        double nodeComputingPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Node")){
-                                nodeComputingPower = nodeComputingPower+ acc.getSum();
-                        }
-                        double itComputingPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Processor")){
-                                itComputingPower = itComputingPower + acc.getSum();
-                        }
-                        double nodeGroupFansPowerConumspion = nodeComputingPower - itComputingPower;
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_node_group_fans_energy_consumption", nodeGroupFansPowerConumspion, timestamp, "Wh");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_node_group_fans_energy_consumption", -1, timestamp, "Wh");
-                }
-                return metric;
-        }
-        
-        private MetricsStats calculatePUELevel4(){
-                
-                MetricsStats metric;
-                try{
-                        
-                        double roomPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Room")){
-                                roomPower = roomPower + acc.getSum();
-                        }
-                        
-                        double totalSitePower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Rack")){
-                                totalSitePower = totalSitePower + acc.getSum();
-                        }
-                        
-                
-                        double nodeComputingPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Node")){
-                                nodeComputingPower = nodeComputingPower+ acc.getSum();
-                        }
-                        double itComputingPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Processor")){
-                                itComputingPower = itComputingPower + acc.getSum();
-                        }
-                        double nodeGroupFansPowerConumspion = nodeComputingPower - itComputingPower;
-
-                        metric = new MetricsStats("CoolEmAllTestbed", "PUE_Level_4", roomPower/(totalSitePower * CoolEmAllTestbedMeasurements.POWER_SUPPLY_EFFICIENCY - nodeGroupFansPowerConumspion), timestamp, "");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "PUE_Level_4", -1, timestamp, "");
-                }
-                return metric;
-        }
-        
-        private MetricsStats calculatePUE(){
-                
-                MetricsStats metric;
-                try{
-                        
-                        double roomPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Room")){
-                                roomPower = roomPower + acc.getSum();
-                        }
-                        
-                        double totalSitePower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Rack")){
-                                totalSitePower = totalSitePower + acc.getSum();
-                        }
-
-
-                        metric = new MetricsStats("CoolEmAllTestbed", "PUE", roomPower/totalSitePower, timestamp, "");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "PUE", -1, timestamp, "");
-                }
-                return metric;
-        }
-
-        private MetricsStats calculateUsefulWork(){
-                
-                MetricsStats metric;
-                try{
-                        double usefulWork = 0;
-                        for(String key: metricsData.keySet()){
-                                if(key.contains("/")){
-                                        for(GSSAccumulator acc: metricsData.get(key)){
-                                                usefulWork= usefulWork + acc.getSum();
-                                        }
-                                }
-                        }
-                        metric = new MetricsStats("CoolEmAllTestbed", "Useful_Work", usefulWork, timestamp, "UW units");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "Useful_Work", -1, timestamp, "UW units");
-                }
-                
-                return metric;
-        }
-        
-        private MetricsStats calculateProductivity(){
-                
-                MetricsStats metric;
-                try{
-                        double usefulWork = 0;
-                        for(String key: metricsData.keySet()){
-                                if(key.contains("/")){
-                                        for(GSSAccumulator acc: metricsData.get(key)){
-                                                usefulWork= usefulWork + acc.getSum();
-                                        }
-                                }
-                        }
-                        double totalSitePower = 0; 
-                        for(GSSAccumulator acc: metricsData.get("Rack")){
-                                totalSitePower = totalSitePower + acc.getSum();
-                        }
-                        
-                        metric = new MetricsStats("CoolEmAllTestbed", "Productivity", usefulWork/totalSitePower, timestamp, "UW units/Wh");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "Productivity", -1, timestamp, "UW units/Wh");
-                }
-                
-                return metric;
-        }
-        
-        
-        private MetricsStats calculateMaxRackPower(){
-                
-                MetricsStats metric;
-                try{
-                        double maxPower = 0;
-                        
-                        for(GSSAccumulator acc: metricsData.get("Rack_MAX")){
-                                maxPower = maxPower + acc.getSum();
-                        }
-
-                        metric = new MetricsStats("CoolEmAllTestbed", "Max_rack_power", maxPower, timestamp, "W");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "Max_rack_power", -1, timestamp, "W");
-                }
-                
-                return metric;
-        }
-        
-        private MetricsStats calculateMaxPower(){
-                
-                MetricsStats metric;
-                try{
-                        double maxPower = 0;
-                        
-                        for(GSSAccumulator acc: metricsData.get("Room_MAX")){
-                                maxPower = maxPower + acc.getSum();
-                        }
-
-                        metric = new MetricsStats("CoolEmAllTestbed", "Max_power", maxPower, timestamp, "W");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "Max_power", -1, timestamp, "W");
-                }
-                
-                return metric;
-        }
-        
-        private MetricsStats calculateDataCenterFansEnergyConsumption(){
-                
-                MetricsStats metric;
-                try{
-                        double inletsPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Inlet")){
-                                inletsPower = inletsPower + acc.getSum();
-                        }
-                        
-                        double outletsPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Outlet")){
-                                outletsPower = outletsPower + acc.getSum();
-                        }
-                        
-                        double nodeComputingPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Node")){
-                                nodeComputingPower = nodeComputingPower+ acc.getSum();
-                        }
-                        double itComputingPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Processor")){
-                                itComputingPower = itComputingPower + acc.getSum();
-                        }
-                        double nodeGroupFansPowerConumspion = nodeComputingPower - itComputingPower;
-                        
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_data_center_fans_energy_consumption", (inletsPower + outletsPower - nodeGroupFansPowerConumspion), timestamp, "Wh");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_data_center_fans_energy_consumption", -1, timestamp, "Wh");
-                }
-                return metric;
-        }
-        
-        
-        private MetricsStats calculateRackEnergyConsumption(){
-                
-                MetricsStats metric;
-                try{
-                        double roomPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Rack")){
-                                roomPower = roomPower + acc.getSum();
-                        }
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_rack_energy_consumption", roomPower, timestamp, "Wh");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_rack_device_consumption", -1, timestamp, "Wh");
-                }
-                return metric;
-        }
-        
-        private MetricsStats calculateCoolingDeviceEnergyConsumption(){
-                
-                MetricsStats metric;
-                try{
-                        double coolingDevicePower = 0;
-                        for(GSSAccumulator acc: metricsData.get("CoolingDevice")){
-                                coolingDevicePower = coolingDevicePower + acc.getSum();
-                        }
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_cooling_device_energy_consumption", coolingDevicePower, timestamp, "Wh");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_cooling_device_consumption", -1, timestamp, "Wh");
-                }
-                return metric;
-        }
-        
-        private MetricsStats calculateOtherDevicesEnergyConsumption(){
-                
-                MetricsStats metric;
-                try{
-                        double roomPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Room")){
-                                roomPower = roomPower + acc.getSum();
-                        }
-                        
-                        double totalSitePower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Rack")){
-                                totalSitePower = totalSitePower + acc.getSum();
-                        }
-                        
-                        double coolingDevicePower = 0;
-                        for(GSSAccumulator acc: metricsData.get("CoolingDevice")){
-                                coolingDevicePower = coolingDevicePower + acc.getSum();
-                        }
-                        
-                        double inletsPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Inlet")){
-                                inletsPower = inletsPower + acc.getSum();
-                        }
-                        
-                        double outletsPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Outlet")){
-                                outletsPower = outletsPower + acc.getSum();
-                        }
-                        
-                        double nodeComputingPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Node")){
-                                nodeComputingPower = nodeComputingPower+ acc.getSum();
-                        }
-                        double itComputingPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Processor")){
-                                itComputingPower = itComputingPower + acc.getSum();
-                        }
-                        double nodeGroupFansPowerConumspion = nodeComputingPower - itComputingPower;
-                        
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_other_devices_energy_consumption", roomPower - (totalSitePower + coolingDevicePower + (inletsPower + outletsPower - nodeGroupFansPowerConumspion)), timestamp, "Wh");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "Total_other_devices_consumption", -1, timestamp, "Wh");
-                }
-                return metric;
-        }
-
-        
-        private MetricsStats calculateMeanPower(){
-                
-                MetricsStats metric;
-                try{
-                        
-                        double roomPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Room")){
-                                roomPower = roomPower + acc.getSum();
-                        }
-                        metric = new MetricsStats("CoolEmAllTestbed", "Mean_power", roomPower/((this.endTime - this.startTime)/(SEC_IN_HOUR * MILLI_SEC)), timestamp, "W");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "Mean_power", -1, timestamp, "W");
-                }
-                return metric;
-        }
-        
-        
-        private MetricsStats calculateMeanRackPower(){
-                
-                MetricsStats metric;
-                try{
-                        
-                        double roomPower = 0;
-                        for(GSSAccumulator acc: metricsData.get("Rack")){
-                                roomPower = roomPower + acc.getSum();
-                        }
-                        metric = new MetricsStats("CoolEmAllTestbed", "Mean_rack_power", roomPower/((this.endTime - this.startTime)/(SEC_IN_HOUR * MILLI_SEC)), timestamp, "W");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "Mean_rack_power", -1, timestamp, "W");
-                }
-                return metric;
-        }
-        
-        private MetricsStats calculateEnergyWasteRate(){
-                
-                MetricsStats metric;
-                try{
-                        double itComputingEnergy = 0;
-                        for(GSSAccumulator acc: metricsData.get("Processor_CALC")){
-                                itComputingEnergy = itComputingEnergy + acc.getSum();
-                        }
-                        itComputingEnergy = itComputingEnergy + CoolEmAllTestbedMeasurements.OTHER_DEVICES_POWER_CONSUMPTION * (this.endTime - this.startTime)/(SEC_IN_HOUR * MILLI_SEC);
-                        double itEnergy = calculateITEnergyConsumption().getValue();
-                        
-                        metric = new MetricsStats("CoolEmAllTestbed", "Energy_waste_rate", (1 - itComputingEnergy/itEnergy) * 100, timestamp, "%");
-                } catch (Exception e){
-                        metric = new MetricsStats("CoolEmAllTestbed", "Energy_waste_rate", -1, timestamp, "%");
-                }
-                return metric;
-        }
-        
-        public long getStartTime() {
-                return startTime;
-        }
-
-        public void setStartTime(long startTime) {
-                this.startTime = startTime;
-        }
-
-        public long getEndTime() {
-                return endTime;
-        }
-
-        public void setEndTime(long endTime) {
-                this.endTime = endTime;
-        }
 }