Changeset 1299 for DCWoRMS/branches/coolemall/src/simulator/stats/implementation

Timestamp:

03/19/14 18:22:27 (11 years ago)

Author:

wojtekp

Message:

 

File:

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

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

@@ -62 +62 @@
 import schedframe.resources.UserResourceType;
 import schedframe.resources.computing.ComputingResource;
+import schedframe.resources.computing.Processor;
 import schedframe.resources.computing.extensions.Extension;
 import schedframe.resources.computing.extensions.ExtensionList;
 import schedframe.resources.computing.extensions.ExtensionType;
 import schedframe.resources.computing.profiles.energy.EnergyExtension;
+import schedframe.resources.computing.profiles.energy.MeasurementHistory;
 import schedframe.resources.computing.profiles.energy.airthroughput.AirFlowValue;
 import schedframe.resources.computing.profiles.energy.power.PowerUsage;
 import schedframe.resources.computing.profiles.energy.thermal.TemperatureValue;
+import schedframe.resources.computing.profiles.load.LoadExtension;
 import schedframe.resources.devices.Device;
 import schedframe.resources.devices.PhysicalResource;
@@ -85 +88 @@
 import simulator.DataCenterWorkloadSimulator;
 import simulator.GenericUser;
+import simulator.stats.CoolEmAllMetricsCalculator;
+import simulator.stats.DCwormsMetricsCalculator;
 import simulator.stats.GSSAccumulator;
 import simulator.stats.MetricsCalculator;
 import simulator.stats.SimulationStatistics;
-import simulator.stats.implementation.out.AbstractStringSerializer;
 import simulator.stats.implementation.out.CoolEmAllStringSerializer;
 import simulator.stats.implementation.out.StringSerializer;
@@ -110 +114 @@
         protected static final int MILLI_SEC = 1000;
 
-        protected static final String RAW_TASKS_STATISTICS_OUTPUT_FILE_NAME = "Tasks.txt";
+        protected static final String TASKS_STATISTICS_OUTPUT_FILE_NAME = "Tasks.txt";
         protected static final String JOBS_STATISTICS_OUTPUT_FILE_NAME = "Jobs.txt";
 
         protected static final String SIMULATION_STATISTICS_OUTPUT_FILE_NAME = "Simulation.txt";
+        protected static final String RESOURCEOCCUPANCY_STATISTICS_OUTPUT_FILE_NAME = "ResourceOccupancy.txt";
         protected static final String RESOURCEUTILIZATION_STATISTICS_OUTPUT_FILE_NAME = "ResourceUtilization.txt";
         protected static final String ENERGYUSAGE_STATISTICS_OUTPUT_FILE_NAME = "EnergyUsage.txt";
@@ -141 +146 @@
         protected SimulatedEnvironment resourceController;
         protected boolean generateDiagrams = true;
-        protected AbstractStringSerializer serializer;
+        protected StringSerializer serializer;
         protected long startSimulationTime;
         protected long endSimulationTime;
         
         //RESOURCES
-        protected Map<String, List<ResStat>> basicResStats;
+        protected Map<String, List<ResStat>> pesStats;
         protected Map<String, Double> basicResLoad;
         
@@ -156 +161 @@
         protected Map<String, List<XYDataset>> resourceAirFlowDiagrams;
         protected Map<String, List<XYDataset>> resourceTemperatureDiagrams;
-        protected Map<String, List<XYDataset>> resourceLoadDiagrams;
+        protected Map<String, List<XYDataset>> resourceOccupancyDiagrams;
+        protected Map<String, List<XYDataset>> resourceUtilizationDiagrams;
         
         //TASKS
@@ -178 +184 @@
 
                 this.outputFolderName = outputFolderName;
-
-                this.serializer = new StringSerializer();
-                
-                if(DataCenterWorkloadSimulator.MODE.equals("CoolEmAll")){
-                        this.serializer = new CoolEmAllStringSerializer();      
-                }
-                this.serializer.setDefaultNumberFormat(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT);
-
                 this.resourceController = resourceController;
                 this.jr = new JobRegistryImpl("");
