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

Timestamp:

06/03/14 15:12:11 (11 years ago)

Author:

wojtekp

Message:

 

File:

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

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

@@ -16 +16 @@
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
@@ -78 +79 @@
 import schedframe.resources.units.ResourceUnitName;
 import schedframe.resources.units.StandardResourceUnitName;
+import schedframe.scheduling.ExecutionHistoryItem;
 import schedframe.scheduling.ResourceHistoryItem;
 import schedframe.scheduling.Scheduler;
@@ -104 +106 @@
 import eduni.simjava.Sim_stat;
 import example.energy.coolemall.CoolEmAllTestbedMeasurements;
+import gridsim.dcworms.DCWormsTags;
 
 public class DCWormsStatistics implements SimulationStatistics {
@@ -407 +410 @@
                 }
                 
-                pesStats = gatherPEStats(jr.getTasks());
+                pesStats = gatherPEStatsMulti(jr.getTasks());
                 peStatsPostProcessing(pesStats);
                 basicResLoad = calculatePELoad(pesStats);
@@ -763 +766 @@
                         Executable exec = (Executable) execTask;
 
-                        List<ResourceHistoryItem> resHistItemList = exec.getUsedResources();
-                        if(resHistItemList.size() == 0)
+
+                        LinkedList<ResourceHistoryItem> resourceHistory = exec.getAllocatedResources();
+                        if(resourceHistory.size() == 0)
                                 continue;
-                        Map<ResourceUnitName, ResourceUnit> res = resHistItemList.get(resHistItemList.size() - 1).getResourceUnits();
+                        Map<ResourceUnitName, ResourceUnit> res = exec.getAllocatedResources().getLast().getResourceUnits();
                         ResourceUnit resUnit = res.get(StandardResourceUnitName.PE);
                         //ProcessingElements pes = (ProcessingElements) resUnit ;
@@ -820 +824 @@
                 }
                 return basicResStats;
+        }
+        
+        private Map<String, List<ResStat>> gatherPEStatsMulti(ExecutablesList executables) {
+                
+                Map<String, List<ResStat>> basicResStats = new TreeMap<String, List<ResStat>>(new MapPEIdComparator());
+                for (ExecTask execTask:executables) {
+                        Executable exec = (Executable) execTask;
+
+                        LinkedList<ResourceHistoryItem> resourceHistory = exec.getAllocatedResources();
+                        if(resourceHistory.size() == 0)
+                                continue;
+
+                        for(int i = 0; i < resourceHistory .size(); i++){
+                                ResourceHistoryItem resHistItem = resourceHistory.get(i);
+                                Map<ResourceUnitName, ResourceUnit> res = resHistItem.getResourceUnits();
+                                ResourceUnit resUnit = res.get(StandardResourceUnitName.PE);
+                                //ProcessingElements pes = (ProcessingElements) resUnit ;
+                                LinkedList<ExecutionHistoryItem> execHistory = exec.getExecHistory();
+                                long st = -1, et;
+                                for(int j = 0; j < execHistory .size(); j++){
+                                        ExecutionHistoryItem execHistItem = execHistory.get(j);
+                                        if(execHistItem.getStatus() == DCWormsTags.PAUSED || execHistItem.getResIndex() != i){
+                                                continue;
+                                        }
+                                        if(st == -1){
+                                                st = execHistItem.getTimeStamp().getMillis();
+                                        }
+                                                
+                                        if(j < execHistory.size() - 1 && (execHistory.get(j + 1).getResIndex() != execHistItem.getResIndex() || execHistory.get(j + 1).getStatus() == DCWormsTags.PAUSED) || j + 1 == execHistory.size()){
+                                                if(j < execHistory.size() -1 && (execHistory.get(j + 1).getResIndex() != execHistItem.getResIndex() || execHistory.get(j + 1).getStatus() == DCWormsTags.PAUSED))
+                                                        et = execHistory.get(j + 1).getTimeStamp().getMillis(); 
+                                                else et = Double.valueOf(exec.getFinishTime()).longValue() * MILLI_SEC; 
+                                                if(resUnit instanceof ProcessingElements){
+                                                        ProcessingElements pes = (ProcessingElements) resUnit;
+                                                        for(ComputingResource pe: pes){
+                                                                String peName = pe.getFullName();
+                                                                long startDate = st;
+                                                                long endDate;
+                                                                if(i == resourceHistory.size() - 1){
+                                                                        endDate = Double.valueOf(exec.getFinishTime()).longValue() * MILLI_SEC;
+                                                                }else {
+                                                                        endDate = et;
+                                                                }
+
+                                                                String appID = getAppId(execTask);
+                                                                
+                                                                ResStat resStat = new ResStat(peName, pe.getType(), startDate, endDate, appID);
+                                                                
+                                                                List<ResStat> resStats = basicResStats.get(peName);
+                                                                if (resStats == null) {
+                                                                        resStats = new ArrayList<ResStat>();
+                                                                        resStats.add(resStat);
+                                                                        basicResStats.put(peName, resStats);
+                                                                } else {
+                                                                        resStats.add(resStat);
+                                                                }
+                                                                
+                                                                String uniqueTaskID = getUniqueTaskId(execTask);
+
+                                                                Set<ComputingResource> peNames = task_processorsMap.get(uniqueTaskID);
+                                                                if (peNames == null) {
+                                                                        peNames = new HashSet<ComputingResource>();
+                                                                        peNames.add(pe);
+                                                                        task_processorsMap.put(uniqueTaskID, peNames);
+                                                                } else {
+                                                                        peNames.add(pe);
+                                                                }
+
+                                                                try{
+                                                                        double usefulWork = execTask.getResourceConsumptionProfile().getUsefulWork()/pes.size();
+                                                                        usefulWork = ((et - st) / (1000 * getExecutionTime(execTask))) * usefulWork;
+                                                                        GSSAccumulator uwAcc;
+                                                                        if(metCalc.getMetricsData().containsKey("UW_" + pe.getFullName())){
+                                                                                uwAcc = metCalc.getMetricsData().get("UW_" + pe.getFullName()).get(0);
+                                                                                uwAcc.add(usefulWork);
+                                                                        } else {
+                                                                                uwAcc = new GSSAccumulator();
+                                                                                uwAcc.add(usefulWork);
+                                                                                metCalc.addMetricsData("UW_" + pe.getFullName(), uwAcc);
+                                                                        }
+                                                                }  catch (Exception e){
+                                                                        
+                                                                }
+                                                                
+                                                        }
+                                                } 
+                                                st = -1;
+                                        }
+                                }
+                        }
+                }
+                return basicResStats;
+        }
+        
+        private double getExecutionTime(ExecTask execTask) {
+                double executionTime = 0;
+                long previousTimestamp = 0;
+                int previousStatus = DCWormsTags.CREATED;
+                for(ExecutionHistoryItem execHistItem: execTask.getExecHistory()){
+                        if(previousStatus == DCWormsTags.INEXEC){
+                                executionTime = executionTime  + (execHistItem.getTimeStamp().getMillis()/1000 - previousTimestamp);
+                        } 
+                        previousTimestamp  = execHistItem.getTimeStamp().getMillis()/1000;
+                        previousStatus = execHistItem.getStatus();
+                }
+                return executionTime;
+                //return task.getFinishTime() - task.getExecStartTime();
         }