source: DCWoRMS/trunk/src/schedframe/resources/computing/profiles/energy/EnergyExtension.java @ 820

package schedframe.resources.computing.profiles.energy;

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.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;

public class EnergyExtension 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 ComputingResource computingResource;


        public EnergyExtension(ComputingResource computingResource, PowerInterface powerInterface, PowerProfile powerProfile) {
                this.powerProfile = powerProfile;
                this.powerInterface = PowerInterfaceFactory.createPowerInterface(computingResource, powerProfile);
        }
        
        public EnergyExtension(ComputingResource computingResource, PowerProfile powerProfile,
                        AirThroughputProfile airFlowProfile) {
                super();
                this.computingResource = computingResource;
                this.powerProfile = powerProfile;
                this.powerInterface = PowerInterfaceFactory.createPowerInterface(computingResource, powerProfile);
                this.airFlowProfile = airFlowProfile;
                this.airFlowInterface = AirThroughputInterfaceFactory.createAirThroughputInterface(computingResource, airFlowProfile);
        }
        
        public EnergyExtension(ComputingResource computingResource, PowerProfile powerProfile,
                        AirThroughputProfile airFlowProfile, ThermalProfile thermalProfile) {
                super();
                this.computingResource = computingResource;
                this.powerProfile = powerProfile;
                this.powerInterface = PowerInterfaceFactory.createPowerInterface(computingResource, powerProfile);
                this.airFlowProfile = airFlowProfile;
                this.airFlowInterface = AirThroughputInterfaceFactory.createAirThroughputInterface(computingResource, airFlowProfile);
                this.thermalProfile = thermalProfile;
                this.thermalInterface = ThermalInterfaceFactory.createThermalInterface(computingResource, 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;
                
                else return false;
        }

        public void handleEvent(Event event) {
                
                EnergyEvent enEvent = (EnergyEvent)event;
                double power = 0;
                double temperature = 0;
                try{
                        switch (enEvent.getType()) {
                        
                        case POWER_STATE_CHANGED:
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                                /*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*/ powerProfile.addToPowerUsageHistory(power);
                                break;
                                
                        case FREQUENCY_CHANGED:
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                                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(computingResource.getName()), computingResource);
                                powerProfile.addToPowerUsageHistory(power);
                                temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                                thermalProfile.addToTemperatureHistory(temperature);
                                break;
        
                        case TASK_FINISHED:
                                //System.out.println(this.resource.getName() + " - ENERGY EXTENSION: TASK FINISHED");
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                                //System.out.println(this.resource.getName() + " - ESTIMATED ENERGY:" + power);
                                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(computingResource.getName()), computingResource);
                                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(computingResource.getName()), computingResource);
                                airFlowProfile.addToPowerUsageHistory(airFlow);
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                                powerProfile.addToPowerUsageHistory(power);
                                temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                                thermalProfile.addToTemperatureHistory(temperature);
                                break;
                        }
                }catch(Exception e){
                        
                }
        }

        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;
        }

}