Changeset 495 for DCWoRMS/trunk

Timestamp:

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

Author:

wojtekp

Message:

 

Location:

DCWoRMS/trunk/src

Files:

• schedframe/resources/computing/ComputingNode.java (modified) (2 diffs)
• schedframe/resources/computing/ComputingResource.java (modified) (9 diffs)
• schedframe/resources/computing/Core.java (modified) (2 diffs)
• schedframe/resources/computing/DataCenter.java (modified) (2 diffs)
• schedframe/resources/computing/Processor.java (modified) (2 diffs)
• schedframe/resources/computing/Rack.java (modified) (2 diffs)
• schedframe/resources/computing/ResourceFactory.java (modified) (1 diff)
• schedframe/resources/computing/profiles/energy/EnergyEventType.java (modified) (1 diff)
• schedframe/resources/computing/profiles/energy/EnergyExtension.java (modified) (6 diffs)
• schedframe/resources/computing/profiles/energy/MeasurementHistory.java (added)
• schedframe/resources/computing/profiles/energy/airthroughput/AirFlowValue.java (added)
• schedframe/resources/computing/profiles/energy/airthroughput/AirThroughputInterfaceFactory.java (added)
• schedframe/resources/computing/profiles/energy/airthroughput/AirThroughputProfile.java (modified) (3 diffs)
• schedframe/resources/computing/profiles/energy/airthroughput/ui/AirThroughputInterface.java (modified) (1 diff)
• schedframe/resources/computing/profiles/energy/airthroughput/ui/DefaultAirThroughputInterface.java (moved) (moved from DCWoRMS/trunk/src/schedframe/resources/computing/profiles/energy/airthroughput/ui/DefaultAirThrougputInterface.java) (3 diffs)
• schedframe/resources/computing/profiles/energy/power/PowerInterfaceFactory.java (moved) (moved from DCWoRMS/trunk/src/schedframe/resources/computing/profiles/energy/power/PowerProfileFactory.java) (2 diffs)
• schedframe/resources/computing/profiles/energy/power/PowerProfile.java (modified) (1 diff)
• schedframe/resources/computing/profiles/energy/power/PowerUsage.java (modified) (1 diff)
• schedframe/resources/computing/profiles/energy/power/ui/ComputingNodePowerInterface.java (modified) (1 diff)
• schedframe/resources/computing/profiles/energy/power/ui/ComputingResourcePowerInterface.java (moved) (moved from DCWoRMS/trunk/src/schedframe/resources/computing/profiles/energy/power/ui/AbstractPowerInterface.java) (2 diffs)
• schedframe/resources/computing/profiles/energy/power/ui/DataCenterPowerInterface.java (modified) (1 diff)
• schedframe/resources/computing/profiles/energy/power/ui/ProcessorPowerInterface.java (modified) (2 diffs)
• simulator/ConfigurationOptions.java (modified) (4 diffs)
• simulator/stats/implementation/DCWormsStatistics.java (modified) (35 diffs)
• simulator/stats/implementation/GSSAccumulatorsStats.java (modified) (2 diffs)
• simulator/stats/implementation/ResourceAirFlowStats.java (added)
• simulator/stats/implementation/ResourceUsageStats.java (modified) (3 diffs)
• simulator/stats/implementation/out/FormatedStringSerializer.java (deleted)
• simulator/stats/implementation/out/StatsSerializer.java (modified) (2 diffs)
• simulator/stats/implementation/out/StringSerializer.java (modified) (4 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;

DCWoRMS/trunk/src/simulator/ConfigurationOptions.java

@@ -67 +67 @@
         public static final String CREATEDIAGRAMS_UTILIZATION = CREATEDIAGRAMS + ".utilization";
         public static final String CREATEDIAGRAMS_ENERGYUSAGE = CREATEDIAGRAMS + ".energyusage";
+        public static final String CREATEDIAGRAMS_AIRFLOW = CREATEDIAGRAMS + ".airflow";
         public static final String CREATEDIAGRAMS_RESOURCES_SCALE = CREATEDIAGRAMS_UTILIZATION + ".scale";
         public static final String CREATEDIAGRAMS_TASKS = CREATEDIAGRAMS + ".tasks";
@@ -163 +164 @@
         public boolean creatediagrams_resources = true;
         public boolean creatediagrams_energyusage = true;
+        public boolean creatediagrams_airflow = true;
         public boolean creatediagrams_tasks = true;
         public boolean creatediagrams_taskswaitingtime = true;
@@ -173 +175 @@
         
         public String[] resForEnergyChart;
+        public String[] resForAirFlowChart;
         public String[] resForUtilizationChart;
         
@@ -302 +305 @@
                         co.creatediagrams_energyusage = createDiagrams;
                 }
