source: DCWoRMS/branches/coolemall/src/test/fips/models/i5/CpuEnergyEstimationPlugin.java @ 1600

package test.fips.models.i5;

import schedframe.resources.computing.Processor;
import schedframe.resources.computing.profiles.energy.ResourceEvent;
import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName;
import schedframe.resources.devices.PhysicalResource;
import schedframe.scheduling.manager.tasks.JobRegistry;
import example.energy.BaseEnergyEstimationPlugin;

public class CpuEnergyEstimationPlugin extends BaseEnergyEstimationPlugin {


        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry,
                        PhysicalResource resource) {
                /*double powerConsumption = 0;

                Processor cpu = (Processor)resource;
                powerConsumption = Pidle + (Pfull- Pidle) * cpu.getLoadInterface().getRecentUtilization().getValue()/100;                       

                return powerConsumption;*/
                
                double processorLoad = 0;
                double powerConsumption = 0;
                Processor proc = (Processor)resource;
                if(resource.getPowerInterface().getPowerState().equals(StandardPowerStateName.OFF))
                        return 0;
                else {
                        processorLoad = proc.getLoadInterface().getRecentUtilization().getValue();
                        double lowestLoadLevel = 100;
                        double highestLoadLevel = 0;
                        if(proc.getPowerInterface().getPState().getLoadPowerUsage().containsKey(new Double(processorLoad))){
                                powerConsumption = proc.getPowerInterface().getPState().getLoadPowerUsage().get(new Double(processorLoad));
                        } else {
                                for(Double load: proc.getPowerInterface().getPState().getLoadPowerUsage().keySet()){
                                        if(lowestLoadLevel > load){
                                                lowestLoadLevel = load;
                                        }
                                        if(highestLoadLevel < load){
                                                highestLoadLevel = load;
                                        }
                                }
                                if(processorLoad == 0){
                                        try{
                                                powerConsumption = proc.getPowerInterface().getSupportedPowerStates().get(0).getPowerUsage();
                                        } catch (Exception e){
                                                powerConsumption = 0.7 * proc.getPowerInterface().getPState().getLoadPowerUsage().get(new Double(highestLoadLevel));
                                        }
                                } else {
                                        
                                        double lowerLoadLevel = lowestLoadLevel;
                                        double higherLoadLevel = highestLoadLevel;
                                        
                                        try{
                                        
                                                for(Double load: proc.getPowerInterface().getPState().getLoadPowerUsage().keySet()){
                                                        if(processorLoad > load){
                                                                lowerLoadLevel = load;
                                                        }
                                                        else if(processorLoad < load){
                                                                higherLoadLevel = load;
                                                                break;
                                                        }
                                                }
                                                double powerBelow;
                                                double powerAbove;
                                                double a;
                                                double b;
                                                if(lowerLoadLevel != higherLoadLevel) {
                                                        powerBelow = proc.getPowerInterface().getPState().getLoadPowerUsage().get(lowerLoadLevel);
                                                        powerAbove = proc.getPowerInterface().getPState().getLoadPowerUsage().get(higherLoadLevel);
                                                        a = (powerAbove - powerBelow)/(higherLoadLevel - lowerLoadLevel);
                                                        b = powerAbove - a * higherLoadLevel;
                                                } else {
                                                        powerBelow = proc.getPowerInterface().getPState().getLoadPowerUsage().get(lowestLoadLevel);
                                                        powerAbove = proc.getPowerInterface().getPState().getLoadPowerUsage().get(highestLoadLevel);
                                                        a = (powerAbove - powerBelow)/(highestLoadLevel - lowestLoadLevel);
                                                        b = powerAbove - a * highestLoadLevel;
                                                }
                                                powerConsumption = a * processorLoad + b;
                                        } catch (Exception e){
                                                powerConsumption = 0.7 * proc.getPowerInterface().getPState().getLoadPowerUsage().get(new Double(highestLoadLevel));    
                                        }
                                }
                        }
                }
                return powerConsumption;
        }
        

}