Changeset 539 for DCWoRMS/trunk/build/classes/schedframe/resources/computing/profiles

Timestamp:

10/31/12 13:52:06 (12 years ago)

Author:

wojtekp

Message:

 

Location:

DCWoRMS/trunk/build/classes/schedframe/resources/computing/profiles/energy

Files:

• EnergyEventType.class (modified) (previous)
• EnergyEventType.java (modified) (1 diff)
• EnergyExtension$1.class (modified) (previous)
• EnergyExtension.class (modified) (previous)
• EnergyExtension.java (modified) (6 diffs)
• MeasurementHistory.class (added)
• MeasurementHistory.java (added)
• airthroughput/AirFlowValue.class (added)
• airthroughput/AirFlowValue.java (added)
• airthroughput/AirThroughputInterfaceFactory.class (added)
• airthroughput/AirThroughputInterfaceFactory.java (added)
• airthroughput/AirThroughputProfile.class (modified) (previous)
• airthroughput/AirThroughputProfile.java (modified) (4 diffs)
• airthroughput/ui (added)
• airthroughput/ui/AirThroughputInterface.class (added)
• airthroughput/ui/AirThroughputInterface.java (added)
• airthroughput/ui/DefaultAirThroughputInterface.class (added)
• airthroughput/ui/DefaultAirThroughputInterface.java (added)
• power/PowerInterfaceFactory.class (added)
• power/PowerInterfaceFactory.java (added)
• power/PowerProfile.class (modified) (previous)
• power/PowerProfile.java (modified) (2 diffs)
• power/PowerUsage.class (modified) (previous)
• power/PowerUsage.java (modified) (1 diff)
• power/plugin/EnergyEstimationPlugin.class (modified) (previous)
• power/plugin/EnergyEstimationPlugin.java (modified) (1 diff)
• power/ui/ComputingNodePowerInterface.class (modified) (previous)
• power/ui/ComputingNodePowerInterface.java (modified) (3 diffs)
• power/ui/ComputingResourcePowerInterface.class (added)
• power/ui/ComputingResourcePowerInterface.java (added)
• power/ui/DataCenterPowerInterface.class (modified) (previous)
• power/ui/DataCenterPowerInterface.java (modified) (1 diff)
• power/ui/PowerInterface.class (modified) (previous)
• power/ui/PowerInterface.java (modified) (2 diffs)
• power/ui/ProcessorPowerInterface.class (modified) (previous)
• power/ui/ProcessorPowerInterface.java (modified) (5 diffs)

DCWoRMS/trunk/build/classes/schedframe/resources/computing/profiles/energy/EnergyEventType.java

@@ -15 +15 @@
         FREQUENCY_CHANGED(64),
         VOLTAGE_CHANGED(128),
-        RESOURCE_FAILED(256)
+        
+        AIRFLOW_STATE_CHANGED(256),
+        
+        RESOURCE_FAILED(512)
         ;
 

DCWoRMS/trunk/build/classes/schedframe/resources/computing/profiles/energy/EnergyExtension.java

@@ -11 +11 @@
 import schedframe.resources.computing.extensions.ExtensionException;
 import schedframe.resources.computing.extensions.ExtensionType;
+import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputProfile;
+import schedframe.resources.computing.profiles.energy.airthroughput.ui.AirThroughputInterface;
 import schedframe.resources.computing.profiles.energy.power.PowerProfile;
 import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface;
 import schedframe.scheduling.manager.tasks.JobRegistryImpl;
 
-public class EnergyExtension implements Extension/*, ResourceVisitor */{
+public class EnergyExtension implements Extension{
 
         private Log log = LogFactory.getLog(EnergyExtension.class);
@@ -21 +23 @@
         protected PowerInterface powerInterface;
         protected PowerProfile powerProfile;
-
+        
+        protected AirThroughputInterface airFlowInterface;
+        protected AirThroughputProfile airFlowProfile;
+        
         protected ComputingResource computingResource;
 
@@ -29 +34 @@
         }
 
-        @Override
+        public EnergyExtension(PowerInterface powerInterface, PowerProfile powerProfile,
+                        AirThroughputInterface airFlowInterface, AirThroughputProfile airFlowProfile) {
+                super();
+                this.powerInterface = powerInterface;
+                this.powerProfile = powerProfile;
+                this.airFlowInterface = airFlowInterface;
+                this.airFlowProfile = airFlowProfile;
+        }
+
         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;
@@ -43 +55 @@
                 else if(event.getType().getName().equals(EnergyEventType.TASK_FINISHED.getName()))
                         return true;
+                
+                if(airFlowProfile == null)
+                        return false;   
+                if(event.getType().getName().equals(EnergyEventType.AIRFLOW_STATE_CHANGED.getName()))
+                        return true;
+                
                 else return false;
 
         }
