source: DCWoRMS/branches/coolemall/src/test/powerCapping/FanEnergyEstimationPlugin.java @ 1420

package test.powerCapping;

import schedframe.events.EventReason;
import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.Node;
import schedframe.resources.computing.Processor;
import schedframe.resources.computing.profiles.energy.ResourceEvent;
import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName;
import schedframe.resources.devices.Device;
import schedframe.resources.devices.Fan;
import schedframe.resources.devices.PhysicalResource;
import schedframe.scheduling.manager.tasks.JobRegistry;
import example.energy.BaseEnergyEstimationPlugin;

public class FanEnergyEstimationPlugin extends BaseEnergyEstimationPlugin {

        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry,
                        PhysicalResource resource) {
                
                double powerConsumption = 0;
                
                Fan fan = (Fan) resource;
                try {
                        powerConsumption = fan.getAirflowInterface().getPowerConsumption(fan.getAirflowInterface().getAirflowState());
                } catch (NoSuchFieldException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }

                /*if(resource.getAirThroughputInterface().getAirThroughputState().getName().equals(new UserAirThroughputStateName("1").getName())){
                        powerConsumption = CoolEmAllTestbedMeasurements.SINGLE_FAN_OFF_POWER_CONSUMPTION;
                } else {
                        powerConsumption = CoolEmAllTestbedMeasurements.SINGLE_FAN_ON_POWER_CONSUMPTION;
                }*/
                return powerConsumption * getFactor(fan)/(double)fan.getChilledResources().size();
        }
        
        public double estimateAirflow(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) {
                
                double airflow = 0;
                Fan fan = (Fan) resource;
                try {
                        if(event.getReason() == EventReason.SIM_INIT)
                                airflow = fan.getAirflowInterface().getAirflow(fan.getAirflowInterface().getAirflowState());
                        else
                                airflow = fan.getAirflowInterface().getAirflow(fan.getAirflowInterface().getAirflowState());
                } catch (NoSuchFieldException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }

                /*if(event.getReason() == EventReason.SIM_INIT){
                        if(resource.getAirThroughputInterface().getAirThroughputState().getName().equals(new UserAirThroughputStateName("1").getName())){
                                airThroughput = CoolEmAllTestbedMeasurements.SINGLE_FAN_OFF_AIR_FLOW;
                        } else {
                                airThroughput = CoolEmAllTestbedMeasurements.SINGLE_FAN_ON_AIR_FLOW;
                        }
                }
                else {
                        if(resource.getAirThroughputInterface().getAirThroughputState().getName().equals(new UserAirThroughputStateName("1").getName())){
                                airThroughput = CoolEmAllTestbedMeasurements.SINGLE_FAN_OFF_AIR_FLOW;
                        } else {
                                airThroughput = CoolEmAllTestbedMeasurements.SINGLE_FAN_ON_AIR_FLOW;
                        }
                }*/
                
                return airflow * getFactor(fan)/(double)fan.getChilledResources().size();
        }
        
        private int getNumberOfWorkingNodes(Device device){
                int quantity = 0;
                Fan fan = (Fan) device;
                for(ComputingResource compRes: device.getComputingResource().getChildren()){
                        Node node = (Node)compRes;
                        if(fan.getChilledResources().contains(node.getFullName()) && node.getPowerInterface().getPowerState().equals(StandardPowerStateName.ON) ){
                                quantity++;
                        }
                }
                return quantity;
        }

        private double getFactor(Device device){
                int quantity = 0;

                double factor = 0;;
                Fan fan = (Fan) device;
                for(ComputingResource compRes: device.getComputingResource().getChildren()){
                        Node node = (Node)compRes;
                        double nrOfComputingProcessor = 0;
                        double meanCurrFrequency = 0;
                        double meanMaxFrequency = 0;
                        if(fan.getChilledResources().contains(node.getFullName()) && node.getPowerInterface().getPowerState().equals(StandardPowerStateName.ON) ){
                                quantity++;
                                for(Processor proc: node.getProcessors()){
                                        if(proc.getCores().size() != proc.getFreeCores().size()){
                                                nrOfComputingProcessor++;
                                                meanCurrFrequency = meanCurrFrequency + proc.getPowerInterface().getFrequency();
                                                meanMaxFrequency = meanMaxFrequency + proc.getPowerInterface().getLowestPState().getFrequency();        
                                        } else {
                                                meanCurrFrequency = meanCurrFrequency + proc.getPowerInterface().getHighestPState().getFrequency();
                                                meanMaxFrequency = meanMaxFrequency + proc.getPowerInterface().getLowestPState().getFrequency();                                                
                                        }

                                }
                                meanCurrFrequency = meanCurrFrequency/node.getProcessors().size();
                                meanMaxFrequency = meanMaxFrequency/node.getProcessors().size();
                                factor = factor + (meanCurrFrequency /meanMaxFrequency) * (0.5+ nrOfComputingProcessor/node.getProcessors().size());
                        }
                }
                return factor;
        }
}