Changeset 495 for DCWoRMS/trunk/src/schedframe

Timestamp:

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

Author:

wojtekp

Message:

 

Location:

DCWoRMS/trunk/src/schedframe/resources/computing

Files:

• ComputingNode.java (modified) (2 diffs)
• ComputingResource.java (modified) (9 diffs)
• Core.java (modified) (2 diffs)
• DataCenter.java (modified) (2 diffs)
• Processor.java (modified) (2 diffs)
• Rack.java (modified) (2 diffs)
• ResourceFactory.java (modified) (1 diff)
• profiles/energy/EnergyEventType.java (modified) (1 diff)
• profiles/energy/EnergyExtension.java (modified) (6 diffs)
• profiles/energy/MeasurementHistory.java (added)
• profiles/energy/airthroughput/AirFlowValue.java (added)
• profiles/energy/airthroughput/AirThroughputInterfaceFactory.java (added)
• profiles/energy/airthroughput/AirThroughputProfile.java (modified) (3 diffs)
• profiles/energy/airthroughput/ui/AirThroughputInterface.java (modified) (1 diff)
• profiles/energy/airthroughput/ui/DefaultAirThroughputInterface.java (moved) (moved from DCWoRMS/trunk/src/schedframe/resources/computing/profiles/energy/airthroughput/ui/DefaultAirThrougputInterface.java) (3 diffs)
• profiles/energy/power/PowerInterfaceFactory.java (moved) (moved from DCWoRMS/trunk/src/schedframe/resources/computing/profiles/energy/power/PowerProfileFactory.java) (2 diffs)
• profiles/energy/power/PowerProfile.java (modified) (1 diff)
• profiles/energy/power/PowerUsage.java (modified) (1 diff)
• profiles/energy/power/ui/ComputingNodePowerInterface.java (modified) (1 diff)
• profiles/energy/power/ui/ComputingResourcePowerInterface.java (moved) (moved from DCWoRMS/trunk/src/schedframe/resources/computing/profiles/energy/power/ui/AbstractPowerInterface.java) (2 diffs)
• profiles/energy/power/ui/DataCenterPowerInterface.java (modified) (1 diff)
• profiles/energy/power/ui/ProcessorPowerInterface.java (modified) (2 diffs)

DCWoRMS/trunk/src/schedframe/resources/computing/ComputingNode.java

@@ -10 +10 @@
 import schedframe.resources.computing.extensions.ExtensionType;
 import schedframe.resources.computing.profiles.energy.EnergyExtension;
-import schedframe.resources.computing.profiles.energy.power.PowerProfileFactory;
+import schedframe.resources.computing.profiles.energy.power.PowerInterfaceFactory;
 import schedframe.resources.computing.profiles.energy.power.ui.ComputingNodePowerInterface;
 import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface;
@@ -26 +26 @@
                 
                 //extensionList.add(new EnergyExtension(this, resDesc.getPowerInterface(), resDesc.getEnergyEstimationPlugin()));
-                PowerInterface pi = PowerProfileFactory.createPowerInterface(this, resDesc.getPowerProfile());
+                PowerInterface pi = PowerInterfaceFactory.createPowerInterface(this, resDesc.getPowerProfile());
                 accept(new EnergyExtension(pi, resDesc.getPowerProfile()));     
         }

DCWoRMS/trunk/src/schedframe/resources/computing/ComputingResource.java

@@ -28 +28 @@
 import schedframe.resources.computing.profiles.energy.EnergyEventType;
 import schedframe.resources.computing.profiles.energy.EnergyExtension;
+import schedframe.resources.computing.profiles.energy.airthroughput.ui.AirThroughputInterface;
 import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface;
 import schedframe.resources.computing.properties.DefaultPropertiesBuilder;
@@ -68 +69 @@
         }
 