-        
 
-        @Override
         public void handleEvent(Event event) {
                 EnergyEvent enEvent = (EnergyEvent)event;
@@ -87 +103 @@
                         //System.out.println(this.resource.getName() + " - ESTIMATED ENERGY:" + power);
                         powerProfile.addToPowerUsageHistory(power);
-
+                        break;
+                case AIRFLOW_STATE_CHANGED:
+                        System.out.println("=====");
+                        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);
                         break;
                 }
         }
-        
-        @Override
+
         public void init(Properties properties) throws ExtensionException {
                 // TODO Auto-generated method stub
         }
 
-        @Override
         public ExtensionType getType() {
                 return ExtensionType.ENERGY_EXTENSION;
@@ -118 +138 @@
         }
 
+        public AirThroughputInterface getAirThroughputInterface() {
+                return airFlowInterface;
+        }
+
+        public AirThroughputProfile getAirFlowProfile() {
+                return airFlowProfile;
+        }
 
 }

DCWoRMS/trunk/build/classes/schedframe/resources/computing/profiles/energy/airthroughput/AirThroughputProfile.java

@@ -1 +1 @@
 package schedframe.resources.computing.profiles.energy.airthroughput;
 
+import java.util.ArrayList;
 import java.util.List;
+
+import org.joda.time.DateTimeUtils;
 
 import schedframe.Parameters;
@@ -8 +11 @@
 public class AirThroughputProfile {
         
-        AirThroughputEstimationPlugin airThroughputEstimationPlugin;
+        protected List<AirFlowValue> airFlowHistory;
+        
+        protected AirThroughputEstimationPlugin airThroughputEstimationPlugin;
         protected List <AirThroughputState> airThroughputStates;
+        protected Parameters parameters;
 
         public AirThroughputProfile(AirThroughputEstimationPlugin airThroughputEstimationPlugin, List<AirThroughputState> airThroughputStates) {
@@ -15 +21 @@
                 this.airThroughputEstimationPlugin = airThroughputEstimationPlugin;
                 this.airThroughputStates = airThroughputStates;
+                this.airFlowHistory = new ArrayList<AirFlowValue>();
         }
 
@@ -21 +28 @@
         }
         
-        public void init(Parameters parameters){
-                
+        public void addToPowerUsageHistory(double airFlow) {
+
+                if (airFlowHistory.size() == 0) {
+                        AirFlowValue usage = new AirFlowValue(DateTimeUtils.currentTimeMillis(), airFlow);
+                        airFlowHistory.add(usage);
+                        return;
+                }
+
+                int lastIdx = airFlowHistory.size() - 1;
+                double lastAirFlow = airFlowHistory.get(lastIdx).getValue();
+                if (lastAirFlow != airFlow) {
+                        AirFlowValue usage = airFlowHistory.get(lastIdx);
+                        long currentTime = DateTimeUtils.currentTimeMillis();
+                        if (usage.getTimestamp() == currentTime) {
+                                usage.setValue(airFlow);
+                                if(lastIdx > 0 && airFlowHistory.get(lastIdx - 1).getValue() == airFlow)
+                                        airFlowHistory.remove(usage);
+                        } else {
+                                usage = new AirFlowValue(DateTimeUtils.currentTimeMillis(), airFlow);
+                                airFlowHistory.add(usage);
+                        }
+                }
+        }
+
+        public List<AirFlowValue> getAirThroughputHistory() {
+                return airFlowHistory;
+        }
+        
+        public void init(Parameters params){
+                this.parameters = params;
+        }
+
+        public Parameters getParameters() {
+                return parameters;
         }
 }

DCWoRMS/trunk/build/classes/schedframe/resources/computing/profiles/energy/power/PowerProfile.java

@@ -19 +19 @@
         protected Map<String, PState> supportedPStates;
         
+        protected Parameters parameters;
+        
 
