Changeset 1434 for DCWoRMS/branches/coolemall/src/simulator/stats/implementation/DCWormsStatistics.java

Timestamp:

09/15/14 17:00:03 (11 years ago)

Author:

wojtekp

Message:

 

File:

• DCWoRMS/branches/coolemall/src/simulator/stats/implementation/DCWormsStatistics.java (modified) (56 diffs)

DCWoRMS/branches/coolemall/src/simulator/stats/implementation/DCWormsStatistics.java

@@ -133 +133 @@
         protected static final String STATS_FILE_NAME_PREFIX = "Stats_";
 
-        protected static final String TASK_SEPARATOR = ";";
-        protected static final String JOB_SEPARATOR = ";";
+        protected static final String SEPARATOR = ";";
 
         protected String outputFolderName;
@@ -152 +151 @@
         
         //RESOURCES
-        protected Map<String, List<ResStat>> pesStats;
-        protected Map<String, Double> basicResLoad;
-        
-        protected Map<String, TimetableEventSource> peGanttMap;
-        protected Map<String, TimetableEventGroup> taskGanttMap;
-        
+        protected Map<ComputingResource, List<ResStat>> peStats;
+
+                
         protected Timetable ganttDiagramTimetable;
         protected Map<String, List<XYDataset>> resourcePowerUsageDiagrams;
-        protected Map<String, List<XYDataset>> resourceAirFlowDiagrams;
+        protected Map<String, List<XYDataset>> resourceAirflowDiagrams;
         protected Map<String, List<XYDataset>> resourceTemperatureDiagrams;
         protected Map<String, List<XYDataset>> resourceOccupancyDiagrams;
@@ -173 +169 @@
         protected TaskSeriesCollection ganttDiagramTaskSeriesCollection;
         protected TaskSeriesCollection ganttDiagramWaitingTimeSeriesCollection;
-        protected Map<String, Set<ComputingResource>> task_processorsMap;
-
-        protected JobRegistry jr;
+        protected Map<String, Set<ComputingResource>> taskToPEMap;
+
+        protected JobRegistry jobRegistry;
         protected MetricsCalculator metCalc;
         
@@ -183 +179 @@
                 this.configuration = co;
                 this.users = users;
-
                 this.outputFolderName = outputFolderName;
                 this.resourceController = resourceController;
-                this.jr = new JobRegistryImpl("");
+                this.jobRegistry = new JobRegistryImpl();
                 
                 if(users.isSimStartTimeDefined())
@@ -196 +191 @@
 
                 init();
+        }
+        
+        private void init() {
+                taskToPEMap = new HashMap<String, Set<ComputingResource>>(jobRegistry.getFinishedTasks().size());
+
+                statsData = new HashMap<String, DCwormsAccumulator>(2);
+                accStats = new GSSAccumulatorsStats();
+                
+                this.serializer = new StringSerializer();               
+                this.metCalc =  new DCwormsMetricsCalculator(startSimulationTime, endSimulationTime, endSimulationTime);
+                
+                if(DataCenterWorkloadSimulator.MODE.equals("CoolEmAll")){
+                        this.serializer = new CoolEmAllStringSerializer();
+                        this.metCalc = new CoolEmAllMetricsCalculator(startSimulationTime, endSimulationTime, endSimulationTime);
+                }
+                
+                this.serializer.setDefaultNumberFormat(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT);
         }
 
@@ -225 +237 @@
         public String getOutputFolderName() {
                 return outputFolderName;
-        }
-
-        private void init() {
-                task_processorsMap = new HashMap<String, Set<ComputingResource>>();
-                accStats = new GSSAccumulatorsStats();
-                statsData = new HashMap<String, DCwormsAccumulator>();
-                
-                this.serializer = new StringSerializer();               
-                this.metCalc =  new DCwormsMetricsCalculator(startSimulationTime, endSimulationTime, endSimulationTime);
-                
-                if(DataCenterWorkloadSimulator.MODE.equals("CoolEmAll")){
-                        this.serializer = new CoolEmAllStringSerializer();
-                        this.metCalc = new CoolEmAllMetricsCalculator(startSimulationTime, endSimulationTime, endSimulationTime);
-                }
-                this.serializer.setDefaultNumberFormat(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT);
         }
 
@@ -273 +270 @@
                         System.out.println("#STATS " + "System load: " + df.format(accStats.meanTotalLoad.getMean() * 100) + " [%]");
                         
-                        
                         simulationStatsFile.println(txt);
                 }
@@ -303 +299 @@
                         if(ArrayUtils.contains(configuration.compResForEnergyChart, resourceTypeName))
                                 cStats.add(Stats.chartEnergy);
-                        cStats.add(Stats.textAirFlow);
+                        cStats.add(Stats.textAirflow);
                         if(ArrayUtils.contains(configuration.compResForAirflowChart, resourceTypeName))