+                
+                try {
+                        co.resForAirFlowChart = bundle.getString(CREATEDIAGRAMS_AIRFLOW).split(";");
+                        if(co.resForAirFlowChart.length > 0){
+                                co.creatediagrams_airflow = true && createDiagrams;
+                        }
+                } catch(MissingResourceException e){
+                        co.creatediagrams_airflow = createDiagrams;
+                }
+                
                 try {
                         co.creatediagrams_tasks = Boolean.valueOf(

DCWoRMS/trunk/src/simulator/stats/implementation/DCWormsStatistics.java

@@ -62 +62 @@
 import schedframe.resources.computing.extensions.ExtensionType;
 import schedframe.resources.computing.profiles.energy.EnergyExtension;
+import schedframe.resources.computing.profiles.energy.airthroughput.AirFlowValue;
 import schedframe.resources.computing.profiles.energy.power.PowerUsage;
 import schedframe.resources.units.PEUnit;
@@ -81 +82 @@
 import simulator.stats.SimulationStatistics;
 import simulator.stats.implementation.out.AbstractStringSerializer;
-import simulator.stats.implementation.out.FormatedStringSerializer;
 import simulator.stats.implementation.out.StringSerializer;
 import csiro.mit.utils.jfreechart.timetablechart.TimetableChartFactory;
@@ -98 +98 @@
         protected static float ALPHA = 0.5f;
         protected static int GANTT_WIDTH = 1200;
-
-        //protected static final int BITS = 8;
+        
         protected static final int MILLI_SEC = 1000;
 
@@ -106 +105 @@
 
         protected static final String SIMULATION_STATISTICS_OUTPUT_FILE_NAME = "Simulation.txt";
-        protected static final String ENERGYUSAGE_STATISTICS_OUTPUT_FILE_NAME = "Energy.txt";
-        protected static final String RESOURCEUSAGE_STATISTICS_OUTPUT_FILE_NAME = "ResourceUtilization.txt";
+        protected static final String RESOURCEUTILIZATION_STATISTICS_OUTPUT_FILE_NAME = "ResourceUtilization.txt";
+        protected static final String ENERGYUSAGE_STATISTICS_OUTPUT_FILE_NAME = "EnergyUsage.txt";
+        protected static final String AIRFLOW_STATISTICS_OUTPUT_FILE_NAME = "AirThroughput.txt";
 
         protected static final String DIAGRAMS_FILE_NAME_PREFIX = "Chart_";
@@ -123 +123 @@
         protected Map<String, GSSAccumulator> statsData;
         
-        private GenericUser users;
+        protected GenericUser users;
         protected ResourceController resourceController;
         protected boolean generateDiagrams = true;
@@ -132 +132 @@
         //RESOURCES
         protected Timetable ganttDiagramPeTimetable;
-        protected Map<ResourceType, List<XYDataset>> resourceEnergyDiagrams;
+        protected Map<ResourceType, List<XYDataset>> resourcePowerUsageDiagrams;
+        protected Map<ResourceType, List<XYDataset>> resourceAirFlowDiagrams;
         protected Map<ResourceType, List<XYDataset>> resourceLoadDiagrams;
         protected Map<String,List<ResStat>> basicResStats;
@@ -161 +162 @@
                 this.outputFolderName = outputFolderName;
 
-
                 this.serializer = new StringSerializer();
-
                 this.serializer.setDefaultNumberFormat(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT);
 
                 this.resourceController = resourceController;
-                jr = new JobRegistryImpl("");
+                this.jr = new JobRegistryImpl("");
                 init();
         }
@@ -174 +173 @@
 
                 this.startSimulationTime = DateTimeUtilsExt.getOffsetTime().getTimeInMillis();
-
                 this.endSimulationTime = DateTimeUtilsExt.currentTimeMillis();
 
@@ -235 +233 @@
         private void gatherResourceStatistics() {
                 
-                
-                //TEMPORARY CONFIGURATION SECTION
-                
                 HashMap<String, List<Stats>> type_stats = new HashMap<String, List<Stats>>();
                 
@@ -248 +243 @@
                         if(ArrayUtils.contains(configuration.resForEnergyChart, resourceName))
                                 cStats.add(Stats.chartEnergy);
+                        cStats.add(Stats.textAirFlow);
+                        if(ArrayUtils.contains(configuration.resForAirFlowChart, resourceName))
+                                cStats.add(Stats.chartAirFlow);
                         type_stats.put(resourceName, cStats);
                 }               
                 
                 peGanttMap = new HashMap<String, TimetableEventSource>();
-                taskGanttMap = new HashMap<String, TimetableEventGroup>();
-                
+                taskGanttMap = new HashMap<String, TimetableEventGroup>();              
                 
                 resourceLoadDiagrams = new HashMap<ResourceType, List<XYDataset>>();
-                resourceEnergyDiagrams = new HashMap<ResourceType, List<XYDataset>>();
+                resourcePowerUsageDiagrams = new HashMap<ResourceType, List<XYDataset>>();
+                resourceAirFlowDiagrams = new HashMap<ResourceType, List<XYDataset>>();
                 
                 ganttDiagramPeTimetable = new Timetable(new FixedMillisecond(
@@ -265 +263 @@
                         File file = new File(outputFolderName + STATS_FILE_NAME_PREFIX
                                         + simulationIdentifier + "_"
-                                        + RESOURCEUSAGE_STATISTICS_OUTPUT_FILE_NAME);
+                                        + RESOURCEUTILIZATION_STATISTICS_OUTPUT_FILE_NAME);
                         resourceLoadStatsFile = new PrintStream(new FileOutputStream(file));
                 } catch (IOException e) {
@@ -280 +278 @@
                         energyStatsFile = null;
                 }
-                JobRegistry jr = new JobRegistryImpl("stats");
+                
+                PrintStream airFlowStatsFile = null;
+                try {
+                        File file = new File(outputFolderName + STATS_FILE_NAME_PREFIX
+                                        + simulationIdentifier + "_"
+                                        + AIRFLOW_STATISTICS_OUTPUT_FILE_NAME);
+                        airFlowStatsFile = new PrintStream(new FileOutputStream(file));
+                } catch (IOException e) {
+                        airFlowStatsFile = null;
+                }
+
                 basicResStats = gatherPEStats(jr.getExecutableTasks());
                 peStatsPostProcessing(basicResStats);
@@ -291 +299 @@
                 for(String resourceName: resourceController.getComputingResourceLayers()){
                         List<ComputingResource> resources = null;
-                        try {
-                                resources = new ArrayList<ComputingResource>();
-                                for(ComputingResource compRes: resourceController.getComputingResources() ){
-                                        resources.addAll(compRes.getDescendantsByType(new UserResourceType(resourceName)));
-                                }
-                                if(resourceController.getComputingResources().get(0).getType().getName().equals(resourceName))
-                                        resources.addAll(resourceController.getComputingResources());
-                        } catch (Exception e) {
-                                continue;
-                        }
+
+                        resources = new ArrayList<ComputingResource>();
+                        for(ComputingResource compRes: resourceController.getComputingResources() ){
+                                resources.addAll(compRes.getDescendantsByType(new UserResourceType(resourceName)));
+                        }
+                        if(resourceController.getComputingResources().get(0).getType().getName().equals(resourceName))
+                                resources.addAll(resourceController.getComputingResources());
+                
                         if(type_stats.containsKey(resourceName)){
-                                Map<String, GSSAccumulator> energyCategoryStats = new TreeMap<String, GSSAccumulator>();
-                                Map<String, GSSAccumulator> loadCategoryStats = new TreeMap<String, GSSAccumulator>();
                                 for(ComputingResource resource: resources){
                                         ResourceUsageStats resourceUsage = null;
                                         ResourceEnergyStats energyUsage = null;
+                                        ResourceAirFlowStats airFlow = null;
                                         if(type_stats.get(resourceName).contains(Stats.textLoad)){
                                                 resourceUsage = gatherResourceLoadStats(resource, basicResStats);
@@ -358 +363 @@
                                         }
                                         
-                                        /*if(resType == ResourceType.ComputingNode){
-                                                ComputingNode compNode = (ComputingNode) resource;
-                                                if(energyCategoryStats.containsKey(resType+"#"+compNode.getCategory().getName())){
-                                                        GSSAccumulator acc = energyCategoryStats.get(resType+"#"+compNode.getCategory().getName());
-                                                        acc.add(energyUsage.meanUsage);
-                                                        energyCategoryStats.put(resType+"#"+compNode.getCategory().getName(), acc);
-                                                } else{
-                                                        GSSAccumulator acc = new GSSAccumulator();
-                                                        acc.add(energyUsage.meanUsage);
-                                                        energyCategoryStats.put(resType+"#"+compNode.getCategory().getName(), acc);
+                                        if(type_stats.get(resourceName).contains(Stats.textAirFlow)){
+                                                airFlow = gatherResourceAirFlowStats(resource);
+                                                airFlow.setMeanUsage(calculateAirFlowLoad(airFlow));
+                                                airFlow.setSumUsage(airFlow.getMeanUsage() * (endSimulationTime - startSimulationTime) / (3600 * MILLI_SEC));
+                                                
+                                                EnergyExtension een = (EnergyExtension)(resource.getExtensionList().getExtension(ExtensionType.ENERGY_EXTENSION));
+                                                if(resourceController.getComputingResources().contains(resource)) {
+                                                        if( een != null /*&& een.getPp() != null*/ ){
+                                                                accStats.meanAirFlow.add(airFlow.meanValue);
+                                                        }
+
+                                                } else if( een != null && een.getAirFlowProfile() != null ){
+                                                        ComputingResource parent = resource.getParent();
+                                                        een = (EnergyExtension)(parent.getExtensionList().getExtension(ExtensionType.ENERGY_EXTENSION));
+                                                        boolean top = true;
+                                                        while(parent != null){
+                                                                if(een != null &&  een.getAirFlowProfile() != null) {
+                                                                        top = false;
+                                                                        break;
+                                                                }
+                                                                parent = parent.getParent();
+                                                        }
+                                                        if(top == true){
+                                                                accStats.meanAirFlow.add(airFlow.meanValue);
+                                                        }
                                                 }
-                                                
-                                                if(loadCategoryStats.containsKey(resType+"#"+compNode.getCategory().getName())){
-                                                        GSSAccumulator acc = loadCategoryStats.get(resType+"#"+compNode.getCategory().getName());
-                                                        acc.add(resourceUsage.meanUsage);
-                                                        loadCategoryStats.put(resType+"#"+compNode.getCategory().getName(), acc);
-                                                } else{
-                                                        GSSAccumulator acc = new GSSAccumulator();
-                                                        acc.add(resourceUsage.meanUsage);
-                                                        loadCategoryStats.put(resType+"#"+compNode.getCategory().getName(), acc);
+                                                if (airFlowStatsFile != null) {
+                                                        Object txt = airFlow.serialize(serializer);
+                                                        airFlowStatsFile.println(txt);
                                                 }
-                                        } else if(resType == ResourceType.Processor){
-                                                Processor proc = (Processor)resource;
-                                                if(energyCategoryStats.containsKey(resType+"#"+proc.getComputingNode().getCategory().getName())){
-                                                        GSSAccumulator acc = energyCategoryStats.get(resType+"#"+proc.getComputingNode().getCategory().getName());
-                                                        acc.add(energyUsage.meanUsage);
-                                                        energyCategoryStats.put(resType+"#"+proc.getComputingNode().getCategory().getName(), acc);
-                                                } else{
-                                                        GSSAccumulator acc = new GSSAccumulator();
-                                                        acc.add(energyUsage.meanUsage);
-                                                        energyCategoryStats.put(resType+"#"+proc.getComputingNode().getCategory().getName(), acc);
+                                        }
+                                        if(type_stats.get(resourceName).contains(Stats.chartAirFlow)){
+
+                                                if (configuration.creatediagrams_airflow) {
+                                                        createResourceAirFlowGanttDiagram(airFlow);
                                                 }
-                                                
-                                                if(loadCategoryStats.containsKey(resType+"#"+proc.getComputingNode().getCategory().getName())){
-                                                        GSSAccumulator acc = loadCategoryStats.get(resType+"#"+proc.getComputingNode().getCategory().getName());
-                                                        acc.add(resourceUsage.meanUsage);
-                                                        loadCategoryStats.put(resType+"#"+proc.getComputingNode().getCategory().getName(), acc);
-                                                } else{
-                                                        GSSAccumulator acc = new GSSAccumulator();
-                                                        acc.add(resourceUsage.meanUsage);
-                                                        loadCategoryStats.put(resType+"#"+proc.getComputingNode().getCategory().getName(), acc);
-                                                }
-                                        }*/
-                                }
-                                
-                                if(energyCategoryStats.size() > 0)
-                                {
-                                        energyStatsFile.println("\n=========BY CATEGORY===========");
-                                        for(String key: energyCategoryStats.keySet()){
-                                                GSSAccumulator acc = energyCategoryStats.get(key);
-                                                energyStatsFile.println(key + "- mean: "  + acc.getMean()+ " sum: " +acc.getMean() * (endSimulationTime-startSimulationTime) / (3600 * MILLI_SEC) * acc.getCount());
                                         }
-                                        energyStatsFile.println("\n\n");
-                                }
-                                
-                                if(loadCategoryStats.size() > 0)
-                                {
-                                        resourceLoadStatsFile.println("\n=========BY CATEGORY===========");
-                                        for(String key: loadCategoryStats.keySet()){
-                                                GSSAccumulator acc = loadCategoryStats.get(key);
-                                                resourceLoadStatsFile.println(key + "- mean: "  + acc.getMean());
-                                        }
-                                        resourceLoadStatsFile.println("\n\n");
                                 }
                         }
@@ -427 +406 @@
                 saveResourceGanttDiagrams();
                 createAccumulatedResourceSimulationStatistic();
+                if (airFlowStatsFile != null) {
+                        airFlowStatsFile.close();
+                }
                 if (energyStatsFile != null) {
                         energyStatsFile.close();
@@ -472 +454 @@
                 }
         }
