source: DCWoRMS/branches/coolemall/src/experiments/simpat2014/models/article/NodeEnergyEstimationPluginPowerCapping.java @ 1583

package experiments.simpat2014.models.article;


import java.util.List;

import schedframe.resources.CoolEmAllResourceType;
import schedframe.resources.StandardResourceType;
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.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.devices.Device;
import schedframe.resources.devices.Fan;
import schedframe.resources.devices.PhysicalResource;
import schedframe.scheduling.manager.tasks.JobRegistry;
import simulator.DataCenterWorkloadSimulator;
import eduni.simjava.Sim_system;
import example.energy.BaseEnergyEstimationPlugin;
import example.energy.coolemall.CoolEmAllTestbedMeasurements;
import experiments.simpat2014.EnvironmentConditions;
import gridsim.dcworms.DCWormsTags;


public class NodeEnergyEstimationPluginPowerCapping extends BaseEnergyEstimationPlugin {

        //double powerCapLevel = -1;
        //double powerUpgradeLevel = -1;
        
        
        private static double Tidle = 26;

        private double timestamp = 0;
        private double old_temperature = Tidle;
        private double new_temperature = -1;
        private double objective_temperature = Tidle;
        private boolean fan = false;
        
        private double next_timer = -1;

        private static double Pidle = 6;
        private static double Pfull = 20;


        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry,
                        PhysicalResource resource) {
                

                //loadThresholds((ComputingResource)resource);

                Node node = (Node) resource;
                double powerConsumption = 0;

                double Pcpu = 0;        
                for(Processor cpu: node.getProcessors()){
                        Pcpu = Pcpu + cpu.getPowerInterface().getRecentPowerUsage().getValue();
                }
                
                powerConsumption = Pcpu + Pidle + (Pfull- Pidle) * node.getLoadInterface().getRecentUtilization().getValue()/100;
                
                /*if(powerCapLevel!= -1 && powerConsumption > powerCapLevel){
                        DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_POWER_LIMIT_EXCEEDED, null);
                }
                else if(powerUpgradeLevel != -1 && powerConsumption < powerUpgradeLevel){
                        DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(0, DCWormsTags.RESOURCE_POWER_LIMIT_EXCEEDED, null);
                }*/
                return powerConsumption;
        }

        @Override
        public double estimateTemperature(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) {

                Node node = (Node) resource;
                Processor cpu = node.getProcessors().get(0);
                double Pserv = 0;

                double R = 0;
                double Rb = 0;
                double Rcv = 0;
                try{
                        Rb = Double.valueOf(cpu.getPowerInterface().getParameters().get("thermalResistance").get(0).getContent()).doubleValue();
                } catch (Exception e){
                        //
                }
                
                double k = 0;
                try{
                        k = Double.valueOf(cpu.getPowerInterface().getParameters().get("k").get(0).getContent()).doubleValue();
                } catch (Exception e){
                        //
                }
                
                double a = 0;
                try{
                        a = Double.valueOf(cpu.getPowerInterface().getParameters().get("a").get(0).getContent()).doubleValue();
                } catch (Exception e){
                        a = 1;
                }


                double C = 0;
                try{
                        C = Double.valueOf(cpu.getPowerInterface().getParameters().get("thermalCapacity").get(0).getContent()).doubleValue();
                } catch (Exception e){
                        //
                }
                
                double V = 0;
                double Pfan = 0;
                for(Device device: node.getParent().getResourceCharacteristic().getDevices()){
                        if(device.getType().equals(StandardResourceType.Fan)){
                                if(Integer.valueOf(device.getName().split("_")[1]).intValue() == Integer.valueOf(node.getName().split("_")[1]).intValue() || Integer.valueOf(device.getName().split("_")[1]).intValue() == Integer.valueOf(cpu.getParent().getName().split("_")[1]).intValue() - EnvironmentConditions.NODES_IN_A_ROW){
                                        Fan fan = (Fan) device;
                                        V = fan.getAirflowInterface().getRecentAirflow().getValue();
                                        Pfan =  fan.getPowerInterface().getRecentPowerUsage().getValue();
                                        break;
                                }
                        }
                }

                Rcv =  1/ (k * Math.pow(V, a));
                R = Rb + Rcv; 
                
                double K = 0;
                double Cair = EnvironmentConditions.AIR_HEAT_CAPACITY;
                double ro = EnvironmentConditions.AIR_DENSITY;

                K = V * Cair * ro;
                //System.out.println("-------K: " + K +  "; V:" + V);

                double delta_t = Sim_system.clock() - timestamp;

                double Tin = EnvironmentConditions.ROOM_TEMPERATURE;
                Pserv = node.getPowerInterface().getRecentPowerUsage().getValue();
                Pserv = Pserv + Pfan;
                
                NodeGroup ng = (NodeGroup) node.getParent();
                for(Node n: ng.getNodes()){
                        if(Integer.valueOf(n.getName().split("_")[1]) - Integer.valueOf(node.getName().split("_")[1]) == EnvironmentConditions.NODES_IN_A_ROW){
                                Tin = n.getThermalInterface().getRecentTemperature().getValue();
                        }
                }
                
                double targetTemp = Pserv/K + Tin; 
                objective_temperature = targetTemp;

                new_temperature = objective_temperature + (old_temperature - objective_temperature) * Math.exp(-delta_t / (R * C));

                // 5) save everything
                timestamp = Sim_system.clock();
                old_temperature = new_temperature;

                return new_temperature;
        }
        
        /*private void loadThresholds(ComputingResource compResource){
                
                Node n = (Node) compResource;
                double pcLevel = 0;
                double puLevel = 0;
                for(Processor proc: n.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 = 60;
                powerUpgradeLevel = 40;
        }*/
}