-                init();
-                metCalc = new MetricsCalculator();
-        }
-
-        public void generateStatistics() {
-
+                
                 if(users.isSimStartTimeDefined())
                         this.startSimulationTime = DateTimeUtilsExt.getOffsetTime().getTimeInMillis();
                 else
                         this.startSimulationTime = new DateTime(users.getSubmissionStartTime() * 1000l).getMillis();
+                
                 this.endSimulationTime = DateTimeUtilsExt.currentTimeMillis();
 
-                metCalc.setStartTime(startSimulationTime);
-                metCalc.setEndTime(endSimulationTime);
+                init();
+        }
+
+        public void generateStatistics() {
                 
                 long s = 0;
@@ -234 +230 @@
                 accStats = new GSSAccumulatorsStats();
                 statsData = new HashMap<String, GSSAccumulator>();
+                
+                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);
         }
 
@@ -262 +267 @@
                         System.out.println("#STATS " + "===== Performance statistics =====");
                         System.out.println("#STATS " + "Makespan: " + df.format(accStats.makespan.getMean()) + " [s]");
-                        System.out.println("#STATS " + "Task completion time - " + "min: " + df.format(accStats.meanTaskCompletionTime.getMin()) + " [s]" + "; max: " + df.format(accStats.meanTaskCompletionTime.getMax()) + " [s]");
+                        System.out.println("#STATS " + "Task completion time - " + "min: " + df.format(accStats.meanTaskCompletionTime.getMin()) + " [s]" + "; max: " + df.format(accStats.meanTaskCompletionTime.getMax()) + " [s]" + "; mean: " + df.format(accStats.meanTaskCompletionTime.getMean()) + " [s]");
                         System.out.println("#STATS " + "Mean task execution time: " + df.format(accStats.meanTaskExecutionTime.getMean()) + " [s]");
+                        System.out.println("#STATS " + "System occupancy: " + df.format(accStats.meanTotalOccupancy.getMean() * 100) + " [%]");
                         System.out.println("#STATS " + "System load: " + df.format(accStats.meanTotalLoad.getMean() * 100) + " [%]");
+                        
                         
                         simulationStatsFile.println(txt);
@@ -300 +307 @@
                 taskGanttMap = new HashMap<String, TimetableEventGroup>();              
                 
-                resourceLoadDiagrams = new HashMap<String, List<XYDataset>>();
+                resourceOccupancyDiagrams = new HashMap<String, List<XYDataset>>();
+                resourceUtilizationDiagrams = new HashMap<String, List<XYDataset>>();
                 resourcePowerUsageDiagrams = new HashMap<String, List<XYDataset>>();
                 resourceAirFlowDiagrams = new HashMap<String, List<XYDataset>>();
@@ -309 +317 @@
                 
                 
-                PrintStream resourceLoadStatsFile = null;
+                PrintStream resourceOccupancyStatsFile = null;
+                try {
+                        File file = new File(outputFolderName + STATS_FILE_NAME_PREFIX
+                                        + simulationIdentifier + "_"
+                                        + RESOURCEOCCUPANCY_STATISTICS_OUTPUT_FILE_NAME);
+                        resourceOccupancyStatsFile = new PrintStream(new FileOutputStream(file));
+                } catch (IOException e) {
+                        resourceOccupancyStatsFile = null;
+                }
+                
+                PrintStream resourceUtilizationStatsFile = null;
                 try {
                         File file = new File(outputFolderName + STATS_FILE_NAME_PREFIX
                                         + simulationIdentifier + "_"
                                         + RESOURCEUTILIZATION_STATISTICS_OUTPUT_FILE_NAME);
-                        resourceLoadStatsFile = new PrintStream(new FileOutputStream(file));
+                        resourceUtilizationStatsFile = new PrintStream(new FileOutputStream(file));
                 } catch (IOException e) {
-                        resourceLoadStatsFile = null;
+                        resourceUtilizationStatsFile = null;
                 }
                 
@@ -389 +407 @@
                 }
                 
-                basicResStats = gatherPEStats(jr.getTasks());
-                peStatsPostProcessing(basicResStats);
-                basicResLoad = calculatePELoad( basicResStats);
+                pesStats = gatherPEStats(jr.getTasks());
+                peStatsPostProcessing(pesStats);
+                basicResLoad = calculatePELoad(pesStats);
 
                 if (configuration.creatediagrams_gantt) {
-                        createPEGanttDiagram(basicResStats);
+                        createPEGanttDiagram(pesStats);
                 }
                 
