source: DCWoRMS/branches/coolemall/src/test/freqscaling/CB1PowerCappingEnergyEstimationPlugin.java @ 1441

package test.freqscaling;

import java.util.List;

import schedframe.resources.computing.Node;
import schedframe.resources.computing.Processor;
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.power.PState;
import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName;
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 CB1PowerCappingEnergyEstimationPlugin extends BaseEnergyEstimationPlugin{

        private int MAX_THRESHOLD = 450;
        private int MIN_THRESHOLD = 400;
        private double currentFrequencyLevel;
        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry,
                        PhysicalResource resource) {

                double powerConsumption = 0;
                ComputeBox1 computeBox1 = (ComputeBox1)resource;
                for(NodeGroup ng:computeBox1.getNodesGroups()){
                        try{
                                powerConsumption = powerConsumption + ng.getPowerInterface().getRecentPowerUsage().getValue();
                        } catch (Exception e){
                                
                        }
                }
                //System.out.println("rack");
                int nrOfPoweredOffNodes = 0;
                for(Node node: computeBox1.getNodes()){
                        if(node.getPowerInterface().getPowerState().equals(StandardPowerStateName.OFF)){
                                nrOfPoweredOffNodes++;
                        }
                }
                if(nrOfPoweredOffNodes != computeBox1.getNodes().size()){
                        powerConsumption = (powerConsumption + CoolEmAllTestbedMeasurements.OTHER_DEVICES_POWER_CONSUMPTION)/CoolEmAllTestbedMeasurements.POWER_SUPPLY_EFFICIENCY;                      
                }
                
                loadThresholds(resource);
                ///System.out.println(resource.getFullName() + " min: " + minValue);
                //System.out.println(resource.getFullName() + " max: " + maxValue);
                //System.out.println(resource.getFullName() + " current: " + powerConsumption);
                //System.out.println(event.getType().toString() + ";" + event.getTag() + ":" + event.getSource());
                //System.out.println(CB2_FCFS_Random_SP.mode);
                if(powerConsumption > MAX_THRESHOLD){
                        DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_POWER_LIMIT_EXCEEDED, null);
                }
                else if(powerConsumption < MAX_THRESHOLD){
                        DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_POWER_LIMIT_EXCEEDED, null);
                }
                
                if(false){

                        List<Processor> processors = computeBox1.getProcessors();
                        currentFrequencyLevel = processors.get(0).getPowerInterface().getLowestPState().getFrequency();

                        boolean overThreshold = true;
                        boolean canDoBetter = true;

                        while(overThreshold && canDoBetter){
                                //System.out.println(compRes.getFullName() + " - downgrading");
                                int procNumberWithoutChange = 0;
                                boolean improvement = false;
                                //System.out.println(compRes.getFullName() + "; currentFrequencyLevel: " + currentFrequencyLevel);
                                for (Processor proc: processors){
                                        PState currPState = proc.getPowerInterface().getPState();
                                        //System.out.println(proc.getFullName() + " - checking");
                                        if(currPState.getFrequency() <= currentFrequencyLevel && proc.getFreeCores().size() != proc.getCores().size()){
                                                //System.out.println("operating same level");
                                                procNumberWithoutChange++;
                                                continue;
                                        } 
                                        if (proc.getFreeCores().size() == proc.getCores().size()){      
                                                //System.out.println("free");
                                                procNumberWithoutChange++;
                                                continue;
                                        } 
        
                                        double lowerFrequency = proc.getPowerInterface().getHighestPState().getFrequency();
                                        for(String pStateName: proc.getPowerInterface().getSupportedPStates().keySet()){
                                                PState pState = proc.getPowerInterface().getSupportedPStates().get(pStateName);
                                                if(pState.getFrequency() > lowerFrequency && pState.getFrequency() < currPState.getFrequency()){
                                                        lowerFrequency = pState.getFrequency();
                                                }
                                        }
                                        //System.out.println(proc.getFullName() + "; lower frequency: " + lowerFrequency);
                                        if(lowerFrequency < currentFrequencyLevel){
                                                //System.out.println(compRes.getFullName() + " - changing current frequency level");

                                                currentFrequencyLevel = lowerFrequency;
                                        }
                                        
                                        if(lowerFrequency != currPState.getFrequency()) {
                                                //System.out.println(proc.getFullName() + " - lowering frequency");
                                                proc.getPowerInterface().setFrequency(lowerFrequency);
                                                improvement = true;
                                        }
                                        if(lowerFrequency == proc.getPowerInterface().getHighestPState().getFrequency()){
                                                canDoBetter = false;
                                        } else {
                                                canDoBetter = true;
                                        }
                                        if(computeBox1.getPowerInterface().getRecentPowerUsage().getValue() <= MAX_THRESHOLD){
                                                overThreshold = false;
                                                break;
                                        }
                                }       
                                if(procNumberWithoutChange == processors.size() || improvement == false){
                                        //System.out.println(compRes.getFullName() + " - failed to improve");
                                        double nextFrequencyLevel = processors.get(0).getPowerInterface().getHighestPState().getFrequency();
                                        for (Processor proc: processors){
                                                for(String pStateName: proc.getPowerInterface().getSupportedPStates().keySet()){
                                                        PState pState = proc.getPowerInterface().getSupportedPStates().get(pStateName);
                                                        if(pState.getFrequency() > nextFrequencyLevel && pState.getFrequency() < currentFrequencyLevel){
                                                                nextFrequencyLevel = pState.getFrequency();
                                                        } 
                                                }
                                        }
                                        //System.out.println(compRes.getFullName() + "; nextFrequencyLevel: " + nextFrequencyLevel);
                                        currentFrequencyLevel = nextFrequencyLevel;
                                        if(currentFrequencyLevel == processors.get(0).getPowerInterface().getHighestPState().getFrequency()){
                                                canDoBetter = false;
                                        }
                                        procNumberWithoutChange = 0;
                                }
                        }

                } else if (powerConsumption < MIN_THRESHOLD) {
                }

                return powerConsumption;
        }
                
        private void loadThresholds(PhysicalResource resource){
                String productName = resource.getResourceCharacteristic().getParameters().get("product").get(0).getContent();
                MAX_THRESHOLD =450;
                MIN_THRESHOLD = 400;

        }
}