-                                cStats.add(Stats.chartAirFlow);
+                                cStats.add(Stats.chartAirflow);
                         cStats.add(Stats.textTemperature);
                         if(ArrayUtils.contains(configuration.compResForTemperatureChart, resourceTypeName))
@@ -316 +312 @@
                 resourceUtilizationDiagrams = new HashMap<String, List<XYDataset>>(2);
                 resourcePowerUsageDiagrams = new HashMap<String, List<XYDataset>>(2);
-                resourceAirFlowDiagrams = new HashMap<String, List<XYDataset>>(2);
+                resourceAirflowDiagrams = new HashMap<String, List<XYDataset>>(2);
                 resourceTemperatureDiagrams = new HashMap<String, List<XYDataset>>(2);
                 
@@ -353 +349 @@
                 }
                 
-                PrintStream airFlowStatsFile = null;
+                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));
+                        airflowStatsFile = new PrintStream(new FileOutputStream(file));
                 } catch (IOException e) {
-                        airFlowStatsFile = null;
+                        airflowStatsFile = null;
                 }
                 
@@ -383 +379 @@
                 }
                 
-                PrintStream nodesAvailabilityStatsFile = null;
+                /*PrintStream nodesAvailabilityStatsFile = null;
                 try {
                         File file = new File(outputFolderName + STATS_FILE_NAME_PREFIX
@@ -391 +387 @@
                 } catch (IOException e) {
                         nodesAvailabilityStatsFile = null;
-                }
+                }*/
                 
                 PrintStream metricsStatsFile = null;
@@ -413 +409 @@
                 }
                 