-        //TODO remove if possible (check if all scenarios can be realized - statistics issue) , since it's temporary method
+        //TODO remove if possible (check if all scenarios can be realized - statistics issue), since it's a temporary method
         private void addFakeProcessors() {
                 if(getResourceCharacteristic().getResourceUnits().get(StandardResourceUnitName.PE) != null){
@@ -145 +146 @@
                 sec.execute(event);
 
-                
                 //old, correctly working method
                 /*if (extensionList != null) {
@@ -188 +188 @@
         }
         
-        protected List<? extends ComputingResource> searchDescendants(List<ResourceValidator> validators, boolean cutoff) {
+        protected List<? extends ComputingResource> searchDescendants(List<ResourceValidator> validators, boolean cutOff) {
 
                 List<ComputingResource> descendants = new ArrayList<ComputingResource>();
@@ -198 +198 @@
                                 ComputingResource resource = toExamine.pop();
                                 List<ComputingResource> resources = resource.getChildren();
-                                /*if (resources == null)
-                                        continue;*/
                                 int numberOfRes = resources.size();
                                 for (int i = 0; i < numberOfRes; i++) {
@@ -205 +203 @@
                                         if (resourceChild.match(validators)) {
                                                 descendants.add(resourceChild);
-                                                if(cutoff == false) {
+                                                if(cutOff == false) {
                                                         toExamine.addLast(resourceChild);
                                                 }
@@ -243 +241 @@
                 return null;
         }
+        
+        public AirThroughputInterface getAirThroughputInterface(){
+                if (extensionList != null) {
+                        for (Extension extension : extensionList) {
+                                if (extension.getType() == ExtensionType.ENERGY_EXTENSION) {
+                                        EnergyExtension ee = (EnergyExtension)extension;
+                                        return ee.getAirThroughputInterface();
+                                }
+                        }
+                }
+                return null;
+        }
 
         public Scheduler getScheduler() {
@@ -257 +267 @@
         }
 
-        class SimpleEventHandler implements EventHandler{
+        class ComputingResourceEventHandler implements EventHandler{
                 
                 public void handleResourceEvent(Event event){
@@ -282 +292 @@
         
         public EventHandler getEventHandler(){
-                return new SimpleEventHandler();
+                return new ComputingResourceEventHandler();
         }
         
         public void initiate(){
+                
                 ResourceEventCommand rec = new ResourceEventCommand(this);
-                EnergyEvent event = new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, "Resource controller");
+                EnergyEvent event = new EnergyEvent(EnergyEventType.AIRFLOW_STATE_CHANGED, "Resource controller");
                 event.setReason(EventReason.SIM_INIT);
                 rec.execute(event);
+                
+                rec = new ResourceEventCommand(this);
+                event = new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, "Resource controller");
+                event.setReason(EventReason.SIM_INIT);
+                rec.execute(event);
+                
                 //alternative way
+                //getEventHandler().handleResourceEvent(new EnergyEvent(EnergyEventType.AIRFLOW_STATE_CHANGED, "Resource controller"));
                 //getEventHandler().handleResourceEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, "Resource controller"));
         }

DCWoRMS/trunk/src/schedframe/resources/computing/Core.java

@@ -3 +3 @@
 import schedframe.resources.computing.description.ComputingResourceDescription;
 import schedframe.resources.computing.profiles.energy.EnergyExtension;
-import schedframe.resources.computing.profiles.energy.power.PowerProfileFactory;
+import schedframe.resources.computing.profiles.energy.power.PowerInterfaceFactory;
 import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface;
 import schedframe.resources.units.CpuSpeed;
@@ -13 +13 @@
         public Core (ComputingResourceDescription resDesc) {
                 super(resDesc);
-                PowerInterface pi = PowerProfileFactory.createPowerInterface(this, resDesc.getPowerProfile());
+                PowerInterface pi = PowerInterfaceFactory.createPowerInterface(this, resDesc.getPowerProfile());
                 accept(new EnergyExtension(pi, resDesc.getPowerProfile()));     
         }

DCWoRMS/trunk/src/schedframe/resources/computing/DataCenter.java

@@ -3 +3 @@
 import schedframe.resources.computing.description.ComputingResourceDescription;
 import schedframe.resources.computing.profiles.energy.EnergyExtension;
-import schedframe.resources.computing.profiles.energy.power.PowerProfileFactory;
+import schedframe.resources.computing.profiles.energy.power.PowerInterfaceFactory;
 import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface;
 
@@ -11 +11 @@
                 super(resDesc);
                 //extensionList.add(new EnergyExtension(this, resDesc.getPowerInterface(), resDesc.getEnergyEstimationPlugin()));
-                PowerInterface pi = PowerProfileFactory.createPowerInterface(this, resDesc.getPowerProfile());
+                PowerInterface pi = PowerInterfaceFactory.createPowerInterface(this, resDesc.getPowerProfile());
                 accept(new EnergyExtension(pi, resDesc.getPowerProfile()));
         }

DCWoRMS/trunk/src/schedframe/resources/computing/Processor.java

@@ -8 +8 @@
 import schedframe.resources.computing.extensions.ExtensionType;
 import schedframe.resources.computing.profiles.energy.EnergyExtension;
-import schedframe.resources.computing.profiles.energy.power.PowerProfileFactory;
+import schedframe.resources.computing.profiles.energy.power.PowerInterfaceFactory;
 import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface;
 import schedframe.resources.computing.profiles.energy.power.ui.ProcessorPowerInterface;
@@ -22 +22 @@
                 super(resDesc);
                 //extensionList.add(new EnergyExtension(this, resDesc.getPowerInterface(), resDesc.getEnergyEstimationPlugin()));
-                PowerInterface pi = PowerProfileFactory.createPowerInterface(this, resDesc.getPowerProfile());
+                PowerInterface pi = PowerInterfaceFactory.createPowerInterface(this, resDesc.getPowerProfile());
                 accept(new EnergyExtension(pi, resDesc.getPowerProfile()));     
         }

DCWoRMS/trunk/src/schedframe/resources/computing/Rack.java

@@ -6 +6 @@
 import schedframe.resources.computing.description.ComputingResourceDescription;
 import schedframe.resources.computing.profiles.energy.EnergyExtension;
-import schedframe.resources.computing.profiles.energy.power.PowerProfileFactory;
+import schedframe.resources.computing.profiles.energy.power.PowerInterfaceFactory;
 import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface;
 
@@ -14 +14 @@
         public Rack (ComputingResourceDescription resDesc) {
                 super(resDesc);
-                PowerInterface pi = PowerProfileFactory.createPowerInterface(this, resDesc.getPowerProfile());
+                PowerInterface pi = PowerInterfaceFactory.createPowerInterface(this, resDesc.getPowerProfile());
                 accept(new EnergyExtension(pi, resDesc.getPowerProfile()));     
         }

DCWoRMS/trunk/src/schedframe/resources/computing/ResourceFactory.java

@@ -20 +20 @@
                 if (resDesc.getType().equals(StandardResourceType.DataCenter))
                         return new DataCenter(resDesc);
+                else if (resDesc.getType().equals(StandardResourceType.Rack))
+                        return  new Rack(resDesc);
                 else if (resDesc.getType().equals(StandardResourceType.ComputingNode))
                         return  new ComputingNode(resDesc);

DCWoRMS/trunk/src/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/src/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/src/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;
@@ -7 +10 @@
 
 public class AirThroughputProfile {
+        
+        protected List<AirFlowValue> airFlowHistory;
         
         protected AirThroughputEstimationPlugin airThroughputEstimationPlugin;
@@ -16 +21 @@
                 this.airThroughputEstimationPlugin = airThroughputEstimationPlugin;
                 this.airThroughputStates = airThroughputStates;
+                this.airFlowHistory = new ArrayList<AirFlowValue>();
         }
 
         public List<AirThroughputState> getAirThroughputStates() {
                 return airThroughputStates;
+        }
+        
+        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;
         }
         

DCWoRMS/trunk/src/schedframe/resources/computing/profiles/energy/airthroughput/ui/AirThroughputInterface.java

@@ -10 +10 @@
         public String getAirThroughputState();
         
-        public boolean setAirThroughputState(String airThrougputState);
+        public boolean setAirThroughputState(String airThroughputState);
         
         public boolean supportAirThroughputState(String powerState);

DCWoRMS/trunk/src/schedframe/resources/computing/profiles/energy/airthroughput/ui/DefaultAirThroughputInterface.java

@@ -6 +6 @@
 import schedframe.Parameters;
 import schedframe.resources.computing.ComputingResource;
+import schedframe.resources.computing.profiles.energy.EnergyEvent;
+import schedframe.resources.computing.profiles.energy.EnergyEventType;
 import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputProfile;
 import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputState;
 
-public class DefaultAirThrougputInterface implements AirThroughputInterface{
+public class DefaultAirThroughputInterface implements AirThroughputInterface{
 
         protected String currentAirThroughputState;
         protected AirThroughputProfile airThroughputProfile;
         protected ComputingResource resource;
+        
+        public DefaultAirThroughputInterface(ComputingResource resource, AirThroughputProfile airThroughputProfile){
+                this.resource = resource;
+                this.airThroughputProfile = airThroughputProfile;
+        }
         
         public String getAirThroughputState() {
@@ -22 +29 @@
                 if(supportAirThroughputState(state)){
                         currentAirThroughputState = state;
+                        
+                        //TO DO - notifications should be called for all resources starting form the lowest layer
+                        resource.handleEvent(new EnergyEvent(EnergyEventType.AIRFLOW_STATE_CHANGED, resource.getName()));
+
                         return true;
                 }
@@ -28 +39 @@
 
         public boolean supportAirThroughputState(String state) {
-
                 for(AirThroughputState airFlowState: airThroughputProfile.getAirThroughputStates()){
                         if(airFlowState.getName().equals(state)){

DCWoRMS/trunk/src/schedframe/resources/computing/profiles/energy/power/PowerInterfaceFactory.java

@@ -5 +5 @@
 import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface;
 
-public class PowerProfileFactory {
+public class PowerInterfaceFactory {
 
 
@@ -36 +36 @@
                 else if (resource.getType().getName().equals(StandardResourceType.Processor.getName()))
                         powerInterface = new schedframe.resources.computing.profiles.energy.power.ui.ProcessorPowerInterface(resource, pp);
-                else throw new IllegalArgumentException("ResourceType " + resource.getType() + " is not supported.");
+                else 
+                        powerInterface = new schedframe.resources.computing.profiles.energy.power.ui.ComputingResourcePowerInterface(resource, pp);
 
                 /*switch(resource.getType()){

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

@@ -22 +22 @@
         
 
-        public PowerProfile(EnergyEstimationPlugin energyEstimationPlugin, List<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<PowerState> supportedPowerStates,  List<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)

DCWoRMS/trunk/src/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/src/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;

DCWoRMS/trunk/src/schedframe/resources/computing/profiles/energy/power/ui/ComputingResourcePowerInterface.java

@@ -17 +17 @@
 import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName;
 
-public abstract class AbstractPowerInterface implements PowerInterface{
+public class ComputingResourcePowerInterface implements PowerInterface{
 
         protected PowerStateName currentPowerState;
@@ -23 +23 @@
         protected ComputingResource resource;
         
-        public AbstractPowerInterface(ComputingResource resource, PowerProfile powerProfile){
+        public ComputingResourcePowerInterface(ComputingResource resource, PowerProfile powerProfile){
                 this.resource = resource;
                 this.powerProfile = powerProfile;

DCWoRMS/trunk/src/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/src/schedframe/resources/computing/profiles/energy/power/ui/ProcessorPowerInterface.java

@@ -1 +1 @@
 package schedframe.resources.computing.profiles.energy.power.ui;
 
-import gridsim.dcworms.DCWormsTags;
 
 import java.util.Map;
@@ -16 +15 @@
 import schedframe.resources.units.StandardResourceUnitName;
 
-public class ProcessorPowerInterface extends AbstractPowerInterface {
+public class ProcessorPowerInterface extends ComputingResourcePowerInterface {
 
         protected PState currentPState;