source: xssim/branches/tpiontek/src/test/rewolucja/energy/profile/implementation/CPUPowerProfile.java @ 257

package test.rewolucja.energy.profile.implementation;

import gridsim.GridSimTags;
import gridsim.gssim.GssimTags;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import schedframe.resources.PowerState;
import schedframe.resources.units.CpuSpeed;
import schedframe.scheduling.utils.ResourceParameterName;
import test.rewolucja.energy.EnergyEvent;
import test.rewolucja.energy.EnergyEventType;
import test.rewolucja.energy.extension.EnergyExtension;
import test.rewolucja.energy.profile.AbstractPowerProfile;
import test.rewolucja.energy.profile.PState;
import test.rewolucja.energy.profile.PStateType;
import test.rewolucja.extensions.ExtensionType;
import test.rewolucja.resources.ResourceStatus;
import test.rewolucja.resources.physical.implementation.Processor;

public class CPUPowerProfile extends AbstractPowerProfile{

        protected Processor cpu;
        protected PState pState;

        public CPUPowerProfile(){
                powerState = PowerState.ON;
                pState = getSupportedPStates().get(PStateType.P0);
                //pState = getSupportedPStates().get(PStateType.P3);
        }

        public void visit(Processor p){
                cpu = p;
                energyExtension = (EnergyExtension) cpu.getExtensionList().getExtension(ExtensionType.ENERGY_EXTENSION);
        }

        public boolean setPowerState(PowerState state){
                if(!supportPowerState(state))
                        return false;
                powerState = state;

                if(state == PowerState.OFF){
                        cpu.setStatus(ResourceStatus.UNAVAILABLE);
                }
                else if(state == PowerState.ON){
                        cpu.setStatus(ResourceStatus.FREE);
                }
                
                cpu.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, cpu.getName()));
                return true;
        }

        
        public double getPowerConsumption(PowerState state) {
                if(powerState == PowerState.OFF)
                        return 0;
                else if(powerState == PowerState.ON){
                        if(cpu.getStatus() == ResourceStatus.BUSY)
                                return getPState().getPower();
                        else if(cpu.getStatus() == ResourceStatus.FREE)
                                return getPState().getPower()/1.25;
                }
                return 1;
        }


        public boolean supportPowerState(PowerState state) {
                switch(state){
                        case ON: 
                                return true;
                        case OFF: 
                                return true;
                        default: return false;
                }
        }

        public List<PowerState> getSupportedPowerStates() {
                return Arrays.asList(new PowerState[]{PowerState.ON, PowerState.OFF});
        }

        
        public double getFrequency() {
                return pState.getFrequency();
        }

        public boolean setFrequency(double freq) {
                for(PStateType pStateType: getSupportedPStates().keySet()){
                        if(getSupportedPStates().get(pStateType).getFrequency() == freq){
                                setPState(pStateType);
                                return true;
                        }
                }
                return false;
        }

        public PState getPState(){
                return pState;
        }
        
        public boolean setPState(PStateType pStateType){
                        
                PState newPState = getSupportedPStates().get(pStateType);
                
                if( newPState == getPState())
                        return false;
                
                if(newPState != null)
                {
                        pState = newPState;
                        CpuSpeed speed = (CpuSpeed )cpu.getResourceCharacteristic().getResourceUnits().get(ResourceParameterName.CPUSPEED).get(0);
                        speed.setAmount( newPState.getSpeed());
                        
                        cpu.handleEvent(new EnergyEvent(EnergyEventType.FREQUENCY_CHANGED, cpu.getName()));
                        cpu.getLogicalResource().sendInternal(GridSimTags.SCHEDULE_NOW, GssimTags.UPDATE, cpu.getName());
                        return true;
                }
                return false;
        }
        
        public Map<PStateType, PState> getSupportedPStates(){
                return DefaultModel.getConfiguration();
        }
        
        private static class DefaultModel{
                private static Map<PStateType, PState> pStates;
                static {
                        Map<PStateType, PState> pStatesMap = new HashMap<PStateType, PState>();
                        pStatesMap.put(PStateType.P0, new PState(PStateType.P0, 3000, 0, 350, 1000));
                        pStatesMap.put(PStateType.P1, new PState(PStateType.P1, 2660, 0, 343, 1000));
                        pStatesMap.put(PStateType.P2, new PState(PStateType.P2, 2330, 0, 337, 1000));
                        pStatesMap.put(PStateType.P3, new PState(PStateType.P3, 2000, 0, 330, 1000));
                        pStates = Collections.unmodifiableMap(pStatesMap);
                }
                
                public static Map<PStateType, PState> getConfiguration(){
                        return pStates;
                }
        }
}