-        public PowerProfile(EnergyEstimationPlugin energyEstimationPlugin, List<schedframe.resources.computing.profiles.energy.power.PowerState> supportedPowerStates) {
+        public PowerProfile(EnergyEstimationPlugin energyEstimationPlugin, List<PowerState> powerStates) {
                 this.energyEstimationPlugin = energyEstimationPlugin;
                 this.powerUsage = new ArrayList<PowerUsage>();
-                this.supportedPowerStates = supportedPowerStates;
+                this.supportedPowerStates = powerStates;
         }
         
-        public PowerProfile(EnergyEstimationPlugin energyEstimationPlugin, List<schedframe.resources.computing.profiles.energy.power.PowerState> supportedPowerStates,  List<schedframe.resources.computing.profiles.energy.power.PState> pStates) {
+        public PowerProfile(EnergyEstimationPlugin energyEstimationPlugin, List<PowerState> powerStates,  List<PState> pStates) {
                 this.energyEstimationPlugin = energyEstimationPlugin;
-                this.supportedPowerStates = supportedPowerStates;
+                this.supportedPowerStates = powerStates;
                 this.powerUsage = new ArrayList<PowerUsage>();
                 if(pStates.size() > 0)
@@ -98 +100 @@
         }
 
-        public void init(Parameters parameters){
-                
+        public void init(Parameters params){
+                this.parameters = params;
+        }
+        
+        public Parameters getParameters() {
+                return parameters;
         }
 
+
 }

DCWoRMS/trunk/build/classes/schedframe/resources/computing/profiles/energy/power/PowerUsage.java

@@ -1 +1 @@
 package schedframe.resources.computing.profiles.energy.power;
 
-public class PowerUsage {
+import schedframe.resources.computing.profiles.energy.MeasurementHistory;
 
-        protected long timestamp;
-        protected double value;
+public class PowerUsage extends MeasurementHistory{
 
         public PowerUsage(long timestamp, double value){
-                this.timestamp = timestamp;
-                this.value = value;
-        }
-        
-        public long getTimestamp() {
-                return timestamp;
-        }
-
-        public double getValue() {
-                return value;
-        }
-        
-        public void setValue(double value) {
-                this.value = value;
+                super(timestamp, value);
         }
         

DCWoRMS/trunk/build/classes/schedframe/resources/computing/profiles/energy/power/plugin/EnergyEstimationPlugin.java

@@ -10 +10 @@
         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, ComputingResource resource);
 
-        public double estimateEnergyDissipation(EnergyEvent event, JobRegistry jobRegistry, ComputingResource resource);
+        public double estimateAirThroughput(EnergyEvent event, JobRegistry jobRegistry, ComputingResource resource);
 
         public double estimateTemperature(EnergyEvent event, JobRegistry jobRegistry, ComputingResource resource);

DCWoRMS/trunk/build/classes/schedframe/resources/computing/profiles/energy/power/ui/ComputingNodePowerInterface.java

@@ -10 +10 @@
 import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName;
 
-public class ComputingNodePowerInterface extends AbstractPowerInterface{
+public class ComputingNodePowerInterface extends ComputingResourcePowerInterface{
 
         public static long START_TIME = 600000;
@@ -28 +28 @@
                 currentPowerState = state;
                 ComputingNode computingNode = (ComputingNode) resource;
+                boolean pePowerStateChangeStatus = false;
                 if(computingNode.getProcessors() != null)
                 {
                         for(ComputingResource child:computingNode.getProcessors()){
-                                child.getPowerInterface().setPowerState(state);
+                                if(child.getPowerInterface() != null){
+                                        pePowerStateChangeStatus = child.getPowerInterface().setPowerState(state);      
+                                }
                         }
-                } else {
+                } 
+                
+                if(!pePowerStateChangeStatus){
                         computingNode.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, computingNode.getName()));
                 }
-                
+
                 if(state == StandardPowerStateName.OFF){
                         computingNode.setStatus(ResourceStatus.UNAVAILABLE);
@@ -46 +51 @@
                 return true;
         }
-        
-        /*public double getPowerConsumption(PowerState state) {
-                if(currentPowerState == PowerState.OFF)
-                        return 0;
-                else if(currentPowerState == PowerState.ON)
-                        return 750;
-                else return 500;
-        }*/
-
-        /*public boolean supportPowerState(PowerState state) {
-                switch(state){
-                        case ON: 
-                                return true;
-                        case OFF: 
-                                return true;
-                        case SLEEP: 
-                                return true;
-                        case HIBERNATE: 
-                                return true;
-                        default: 
-                                return false;
-                }
-        }
-
-        public List<PowerState> getSupportedPowerStates() {
-                return Arrays.asList(new PowerState[]{PowerState.ON, PowerState.OFF, PowerState.SLEEP, PowerState.HIBERNATE});
-        }*/
 
         public void turnOn(){

DCWoRMS/trunk/build/classes/schedframe/resources/computing/profiles/energy/power/ui/DataCenterPowerInterface.java

@@ -7 +7 @@
 import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName;
 
-public class DataCenterPowerInterface extends AbstractPowerInterface{
+public class DataCenterPowerInterface extends ComputingResourcePowerInterface{
 
-
-
-        
         public DataCenterPowerInterface(ComputingResource resource, PowerProfile pp){
                 super(resource, pp);

DCWoRMS/trunk/build/classes/schedframe/resources/computing/profiles/energy/power/ui/PowerInterface.java

@@ -3 +3 @@
 import java.util.List;
 
+import schedframe.Parameters;
 import schedframe.resources.computing.profiles.energy.power.PowerState;
 import schedframe.resources.computing.profiles.energy.power.PowerStateName;
@@ -25 +26 @@
         List<PowerUsage> getPowerUsageHistory();
         
+        public Parameters getParameters();
 }

DCWoRMS/trunk/build/classes/schedframe/resources/computing/profiles/energy/power/ui/ProcessorPowerInterface.java

@@ -1 +1 @@
 package schedframe.resources.computing.profiles.energy.power.ui;
+
+
+import gridsim.GridSimTags;
+import gridsim.dcworms.DCWormsTags;
 
 import java.util.Map;
 
-import schedframe.events.ResourceEventCommand;
 import schedframe.resources.ResourceStatus;
 import schedframe.resources.computing.ComputingResource;
-import schedframe.resources.computing.Processor;
 import schedframe.resources.computing.profiles.energy.EnergyEvent;
 import schedframe.resources.computing.profiles.energy.EnergyEventType;
@@ -16 +18 @@
 import schedframe.resources.units.StandardResourceUnitName;
 
-public class ProcessorPowerInterface extends AbstractPowerInterface {
+public class ProcessorPowerInterface extends ComputingResourcePowerInterface {
 
         protected PState currentPState;
@@ -36 +38 @@
                 if(powerState != currentPowerState){
                         currentPowerState = powerState;
-                        //Processor cpu = (Processor) resource;
                         if(powerState == StandardPowerStateName.OFF){
                                 resource.setStatus(ResourceStatus.UNAVAILABLE);
@@ -42 +43 @@
                                 resource.setStatus(ResourceStatus.FREE);
                         }
-                        resource.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, resource.getName()));
-                        //cpu.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, cpu.getName()));                 
+                        resource.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, resource.getName()));         
                 }
 
@@ -79 +79 @@
 
                 if(newPState != currentPState){
-                        double factor = newPState.getFrequency()/currentPState.getFrequency();
+                        //double factor = newPState.getFrequency()/currentPState.getFrequency();
                         currentPState = newPState;
-                        CpuSpeed speed = (CpuSpeed)resource.getResourceCharacteristic().getResourceUnits().get(StandardResourceUnitName.CPUSPEED).get(0);
-                        speed.setAmount(Double.valueOf(currentPState.getFrequency()).intValue());
+                        //CpuSpeed speed = (CpuSpeed)resource.getResourceCharacteristic().getResourceUnits().get(StandardResourceUnitName.CPUSPEED).get(0);
+                        //speed.setAmount(Double.valueOf(currentPState.getFrequency()).intValue());
                         //new ResourceEventCommand(resource).execute(EnergyEventType.FREQUENCY_CHANGED);
                         resource.handleEvent(new EnergyEvent(EnergyEventType.FREQUENCY_CHANGED, resource.getName()));
-                        //resource.getScheduler().sendInternal(GridSimTags.SCHEDULE_NOW, GssimTags.UPDATE, resource.getName());
+                        //resource.getScheduler().sendInternal(GridSimTags.SCHEDULE_NOW, DCWormsTags.UPDATE, resource.getName());
                         return true;
                 }