source: DCWoRMS/branches/coolemall/src/test/simpat/models/article/NodeGroupEnergyEstimationPluginPowerCapping.java @ 1469

package test.simpat.models.article;

import schedframe.resources.StandardResourceType;
import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.Node;
import schedframe.resources.computing.Processor;
import schedframe.resources.computing.coolemall.NodeGroup;
import schedframe.resources.computing.profiles.energy.ResourceEvent;
import schedframe.resources.computing.profiles.energy.power.PState;
import schedframe.resources.devices.Device;
import schedframe.resources.devices.Fan;
import schedframe.resources.devices.PhysicalResource;
import schedframe.scheduling.manager.tasks.JobRegistry;
import simulator.DataCenterWorkloadSimulator;
import test.simpat.EnvironmentConditions;
import example.energy.BaseEnergyEstimationPlugin;
import gridsim.dcworms.DCWormsTags;

public class NodeGroupEnergyEstimationPluginPowerCapping extends BaseEnergyEstimationPlugin{

        double powerCapLevel = -1;
        double powerUpgradeLevel = -1;
        
        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry,
                        PhysicalResource resource) {
                

                loadThresholds((ComputingResource)resource);
                
                double powerConsumption = 0;
                NodeGroup nodeGroup = (NodeGroup)resource;
                for(Node node: nodeGroup.getNodes()){
                        try{
                                powerConsumption = powerConsumption + node.getPowerInterface().getRecentPowerUsage().getValue();
                                powerConsumption = powerConsumption + node.getProcessors().get(0).getResourceCharacteristic().getDevices().get(0).getPowerInterface().getRecentPowerUsage().getValue();

                        } catch (Exception e){
                        }
                }

                for(Device device: nodeGroup.getResourceCharacteristic().getDevices()){
                        if(device.getType().equals(StandardResourceType.Fan)){
                                Fan fan = (Fan) device;
                                powerConsumption = powerConsumption + fan.getPowerInterface().getRecentPowerUsage().getValue();
                        }
                }
                
                if(powerCapLevel!= -1 && powerConsumption > powerCapLevel){
                        DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_POWER_LIMIT_EXCEEDED, resource.getFullName());
                }
                else if(powerUpgradeLevel != -1 && powerConsumption < powerUpgradeLevel){
                        DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_POWER_LIMIT_EXCEEDED, resource.getFullName());
                }
                
                return powerConsumption;
        }

        private void loadThresholds(ComputingResource compResource){
                
                NodeGroup ng = (NodeGroup) compResource;
                double pcLevel = 0;
                double puLevel = 0;
                for(Processor proc: ng.getProcessors()){
                        PState highestPState =  proc.getPowerInterface().getHighestPState();
                        PState secondHighestPState =  proc.getPowerInterface().getLowestPState();
                        for(String pStateName: proc.getPowerInterface().getSupportedPStates().keySet()){
                                PState pState = proc.getPowerInterface().getSupportedPStates().get(pStateName);
                                if(pState.getFrequency()  < secondHighestPState.getFrequency() && pState.getFrequency() > highestPState.getFrequency()){
                                        secondHighestPState = pState;
                                }
                        }
                        double maxMinPowerUsage = 0;
                        double powerUsage = 0;
                        
                        for(Double load: highestPState.getLoadPowerUsage().keySet()){
                                powerUsage = highestPState.getLoadPowerUsage().get(load);
                                if(powerUsage > maxMinPowerUsage){
                                        maxMinPowerUsage= powerUsage;                           
                                }
                        }
                        pcLevel = pcLevel + maxMinPowerUsage;
                        
                        maxMinPowerUsage = 0;
                        powerUsage = 0;
                        
                        for(Double load: secondHighestPState.getLoadPowerUsage().keySet()){
                                powerUsage = secondHighestPState.getLoadPowerUsage().get(load);
                                if(powerUsage > maxMinPowerUsage){
                                        maxMinPowerUsage= powerUsage;                           
                                }
                        }
                        puLevel = puLevel + maxMinPowerUsage;
                        
                }

                puLevel = (pcLevel * pcLevel / puLevel);

                //powerCapLevel = pcLevel;
                //powerUpgradeLevel = puLevel;
                
                powerCapLevel = EnvironmentConditions.powerCapLevel;
                powerUpgradeLevel = EnvironmentConditions.powerUpgradeLevel;
        }
}