source: DCWoRMS/branches/coolemall/src/schedframe/resources/computing/profiles/energy/EnergyExtension.java @ 1596

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.Node;
import schedframe.resources.computing.Processor;
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.AirflowInterfaceFactory;
import schedframe.resources.computing.profiles.energy.airthroughput.AirflowProfile;
import schedframe.resources.computing.profiles.energy.airthroughput.ui.AirflowInterface;
import schedframe.resources.computing.profiles.energy.power.PowerInterfaceFactory;
import schedframe.resources.computing.profiles.energy.power.PowerProfile;
import schedframe.resources.computing.profiles.energy.power.PowerStateName;
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.resources.devices.PhysicalResource;
import schedframe.scheduling.manager.tasks.JobRegistryImpl;
import simulator.DataCenterWorkloadSimulator;

public class EnergyExtension implements Extension{

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

        protected PowerInterface powerInterface;
        protected PowerProfile powerProfile;
        
        protected AirflowInterface airflowInterface;
        protected AirflowProfile airflowProfile;
        
        protected ThermalInterface thermalInterface;
        protected ThermalProfile thermalProfile;
        
        protected PhysicalResource resource;


        /*public EnergyExtension(PhysicalResource resource, PowerInterface powerInterface, PowerProfile powerProfile) {
                super();
                this.resource = resource;
                this.powerProfile = powerProfile;
                this.powerInterface = PowerInterfaceFactory.createPowerInterface(resource, powerProfile);
        }
        
        public EnergyExtension(PhysicalResource resource, PowerProfile powerProfile,
                        AirThroughputProfile airFlowProfile) {
                super();
                this.resource = resource;
                this.powerProfile = powerProfile;
                this.powerInterface = PowerInterfaceFactory.createPowerInterface(resource, powerProfile);
                this.airFlowProfile = airFlowProfile;
                this.airFlowInterface = AirThroughputInterfaceFactory.createAirThroughputInterface(resource, airFlowProfile);
        }
        
        public EnergyExtension(PhysicalResource resource, PowerProfile powerProfile,
                        AirThroughputProfile airFlowProfile, ThermalProfile thermalProfile) {
                super();
                this.resource = resource;
                this.powerProfile = powerProfile;
                this.powerInterface = PowerInterfaceFactory.createPowerInterface(resource, powerProfile);
                this.airFlowProfile = airFlowProfile;
                this.airFlowInterface = AirThroughputInterfaceFactory.createAirThroughputInterface(resource, airFlowProfile);
                this.thermalProfile = thermalProfile;
                this.thermalInterface = ThermalInterfaceFactory.createThermalInterface(resource, thermalProfile);
        }*/

        public static class Builder {
                  
                protected PhysicalResource resource;
                protected PowerInterface powerInterface;
                protected PowerProfile powerProfile;
                
                protected AirflowInterface airflowInterface;
                protected AirflowProfile 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(AirflowProfile atp){this.airflowProfile = atp; this.airflowInterface = AirflowInterfaceFactory.createAirflowInterface(resource, airflowProfile); return this; }

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

        public EnergyExtension build() {
            return new EnergyExtension(this);
        }
        }
        
        private EnergyExtension(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(ResourceEventType.UTILIZATION_CHANGED.getName()))
                        return true;
                else if(event.getType().getName().equals(ResourceEventType.TASK_STARTED.getName()))
                        return true;
                else if(event.getType().getName().equals(ResourceEventType.TASK_FINISHED.getName()))
                        return true;
                else if(event.getType().getName().equals(ResourceEventType.POWER_STATE_CHANGED.getName()))
                        return true;
                else if(event.getType().getName().equals(ResourceEventType.CPU_FREQUENCY_CHANGED.getName()))
                        return true;
                else if(event.getType().getName().equals(ResourceEventType.UPDATE_POWER_STATE.getName()))
                        return true;
        
                if(event.getType().getName().equals(ResourceEventType.AIRFLOW_STATE_CHANGED.getName()))
                        return true;
                if(event.getType().getName().equals(ResourceEventType.TEMPERATURE_CHANGED.getName()))
                        return true;
                if(event.getType().getName().equals(ResourceEventType.TIMER.getName()))
                        return true;
                
                else return false;
        }

        public void handleEvent(Event event) {
                
                ResourceEvent resEvent = (ResourceEvent)event;
                double power = 0;
                boolean status = false;
                try{
                        switch (resEvent.getType()) {
                        
                        case UTILIZATION_CHANGED:
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(resEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                status = powerProfile.addToPowerUsageHistory(power);
                                break;
                                
                        case TASK_STARTED:
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(resEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                status = powerProfile.addToPowerUsageHistory(power);
                                break;
        
                        case TASK_FINISHED:
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(resEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                status = powerProfile.addToPowerUsageHistory(power);
                                break;
                                                                
                        case POWER_STATE_CHANGED:
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(resEvent, new JobRegistryImpl(resource.getFullName()), resource);                     
                                status = powerProfile.addToPowerUsageHistory(power);
                                break;
                                
                        case CPU_FREQUENCY_CHANGED:
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(resEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                status = powerProfile.addToPowerUsageHistory(power);
                                break;
                                
                        case UPDATE_POWER_STATE:
                                if(resource.getFullName().equals(resEvent.getSource())){
                                        PowerStateName newPowerState = (PowerStateName) resEvent.getData();
                                        powerInterface.setPowerState(newPowerState);
                                }
                                break;
                                
                        case AIRFLOW_STATE_CHANGED:
                                double airflow = powerProfile.getEnergyEstimationPlugin().estimateAirflow(resEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                airflowProfile.addToAirFlowHistory(airflow);
                                break;
                                
                        case TEMPERATURE_CHANGED:
                                double temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(resEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                thermalProfile.addToTemperatureHistory(temperature);
                                break;
                                
                        case TIMER:
                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(resEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                status = powerProfile.addToPowerUsageHistory(power);
                                if(resource instanceof Processor || resource instanceof Node){
                                        temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(resEvent, new JobRegistryImpl(resource.getFullName()), resource);
                                        thermalProfile.addToTemperatureHistory(temperature);    
                                }
                                break;
                        }
                }catch(Exception e){
                        
                }
                if(status){
                        DataCenterWorkloadSimulator.getEventManager().sendToResources(resource.getType(), 0, new ResourceEvent(ResourceEventType.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 AirflowInterface getAirflowInterface() {
                return airflowInterface;
        }

        public AirflowProfile getAirflowProfile() {
                return airflowProfile;
        }
        
        public ThermalProfile getThermalProfile() {
                return thermalProfile;
        }

        public ThermalInterface getThermalInterface() {
                return thermalInterface;
        }

}