Changeset 495 for DCWoRMS/trunk/src/simulator/stats/implementation/DCWormsStatistics.java

Timestamp:

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

Author:

wojtekp

Message:

 

File:

• DCWoRMS/trunk/src/simulator/stats/implementation/DCWormsStatistics.java (modified) (35 diffs)

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;
 }