source: DCWoRMS/branches/coolemall/src/schedframe/resources/devices/DeviceEnergyExtension.java @ 1207

package schedframe.resources.devices;

import java.util.Properties;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import schedframe.events.Event;
import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.extensions.Extension;
import schedframe.resources.computing.extensions.ExtensionException;
import schedframe.resources.computing.extensions.ExtensionType;
import schedframe.resources.computing.profiles.energy.EnergyEvent;
import schedframe.resources.computing.profiles.energy.EnergyEventType;
import schedframe.resources.computing.profiles.energy.EnergyExtension;
import schedframe.resources.computing.profiles.energy.EnergyExtension.Builder;
import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputInterfaceFactory;
import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputProfile;
import schedframe.resources.computing.profiles.energy.airthroughput.ui.AirThroughputInterface;
import schedframe.resources.computing.profiles.energy.power.PowerInterfaceFactory;
import schedframe.resources.computing.profiles.energy.power.PowerProfile;
import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface;
import schedframe.resources.computing.profiles.energy.thermal.ThermalInterfaceFactory;
import schedframe.resources.computing.profiles.energy.thermal.ThermalProfile;
import schedframe.resources.computing.profiles.energy.thermal.ui.ThermalInterface;
import schedframe.scheduling.manager.tasks.JobRegistryImpl;
import simulator.DataCenterWorkloadSimulator;

public class DeviceEnergyExtension implements Extension{

        private Log log = LogFactory.getLog(EnergyExtension.class);

        protected PowerInterface powerInterface;
        protected PowerProfile powerProfile;
        
        protected AirThroughputInterface airFlowInterface;
        protected AirThroughputProfile airFlowProfile;
        
        protected ThermalInterface thermalInterface;
        protected ThermalProfile thermalProfile;
        
        protected PhysicalResource resource;


        public static class Builder {
                  
                protected PhysicalResource resource;
                protected PowerInterface powerInterface;
                protected PowerProfile powerProfile;
                
                protected AirThroughputInterface airFlowInterface;
                protected AirThroughputProfile airFlowProfile;
                
                protected ThermalInterface thermalInterface;
                protected ThermalProfile thermalProfile;
                
                public Builder resource(PhysicalResource res) {this.resource = res; return this;}
                
                public Builder powerProfile(PowerProfile pp){this.powerProfile = pp; this.powerInterface = PowerInterfaceFactory.createPowerInterface(resource, powerProfile); return this; }

        public Builder airFlowProfile(AirThroughputProfile atp){this.airFlowProfile = atp; this.airFlowInterface = AirThroughputInterfaceFactory.createAirThroughputInterface(resource, airFlowProfile); return this; }

        public Builder thermalProfile(ThermalProfile tp){this.thermalProfile = tp; this.thermalInterface = ThermalInterfaceFactory.createThermalInterface(resource, thermalProfile); return this; }

        public DeviceEnergyExtension build() {
            return new DeviceEnergyExtension(this);
        }
        }
        
        private DeviceEnergyExtension(Builder builder) {
                this.resource = builder.resource;
                this.powerInterface = builder.powerInterface;
                this.powerProfile = builder.powerProfile;
                
                this.airFlowInterface = builder.airFlowInterface ;
                this.airFlowProfile = builder.airFlowProfile;
                
                this.thermalInterface = builder.thermalInterface;
                this.thermalProfile = builder.thermalProfile;
        }

        
        public boolean supportsEvent(Event event) {

                if(powerProfile == null || powerProfile.getEnergyEstimationPlugin() == null)
                        return false;
                if(event.getType().getName().equals(EnergyEventType.POWER_STATE_CHANGED.getName()))
                        return true;
                else if(event.getType().getName().equals(EnergyEventType.FREQUENCY_CHANGED.getName()))
                        return true;
                else if(event.getType().getName().equals(EnergyEventType.TASK_STARTED.getName()))
                        return true;
                else if(event.getType().getName().equals(EnergyEventType.TASK_FINISHED.getName()))
                        return true;
                else if(event.getType().getName().equals(EnergyEventType.RESOURCE_UTILIZATION_CHANGED.getName()))
                        return true;
        
                if(event.getType().getName().equals(EnergyEventType.AIRFLOW_STATE_CHANGED.getName()))
                        return true;
                if(event.getType().getName().equals(EnergyEventType.TEMPERATURE_CHANGED.getName()))
                        return true;
                
                else return false;
        }