@@ -412 +430 @@
                                 
                                 for(ComputingResource compResource: compResources){
-                                        ResourceUsageStats resourceUsage = null;
+                                        ResourceUsageStats resourceUtilization = null;                                  
+                                        ResourceUsageStats resourceOccupancy = null;
                                         ResourcePowerStats energyUsage = null;
                                         ResourceAirFlowStats airFlow = null;
@@ -418 +437 @@
                                         ResourceUsefulWorkStats usefulWork = null;
                                         if(type_stats.get(resourceTypeName).contains(Stats.textLoad)){
-                                                resourceUsage = gatherResourceLoadStats(compResource, basicResStats);
-                                                resourceUsage.setMeanValue(calculateMeanValue(resourceUsage));
-                                                if (resourceLoadStatsFile != null) {
-                                                        Object txt = resourceUsage.serialize(serializer);
-                                                        resourceLoadStatsFile.print(txt);
+                                                resourceOccupancy = gatherResourceOccupancyStats(compResource, pesStats);
+                                                resourceOccupancy.setMeanValue(calculateMeanValue(resourceOccupancy));
+                                                if (resourceOccupancyStatsFile != null) {
+                                                        Object txt = resourceOccupancy.serialize(serializer);
+                                                        resourceOccupancyStatsFile.print(txt);
                                                 }
-
+                                                
+                                                resourceUtilization = gatherResourceUtlizationStats(compResource);
+                                                resourceUtilization.setMeanValue(calculateMeanValue(resourceUtilization));
+                                                if (resourceUtilizationStatsFile != null) {
+                                                        Object txt = resourceUtilization.serialize(serializer);
+                                                        resourceUtilizationStatsFile.print(txt);
+                                                }
                                         }
                                         if(type_stats.get(resourceTypeName).contains(Stats.chartLoad)){
                                                 if (configuration.creatediagrams_resutilization) {
-                                                        createResourceLoadDiagram(resourceUsage);
+                                                        createResourceOccupancyDiagram(resourceOccupancy);
+                                                        createResourceUtilizationDiagram(resourceUtilization);
                                                 }
                                         }
@@ -437 +463 @@
                                                 resourceEnergyAccumulator.add(energyUsage.getSumValue());
                                                 maxResourceEnergyAccumulator.add(calculateMaxValue(energyUsage));
-                                                double calulcationsEnergy = 0;
+                                                double calculationsEnergy = 0;
                                                 try {
-                                                        /*boolean doCalc = false;
-                                                        double prevTimestamp = 0;
-                                                        for(Long key: resourceUsage.getHistory().keySet()){
-                                                                if(doCalc){
-                                                                        System.out.println(energyUsage.getHistory().get(key));
-                                                                        calulcationsEnergy = calulcationsEnergy + energyUsage.getHistory().get(prevTimestamp) * (key - prevTimestamp) /(3600 * MILLI_SEC);
-                                                                        doCalc  = false;
-                                                                }
-                                                                if(resourceUsage.getHistory().get(key)>0){
-                                                                        prevTimestamp = key;
-                                                                        doCalc = true;
-                                                                }
-                                                        }*/
                                                         boolean doCalc = false;
+                                                        double load = 0;
                                                         long prevTimestamp = 0;
                                                         for(Long key: energyUsage.getHistory().keySet()){
                                                                 if(doCalc){
-                                                                        double load = 0;
-                                                                        if(resourceUsage.getHistory().get(prevTimestamp)!= null){
-                                                                                load = resourceUsage.getHistory().get(prevTimestamp);
+                                                                        if(resourceTypeName.equals("Rack")){
+                                                                                calculationsEnergy = calculationsEnergy + CoolEmAllTestbedMeasurements.OTHER_DEVICES_POWER_CONSUMPTION * (key - prevTimestamp) /(3600.0 * MILLI_SEC);
+                                                                        }/* else if(resourceTypeName.equals("Processor")){
+                                                                                Processor proc =( Processor) compResource;
+                                                                                double maxPower = proc.getPowerInterface().getLowestPState().getLoadPowerUsage().get(100.0);
+                                                                                calculationsEnergy = calculationsEnergy + load * maxPower * (key - prevTimestamp) /(3600.0 * MILLI_SEC);
+                                                                        }*/
+                                                                        else 
+                                                                                calculationsEnergy = calculationsEnergy + load * energyUsage.getHistory().get(prevTimestamp) * (key - prevTimestamp) /(3600.0 * MILLI_SEC);
+                                                                        doCalc = false;
+                                                                        load = 0;
+                                                                }
+                                                                
+                                                                if(resourceUtilization.getHistory().get(key) != null){
+                                                                        load = resourceUtilization.getHistory().get(key);
+                                                                        if(load > 0 ){
+                                                                                doCalc = true;
+                                                                                prevTimestamp = key;
                                                                         }
-                                                                        calulcationsEnergy = calulcationsEnergy + load * energyUsage.getHistory().get(prevTimestamp) * (key - prevTimestamp) /(3600.0 * MILLI_SEC);
-                                                                        doCalc = false;
-                                                                }
-                                                                if(energyUsage.getHistory().get(key) > compResource.getPowerInterface().getSupportedPowerStates().get(0).getPowerUsage() - CoolEmAllTestbedMeasurements.SINGLE_FAN_ON_POWER_CONSUMPTION){
-                                                                        
-                                                                        prevTimestamp = key;
-                                                                        doCalc = true;
                                                                 }
                                                         }
-                                                        //calulcationsEnergy = energyUsage.getSumValue() - 
-                                                        //      ((1 - resourceUsage.getMeanValue()) * (endSimulationTime - startSimulationTime) / (3600 * MILLI_SEC)) * 
-                                                        //      (compResource.getPowerInterface().getSupportedPowerStates().get(0).getPowerUsage() - CoolEmAllTestbedMeasurements.SINGLE_FAN_ON_POWER_CONSUMPTION);
-                                                        //System.out.println(compResource.getFullName() + ";" + resourceUsage.getMeanValue() +":"+ calulcationsEnergy  + ":" + energyUsage.getSumValue());
-                                                        calculationsEnergyAccumulator.add(calulcationsEnergy);
+
+                                                        calculationsEnergyAccumulator.add(calculationsEnergy);
                                                 } catch (Exception e) {
                                                         e.printStackTrace();
@@ -510 +529 @@
                                                         devAccumulator.add(deviceEnergyUsage.getSumValue());
                                                         metCalc.addMetricsData(device.getType().getName(), devAccumulator);
+                                                        metCalc.addMetricsData(device.getFullName(), devAccumulator);
                                                         if (deviceStatsFile != null) {
                                                                 Object txt = deviceEnergyUsage.serialize(serializer);
@@ -666 +686 @@
                         //log.info("#STATS " + "Metrics");
                         System.out.println("#STATS " + "===== Metrics =====");
-                        for(MetricsStats metric: metCalc.calulateMetrics(endSimulationTime)){
+                        for(MetricsStats metric: metCalc.calulateMetrics()){
                                 Object txt = metric.serialize(serializer);
                                 //log.info("#STATS " +  metric.getResourceName() + " " + metric.getMetricName() + ": " + metric.getValue());
@@ -676 +696 @@
                         }
                 }
-                saveResourceUsageDiagrams();
+                saveResourceDiagrams();
                 createAccumulatedResourceSimulationStatistic();
                 
@@ -688 +708 @@
                         energyStatsFile.close();
                 }
-                if (resourceLoadStatsFile != null) {
-                        resourceLoadStatsFile.close();
+                if (resourceOccupancyStatsFile != null) {
+                        resourceOccupancyStatsFile.close();
+                }
+                if (resourceUtilizationStatsFile != null) {
+                        resourceUtilizationStatsFile.close();
                 }
                 
@@ -813 +836 @@
         
         
-        private ResourceUsageStats gatherResourceLoadStats(ComputingResource resource, Map<String, List<ResStat>> basicStats) {
+        private ResourceUsageStats gatherResourceOccupancyStats(ComputingResource resource, Map<String, List<ResStat>> basicStats) {
                 String usageType = null;
                 if(resource.getResourceCharacteristic().getParameters().get("load-sensor")!= null){
@@ -844 +867 @@
                 int usedResources = 0;
                 for(ComputingResource compResource: resource.getChildren()){
-                        double meanLoad = calculateMeanValue(gatherResourceLoadStats(compResource, basicResStats));
+                        double meanLoad = calculateMeanValue(gatherResourceOccupancyStats(compResource, pesStats));
                         if(meanLoad > 0){
                                 usedResources++;
@@ -916 +939 @@
         }
         
+        private ResourceUsageStats gatherResourceUtlizationStats(PhysicalResource resource) {
+                
+                String usageType = null;
+                if(resource.getResourceCharacteristic().getParameters().get("load-sensor")!= null){
+                        usageType = resource.getResourceCharacteristic().getParameters().get("load-sensor").get(0).getContent();
+                }
+                ResourceUsageStats resUtlization = new ResourceUsageStats(resource.getFullName(), resource.getType(), usageType);
+                Map<Long, Double> usage = resUtlization.getHistory();
+                
+                ExtensionList extensionList = resource.getExtensionList();
+                if(extensionList != null){
+                        for (Extension extension : extensionList) {
+                                if (extension.getType() == ExtensionType.LOAD_EXTENSION) {
+                                        LoadExtension le = (LoadExtension)extension;
+                                        if(le.getLoadProfile() == null)
+                                                break;
+                                        List<MeasurementHistory> loadHistory = le.getLoadProfile().getUtilizationHistory();
+                                        if(loadHistory.size() == 0)
+                                                break;
+                                        long endSimulationTime = DateTimeUtilsExt.currentTimeMillis();
+
+                                        loadHistory.add(new MeasurementHistory(endSimulationTime, le.getLoadProfile().getUtilizationHistory().get(le.getLoadProfile().getUtilizationHistory().size() - 1).getValue()/100));
+                                        for(MeasurementHistory l:loadHistory){
+                                                usage.put(l.getTimestamp(), l.getValue()/100);
+                                        }
+                                }
+                        }
+                }
+                return resUtlization;
+        }
         
         private ResourcePowerStats gatherResourcePowerConsumptionStats(PhysicalResource resource) {
@@ -921 +974 @@
                 
                 String usageType = null;
-                if(resource.getResourceCharacteristic().getParameters().get("power-sensor")!= null){
+                if(resource.getResourceCharacteristic().getParameters().get("power-sensor") != null){
                         usageType = resource.getResourceCharacteristic().getParameters().get("power-sensor").get(0).getContent();
                 }
@@ -954 +1007 @@
         }
         
-        
         private ResourceAirFlowStats gatherResourceAirFlowStats(PhysicalResource resource) {
 
                 String usageType = null;
-                if(resource.getResourceCharacteristic().getParameters().get("airflow_volume-sensor")!= null){
+                if(resource.getResourceCharacteristic().getParameters().get("airflow_volume-sensor") != null){
                         usageType = resource.getResourceCharacteristic().getParameters().get("airflow_volume-sensor").get(0).getContent();
                 }
@@ -1016 +1068 @@
         }
         
-        private void createResourceLoadDiagram(ResourceUsageStats resLoadStats) {
+        private void createResourceOccupancyDiagram(ResourceUsageStats resLoadStats) {
 
                 for(Long key: resLoadStats.getHistory().keySet()){
@@ -1026 +1078 @@
                                 startSimulationTime, endSimulationTime);
 
-                List<XYDataset> loadDiagram = resourceLoadDiagrams.get(resLoadStats.getResourceType().getName());
-                if(loadDiagram == null){
-                        loadDiagram = new ArrayList<XYDataset>();
-                        loadDiagram.add(dataset);
-                        resourceLoadDiagrams.put(resLoadStats.getResourceType().getName(), loadDiagram);
+                List<XYDataset> occupancyDiagram = resourceOccupancyDiagrams.get(resLoadStats.getResourceType().getName());
+                if(occupancyDiagram == null){
+                        occupancyDiagram = new ArrayList<XYDataset>();
+                        occupancyDiagram.add(dataset);
+                        resourceOccupancyDiagrams.put(resLoadStats.getResourceType().getName(), occupancyDiagram);
                 } else {
-                        loadDiagram.add(dataset);
+                        occupancyDiagram.add(dataset);
+                }
+        }
+        
+        private void createResourceUtilizationDiagram(ResourceUsageStats resLoadStats) {
+
+                for(Long key: resLoadStats.getHistory().keySet()){
+                        Double value = resLoadStats.getHistory().get(key) * 100;
+                        resLoadStats.getHistory().put(key, value);
+                }
+                
+                XYDataset dataset = createResourceChartDataSet(resLoadStats,
+                                startSimulationTime, endSimulationTime);
+
+                List<XYDataset> utilizationDiagram = resourceUtilizationDiagrams.get(resLoadStats.getResourceType().getName());
+                if(utilizationDiagram == null){
+                        utilizationDiagram = new ArrayList<XYDataset>();
+                        utilizationDiagram.add(dataset);
+                        resourceUtilizationDiagrams.put(resLoadStats.getResourceType().getName(), utilizationDiagram);
+                } else {
+                        utilizationDiagram.add(dataset);
                 }
         }
@@ -1109 +1181 @@
         }
 
-        private boolean saveResourceUsageDiagrams() {
+        private boolean saveResourceDiagrams() {
 
                 if (!generateDiagrams)
@@ -1133 +1205 @@
                 chartName = "Load diagram for "
                         + DataCenterWorkloadSimulator.SIMULATOR_NAME;
-                JFreeChart resourceLoadDiagram = null;
+                JFreeChart resourceOccupancyDiagram = null;
+                if (configuration.creatediagrams_resutilization) {
+                        String axisName = "OCCUPANCY [%]";
+                        for(String resType: resourceOccupancyDiagrams.keySet()){
+                                resourceOccupancyDiagram = getResourceDynamicDiagram(resourceOccupancyDiagrams.get(resType), simulationTime, chartName,
+                                                subtitle, axisName);
+                                if (!saveXYPlotChart(resourceOccupancyDiagram, fileName + "ResourcesOccupancy_" + resType))
+                                        return false;
+                        }
+                }
+                
+                chartName = "Utilization diagram for "
+                        + DataCenterWorkloadSimulator.SIMULATOR_NAME;
+                JFreeChart resourceUtilizationDiagram = null;
                 if (configuration.creatediagrams_resutilization) {
                         String axisName = "UTILIZATION [%]";
-                        for(String resType: resourceLoadDiagrams.keySet()){
-                                resourceLoadDiagram = getResourceDynamicDiagram(resourceLoadDiagrams.get(resType), simulationTime, chartName,
+                        for(String resType: resourceUtilizationDiagrams.keySet()){
+                                resourceUtilizationDiagram = getResourceDynamicDiagram(resourceUtilizationDiagrams.get(resType), simulationTime, chartName,
                                                 subtitle, axisName);
-                                if (!saveXYPlotChart(resourceLoadDiagram, fileName + "ResourcesLoad_" + resType))
+                                if (!saveXYPlotChart(resourceUtilizationDiagram, fileName + "ResourcesUtilization_" + resType))
                                         return false;
                         }
@@ -1322 +1407 @@
                                 //double load = calculateMeanValue(resourceUsage);
                                 double load = calculateResourceLoad(compRes, basicResLoad);
-                                accStats.meanTotalLoad.add(load);
+                                accStats.meanTotalOccupancy.add(load);
+
+                                ResourceUsageStats resourceUtilization = gatherResourceUtlizationStats(compRes);
+                                accStats.meanTotalLoad.add(calculateMeanValue(resourceUtilization));
                                 /*ResourceEnergyStats energyUsage = gatherResourceEnergyStats(compRes);
                                 energyUsage.setMeanUsage(calculateEnergyLoad(energyUsage));
@@ -1365 +1453 @@
 
         
-        private double calculateMeanValue(ResourceDynamicStats resDynamicStats ){
+        private double calculateMeanValue(ResourceDynamicStats resDynamicStats){
                 double meanValue = 0;
                 long time = -1;
@@ -1387 +1475 @@
         
         
-        private double calculateMaxValue(ResourceDynamicStats resDynamicStats ){
+        private double calculateMaxValue(ResourceDynamicStats resDynamicStats){
                 double maxValue = 0;
 
@@ -1414 +1502 @@
                 try {
                         File file = new File(outputFolderName + STATS_FILE_NAME_PREFIX + simulationIdentifier + "_"
-                                        + RAW_TASKS_STATISTICS_OUTPUT_FILE_NAME);
+                                        + TASKS_STATISTICS_OUTPUT_FILE_NAME);
                         taskStatsFile = new PrintStream(new FileOutputStream(file));
                 } catch (IOException e) {
@@ -1634 +1722 @@
                 chartName = "Task waiting times diagram for " + DataCenterWorkloadSimulator.SIMULATOR_NAME;
                 if (configuration.creatediagrams_taskswaitingtime) {
-                        waitingTimeDiagram = getWaitingTimeDiagram(chartName, subtitle, simulationTime);
+                        waitingTimeDiagram = getTaskWaitingTimeDiagram(chartName, subtitle, simulationTime);
                         if (!saveCategoryChart(waitingTimeDiagram, fileName + "Waiting_Time", null /* "Task {1} at {0}" */))
                                 return false;
@@ -1655 +1743 @@
         }
 
-        private JFreeChart getWaitingTimeDiagram(String chartName, Title subtitle, String simulationTime) {
+        private JFreeChart getTaskWaitingTimeDiagram(String chartName, Title subtitle, String simulationTime) {
                 String tasks = "Tasks";
                 boolean urls = false;
@@ -1878 +1966 @@
         textTemperature,
         chartTemperature,
-        textUsefulWorl;
+        textUsefulWork;
 }