source: DCWoRMS/branches/coolemall/src/test/simpat/models/basic/RackEnergyEstimationPlugin.java @ 1469

package test.simpat.models.basic;

import java.util.List;

import schedframe.resources.CoolEmAllResourceType;
import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.Node;
import schedframe.resources.computing.Processor;
import schedframe.resources.computing.Rack;
import schedframe.resources.computing.coolemall.ComputeBox1;
import schedframe.resources.computing.coolemall.NodeGroup;
import schedframe.resources.computing.profiles.energy.ResourceEvent;
import schedframe.resources.computing.profiles.energy.airthroughput.CustomAirflowStateName;
import schedframe.resources.computing.profiles.energy.power.PState;
import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName;
import schedframe.resources.devices.Device;
import schedframe.resources.devices.PhysicalResource;
import schedframe.scheduling.manager.tasks.JobRegistry;
import simulator.DataCenterWorkloadSimulator;
import example.energy.BaseEnergyEstimationPlugin;
import example.energy.coolemall.CoolEmAllTestbedMeasurements;
import gridsim.dcworms.DCWormsTags;

public class RackEnergyEstimationPlugin extends BaseEnergyEstimationPlugin{

        double powerCapLevel = -1;
        double powerUpgradeLevel = -1;
        
        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry,
                        PhysicalResource resource) {
                
                if(powerCapLevel == -1 || powerUpgradeLevel == -1){
                        loadThresholds((ComputingResource) resource);
                }
                
                double powerConsumption = 0;
                Rack rack = (Rack)resource;
                for(Node node:rack.getNodes()){
                        try{
                                powerConsumption = powerConsumption + node.getPowerInterface().getRecentPowerUsage().getValue();
                        } catch (Exception e){
                                
                        }
                }
                
                int nrOfPoweredOffNodes = 0;
                for(Node node: rack.getNodes()){
                        if(node.getPowerInterface().getPowerState().equals(StandardPowerStateName.OFF)){
                                nrOfPoweredOffNodes++;
                        }
                }
                if(nrOfPoweredOffNodes != rack.getNodes().size()){
                        powerConsumption = (powerConsumption + CoolEmAllTestbedMeasurements.OTHER_DEVICES_POWER_CONSUMPTION)/CoolEmAllTestbedMeasurements.POWER_SUPPLY_EFFICIENCY;                      
                }
                
                if(powerConsumption > powerCapLevel){
                        DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_POWER_LIMIT_EXCEEDED, null);
                }
                else if(powerConsumption < powerUpgradeLevel){
                        DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_POWER_LIMIT_EXCEEDED, null);
                }
                return powerConsumption;
        }
        
        private void loadThresholds(ComputingResource compResource){
                
                Rack rack = (Rack) compResource;
                double pcLevel = 0;
                double puLevel = 0;
                for(Processor proc: rack.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;
                        
                }
                
                double fpc = 0;
                for(Node node: rack.getNodes()){
                        for(Device device: node.getResourceCharacteristic().getDevices()){
                                try {
                                        fpc = fpc + device.getAirflowInterface().getPowerConsumption(new CustomAirflowStateName("ON_100"));
                                } catch (NoSuchFieldException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                        }

                }
                pcLevel = (pcLevel + fpc) / CoolEmAllTestbedMeasurements.POWER_SUPPLY_EFFICIENCY;
                puLevel = (puLevel + fpc) / CoolEmAllTestbedMeasurements.POWER_SUPPLY_EFFICIENCY;

                puLevel = (pcLevel * pcLevel / puLevel);

                powerCapLevel = pcLevel;
                powerUpgradeLevel = puLevel;
        }

}