source: DCWoRMS/branches/coolemall/src/experiments/simpat2014/models/basic/NodeEnergyEstimationPlugin.java @ 1500

package experiments.simpat2014.models.basic;


import schedframe.resources.StandardResourceType;
import schedframe.resources.computing.Node;
import schedframe.resources.computing.Processor;
import schedframe.resources.computing.profiles.energy.ResourceEvent;
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 experiments.simpat2014.EnvironmentConditions;

public class NodeEnergyEstimationPlugin extends BaseEnergyEstimationPlugin {

        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 = 10;
        private static double Pfull = 76;

        
        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry,
                        PhysicalResource resource) {
                Node node = (Node) resource;
                double powerConsumption = 0;

                /*double Pcpu = 0;      
                for(Processor cpu: node.getProcessors()){
                        Pcpu = Pcpu + cpu.getPowerInterface().getRecentPowerUsage().getValue();
                }*/
                
                powerConsumption = Pidle + (Pfull- Pidle) * node.getLoadInterface().getRecentUtilization().getValue()/100; 
                double Pfan = 0;
                for(Device device: node.getResourceCharacteristic().getDevices()){
                        if(device.getType().equals(StandardResourceType.Fan)){
                                Fan fan = (Fan) device;
                                Pfan = Pfan + fan.getPowerInterface().getRecentPowerUsage().getValue();
                        }
                }
                //powerConsumption = Pcpu + Pfan;
                powerConsumption = powerConsumption + Pfan;
                return powerConsumption;
        }

        @Override
        public double estimateTemperature(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) {
                double future = -1;

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

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

                double C = 0;
                try{
                        C = Double.valueOf(cpu.getPowerInterface().getParameters().get("thermalCapacity").get(0).getContent()).doubleValue();
                } catch (Exception e){
                        //
                }
                
                double K = 0;
                double V = 0;
                double Cair = EnvironmentConditions.AIR_HEAT_CAPACITY;
                double ro = EnvironmentConditions.AIR_DENSITY;

                for(Device device: node.getResourceCharacteristic().getDevices()){
                        if(device.getType().equals(StandardResourceType.Fan)){
                                Fan fan = (Fan) device;
                                V = V + fan.getAirflowInterface().getRecentAirflow().getValue();
                                //double dp = EnvironmentConditions.AIR_PRESSURE;
                                //V = fan.getPowerInterface().getRecentPowerUsage().getValue() * 0.6 /dp;
                        }
                }

                K = V * Cair * ro;
                //System.out.println("-------A: " + A +  "; V:" + V);
                // 1) look where we are
                double delta_t = Sim_system.clock() - timestamp;
                double currentCpuTemp = cpu.getThermalInterface().getRecentTemperature().getValue();
                
                double Tin = EnvironmentConditions.ROOM_TEMPERATURE;
                Pserv = node.getPowerInterface().getRecentPowerUsage().getValue();
                double Pcpu = node.getProcessors().get(0).getPowerInterface().getRecentPowerUsage().getValue();
                double objectiveCpuTemp = Pcpu * R + Tin; 
                double targetTemp = Pserv/K + Tin; 
                objective_temperature = targetTemp;
                //System.out.println("node: " + node.getFullName() +  "; objective_temperature"  + objective_temperature +" : currentCpuTemp + ; " +currentCpuTemp + "; targetCpuTemp: " +objectiveCpuTemp );
                /*if(delta_t == 0)
                        new_temperature =Tin +  ((objectiveCpuTemp+ (currentCpuTemp-objectiveCpuTemp)* Math.exp(-delta_t/ (H * C)))/H)/A;
                else
                        new_temperature =Tin +  ((objectiveCpuTemp+ (currentCpuTemp-objectiveCpuTemp)* Math.exp(-delta_t/ (H * C)))/H + (C *(1/delta_t)))/A;
*/
                
                //new_temperature =currentCpuTemp +  (old_temperature-currentCpuTemp)* Math.exp(-delta_t/ (H * C));
                new_temperature = objective_temperature + (old_temperature - objective_temperature) * Math.exp(-delta_t / (R * C));
                //new_temperature = objective_temperature +   1/ (A *R) *(currentCpuTemp - objective_temperature)* Math.exp(-delta_t / (R * C));
                
                //new_temperature = currentCpuTemp + (Tin - currentCpuTemp) * Math.exp(-delta_t / (R * A));
                //System.out.println("***************" +new_temperature);
                //new_temperature = (Tin + Pserv/A + ((14.4 - Pserv/A) * Math.exp(- Sim_system.clock() * A / C)));
                //System.out.println("################" + new_temperature);
                //new_temperature =Tin + (currentCpuTemp - Tin)/(H * A) + (old_temperature-objective_temperature)* Math.exp(-delta_t * A/ C);
                
                
                // 3) compute new objective


                //System.out.println("=========== " + Sim_system.clock() +  "; objective_temperature: " + objective_temperature  + "; new_temperature: " + new_temperature +  "; targetTemp: " + targetTemp);

                
                // 4) check if we will need to tune fans
                if(fan && targetTemp < EnvironmentConditions.TFanLow) {
                        double timer = Cair/K * Math.log((new_temperature - targetTemp)/(targetTemp - EnvironmentConditions.TFanLow));
                        if(future == -1 || future > timer) {
                                future = timer;
                        }
                }
                if(!fan && targetTemp > EnvironmentConditions.TFanHigh) {
                        double timer = Cair/K * Math.log((new_temperature - targetTemp)/(targetTemp - EnvironmentConditions.TFanHigh));
                        if(future == -1 || future > timer) {
                                future = timer;
                        }
                }
                
                // 5) save everything
                timestamp = Sim_system.clock();
                old_temperature = new_temperature;
                //objective_temperature = targetTemp;


                if((future >= 0) && ((next_timer < Sim_system.clock()) || (next_timer >= future + Sim_system.clock()))) {
                        //DataCenterWorkloadSimulator.getEventManager().sendToAllSchedulers(future, DCWormsTags.FANMGT, "Test");
                        next_timer = future + Sim_system.clock() - 0.01;
                }               
                //System.out.println("------- " + new_temperature);
                return new_temperature;
        }
}