source: DCWoRMS/branches/coolemall/src/test/stencils/plugins/CommunicationBusEnergyEstimationPlugin.java @ 1605

package test.stencils.plugins;

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 CommunicationBusEnergyEstimationPlugin extends BaseEnergyEstimationPlugin  {

        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry,
                        PhysicalResource resource) {
                
                double processorLoad = 0;
                double powerConsumption = 0;
                Processor proc = (Processor)resource;
                if(resource.getPowerInterface().getPowerState().equals(StandardPowerStateName.OFF))
                        return 0;
                else {

                        /*double usedFreq = proc.getPowerInterface().getHighestPState().getFrequency();

                        JobRegistry jr = new JobRegistryImpl(proc.getFullName());
                        for(ExecTask task: jr.getRunningTasks()){
                                String taskFreqString = task.getCurrentResourceConsumption().getReferenceHardware().get("cpu_maxfreq");
                                double taskFreq = Double.valueOf(taskFreqString);
                                if(taskFreq > usedFreq){
                                        usedFreq = taskFreq;
                                }
                        }
                        
                        processorLoad = proc.getLoadInterface().getRecentUtilization().getValue();
                        //System.out.println(proc.getFullName() + "processorLoad v2: " +  processorLoad);
                        
                        if(processorLoad != 0 && proc.getPowerInterface().getFrequency() != usedFreq) {
                                proc.getPowerInterface().setFrequency(usedFreq);
                        }*/
                        
                        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));
                                //System.out.println("power from profile: " + powerConsumption);
                        } 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();
                                                //System.out.println("load = 0; power = idle power usage: " + powerConsumption);
                                        } catch (Exception e){
                                                powerConsumption = 0.7 * proc.getPowerInterface().getPState().getLoadPowerUsage().get(new Double(highestLoadLevel));
                                                //System.out.println("error load = 0; power = 0.7 max power: " + powerConsumption);
                                        }
                                } 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;
                                                /*System.out.println("a" +lowestLoadLevel + ";" +highestLoadLevel);
                                                System.out.println("b" +lowerLoadLevel + ";" +higherLoadLevel);
                                                System.out.println("c" +powerBelow + ";" +powerAbove);
                                                System.out.println(resource.getFullName() + "load: " + processorLoad + "linear power estimation " + powerConsumption);*/
        
                                        } catch (Exception e){
                                                powerConsumption = 0.7 * proc.getPowerInterface().getPState().getLoadPowerUsage().get(new Double(highestLoadLevel));    
                                                //System.out.println("error; power = 0.7 max power: " + powerConsumption);
                                        }
                                }
                        }
                }
                //System.out.println("estimated power consumption: " + powerConsumption);
                return powerConsumption;
        }

}