source: xssim/src/test/rewolucja/energy/extension/EnergyExtension.java @ 104

package test.rewolucja.energy.extension;

import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.joda.time.DateTimeUtils;

import schedframe.resources.profile.PowerUsage;
import simulator.utils.InstanceFactory;
import test.rewolucja.energy.EnergyEvent;
import test.rewolucja.energy.EnergyEventType;
import test.rewolucja.energy.plugin.EnergyEstimationPluginInterface;
import test.rewolucja.energy.profile.PowerInterface;
import test.rewolucja.extensions.Extension;
import test.rewolucja.extensions.ExtensionException;
import test.rewolucja.extensions.ExtensionType;
import test.rewolucja.resources.ResourceType;
import test.rewolucja.resources.physical.base.ComputingResource;
import test.rewolucja.resources.test.Event;
import test.rewolucja.scheduling.JobRegistry;
import example.energy.DefaultEnergyEstimationPlugin;

public class EnergyExtension implements Extension {

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

        protected PowerInterface powerInterface;
        protected List<PowerUsage> powerUsage;
        protected EnergyEstimationPluginInterface energyEstimationPlugin;

   protected ComputingResource resource;


        
        public EnergyExtension(ComputingResource resource, PowerInterface powerInterface, String energyEstimationPluginClassName) {
                initPlugin(energyEstimationPluginClassName);
                this.powerInterface = powerInterface;
                this.resource = resource;
                this.powerUsage = new ArrayList<PowerUsage>();
                //int power = energyEstimationPlugin.estimatePowerConsumption(null, resource);
                //if(resource.getType()==ResourceType.CPU)
                //      addToPowerUsageHistory(powerInterface.getPowerConsumption(powerInterface.getPowerState()));
        }
        
        public void initPlugin(String energyEstimationPluginClassName){
                if(energyEstimationPluginClassName != null) {
                        energyEstimationPlugin = (EnergyEstimationPluginInterface) InstanceFactory.createInstance(
                                        energyEstimationPluginClassName, EnergyEstimationPluginInterface.class);
                        if(energyEstimationPlugin == null){
                                energyEstimationPlugin = new DefaultEnergyEstimationPlugin();
                                log.info("Using default energy estimation plugin: " + DefaultEnergyEstimationPlugin.class.getName());
                                
                        } else {
                                energyEstimationPlugin.init(null);
                        }
                        
                } else {
                        energyEstimationPlugin = new DefaultEnergyEstimationPlugin();
                        log.info("Using default energy estimation plugin: " + DefaultEnergyEstimationPlugin.class.getName());
                }
        }

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

        @Override
        public void dispose() throws ExtensionException {
                // TODO Auto-generated method stub

        }

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

        @Override
        public boolean supportsEvent(Event event) {
                EnergyEvent enEvent = (EnergyEvent)event;
                switch (enEvent.getType()) {

                case POWER_STATE_CHANGED:
                        return true;
                case FREQUENCY_CHANGED:
                        return true;
                case TASK_STARTED:
                        return true;
                case TASK_FINISHED:
                        return true;
                default:
                        return false;
                }
        }

        public PowerInterface getPowerInterface() {
                return powerInterface;
        }

        private void addToPowerUsageHistory(double power) {

                if (powerUsage.size() == 0) {
                        PowerUsage usage = new PowerUsage(DateTimeUtils.currentTimeMillis(), power);
                        powerUsage.add(usage);
                        return;
                }

                int lastIdx = powerUsage.size() - 1;
                double lastPower = powerUsage.get(lastIdx).getValue();
                if (lastPower != power) {
                        PowerUsage usage = powerUsage.get(lastIdx);
                        long currentTime = DateTimeUtils.currentTimeMillis();
                        if (usage.getTimestamp() == currentTime) {
                                usage.setValue(power);
                                if(lastIdx > 0 && powerUsage.get(lastIdx - 1).getValue() == power)
                                        powerUsage.remove(usage);

                                //powerUsage.remove(usage);
                                //usage = new PowerUsage(DateTimeUtils.currentTimeMillis(), power);
                                //powerUsage.add(usage);
                        } else {
                                usage = new PowerUsage(DateTimeUtils.currentTimeMillis(), power);
                                powerUsage.add(usage);
                        }
                }
        }

        public List<PowerUsage> getPowerUsageHistory() {
                if(powerUsage.size() == 0){
                        double power = energyEstimationPlugin.estimatePowerConsumption(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, resource.getName()), new JobRegistry(resource.getName()), resource);
                        addToPowerUsageHistory(power);
                }
                return powerUsage;
        }


        @Override
        public void handleEvent(Event event) {
                EnergyEvent enEvent = (EnergyEvent)event;
                double power = 0;
                switch (enEvent.getType()) {
                
                case POWER_STATE_CHANGED:
                        power = energyEstimationPlugin.estimatePowerConsumption(enEvent, new JobRegistry(resource.getName()), resource);
                        addToPowerUsageHistory(power);
                        break;
                        
                case FREQUENCY_CHANGED:
                        power = energyEstimationPlugin.estimatePowerConsumption(enEvent, new JobRegistry(resource.getName()), resource);
                        addToPowerUsageHistory(power);
                        break;
                        
                case TASK_STARTED:
                        
                        power = energyEstimationPlugin.estimatePowerConsumption(enEvent, new JobRegistry(resource.getName()), resource);
                        addToPowerUsageHistory(power);
                        break;

                case TASK_FINISHED:
                        //System.out.println(this.resource.getName() + " - ENERGY EXTENSION: TASK FINISHED");
                        power = energyEstimationPlugin.estimatePowerConsumption(enEvent, new JobRegistry(resource.getName()), resource);
                        //System.out.println(this.resource.getName() + " - ESTIMATED ENERGY:" + power);
                        addToPowerUsageHistory(power);

                        break;

                }
        }
        

        public ComputingResource getResource() {
                return resource;
        }


}