        public void handleEvent(Event event) {
                
                EnergyEvent enEvent = (EnergyEvent)event;
                double power = 0;
                boolean status = false;
                try{
                        switch (enEvent.getType()) {
                        
                        case POWER_STATE_CHANGED:
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                /*if(computingResource instanceof ComputingNode){
                                        ComputingNode node = (ComputingNode)computingResource;
                                        if(event.getData() instanceof PowerState){
                                                PowerState newState = (PowerState)event.getData();
                                                if(newState == PowerState.ON) {
                                                        addToPowerUsageHistory(power+node.getPowerInterface().START_COST);
                                                        addToPowerUsageHistory(DateTimeUtils.currentTimeMillis() + node.getPowerInterface().START_TIME, power);
                                                }else if(newState == PowerState.OFF){
                                                        addToPowerUsageHistory(power+node.getPowerInterface().SHUTDOWN_COST);
                                                        addToPowerUsageHistory(DateTimeUtils.currentTimeMillis() + node.getPowerInterface().SHUTDOWN_TIME, power);
                                                }
                                        }
                                }
                                else*/ 
                                
                                status = powerProfile.addToPowerUsageHistory(power);
                                //temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                                //thermalProfile.addToTemperatureHistory(temperature);
                                break;
                                
                        case FREQUENCY_CHANGED:
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                status = powerProfile.addToPowerUsageHistory(power);
                                //temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                                //thermalProfile.addToTemperatureHistory(temperature);
                                break;
                                
                        case TASK_STARTED:
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                status = powerProfile.addToPowerUsageHistory(power);
                                //temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                                //thermalProfile.addToTemperatureHistory(temperature);
                                break;
        
                        case TASK_FINISHED:
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                status = powerProfile.addToPowerUsageHistory(power);
                                //temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                                //thermalProfile.addToTemperatureHistory(temperature);
                                break;
                                
                        case RESOURCE_UTILIZATION_CHANGED:
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                status = powerProfile.addToPowerUsageHistory(power);
                                //temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                                //thermalProfile.addToTemperatureHistory(temperature);
                                break;
                                
                        case AIRFLOW_STATE_CHANGED:
                                double airFlow = powerProfile.getEnergyEstimationPlugin().estimateAirThroughput(enEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                airFlowProfile.addToAirFlowHistory(airFlow);
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                powerProfile.addToPowerUsageHistory(power);
                                //temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                                //thermalProfile.addToTemperatureHistory(temperature);
                                break;
                                
                        case TEMPERATURE_CHANGED:
                                double temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(enEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                thermalProfile.addToTemperatureHistory(temperature);
                                break;
                        }
                }catch(Exception e){
                        
                }
                if(status){
                        DataCenterWorkloadSimulator.getEventManager().sendToResources(resource.getType(), 0, new EnergyEvent(EnergyEventType.TEMPERATURE_CHANGED, resource.getFullName()));

                }
        }

        public void init(Properties properties) throws ExtensionException {
                // TODO Auto-generated method stub
        }

        public ExtensionType getType() {
                return ExtensionType.ENERGY_EXTENSION;
        }

        /*public ComputingResource getResource() {
                return computingResource;
        }

        public void setResource(ComputingResource compRes){
                this.computingResource = compRes;
        }*/

        public PowerInterface getPowerInterface() {
                return powerInterface;
        }

        public PowerProfile getPowerProfile() {
                return powerProfile;
        }

        public AirThroughputInterface getAirThroughputInterface() {
                return airFlowInterface;
        }

        public AirThroughputProfile getAirFlowProfile() {
                return airFlowProfile;
        }
        
        public ThermalProfile getThermalProfile() {
                return thermalProfile;
        }

        public ThermalInterface getThermalInterface() {
                return thermalInterface;
        }

}