+        
         private Map<String, List<ResStat>> gatherPEStats( ExecutablesList executables) {
-
                 
                 Map<String, List<ResStat>> basicResStats = new TreeMap<String, List<ResStat>>(new MapPEIdComparator());
-                //Map<Integer, Map<String, Object>> history
-                
+
                 for (ExecTask execTask:executables) {
                         Executable exec = (Executable) execTask;
@@ -485 +466 @@
                         ResourceUnit resUnit = res.get(StandardResourceUnitName.PE);
                         //ProcessingElements pes = (ProcessingElements) resUnit ;
-                        if(resUnit instanceof ProcessingElements ){
+                        if(resUnit instanceof ProcessingElements){
                                 ProcessingElements pes = (ProcessingElements) resUnit;
                                 for(ComputingResource pe: pes){
@@ -491 +472 @@
                                         long startDate = Double.valueOf(exec.getExecStartTime()).longValue() * MILLI_SEC;
                                         long endDate = Double.valueOf(exec.getFinishTime()).longValue() * MILLI_SEC;
-
 
                                         String uniqueTaskID = execTask.getJobId() + "_" + execTask.getId();
@@ -525 +505 @@
         private ResourceUsageStats gatherResourceLoadStats(ComputingResource resource, Map<String,List<ResStat>> basicStats) {
                 ResourceUsageStats usageStats = new ResourceUsageStats(resource.getName(), resource.getType(), "resourceLoadStats");
+                int cnt =0;
                 for(String resName: basicStats.keySet()){
                         try {
                                 if(resource.getDescendantByName(resName) != null || resource.getName().compareTo(resName) == 0){
+                                        cnt++;
                                         createResourceLoadData(usageStats, basicStats.get(resName));
                                 }
@@ -535 +517 @@
                         }
                 }
+                for(Long key: usageStats.getUsage().keySet()){
+                        Double value = usageStats.getUsage().get(key)/cnt;
+                        usageStats.getUsage().put(key, value);
+                }
+
                 return usageStats;
         }
         
-        private TreeMap<Long, Integer> createResourceLoadData(ResourceUsageStats usageStats, List<ResStat> resStats) {
-
-                TreeMap<Long, Integer> ganttData = (TreeMap)usageStats.getUsage();
+        private TreeMap<Long, Double> createResourceLoadData(ResourceUsageStats usageStats, List<ResStat> resStats) {
+
+                TreeMap<Long, Double> ganttData = (TreeMap<Long, Double>)usageStats.getUsage();
                 for (ResStat resStat : resStats) {
                         
@@ -546 +533 @@
                         long end_time = resStat.getEndDate();
                         if (end_time > start_time) {
-                                Integer end = ganttData.get(end_time);
+                                Double end = ganttData.get(end_time);
                                 if (end == null) {
-                                        ganttData.put(end_time, 0);
+                                        ganttData.put(end_time, 0.0);
                                         Long left = getLeftKey(ganttData, end_time);
                                         if (left != null) {
-                                                Integer leftValue = ganttData.get(left);
+                                                Double leftValue = ganttData.get(left);
                                                 ganttData.put(end_time, leftValue);
                                         }
                                 }
 
-                                Integer start = ganttData.get(start_time);
+                                Double start = ganttData.get(start_time);
                                 if (start == null) {
-                                        ganttData.put(start_time, 0);
+                                        ganttData.put(start_time, 0.0);
                                         Long left = getLeftKey(ganttData, start_time);
                                         if (left != null) {
-                                                Integer leftValue = ganttData.get(left);
+                                                Double leftValue = ganttData.get(left);
                                                 ganttData.put(start_time, leftValue);
                                         }
                                 }
 
-                                SortedMap<Long, Integer> sm = ganttData.subMap(start_time,
+                                SortedMap<Long, Double> sm = ganttData.subMap(start_time,
                                                 end_time);
                                 for (Long key : sm.keySet()) {
-                                        Integer keyVal = ganttData.get(key);
+                                        Double keyVal = ganttData.get(key);
                                         ganttData.put(key, keyVal + 1);
                                 }
                         }
                 }
+
                 return ganttData;
         }
 
-        private Long getLeftKey(TreeMap<Long, Integer> ganttData, Long toKey) {
-
-                SortedMap<Long, Integer> sm = ganttData.headMap(toKey);
+        private Long getLeftKey(TreeMap<Long, Double> ganttData, Long toKey) {
+
+                SortedMap<Long, Double> sm = ganttData.headMap(toKey);
                 if (sm.isEmpty()) {
                         return null;
@@ -621 +609 @@
         }
         
-        private void createResourceEnergyGanttDiagram(ResourceEnergyStats energyUsage) {
-
-                XYDataset dataset = createResourceEnergyGanttDataSet(energyUsage,
+        
+        private ResourceAirFlowStats gatherResourceAirFlowStats(ComputingResource resource) {
+
+                ResourceAirFlowStats resAirFlow = new ResourceAirFlowStats(resource.getName(), resource.getType(), "resourceAirFlowStats");
+                Map<Long, Double> airFlow = resAirFlow.getAirFlow();
+                
+                ExtensionList extensionList = resource.getExtensionList();
+                if(extensionList != null){
+                        for (Extension extension : extensionList) {
+                                if (extension.getType() == ExtensionType.ENERGY_EXTENSION) {
+                                        EnergyExtension ee = (EnergyExtension)extension;
+                                        if(ee.getAirFlowProfile() == null)
+                                                break;
+                                        List<AirFlowValue> airFlowHistory = ee.getAirFlowProfile().getAirThroughputHistory();
+                                        if(airFlowHistory.size() == 0)
+                                                break;
+                                        long lastTime = DateTimeUtilsExt.getOffsetTime().getTimeInMillis();
+                                        long endSimulationTime = DateTimeUtilsExt.currentTimeMillis();
+                                        double lastAirFlow = 0;
+                                        airFlowHistory.add(new AirFlowValue(endSimulationTime, ee.getAirFlowProfile().getAirThroughputHistory().get(ee.getAirFlowProfile().getAirThroughputHistory().size()-1).getValue()));
+                                        for(AirFlowValue af:airFlowHistory){
+                                                airFlow.put(af.getTimestamp(), af.getValue());
+
+                                                lastAirFlow = af.getValue();
+                                                lastTime = af.getTimestamp();
+                                        }
+                                }
+                        }
+                }
+                return resAirFlow;
+        }
+        
+        private void createResourceEnergyGanttDiagram(ResourceEnergyStats powerUsage) {
+
+                XYDataset dataset = createResourceEnergyGanttDataSet(powerUsage,
                                 startSimulationTime, endSimulationTime);
                 
-                List<XYDataset> energyDiagram = resourceEnergyDiagrams.get(energyUsage.getResourceType());
+                List<XYDataset> energyDiagram = resourcePowerUsageDiagrams.get(powerUsage.getResourceType());
                 if(energyDiagram == null){
                         energyDiagram = new ArrayList<XYDataset>();
                         energyDiagram.add(dataset);
-                        resourceEnergyDiagrams.put(energyUsage.getResourceType(), energyDiagram);
+                        resourcePowerUsageDiagrams.put(powerUsage.getResourceType(), energyDiagram);
                 } else {
                         energyDiagram.add(dataset);
@@ -637 +657 @@
         }
 
+        private void createResourceAirFlowGanttDiagram(ResourceAirFlowStats airFlow) {
+
+                XYDataset dataset = createResourceAirFlowGanttDataSet(airFlow,
+                                startSimulationTime, endSimulationTime);
+                
+                List<XYDataset> airFlowDiagram = resourceAirFlowDiagrams.get(airFlow.getResourceType());
+                if(airFlowDiagram == null){
+                        airFlowDiagram = new ArrayList<XYDataset>();
+                        airFlowDiagram.add(dataset);
+                        resourceAirFlowDiagrams.put(airFlow.getResourceType(), airFlowDiagram);
+                } else {
+                        airFlowDiagram.add(dataset);
+                }
+
+        }
+        
         private XYDataset createResourceEnergyGanttDataSet(
                         ResourceEnergyStats energyUsage, long start, long end) {
@@ -665 +701 @@
         }
 
+        private XYDataset createResourceAirFlowGanttDataSet(
+                        ResourceAirFlowStats airFlowStats, long start, long end) {
+
+                TreeMap<Long, Double> ganttdata = createResourceAirFlowGanttData(airFlowStats);
+                XYSeriesCollection dataset = new XYSeriesCollection();
+                XYSeries data = new XYSeries(airFlowStats.getResourceName(), false, true);
+                //data.add(start, 0);
+                for (Long key : ganttdata.keySet()) {
+                        Double val = ganttdata.get(key);
+                        data.add(key, val);
+                }
+                data.add(end, 0);
+                dataset.addSeries(data);
+                return dataset;
+        }
+
+        private TreeMap<Long, Double> createResourceAirFlowGanttData(
+                        ResourceAirFlowStats airFlowStats) {
+
+                Map<Long, Double> airFlow = airFlowStats.getAirFlow();
+                TreeMap<Long, Double> ganttData = new TreeMap<Long, Double>();
+                for (Long afKey : airFlow.keySet()) {
+                        ganttData.put(afKey, airFlow.get(afKey));
+                }
+                return ganttData;
+        }
 
         private boolean saveResourceGanttDiagrams() {
@@ -670 +732 @@
                 JFreeChart peDiagram = null;
                 JFreeChart resourceEnergyDiagram = null;
+                JFreeChart resourceAirFlowDiagram = null;
                 if (!generateDiagrams)
                         return false;
@@ -701 +764 @@
                 }
                 if (configuration.creatediagrams_energyusage) {
-                        for(ResourceType resType: resourceEnergyDiagrams.keySet()){
+                        for(ResourceType resType: resourcePowerUsageDiagrams.keySet()){
                                 resourceEnergyDiagram = getResourcesEnergyDiagram(resType, chartName,
                                                 subtitle, simulationTime);
@@ -708 +771 @@
                         }
                 }
+                
+                
+                if (configuration.creatediagrams_airflow) {
+                        for(ResourceType resType: resourceAirFlowDiagrams.keySet()){
+                                resourceAirFlowDiagram = getResourcesAirFlowDiagram(resType, chartName,
+                                                subtitle, simulationTime);
+                                if (!saveXYPlotChart(resourceAirFlowDiagram, fileName + "AirThroughput - "+resType))
+                                        return false;
+                        }
+                }
                 return true;
         }
@@ -713 +786 @@
         private JFreeChart getResourcesLoadDiagram(ResourceType resType, String chartName, Title subtitle,
                         String simulationTime) {
-                String cpu = "CPU";
+                String cpu = "UTILIZATION [%]";
                 boolean urls = false;
                 boolean tooltip = true;
@@ -750 +823 @@
                 DateAxis xAxis = new DateAxis(simulationTime);
 
-                List<XYDataset> energyDiagram = resourceEnergyDiagrams.get(resType);
+                List<XYDataset> energyDiagram = resourcePowerUsageDiagrams.get(resType);
                 for (XYDataset dataset : energyDiagram) {
 
@@ -759 +832 @@
                         XYPlot tPlot = tChart.getXYPlot();
                         NumberAxis yAxis = new NumberAxis(energy);
+                        yAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());
+                        tPlot.setRangeAxis(yAxis);
+                        XYStepAreaRenderer rend = (XYStepAreaRenderer) tPlot.getRenderer();
+                        rend.setShapesVisible(false);
+                        cPlot.add(tPlot);
+                }
+                cPlot.setDomainAxis(xAxis);
+                cPlot.setDomainAxisLocation(AxisLocation.TOP_OR_LEFT);
+                JFreeChart chart = new JFreeChart(chartName, cPlot);
+                chart.addSubtitle(subtitle);
+                return chart;
+        }
+        
+        private JFreeChart getResourcesAirFlowDiagram(ResourceType resType, String chartName,
+                        Title subtitle, String simulationTime) {
+                String airFlow = "AIR FLOW [m^3/min]";
+                boolean urls = false;
+                boolean tooltip = true;
+                boolean legend = true;
+                CombinedDomainXYPlot cPlot = new CombinedDomainXYPlot();
+                DateAxis xAxis = new DateAxis(simulationTime);
+
+                List<XYDataset> airFlowDiagram = resourceAirFlowDiagrams.get(resType);
+                for (XYDataset dataset : airFlowDiagram) {
+
+                        JFreeChart tChart = ChartFactory.createXYStepAreaChart("", "",
+                                        null, dataset, PlotOrientation.VERTICAL, legend, tooltip,
+                                        urls);
+
+                        XYPlot tPlot = tChart.getXYPlot();
+                        NumberAxis yAxis = new NumberAxis(airFlow);
                         yAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());
                         tPlot.setRangeAxis(yAxis);
@@ -870 +974 @@
                 XYSeriesCollection dataset = new XYSeriesCollection();
                 XYSeries data = new XYSeries(resStats.resourceName, false, true);
-                Map<Long, Integer> usage = resStats.getUsage();
+                Map<Long, Double> usage = resStats.getUsage();
                 
                 for (Long key : usage.keySet()) {
-                        Integer val = usage.get(key);
-                        double newv =100*val/basicResStats.size();
-                        int newinv = (int)newv;
-                        data.add(key, new Integer(newinv));
+                        Double val = usage.get(key);
+                        double newv = 100 * val;
+                        //System.out.println(newv+":"+val+";"+basicResStats.size());
+                        data.add(key, new Double(newv));
                 }
                 dataset.addSeries(data);
@@ -950 +1054 @@
         }
         
+        private double calculateAirFlowLoad(ResourceAirFlowStats resAirFlowStats ){
+                double meanAirFlow = 0;
+                long time = 0;
+                double usage = 0;
+                Map<Long, Double> airFlow = resAirFlowStats.getAirFlow();
+                for (Long key : airFlow.keySet()) {
+                        
+                        if (time != 0) {
+                                meanAirFlow += (usage * (key - time))
+                                                / (endSimulationTime - startSimulationTime);
+
+                                time = key;
+                        } else {
+                                time = key;
+                        }
+                        usage = (double) airFlow.get(key);
+                }
+                return meanAirFlow;
+        }
+        
+        
         /*private void createPEGanttDiagram(String peName,
                         String uniqueTaskID, Map<String, Object> historyItem) {
@@ -1006 +1131 @@
                         Job job = (Job) jobs.get(i);
 
-                        //List<TaskInterface> execList = JobRegistry.getInstance("COMPUTING_GRID_0#BROKER").getAllSubmittedTasks();
                         List<Executable> execList = jr.getExecutableTasks().getJobExecutables(job.getId());
                         List<TaskStats> taskStatsList = new ArrayList<TaskStats>();
@@ -1346 +1470 @@
                 statsData.put(RESOURCES_RESERVATION_LOAD, accStats.meanEnergyUsage);
                 statsData.put(RESOURCES_QUEUE_LENGTH, accStats.meanQueueLength);
-
         }
 
@@ -1417 +1540 @@
         chartLoad,
         textEnergy,
-        chartEnergy;
+        chartEnergy,
+        textAirFlow,
+        chartAirFlow;
 }

DCWoRMS/trunk/src/simulator/stats/implementation/GSSAccumulatorsStats.java

@@ -10 +10 @@
         public GSSAccumulator meanQueueLength;
         public GSSAccumulator meanEnergyUsage;
+        public GSSAccumulator meanAirFlow;
 
         public GSSAccumulator meanTaskStartTime;
@@ -29 +30 @@
                 meanReservationLoad = new GSSAccumulator();
                 meanQueueLength = new GSSAccumulator();
-                meanEnergyUsage = new GSSAccumulator();
+                meanEnergyUsage = new GSSAccumulator(); 
+                meanAirFlow = new GSSAccumulator(); 
 
                 meanTaskStartTime = new GSSAccumulator();

DCWoRMS/trunk/src/simulator/stats/implementation/ResourceUsageStats.java

@@ -15 +15 @@
 public class ResourceUsageStats implements StatsInterface {
 
-        protected Map<Long, Integer> usage;
+        protected Map<Long, Double> usage;
         protected String resourceName;
         protected String usageType;
@@ -31 +31 @@
                 this.resourceType = resourceType;
                 this.usageType = usageType;
-                this.usage = new TreeMap<Long, Integer>();
+                this.usage = new TreeMap<Long, Double>();
                 this.meanUsage = 0;
         }
@@ -51 +51 @@
         }       
 
-        public Map<Long, Integer> getUsage() {
+        public Map<Long, Double> getUsage() {
                 return this.usage;
         }

DCWoRMS/trunk/src/simulator/stats/implementation/out/StatsSerializer.java

@@ -4 +4 @@
 import simulator.stats.implementation.GSSAccumulatorsStats;
 import simulator.stats.implementation.JobStats;
+import simulator.stats.implementation.ResourceAirFlowStats;
 import simulator.stats.implementation.ResourceEnergyStats;
 import simulator.stats.implementation.ResourceStats;
@@ -28 +29 @@
         public Object visit(ResourceEnergyStats arg);
 
+        public Object visit(ResourceAirFlowStats arg);
         
         public Object visit(GSSAccumulatorsStats arg);

DCWoRMS/trunk/src/simulator/stats/implementation/out/StringSerializer.java

@@ -11 +11 @@
 import simulator.stats.implementation.GSSAccumulatorsStats;
 import simulator.stats.implementation.JobStats;
+import simulator.stats.implementation.ResourceAirFlowStats;
 import simulator.stats.implementation.ResourceEnergyStats;
 import simulator.stats.implementation.ResourceStats;
@@ -258 +259 @@
 
         public Object visit(ResourceUsageStats resourceUsageStats) {
-                Map<Long, Integer> resourceUsage = resourceUsageStats.getUsage();
+                Map<Long, Double> resourceUsage = resourceUsageStats.getUsage();
                 
                 int mapSize = resourceUsage.size();
@@ -297 +298 @@
                         buffer.append(resourceUsageStats.getResourceName());
                         buffer.append(fieldSeparator);
-                        Integer value = resourceUsage.get(timestamp);
+                        Double value = resourceUsage.get(timestamp);
                         buffer.append(timestamp);
                         buffer.append(fieldSeparator);
@@ -371 +372 @@
         }
 
+        public Object visit(ResourceAirFlowStats resourceAirFlowStats) {
+                Map<Long, Double> resourceAirFlow = resourceAirFlowStats.getAirFlow();
+                
+                int mapSize = resourceAirFlow.size();
+                /*
+                 * FIXME:
+                 * Integer.MAX_VALUE = 2147483647. We assume, that each line contains 
+                 * max 30 signs - this gives max 71582788 lines. If resourceUsage map
+                 * contains more elements then we have a problem, because content of
+                 * resourceUsage map will not fit in the buffer.
+                 * This will need further attention in the future.
+                 */
+                int maxSize = (Integer.MAX_VALUE / 30 ) - 1;
+                if(mapSize >= maxSize){
+                        log.error("Resource usage data is to long to fit in the buffer.");
+                        return null;
+                }
+                
+                int size = 30 * resourceAirFlow.size();
+                
+                StringBuffer buffer = null;
+
+                if(printedHeaders.add(resourceAirFlowStats.getUsageType())) {
+                        buffer = new StringBuffer(size + 42);
+                        String[] headers = resourceAirFlowStats.getHeaders();
+                        for(int i = 0; i < headers.length; i++)
+                        {
+                                buffer.append(headers[i]);
+                                buffer.append(fieldSeparator);
+                        }
+                        buffer.append(System.getProperty("line.separator"));
+                } else {
+                        buffer = new StringBuffer(size);
+                }
+                
+                
+                for (Long timestamp : resourceAirFlow.keySet()) {
+                        
+                        buffer.append(resourceAirFlowStats.getResourceName());
+                        buffer.append(fieldSeparator);
+                        Double value = resourceAirFlow.get(timestamp);
+                        buffer.append(timestamp);
+                        buffer.append(fieldSeparator);
+                        buffer.append(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT
+                                        .format(value));
+                        buffer.append(fieldSeparator);
+                        buffer.append(System.getProperty("line.separator"));
+
+                }
+                
+                if(resourceAirFlow.size() > 0) {
+                        buffer.append("mean: "+resourceAirFlowStats.getMeanUsage() + " sum: " +resourceAirFlowStats.getSumUsage());
+                        buffer.append(System.getProperty("line.separator"));    
+                }
+
+                return buffer.toString();
+        }
+
         public Object visit(GSSAccumulatorsStats accStats) {