-                pesStats = gatherPEStatsMulti(jr.getTasks());
-                peStatsPostProcessing(pesStats);
-                basicResLoad = calculatePELoad(pesStats);
+                peStats = gatherPEStatsMulti(jobRegistry.getTasks());
+                peStatsPostProcessing(peStats);
 
                 if (configuration.creatediagrams_gantt) {
-                        createPEGanttDiagram(pesStats);
-                }
-                
-                List<ComputingResource> compResources = null;
+                        createGanttDiagram(peStats);
+                }
+
                 for(String resourceTypeName: resourceController.getComputingResourceLayers()){
                         DCwormsAccumulator resourceEnergyAccumulator = new DCwormsAccumulator();
                         DCwormsAccumulator maxResourceEnergyAccumulator = new DCwormsAccumulator();
                         DCwormsAccumulator calculationsEnergyAccumulator = new DCwormsAccumulator();
-                        compResources = new ArrayList<ComputingResource>();
+                        List<ComputingResource> compResources = new ArrayList<ComputingResource>();
                         for(ComputingResource compRes: resourceController.getComputingResources() ){
                                 compResources.addAll(compRes.getDescendantsByType(new CustomResourceType(resourceTypeName)));
@@ -439 +433 @@
                                         ResourceUsageStats resourceOccupancy = null;
                                         ResourcePowerStats energyUsage = null;
-                                        ResourceAirFlowStats airFlow = null;
+                                        ResourceAirflowStats airflow = null;
                                         ResourceTemperatureStats temperature = null;
                                         ResourceUsefulWorkStats usefulWork = null;
+
                                         if(type_stats.get(resourceTypeName).contains(Stats.textLoad)){
-                                                resourceOccupancy = gatherResourceOccupancyStats(compResource, pesStats);
+                                                resourceOccupancy = gatherResourceOccupancyStats(compResource, peStats);
                                                 resourceOccupancy.setMeanValue(calculateMeanValue(resourceOccupancy));
                                                 if (resourceOccupancyStatsFile != null) {
@@ -457 +452 @@
                                                 }
                                         }
+
                                         if(type_stats.get(resourceTypeName).contains(Stats.chartLoad)){
                                                 if (configuration.creatediagrams_resutilization) {
@@ -463 +459 @@
                                                 }
                                         }
+
                                         if(type_stats.get(resourceTypeName).contains(Stats.textEnergy)){
                                                 energyUsage = gatherResourcePowerConsumptionStats(compResource);
@@ -548 +545 @@
                                                 }
                                         }
+
                                         if(type_stats.get(resourceTypeName).contains(Stats.chartEnergy)){
                                                 if (configuration.creatediagrams_respowerusage) {
@@ -553 +551 @@
                                                 }
                                         }
-                                        
-                                        if(type_stats.get(resourceTypeName).contains(Stats.textAirFlow)){
-                                                airFlow = gatherResourceAirFlowStats(compResource);
-                                                airFlow.setMeanValue(calculateMeanValue(airFlow));
-                                                airFlow.setSumValue(airFlow.getMeanValue() * (endSimulationTime - startSimulationTime) / (60 * MILLI_SEC));
+
+                                        if(type_stats.get(resourceTypeName).contains(Stats.textAirflow)){
+                                                airflow = gatherResourceAirflowStats(compResource);
+                                                airflow.setMeanValue(calculateMeanValue(airflow));
+                                                airflow.setSumValue(airflow.getMeanValue() * (endSimulationTime - startSimulationTime) / (60 * MILLI_SEC));
                                                 
                                                 EnergyExtension een = (EnergyExtension)(compResource.getExtensionList().getExtension(ExtensionType.ENERGY_EXTENSION));
                                                 if(resourceController.getComputingResources().contains(compResource)) {
-                                                        if( een != null && een.getAirFlowProfile() != null &&  een.getPowerProfile().getEnergyEstimationPlugin() != null){
-                                                                accStats.meanAirFlow.add(airFlow.getMeanValue());
+                                                        if( een != null && een.getAirflowProfile() != null &&  een.getPowerProfile().getEnergyEstimationPlugin() != null){
+                                                                accStats.meanAirflow.add(airflow.getMeanValue());
                                                         }
 
-                                                } else if( een != null && een.getAirFlowProfile() != null ){
+                                                } else if( een != null && een.getAirflowProfile() != null ){
                                                         ComputingResource parent = compResource.getParent();
                                                         een = (EnergyExtension)(parent.getExtensionList().getExtension(ExtensionType.ENERGY_EXTENSION));
                                                         boolean top = true;
                                                         while(parent != null){
-                                                                if(een != null &&  een.getAirFlowProfile() != null) {
+                                                                if(een != null &&  een.getAirflowProfile() != null) {
                                                                         top = false;
                                                                         break;
@@ -577 +575 @@
                                                         }
                                                         if(top == true){
-                                                                accStats.meanAirFlow.add(airFlow.getMeanValue());
+                                                                accStats.meanAirflow.add(airflow.getMeanValue());
                                                         }
                                                 }
-                                                if (airFlowStatsFile != null) {
-                                                        Object txt = airFlow.serialize(serializer);
-                                                        airFlowStatsFile.print(txt);
+                                                if (airflowStatsFile != null) {
+                                                        Object txt = airflow.serialize(serializer);
+                                                        airflowStatsFile.print(txt);
                                                 }
                                                 
                                                 for(Device device: compResource.getResourceCharacteristic().getDevices()){
-                                                        ResourceAirFlowStats deviceAirFlow = gatherResourceAirFlowStats(device);
-                                                        deviceAirFlow.setMeanValue(calculateMeanValue(deviceAirFlow));
-                                                        deviceAirFlow.setSumValue(deviceAirFlow.getMeanValue() * (endSimulationTime - startSimulationTime) / (60 * MILLI_SEC));
+                                                        ResourceAirflowStats deviceAirflow = gatherResourceAirflowStats(device);
+                                                        deviceAirflow.setMeanValue(calculateMeanValue(deviceAirflow));
+                                                        deviceAirflow.setSumValue(deviceAirflow.getMeanValue() * (endSimulationTime - startSimulationTime) / (60 * MILLI_SEC));
                                                         
                                                         if (deviceStatsFile != null) {
-                                                                Object txt = deviceAirFlow.serialize(serializer);
+                                                                Object txt = deviceAirflow.serialize(serializer);
                                                                 deviceStatsFile.print(txt);
                                                         }
@@ -597 +595 @@
                                                         if(ArrayUtils.contains(configuration.compResForAirflowChart, device.getType().getName())){
                                                                 if (configuration.creatediagrams_resairflow) {
-                                                                        createResourceAirFlowDiagramData(deviceAirFlow);
+                                                                        createResourceAirflowDiagramData(deviceAirflow);
                                                                 }
                                                         }
                                                 }
                                         }
-                                        if(type_stats.get(resourceTypeName).contains(Stats.chartAirFlow)){
+
+                                        if(type_stats.get(resourceTypeName).contains(Stats.chartAirflow)){
 
                                                 if (configuration.creatediagrams_resairflow) {
-                                                        createResourceAirFlowDiagramData(airFlow);
+                                                        createResourceAirflowDiagramData(airflow);
                                                 }
                                         }
-                                        
+
                                         if(type_stats.get(resourceTypeName).contains(Stats.textTemperature)){
                                                 temperature = gatherResourceTemperatureStats(compResource);
@@ -657 +656 @@
                                                 }                                               
                                         }
+
                                         if(type_stats.get(resourceTypeName).contains(Stats.chartTemperature)){
                                                 if (configuration.creatediagrams_restemperature) {
@@ -662 +662 @@
                                                 }
                                         }
-                                        
+
                                         if(type_stats.get(resourceTypeName).contains(Stats.textLoad)){
                                                 usefulWork = gatherResourceUsefulWorkStats(compResource);
@@ -670 +670 @@
                                                 }
                                         }
-                                        
-                                        
-                                        if (nodesAvailabilityStatsFile != null) {
+                                        /*if (nodesAvailabilityStatsFile != null) {
                                                 ResourceAvailabilityStats ras = new ResourceAvailabilityStats(compResource.getFullName(), compResource.getType(), "availableNodes", compResource.getChildren().size(), endSimulationTime);
                                                 Object txt = ras.serialize(serializer);
@@ -679 +677 @@
                                                 txt = ras.serialize(serializer);
                                                 nodesAvailabilityStatsFile.print(txt);
-                                        }
+                                        }*/
                                         
                                 }
@@ -708 +706 @@
                         temperatureStatsFile.close();
                 }
-                if (airFlowStatsFile != null) {
-                        airFlowStatsFile.close();
+                if (airflowStatsFile != null) {
+                        airflowStatsFile.close();
                 }
                 if (energyStatsFile != null) {
@@ -728 +726 @@
                 }
                 
-                if (nodesAvailabilityStatsFile != null) {
+                /*if (nodesAvailabilityStatsFile != null) {
                         nodesAvailabilityStatsFile.close();
-                }
+                }*/
                 
                 if (metricsStatsFile != null) {
@@ -739 +737 @@
 
         
-        private void peStatsPostProcessing(Map<String, List<ResStat>> basicResStats){
+        private void peStatsPostProcessing(Map<ComputingResource, List<ResStat>> basicResStats){
                 ResourceType resType = null;
 
-                for(String key: basicResStats.keySet()){
-                        List<ResStat> resStats = basicResStats.get(key);
+                for(ComputingResource pe: basicResStats.keySet()){
+                        List<ResStat> resStats = basicResStats.get(pe);
                         resType = resStats.get(0).getResType();
                         break;
@@ -757 +755 @@
                 }
                 for(ComputingResource resource: resources){
-                        if(!basicResStats.containsKey(resource.getFullName())){
-                                basicResStats.put(resource.getFullName(), new ArrayList<ResStat>());
-                        }
-                }
-        }
-        
-        private Map<String, List<ResStat>> gatherPEStats(ExecutablesList executables) {
-                
-                Map<String, List<ResStat>> basicResStats = new TreeMap<String, List<ResStat>>(new MapPEIdComparator());
+                        if(!basicResStats.containsKey(resource)){
+                                basicResStats.put(resource, new ArrayList<ResStat>());
+                        }
+                }
+        }
+        
+        //TO DELETE
+        /*private Map<ComputingResource, List<ResStat>> gatherPEStats(ExecutablesList executables) {
+                
+                Map<ComputingResource, List<ResStat>> basicResStats = new TreeMap<ComputingResource, List<ResStat>>(new peIdComparator());
                 for (ExecTask execTask:executables) {
                         Executable exec = (Executable) execTask;
@@ -787 +786 @@
                                         ResStat resStat = new ResStat(peName, pe.getType(), startDate, endDate, appID);
                                         
-                                        List<ResStat> resStats = basicResStats.get(peName);
+                                        List<ResStat> resStats = basicResStats.get(pe);
                                         if (resStats == null) {
                                                 resStats = new ArrayList<ResStat>();
                                                 resStats.add(resStat);
-                                                basicResStats.put(peName, resStats);
+                                                basicResStats.put(pe, resStats);
                                         } else {
                                                 resStats.add(resStat);
@@ -798 +797 @@
                                         String uniqueTaskID = getUniqueTaskId(execTask);
 
-                                        Set<ComputingResource> peNames = task_processorsMap.get(uniqueTaskID);
+                                        Set<ComputingResource> peNames = taskToPEMap.get(uniqueTaskID);
                                         if (peNames == null) {
                                                 peNames = new HashSet<ComputingResource>();
                                                 peNames.add(pe);
-                                                task_processorsMap.put(uniqueTaskID, peNames);
+                                                taskToPEMap.put(uniqueTaskID, peNames);
                                         } else {
                                                 peNames.add(pe);
@@ -827 +826 @@
                 }
                 return basicResStats;
-        }
-        
-        private Map<String, List<ResStat>> gatherPEStatsMulti(ExecutablesList executables) {
-                
-                Map<String, List<ResStat>> basicResStats = new TreeMap<String, List<ResStat>>(new MapPEIdComparator());
+        }*/
+        
+        private Map<ComputingResource, List<ResStat>> gatherPEStatsMulti(ExecutablesList executables) {
+                
+                Map<ComputingResource, List<ResStat>> basicResStats = new TreeMap<ComputingResource, List<ResStat>>(new peIdComparator());
                 for (ExecTask execTask:executables) {
                         Executable exec = (Executable) execTask;
@@ -839 +838 @@
                                 continue;
 
-                        for(int i = 0; i < resourceHistory .size(); i++){
+                        for(int i = 0; i < resourceHistory.size(); i++){
                                 ResourceItem resHistItem = resourceHistory.get(i);
                                 Map<ResourceUnitName, ResourceUnit> res = resHistItem.getResourceUnits();
@@ -875 +874 @@
                                                                 ResStat resStat = new ResStat(peName, pe.getType(), startDate, endDate, appID);
                                                                 
-                                                                List<ResStat> resStats = basicResStats.get(peName);
+                                                                List<ResStat> resStats = basicResStats.get(pe);
                                                                 if (resStats == null) {
                                                                         resStats = new ArrayList<ResStat>();
                                                                         resStats.add(resStat);
-                                                                        basicResStats.put(peName, resStats);
+                                                                        basicResStats.put(pe, resStats);
                                                                 } else {
                                                                         resStats.add(resStat);
@@ -886 +885 @@
                                                                 String uniqueTaskID = getUniqueTaskId(execTask);
 
-                                                                Set<ComputingResource> peNames = task_processorsMap.get(uniqueTaskID);
+                                                                Set<ComputingResource> peNames = taskToPEMap.get(uniqueTaskID);
                                                                 if (peNames == null) {
                                                                         peNames = new HashSet<ComputingResource>();
                                                                         peNames.add(pe);
-                                                                        task_processorsMap.put(uniqueTaskID, peNames);
+                                                                        taskToPEMap.put(uniqueTaskID, peNames);
                                                                 } else {
                                                                         peNames.add(pe);
@@ -910 +909 @@
                                                                         
                                                                 }
-                                                                
                                                         }
                                                 } 
@@ -949 +947 @@
         }
         
-        
-        private ResourceUsageStats gatherResourceOccupancyStats(ComputingResource resource, Map<String, List<ResStat>> basicStats) {
+        //TO DELETE
+        /*private ResourceUsageStats gatherResourceOccupancyStatsOld(ComputingResource resource, Map<String, List<ResStat>> basicStats) {
                 String usageType = null;
-                if(resource.getResourceCharacteristic().getParameters().get("load-sensor")!= null){
+                if(resource.getResourceCharacteristic().getParameters().get("load-sensor") != null){
                         usageType = resource.getResourceCharacteristic().getParameters().get("load-sensor").get(0).getContent();
                 }
                 ResourceUsageStats usageStats = new ResourceUsageStats(resource.getFullName(), resource.getType(), usageType);
                 int cnt = 0;
+                System.out.println("a: " + System.currentTimeMillis());
                 for(String resName: basicStats.keySet()){
 
@@ -964 +963 @@
                         }
                 }
+                System.out.println("b: " + System.currentTimeMillis());
                 for(Long key: usageStats.getHistory().keySet()){
                         Double value = usageStats.getHistory().get(key)/cnt;
@@ -971 +971 @@
                 return usageStats;
         }
-        
-        private ResourceUsageStats gatherResourceOccupancyStatsNew(ComputingResource resource, Map<String, List<ResStat>> basicStats) {
+        */
+        private ResourceUsageStats gatherResourceOccupancyStats(ComputingResource compRes, Map<ComputingResource, List<ResStat>> basicStats) {
 
                 String usageType = null;
-                if(resource.getResourceCharacteristic().getParameters().get("load-sensor")!= null){
-                        usageType = resource.getResourceCharacteristic().getParameters().get("load-sensor").get(0).getContent();
-                }
-                ResourceUsageStats usageStats = new ResourceUsageStats(resource.getFullName(), resource.getType(), usageType);
+                if(compRes.getResourceCharacteristic().getParameters().get("load-sensor")!= null){
+                        usageType = compRes.getResourceCharacteristic().getParameters().get("load-sensor").get(0).getContent();
+                }
+                ResourceUsageStats usageStats = new ResourceUsageStats(compRes.getFullName(), compRes.getType(), usageType);
                 int cnt = 0;
-                
-                ResourceType resType = null;
-
-                for(String key: basicStats.keySet()){
-                        List<ResStat> resStats = basicStats.get(key);
-                        resType = resStats.get(0).getResType();
-                        break;
-                }
-                List<ComputingResource> resources = null;
-                try {
-                        resources = new ArrayList<ComputingResource>();
-                        for(ComputingResource compRes: resourceController.getComputingResources()){
-                                resources.addAll(compRes.getDescendantsByType(resType));
-                        }
-                } catch (Exception e) {
-
-                }
-                
-                List<String> resourcesNames = new ArrayList<String>(resources.size());
-                for(ComputingResource compRes: resources){
-                        resourcesNames.add(compRes.getFullName());
-                }
-                
-                
-                for(String resName: basicStats.keySet()){
-                                if( resourcesNames.contains(resName)  || resource.getFullName().compareTo(resName) == 0){
-                                        createResourceLoadData(usageStats, basicStats.get(resName));
+
+                if(basicStats.containsKey(compRes)){
+                        createResourceLoadData(usageStats, basicStats.get(compRes));
+                        cnt++;
+                } else {
+                        for(ComputingResource pe: basicStats.keySet()){
+                                if(compRes.contains(pe)){
+                                        createResourceLoadData(usageStats, basicStats.get(pe));
                                         cnt++;
                                 }
-                }
+                        }
+                }
+
                 for(Long key: usageStats.getHistory().keySet()){
                         Double value = usageStats.getHistory().get(key)/cnt;
@@ -1022 +1005 @@
                 int usedResources = 0;
                 for(ComputingResource compResource: resource.getChildren()){
-                        double meanLoad = calculateMeanValue(gatherResourceOccupancyStats(compResource, pesStats));
+                        double meanLoad = calculateMeanValue(gatherResourceOccupancyStats(compResource, peStats));
                         if(meanLoad > 0){
                                 usedResources++;
@@ -1034 +1017 @@
                 String usageType = "usefulWork";
                 double usefulWork = 0;
-                JobRegistry jr = new JobRegistryImpl(compResource.getFullName());
+                JobRegistry jr = new JobRegistryImpl(compResource);
                 for(ExecTask task: jr.getFinishedTasks()){
                         usefulWork = usefulWork + task.getExecutionProfile().getUsefulWork();
@@ -1162 +1145 @@
         }
         
-        private ResourceAirFlowStats gatherResourceAirFlowStats(PhysicalResource resource) {
+        private ResourceAirflowStats gatherResourceAirflowStats(PhysicalResource resource) {
 
                 String usageType = null;
@@ -1168 +1151 @@
                         usageType = resource.getResourceCharacteristic().getParameters().get("airflow_volume-sensor").get(0).getContent();
                 }
-                ResourceAirFlowStats resAirFlow = new ResourceAirFlowStats(resource.getFullName(), resource.getType(), usageType);
-                Map<Long, Double> airFlow = resAirFlow.getHistory();
+                ResourceAirflowStats resAirflow = new ResourceAirflowStats(resource.getFullName(), resource.getType(), usageType);
+                Map<Long, Double> airflow = resAirflow.getHistory();
                 
                 ExtensionList extensionList = resource.getExtensionList();
@@ -1176 +1159 @@
                                 if (extension.getType() == ExtensionType.ENERGY_EXTENSION) {
                                         EnergyExtension ee = (EnergyExtension)extension;
-                                        if(ee.getAirFlowProfile() == null)
+                                        if(ee.getAirflowProfile() == null)
                                                 break;
-                                        List<AirflowValue> airFlowHistory = ee.getAirFlowProfile().getAirflowHistory();
-                                        if(airFlowHistory.size() == 0)
+                                        List<AirflowValue> airflowHistory = ee.getAirflowProfile().getAirflowHistory();
+                                        if(airflowHistory.size() == 0)
                                                 break;
                                         long endSimulationTime = DateTimeUtilsExt.currentTimeMillis();
-                                        airFlowHistory.add(new AirflowValue(endSimulationTime, ee.getAirFlowProfile().getAirflowHistory().get(ee.getAirFlowProfile().getAirflowHistory().size()-1).getValue()));
-                                        for(AirflowValue af:airFlowHistory){
-                                                airFlow.put(af.getTimestamp(), af.getValue());
+                                        airflowHistory.add(new AirflowValue(endSimulationTime, ee.getAirflowProfile().getAirflowHistory().get(ee.getAirflowProfile().getAirflowHistory().size()-1).getValue()));
+                                        for(AirflowValue af:airflowHistory){
+                                                airflow.put(af.getTimestamp(), af.getValue());
                                         }
                                 }
                         }
                 }
-                return resAirFlow;
+                return resAirflow;
         }
         
@@ -1293 +1276 @@
         }
 
-        private void createResourceAirFlowDiagramData(ResourceDynamicStats airFlowStats) {
-
-                XYDataset dataset = createResourceChartDataSet(airFlowStats,
+        private void createResourceAirflowDiagramData(ResourceDynamicStats airflowStats) {
+
+                XYDataset dataset = createResourceChartDataSet(airflowStats,
                                 startSimulationTime, endSimulationTime);
                 
-                List<XYDataset> airFlowDiagramData = resourceAirFlowDiagrams.get(airFlowStats.getResourceType().getName());
-                if(airFlowDiagramData == null){
-                        airFlowDiagramData = new ArrayList<XYDataset>();
-                        airFlowDiagramData.add(dataset);
-                        resourceAirFlowDiagrams.put(airFlowStats.getResourceType().getName(), airFlowDiagramData);
+                List<XYDataset> airflowDiagramData = resourceAirflowDiagrams.get(airflowStats.getResourceType().getName());
+                if(airflowDiagramData == null){
+                        airflowDiagramData = new ArrayList<XYDataset>();
+                        airflowDiagramData.add(dataset);
+                        resourceAirflowDiagrams.put(airflowStats.getResourceType().getName(), airflowDiagramData);
                 } else {
-                        airFlowDiagramData.add(dataset);
+                        airflowDiagramData.add(dataset);
                 }
         }
@@ -1399 +1382 @@
                 chartName = "Air flow diagram for "
                         + DataCenterWorkloadSimulator.SIMULATOR_NAME;
-                JFreeChart resourceAirFlowDiagram = null;
+                JFreeChart resourceAirflowDiagram = null;
                 if (configuration.creatediagrams_resairflow) {
                         String axisName = "AIR FLOW [m^3/min]";
-                        for(String resType: resourceAirFlowDiagrams.keySet()){
-                                resourceAirFlowDiagram = getResourceDynamicDiagram(resourceAirFlowDiagrams.get(resType), simulationTime, chartName,
+                        for(String resType: resourceAirflowDiagrams.keySet()){
+                                resourceAirflowDiagram = getResourceDynamicDiagram(resourceAirflowDiagrams.get(resType), simulationTime, chartName,
                                                 subtitle, axisName);
-                                if (!saveXYPlotChart(resourceAirFlowDiagram, fileName + "Airflow_" + resType))
+                                if (!saveXYPlotChart(resourceAirflowDiagram, fileName + "Airflow_" + resType))
                                         return false;
                         }
@@ -1524 +1507 @@
         }
         
-        private void createPEGanttDiagram(Map<String,List<ResStat>> basicResStats) {
-                peGanttMap = new HashMap<String, TimetableEventSource>();
-                taskGanttMap = new HashMap<String, TimetableEventGroup>();
-                for(String peName: basicResStats.keySet()){
-                        TimetableEventSource pe = new TimetableEventSource(peName);
-                        ganttDiagramTimetable.addEventSource(pe);
-                        peGanttMap.put(peName, pe);
-                        for(ResStat resStat: basicResStats.get(peName)){
-
-                                pe = peGanttMap.get(resStat.getPeName());
-                                if(pe == null){
+        private void createGanttDiagram(Map<ComputingResource, List<ResStat>> basicResStats) {
+                Map<String, TimetableEventSource> peGanttMap = new HashMap<String, TimetableEventSource>();
+                Map<String, TimetableEventGroup> taskGanttMap = new HashMap<String, TimetableEventGroup>();
+                for(ComputingResource pe: basicResStats.keySet()){
+                        TimetableEventSource peES = new TimetableEventSource(pe.getFullName());
+                        ganttDiagramTimetable.addEventSource(peES);
+                        peGanttMap.put(pe.getFullName(), peES);
+                        for(ResStat resStat: basicResStats.get(pe)){
+
+                                peES = peGanttMap.get(resStat.getPeName());
+                                if(peES == null){
                                         //pe = new TimetableEventSource(resStat.getPeName());
                                 //      ganttDiagramPeTimetable.addEventSource(pe);
                                 //      peGanttMap.put(resStat.getPeName(), pe);
                                 }
-                                TimetableEventGroup task = taskGanttMap.get(resStat.getTaskID());
+                                TimetableEventGroup taskEG = taskGanttMap.get(resStat.getTaskID());
                                 long startDate = resStat.getStartDate();
                                 long endDate = resStat.getEndDate();
-                                if (task == null) {
-                                        task = new TimetableEventGroup(resStat.getTaskID());
-                                        taskGanttMap.put(resStat.getTaskID(), task);
-                                        ganttDiagramTimetable.addEventGroup(task);
+                                if (taskEG == null) {
+                                        taskEG = new TimetableEventGroup(resStat.getTaskID());
+                                        taskGanttMap.put(resStat.getTaskID(), taskEG);
+                                        ganttDiagramTimetable.addEventGroup(taskEG);
                                 }
-                                ganttDiagramTimetable.addEvent(pe, task,
+                                ganttDiagramTimetable.addEvent(peES, taskEG,
                                                 new FixedMillisecond(startDate), new FixedMillisecond(endDate));
                         }
@@ -1556 +1539 @@
         //TO DO
         private void createAccumulatedResourceSimulationStatistic() {
+                Map<ComputingResource, Double> basicResLoad = calculatePELoad(peStats);
 
                 List<ComputingResource> resources = resourceController.getComputingResources();
@@ -1575 +1559 @@
         }
 
-        private Map<String, Double> calculatePELoad(Map<String, List<ResStat>> basicResStats){
-                Map<String, Double> peLoad = new HashMap<String, Double>();
-                for(String resName: basicResStats.keySet()){
-                        List<ResStat> resStats = basicResStats.get(resName);
+        private Map<ComputingResource, Double> calculatePELoad(Map<ComputingResource, List<ResStat>> basicResStats){
+                Map<ComputingResource, Double> peLoad = new HashMap<ComputingResource, Double>();
+                for(ComputingResource compRes: basicResStats.keySet()){
+                        List<ResStat> resStats = basicResStats.get(compRes);
                         double sum = 0;
                         for(ResStat resStat:resStats){
@@ -1584 +1568 @@
                         }
                         double load = sum / (endSimulationTime - startSimulationTime);
-                        peLoad.put(resName, load);
+                        peLoad.put(compRes, load);
                 }
                 return peLoad;
         }
         
-        private  Double calculateResourceLoad(ComputingResource resource, Map<String, Double> peLoad ){
+        private  Double calculateResourceLoad(ComputingResource compRes, Map<ComputingResource, Double> peLoad ){
                 int peCnt = 0;
                 double sum = 0;
-                for(String resName: peLoad.keySet()){
-
-                        if(resource.getDescendantByName(resName) != null || resource.getFullName().compareTo(resName) == 0){
-                                Double load = peLoad.get(resName);
+                for(ComputingResource pe: peLoad.keySet()){
+
+                        if(compRes.contains(pe)){
+                                Double load = peLoad.get(pe);
                                 sum += load;
                                 peCnt++;
@@ -1674 +1658 @@
                         Job job = (Job) jobs.get(i);
 
-                        List<ExecTask> execList = jr.getTasks().getExecutables(job.getId());
+                        List<ExecTask> execList = jobRegistry.getTasks().getExecutables(job.getId());
                         List<TaskStats> taskStatsList = new ArrayList<TaskStats>();
 
-                        this.serializer.setFieldSeparator(TASK_SEPARATOR);
+                        this.serializer.setFieldSeparator(SEPARATOR);
 
                         for (int j = 0; j < execList.size(); j++) {
@@ -1706 +1690 @@
                         if (configuration.createjobsstatistics && taskStatsList.size() > 0) {
 
-                                this.serializer.setFieldSeparator(JOB_SEPARATOR);
+                                this.serializer.setFieldSeparator(SEPARATOR);
                                 JobStats jobStats = createJobStats(taskStatsList);
                                 if (jobStatsFile != null) {
@@ -1756 +1740 @@
                 TaskStats taskStats = new TaskStats(task, startSimulationTime);
                 String uniqueTaskID = getUniqueTaskId(task);
-                taskStats.setProcessors(task_processorsMap.get(uniqueTaskID));
+                taskStats.setProcessors(taskToPEMap.get(uniqueTaskID));
                 return taskStats;
         }
@@ -2016 +2000 @@
         }
         
-        private static class MapPEIdComparator implements Comparator<String> {
-
-                public int compare(String o1, String o2)  {
+        private static class peIdComparator implements Comparator<ComputingResource> {
+
+                public int compare(ComputingResource o1, ComputingResource o2)  {
                         Integer o1int = 0;
                         Integer o2int = 0;
-                        String o1string;
+                        String o1string = null;
                         String o2string = null;
-
-                        if(o1.contains("_")){
-                                o1string = o1.substring(0, o1.lastIndexOf("_"));
-                                o1int = Integer.parseInt(o1.substring(o1.lastIndexOf("_")+1));
-                        } else {
-                                o1string = o1;
-                        }
-                        
-                        if(o2.contains("_")){
-                                o2string = o2.substring(0, o2.lastIndexOf("_"));
-                                o2int = Integer.parseInt(o2.substring(o2.lastIndexOf("_")+1));
-                        }else {
-                                o2string = o2;
-                        }
+                        try {
+                                if(o1.getFullName().contains("_")){
+                                        o1string = o1.getFullName().substring(0, o1.getFullName().lastIndexOf("_"));
+                                        o1int = Integer.parseInt(o1.getFullName().substring(o1.getFullName().lastIndexOf("_") + 1));
+                                } else {
+                                        o1string = o1.getFullName();
+                                }
+                                
+                                if(o2.getFullName().contains("_")){
+                                        o2string = o2.getFullName().substring(0, o2.getFullName().lastIndexOf("_"));
+                                        o2int = Integer.parseInt(o2.getFullName().substring(o2.getFullName().lastIndexOf("_") + 1));
+                                }else {
+                                        o2string = o2.getFullName();
+                                }
+                        } catch (Exception e) {
+                                o1int = 0;
+                                o2int = 0;
+                                o1string = o1.getFullName();
+                                o2string = o2.getFullName();
+                        }
+
 
                         if(o1int.compareTo(o2int) != 0)
@@ -2077 +2068 @@
 
         public ResStat(String peName, long startDate, long endDate, String taskID) {
-                super();
                 this.startDate = startDate;
                 this.endDate = endDate;
@@ -2090 +2080 @@
         }
         public ResStat(String peName, ResourceType resType, long startDate, long endDate, String taskID) {
-                super();
                 this.peName = peName;
                 this.resType = resType;
@@ -2116 +2105 @@
         textEnergy,
         chartEnergy,
-        textAirFlow,
-        chartAirFlow,
+        textAirflow,
+        chartAirflow,
         textTemperature,
         chartTemperature,