Ignore:
Timestamp:
06/26/14 14:18:01 (11 years ago)
Author:
wojtekp
Message:
 
Location:
DCWoRMS/branches/coolemall/src/simulator
Files:
16 edited
1 moved

Legend:

Unmodified
Added
Removed

  • DCWoRMS/branches/coolemall/src/simulator/ConfigurationOptions.java

    r1299 r1396  
    187187         
    188188        public String [] resForEnergyChart; 
    189         public String [] resForAirFlowChart; 
     189        public String [] resForAirflowChart; 
    190190        public String [] resForTemperatureChart; 
    191191        public String [] resForUtilizationChart; 
    … …  
    195195        public double inletRoomAirTempeature; 
    196196        public double ambientAirTempeature; 
    197         public double airFlowVolume; 
     197        public double airflowVolume; 
    198198        public double alpha; 
    199199         
    … …  
    334334                 
    335335                try { 
    336                         co.resForAirFlowChart = bundle.getString(CREATEDIAGRAMS_AIRFLOW).split(";"); 
    337                         if(co.resForAirFlowChart.length > 0){ 
     336                        co.resForAirflowChart = bundle.getString(CREATEDIAGRAMS_AIRFLOW).split(";"); 
     337                        if(co.resForAirflowChart.length > 0){ 
    338338                                co.creatediagrams_resairflow = true; 
    339339                        } 
    … …  
    416416                 
    417417                try { 
    418                         co.airFlowVolume = Double.valueOf(bundle.getString(AIR_FLOW_VOLUME)).doubleValue(); 
    419                 } catch(MissingResourceException e){ 
    420                         co.airFlowVolume = -1; 
     418                        co.airflowVolume = Double.valueOf(bundle.getString(AIR_FLOW_VOLUME)).doubleValue(); 
     419                } catch(MissingResourceException e){ 
     420                        co.airflowVolume = -1; 
    421421                } 
    422422                 
    … …  
    427427                } 
    428428                 
    429                 ConfigurationOptions.coolingData = new CoolingModelData(co.pressureDrop, co.outletRoomAirTempeature, co.inletRoomAirTempeature, co.ambientAirTempeature, co.airFlowVolume, co.alpha); 
     429                ConfigurationOptions.coolingData = new CoolingModelData(co.pressureDrop, co.outletRoomAirTempeature, co.inletRoomAirTempeature, co.ambientAirTempeature, co.airflowVolume, co.alpha); 
    430430                return co; 
    431431        } 

  • DCWoRMS/branches/coolemall/src/simulator/reader/ResourceReader.java

    r1374 r1396  
    2626import schedframe.Parameters; 
    2727import schedframe.SimulatedEnvironment; 
    28 import schedframe.exceptions.ResourceException; 
    2928import schedframe.resources.CoolEmAllResourceFactory; 
    3029import schedframe.resources.Resource; 

  • DCWoRMS/branches/coolemall/src/simulator/stats/AbstractMetricsCalculator.java

    r1299 r1396  
    1313        protected static final double SEC_IN_HOUR = 3600; 
    1414         
    15         protected Map<String, List<GSSAccumulator>> metricsData = new HashMap<String, List<GSSAccumulator>>(); 
     15        protected Map<String, List<DCwormsAccumulator>> metricsData = new HashMap<String, List<DCwormsAccumulator>>(); 
    1616 
    1717        protected long startTime; 
    … …  
    2828        abstract public List<MetricsStats> calulateMetrics(); 
    2929         
    30         public void addMetricsData(String resourceTypeName, GSSAccumulator resourceEnergyAccumulator){ 
    31                 List<GSSAccumulator> resourceEnergyAccumulatorList = metricsData.get(resourceTypeName); 
     30        public void addMetricsData(String resourceTypeName, DCwormsAccumulator resourceEnergyAccumulator){ 
     31                List<DCwormsAccumulator> resourceEnergyAccumulatorList = metricsData.get(resourceTypeName); 
    3232                if(resourceEnergyAccumulatorList == null){ 
    33                         resourceEnergyAccumulatorList = new ArrayList<GSSAccumulator>(); 
     33                        resourceEnergyAccumulatorList = new ArrayList<DCwormsAccumulator>(); 
    3434                } 
    3535                resourceEnergyAccumulatorList.add(resourceEnergyAccumulator); 
    … …  
    3737        } 
    3838         
    39         public Map<String, List<GSSAccumulator>> getMetricsData(){ 
     39        public Map<String, List<DCwormsAccumulator>> getMetricsData(){ 
    4040                return metricsData; 
    4141        } 

  • DCWoRMS/branches/coolemall/src/simulator/stats/AccumulatedStatistics.java

    r481 r1396  
    1010import java.util.List; 
    1111 
    12 import simulator.stats.implementation.DCWormsStatistics; 
    1312import gridsim.Accumulator; 
    1413 
    … …  
    5049                } 
    5150                 
    52                 GSSAccumulator resourceLoad = getAccumulatedResourceLoad(); 
    53                 GSSAccumulator reservationLoad = getAccumulatedReservationLoad(); 
    54                 GSSAccumulator makespan = getAccumulatedMakespan(); 
    55                 GSSAccumulator taskExecutionTime = getAccumulatedJobExecutionTime(); 
    56                 GSSAccumulator taskQueueLength = getAccumulatedQueueJobCount(); 
    57                 GSSAccumulator taskCompletionTime = getAccumulatedCompletionTime(); 
    58                 GSSAccumulator taskWaitingTime = getAccumulatedWaitingTime(); 
    59                 GSSAccumulator taskFlowTime = getAccumulatedJobFlowTime(); 
    60                 GSSAccumulator taskLateness = getAccumulatedLateness(); 
    61                 GSSAccumulator delayedTasks = getAccumulatedDelayedTasks(); 
    62                 GSSAccumulator taskTardiness = getAccumulatedTardiness(); 
    63                 GSSAccumulator failedRequests = getAccumulatedFailedRequests(); 
     51                DCwormsAccumulator resourceLoad = getAccumulatedResourceLoad(); 
     52                DCwormsAccumulator reservationLoad = getAccumulatedReservationLoad(); 
     53                DCwormsAccumulator makespan = getAccumulatedMakespan(); 
     54                DCwormsAccumulator taskExecutionTime = getAccumulatedJobExecutionTime(); 
     55                DCwormsAccumulator taskQueueLength = getAccumulatedQueueJobCount(); 
     56                DCwormsAccumulator taskCompletionTime = getAccumulatedCompletionTime(); 
     57                DCwormsAccumulator taskWaitingTime = getAccumulatedWaitingTime(); 
     58                DCwormsAccumulator taskFlowTime = getAccumulatedJobFlowTime(); 
     59                DCwormsAccumulator taskLateness = getAccumulatedLateness(); 
     60                DCwormsAccumulator delayedTasks = getAccumulatedDelayedTasks(); 
     61                DCwormsAccumulator taskTardiness = getAccumulatedTardiness(); 
     62                DCwormsAccumulator failedRequests = getAccumulatedFailedRequests(); 
    6463                 
    6564                out.print("Delayed tasks (accumulated)"); 
    … …  
    9190        } 
    9291 
    93         public GSSAccumulator getAccumulatedResourceLoad() { 
    94                 GSSAccumulator resourceMeanLoad = new GSSAccumulator();  
    95                 for (SimulationStatistics simStat : simulations) { 
    96                         GSSAccumulator simulationResTotalLoad = simStat.getStats(SimulationStatistics.RESOURCES_TOTAL_LOAD);  
     92        public DCwormsAccumulator getAccumulatedResourceLoad() { 
     93                DCwormsAccumulator resourceMeanLoad = new DCwormsAccumulator();  
     94                for (SimulationStatistics simStat : simulations) { 
     95                        DCwormsAccumulator simulationResTotalLoad = simStat.getStats(SimulationStatistics.RESOURCES_TOTAL_LOAD);  
    9796                        resourceMeanLoad.add(simulationResTotalLoad.getMean()); 
    9897                } 
    … …  
    10099        } 
    101100 
    102         public GSSAccumulator getAccumulatedReservationLoad(){ 
    103                 GSSAccumulator reservationMean = new GSSAccumulator(); 
     101        public DCwormsAccumulator getAccumulatedReservationLoad(){ 
     102                DCwormsAccumulator reservationMean = new DCwormsAccumulator(); 
    104103                for (SimulationStatistics simStat : simulations) { 
    105104                        Accumulator simulationResvTotalLoad = simStat.getStats(SimulationStatistics.RESOURCES_RESERVATION_LOAD); 
    … …  
    119118        }*/ 
    120119 
    121         public GSSAccumulator getAccumulatedJobFlowTime() { 
    122                 GSSAccumulator meanJobFlowTime = new GSSAccumulator(); 
     120        public DCwormsAccumulator getAccumulatedJobFlowTime() { 
     121                DCwormsAccumulator meanJobFlowTime = new DCwormsAccumulator(); 
    123122                for (SimulationStatistics simStat : simulations) { 
    124123                        Accumulator simulationJobFlowTime = simStat.getStats(SimulationStatistics.TASK_FLOW_TIME); 
    … …  
    128127        } 
    129128 
    130         public GSSAccumulator getAccumulatedLateness() { 
    131                 GSSAccumulator meanLateness = new GSSAccumulator(); 
     129        public DCwormsAccumulator getAccumulatedLateness() { 
     130                DCwormsAccumulator meanLateness = new DCwormsAccumulator(); 
    132131                for (SimulationStatistics simStat : simulations) { 
    133132                        Accumulator simulationLateness = simStat.getStats(SimulationStatistics.TASK_LATENESS); 
    … …  
    137136        } 
    138137 
    139         public GSSAccumulator getAccumulatedFailedRequests() { 
    140                 GSSAccumulator meanFailedRequests = new GSSAccumulator(); 
     138        public DCwormsAccumulator getAccumulatedFailedRequests() { 
     139                DCwormsAccumulator meanFailedRequests = new DCwormsAccumulator(); 
    141140                for (SimulationStatistics simStat : simulations) { 
    142141                        Accumulator simulationFailedRequestes = simStat.getStats(SimulationStatistics.FAILED_REQUESTS); 
    … …  
    146145        } 
    147146 
    148         public GSSAccumulator getAccumulatedTardiness() { 
    149                 GSSAccumulator meanTardiness = new GSSAccumulator(); 
     147        public DCwormsAccumulator getAccumulatedTardiness() { 
     148                DCwormsAccumulator meanTardiness = new DCwormsAccumulator(); 
    150149                for (SimulationStatistics simStat : simulations) { 
    151150                        Accumulator simulationJobTardiness = simStat.getStats(SimulationStatistics.TASK_TARDINESS); 
    … …  
    155154        } 
    156155 
    157         public GSSAccumulator getAccumulatedDelayedTasks() { 
    158                 GSSAccumulator delayedTasks = new GSSAccumulator(); 
     156        public DCwormsAccumulator getAccumulatedDelayedTasks() { 
     157                DCwormsAccumulator delayedTasks = new DCwormsAccumulator(); 
    159158                for (SimulationStatistics simStat : simulations) { 
    160159                        Accumulator simulationDelayedTasks = simStat.getStats(SimulationStatistics.DELAYED_TASKS); 
    … …  
    164163        } 
    165164 
    166         public GSSAccumulator getAccumulatedCompletionTime() { 
    167                 GSSAccumulator meanJobCompletionTime = new GSSAccumulator(); 
     165        public DCwormsAccumulator getAccumulatedCompletionTime() { 
     166                DCwormsAccumulator meanJobCompletionTime = new DCwormsAccumulator(); 
    168167                 
    169168                for (SimulationStatistics simStat : simulations) { 
    … …  
    174173        } 
    175174 
    176         public GSSAccumulator getAccumulatedMakespan() { 
    177                 GSSAccumulator meanMakespan = new GSSAccumulator(); 
     175        public DCwormsAccumulator getAccumulatedMakespan() { 
     176                DCwormsAccumulator meanMakespan = new DCwormsAccumulator(); 
    178177                for (SimulationStatistics simStat : simulations) { 
    179178                        meanMakespan.add(simStat.getStats(SimulationStatistics.MAKESPAN).getMean()); 
    … …  
    182181        } 
    183182 
    184         public GSSAccumulator getAccumulatedWaitingTime() { 
    185                 GSSAccumulator meanWaitingTime = new GSSAccumulator(); 
     183        public DCwormsAccumulator getAccumulatedWaitingTime() { 
     184                DCwormsAccumulator meanWaitingTime = new DCwormsAccumulator(); 
    186185                for (SimulationStatistics simStat : simulations) 
    187186                        meanWaitingTime.add(simStat.getStats(SimulationStatistics.TASK_WAITING_TIME).getMean()); 
    … …  
    189188        } 
    190189 
    191         public GSSAccumulator getAccumulatedJobExecutionTime() { 
    192                 GSSAccumulator meanJobExecutionTime = new GSSAccumulator(); 
     190        public DCwormsAccumulator getAccumulatedJobExecutionTime() { 
     191                DCwormsAccumulator meanJobExecutionTime = new DCwormsAccumulator(); 
    193192                for (SimulationStatistics simStat : simulations) 
    194193                        meanJobExecutionTime.add(simStat.getStats(SimulationStatistics.TASK_EXECUTION_TIME).getMean()); 
    … …  
    196195        } 
    197196 
    198         public GSSAccumulator getAccumulatedQueueJobCount() { 
    199                 GSSAccumulator meanQueuJobCount = new GSSAccumulator(); 
     197        public DCwormsAccumulator getAccumulatedQueueJobCount() { 
     198                DCwormsAccumulator meanQueuJobCount = new DCwormsAccumulator(); 
    200199                for (SimulationStatistics simStat : simulations) 
    201200                        meanQueuJobCount.add(simStat.getStats(SimulationStatistics.RESOURCES_QUEUE_LENGTH).getMean()); 

  • DCWoRMS/branches/coolemall/src/simulator/stats/CoolEmAllMetricsCalculator.java

    r1331 r1396  
    5151                         
    5252                        double roomPower = 0; 
    53                         for(GSSAccumulator acc: metricsData.get("Room")){ 
     53                        for(DCwormsAccumulator acc: metricsData.get("Room")){ 
    5454                                roomPower = roomPower + acc.getSum(); 
    5555                        } 
    … …  
    6666                try{ 
    6767                        double itComputingPower = 0; 
    68                         for(GSSAccumulator acc: metricsData.get("Processor")){ 
     68                        for(DCwormsAccumulator acc: metricsData.get("Processor")){ 
    6969                                itComputingPower = itComputingPower + acc.getSum(); 
    7070                        } 
    … …  
    8181                try{ 
    8282                        double totalSitePower = 0;  
    83                         for(GSSAccumulator acc: metricsData.get("Rack")){ 
     83                        for(DCwormsAccumulator acc: metricsData.get("Rack")){ 
    8484                                totalSitePower = totalSitePower + acc.getSum(); 
    8585                        } 
    8686                        double nodeComputingPower = 0; 
    87                         for(GSSAccumulator acc: metricsData.get("Node")){ 
     87                        for(DCwormsAccumulator acc: metricsData.get("Node")){ 
    8888                                nodeComputingPower = nodeComputingPower+ acc.getSum(); 
    8989                        } 
    9090                        double itComputingPower = 0; 
    91                         for(GSSAccumulator acc: metricsData.get("Processor")){ 
     91                        for(DCwormsAccumulator acc: metricsData.get("Processor")){ 
    9292                                itComputingPower = itComputingPower + acc.getSum(); 
    9393                        } 
    … …  
    105105                try{ 
    106106                        double nodeComputingPower = 0; 
    107                         for(GSSAccumulator acc: metricsData.get("Node")){ 
     107                        for(DCwormsAccumulator acc: metricsData.get("Node")){ 
    108108                                nodeComputingPower = nodeComputingPower+ acc.getSum(); 
    109109                        } 
    110110                        double itComputingPower = 0; 
    111                         for(GSSAccumulator acc: metricsData.get("Processor")){ 
     111                        for(DCwormsAccumulator acc: metricsData.get("Processor")){ 
    112112                                itComputingPower = itComputingPower + acc.getSum(); 
    113113                        } 
    … …  
    126126                         
    127127                        double roomPower = 0; 
    128                         for(GSSAccumulator acc: metricsData.get("Room")){ 
     128                        for(DCwormsAccumulator acc: metricsData.get("Room")){ 
    129129                                roomPower = roomPower + acc.getSum(); 
    130130                        } 
    131131                         
    132132                        double totalSitePower = 0; 
    133                         for(GSSAccumulator acc: metricsData.get("Rack")){ 
     133                        for(DCwormsAccumulator acc: metricsData.get("Rack")){ 
    134134                                totalSitePower = totalSitePower + acc.getSum(); 
    135135                        } 
    … …  
    137137                 
    138138                        double nodeComputingPower = 0; 
    139                         for(GSSAccumulator acc: metricsData.get("Node")){ 
     139                        for(DCwormsAccumulator acc: metricsData.get("Node")){ 
    140140                                nodeComputingPower = nodeComputingPower+ acc.getSum(); 
    141141                        } 
    142142                        double itComputingPower = 0; 
    143                         for(GSSAccumulator acc: metricsData.get("Processor")){ 
     143                        for(DCwormsAccumulator acc: metricsData.get("Processor")){ 
    144144                                itComputingPower = itComputingPower + acc.getSum(); 
    145145                        } 
    … …  
    159159                         
    160160                        double roomPower = 0; 
    161                         for(GSSAccumulator acc: metricsData.get("Room")){ 
     161                        for(DCwormsAccumulator acc: metricsData.get("Room")){ 
    162162                                roomPower = roomPower + acc.getSum(); 
    163163                        } 
    164164                         
    165165                        double totalSitePower = 0; 
    166                         for(GSSAccumulator acc: metricsData.get("Rack")){ 
     166                        for(DCwormsAccumulator acc: metricsData.get("Rack")){ 
    167167                                totalSitePower = totalSitePower + acc.getSum(); 
    168168                        } 
    … …  
    183183                        for(String key: metricsData.keySet()){ 
    184184                                if(key.contains("UW_")){ 
    185                                         for(GSSAccumulator acc: metricsData.get(key)){ 
     185                                        for(DCwormsAccumulator acc: metricsData.get(key)){ 
    186186                                                usefulWork= usefulWork + acc.getSum(); 
    187187                                        } 
    … …  
    203203                        for(String key: metricsData.keySet()){ 
    204204                                if(key.contains("/")){ 
    205                                         for(GSSAccumulator acc: metricsData.get(key)){ 
     205                                        for(DCwormsAccumulator acc: metricsData.get(key)){ 
    206206                                                usefulWork= usefulWork + acc.getSum(); 
    207207                                        } 
    … …  
    209209                        } 
    210210                        double totalSitePower = 0;  
    211                         for(GSSAccumulator acc: metricsData.get("Rack")){ 
     211                        for(DCwormsAccumulator acc: metricsData.get("Rack")){ 
    212212                                totalSitePower = totalSitePower + acc.getSum(); 
    213213                        } 
    … …  
    228228                        double maxPower = 0; 
    229229                         
    230                         for(GSSAccumulator acc: metricsData.get("Rack_MAX")){ 
     230                        for(DCwormsAccumulator acc: metricsData.get("Rack_MAX")){ 
    231231                                maxPower = maxPower + acc.getSum(); 
    232232                        } 
    … …  
    246246                        double maxPower = 0; 
    247247                         
    248                         for(GSSAccumulator acc: metricsData.get("Room_MAX")){ 
     248                        for(DCwormsAccumulator acc: metricsData.get("Room_MAX")){ 
    249249                                maxPower = maxPower + acc.getSum(); 
    250250                        } 
    … …  
    263263                try{ 
    264264                        double inletsPower = 0; 
    265                         for(GSSAccumulator acc: metricsData.get("Inlet")){ 
     265                        for(DCwormsAccumulator acc: metricsData.get("Inlet")){ 
    266266                                inletsPower = inletsPower + acc.getSum(); 
    267267                        } 
    268268                         
    269269                        double outletsPower = 0; 
    270                         for(GSSAccumulator acc: metricsData.get("Outlet")){ 
     270                        for(DCwormsAccumulator acc: metricsData.get("Outlet")){ 
    271271                                outletsPower = outletsPower + acc.getSum(); 
    272272                        } 
    273273                         
    274274                        double nodeComputingPower = 0; 
    275                         for(GSSAccumulator acc: metricsData.get("Node")){ 
     275                        for(DCwormsAccumulator acc: metricsData.get("Node")){ 
    276276                                nodeComputingPower = nodeComputingPower+ acc.getSum(); 
    277277                        } 
    278278                        double itComputingPower = 0; 
    279                         for(GSSAccumulator acc: metricsData.get("Processor")){ 
     279                        for(DCwormsAccumulator acc: metricsData.get("Processor")){ 
    280280                                itComputingPower = itComputingPower + acc.getSum(); 
    281281                        } 
    … …  
    294294                try{ 
    295295                        double roomPower = 0; 
    296                         for(GSSAccumulator acc: metricsData.get("Rack")){ 
     296                        for(DCwormsAccumulator acc: metricsData.get("Rack")){ 
    297297                                roomPower = roomPower + acc.getSum(); 
    298298                        } 
    … …  
    309309                try{ 
    310310                        double coolingDevicePower = 0; 
    311                         for(GSSAccumulator acc: metricsData.get("CoolingDevice")){ 
     311                        for(DCwormsAccumulator acc: metricsData.get("CoolingDevice")){ 
    312312                                coolingDevicePower = coolingDevicePower + acc.getSum(); 
    313313                        } 
    … …  
    327327                        for(String key: metricsData.keySet()){ 
    328328                                if(key.contains("FlowPump")){ 
    329                                         for(GSSAccumulator acc: metricsData.get(key)){ 
     329                                        for(DCwormsAccumulator acc: metricsData.get(key)){ 
    330330                                                flowPump = flowPump + acc.getSum(); 
    331331                                        } 
    … …  
    346346                try{ 
    347347                        double roomPower = 0; 
    348                         for(GSSAccumulator acc: metricsData.get("Room")){ 
     348                        for(DCwormsAccumulator acc: metricsData.get("Room")){ 
    349349                                roomPower = roomPower + acc.getSum(); 
    350350                        } 
    351351                         
    352352                        double totalSitePower = 0; 
    353                         for(GSSAccumulator acc: metricsData.get("Rack")){ 
     353                        for(DCwormsAccumulator acc: metricsData.get("Rack")){ 
    354354                                totalSitePower = totalSitePower + acc.getSum(); 
    355355                        } 
    356356                         
    357357                        double coolingDevicePower = 0; 
    358                         for(GSSAccumulator acc: metricsData.get("CoolingDevice")){ 
     358                        for(DCwormsAccumulator acc: metricsData.get("CoolingDevice")){ 
    359359                                coolingDevicePower = coolingDevicePower + acc.getSum(); 
    360360                        } 
    361361                         
    362362                        double inletsPower = 0; 
    363                         for(GSSAccumulator acc: metricsData.get("Inlet")){ 
     363                        for(DCwormsAccumulator acc: metricsData.get("Inlet")){ 
    364364                                inletsPower = inletsPower + acc.getSum(); 
    365365                        } 
    366366                         
    367367                        double outletsPower = 0; 
    368                         for(GSSAccumulator acc: metricsData.get("Outlet")){ 
     368                        for(DCwormsAccumulator acc: metricsData.get("Outlet")){ 
    369369                                outletsPower = outletsPower + acc.getSum(); 
    370370                        } 
    371371                         
    372372                        double nodeComputingPower = 0; 
    373                         for(GSSAccumulator acc: metricsData.get("Node")){ 
     373                        for(DCwormsAccumulator acc: metricsData.get("Node")){ 
    374374                                nodeComputingPower = nodeComputingPower+ acc.getSum(); 
    375375                        } 
    376376                        double itComputingPower = 0; 
    377                         for(GSSAccumulator acc: metricsData.get("Processor")){ 
     377                        for(DCwormsAccumulator acc: metricsData.get("Processor")){ 
    378378                                itComputingPower = itComputingPower + acc.getSum(); 
    379379                        } 
    … …  
    394394                         
    395395                        double roomPower = 0; 
    396                         for(GSSAccumulator acc: metricsData.get("Room")){ 
     396                        for(DCwormsAccumulator acc: metricsData.get("Room")){ 
    397397                                roomPower = roomPower + acc.getSum(); 
    398398                        } 
    … …  
    411411                         
    412412                        double roomPower = 0; 
    413                         for(GSSAccumulator acc: metricsData.get("Rack")){ 
     413                        for(DCwormsAccumulator acc: metricsData.get("Rack")){ 
    414414                                roomPower = roomPower + acc.getSum(); 
    415415                        } 
    … …  
    427427                        double itComputingEnergy = 0; 
    428428                         
    429                         for(GSSAccumulator acc: metricsData.get("Processor_CALC")){ 
     429                        for(DCwormsAccumulator acc: metricsData.get("Processor_CALC")){ 
    430430                                itComputingEnergy = itComputingEnergy + acc.getSum(); 
    431431                        } 

  • DCWoRMS/branches/coolemall/src/simulator/stats/DCwormsAccumulator.java

    r477 r1396  
    44package simulator.stats; 
    55 
    6 import java.io.PrintStream; 
    76 
    87import simulator.DataCenterWorkloadSimulator; 
    … …  
    1514 *  
    1615 */ 
    17 public class GSSAccumulator extends Accumulator { 
     16public class DCwormsAccumulator extends Accumulator { 
    1817 
    19         public GSSAccumulator() { 
     18        public DCwormsAccumulator() { 
    2019                super(); 
    2120        } 
    2221 
    23         public GSSAccumulator(Accumulator acc) { 
     22        public DCwormsAccumulator(Accumulator acc) { 
    2423                n_ = acc.getCount(); 
    2524                mean_ = acc.getMean(); 
    … …  
    4948 
    5049        public boolean equals(Object obj) { 
    51                 if (!(obj instanceof GSSAccumulator)) 
     50                if (!(obj instanceof DCwormsAccumulator)) 
    5251                        return false; 
    5352 
    54                 GSSAccumulator otherAcc = (GSSAccumulator) obj; 
     53                DCwormsAccumulator otherAcc = (DCwormsAccumulator) obj; 
    5554                if (Double.compare(this.last_, otherAcc.last_) != 0) 
    5655                        return false; 

  • DCWoRMS/branches/coolemall/src/simulator/stats/DCwormsMetricsCalculator.java

    r1377 r1396  
    55 
    66import simulator.stats.implementation.MetricsStats; 
    7 import example.energy.coolemall.CoolEmAllTestbedMeasurements; 
    87 
    98public class DCwormsMetricsCalculator extends AbstractMetricsCalculator{ 
    … …  
    4544                         
    4645                        double roomPower = 0; 
    47                         for(GSSAccumulator acc: metricsData.get("Room")){ 
     46                        for(DCwormsAccumulator acc: metricsData.get("Room")){ 
    4847                                roomPower = roomPower + acc.getSum(); 
    4948                        } 
    … …  
    6160                try{ 
    6261                        double itComputingPower = 0; 
    63                         for(GSSAccumulator acc: metricsData.get("Processor")){ 
     62                        for(DCwormsAccumulator acc: metricsData.get("Processor")){ 
    6463                                itComputingPower = itComputingPower + acc.getSum(); 
    6564                        } 
    … …  
    7675                try{ 
    7776                        double totalSitePower = 0;  
    78                         for(GSSAccumulator acc: metricsData.get("Rack")){ 
     77                        for(DCwormsAccumulator acc: metricsData.get("Rack")){ 
    7978                                totalSitePower = totalSitePower + acc.getSum(); 
    8079                        } 
    8180                        double nodeComputingPower = 0; 
    82                         for(GSSAccumulator acc: metricsData.get("Node")){ 
     81                        for(DCwormsAccumulator acc: metricsData.get("Node")){ 
    8382                                nodeComputingPower = nodeComputingPower+ acc.getSum(); 
    8483                        } 
    8584                        double itComputingPower = 0; 
    86                         for(GSSAccumulator acc: metricsData.get("Processor")){ 
     85                        for(DCwormsAccumulator acc: metricsData.get("Processor")){ 
    8786                                itComputingPower = itComputingPower + acc.getSum(); 
    8887                        } 
    … …  
    101100                         
    102101                        double roomPower = 0; 
    103                         for(GSSAccumulator acc: metricsData.get("Room")){ 
     102                        for(DCwormsAccumulator acc: metricsData.get("Room")){ 
    104103                                roomPower = roomPower + acc.getSum(); 
    105104                        } 
    106105                         
    107106                        double totalSitePower = 0; 
    108                         for(GSSAccumulator acc: metricsData.get("Rack")){ 
     107                        for(DCwormsAccumulator acc: metricsData.get("Rack")){ 
    109108                                totalSitePower = totalSitePower + acc.getSum(); 
    110109                        } 
    … …  
    112111                 
    113112                        double nodeComputingPower = 0; 
    114                         for(GSSAccumulator acc: metricsData.get("Node")){ 
     113                        for(DCwormsAccumulator acc: metricsData.get("Node")){ 
    115114                                nodeComputingPower = nodeComputingPower+ acc.getSum(); 
    116115                        } 
    117116                        double itComputingPower = 0; 
    118                         for(GSSAccumulator acc: metricsData.get("Processor")){ 
     117                        for(DCwormsAccumulator acc: metricsData.get("Processor")){ 
    119118                                itComputingPower = itComputingPower + acc.getSum(); 
    120119                        } 
    … …  
    134133                         
    135134                        double roomPower = 0; 
    136                         for(GSSAccumulator acc: metricsData.get("Room")){ 
     135                        for(DCwormsAccumulator acc: metricsData.get("Room")){ 
    137136                                roomPower = roomPower + acc.getSum(); 
    138137                        } 
    139138                         
    140139                        double totalSitePower = 0; 
    141                         for(GSSAccumulator acc: metricsData.get("Rack")){ 
     140                        for(DCwormsAccumulator acc: metricsData.get("Rack")){ 
    142141                                totalSitePower = totalSitePower + acc.getSum(); 
    143142                        } 
    … …  
    158157                        for(String key: metricsData.keySet()){ 
    159158                                if(key.contains("/")){ 
    160                                         for(GSSAccumulator acc: metricsData.get(key)){ 
     159                                        for(DCwormsAccumulator acc: metricsData.get(key)){ 
    161160                                                usefulWork= usefulWork + acc.getSum(); 
    162161                                        } 
    … …  
    178177                        for(String key: metricsData.keySet()){ 
    179178                                if(key.contains("/")){ 
    180                                         for(GSSAccumulator acc: metricsData.get(key)){ 
     179                                        for(DCwormsAccumulator acc: metricsData.get(key)){ 
    181180                                                usefulWork= usefulWork + acc.getSum(); 
    182181                                        } 
    … …  
    184183                        } 
    185184                        double totalSitePower = 0;  
    186                         for(GSSAccumulator acc: metricsData.get("Rack")){ 
     185                        for(DCwormsAccumulator acc: metricsData.get("Rack")){ 
    187186                                totalSitePower = totalSitePower + acc.getSum(); 
    188187                        } 
    … …  
    204203                        double maxPower = 0; 
    205204                         
    206                         for(GSSAccumulator acc: metricsData.get("Room_MAX")){ 
     205                        for(DCwormsAccumulator acc: metricsData.get("Room_MAX")){ 
    207206                                maxPower = maxPower + acc.getSum(); 
    208207                        } 
    … …  
    221220                try{ 
    222221                        double coolingDevicePower = 0; 
    223                         for(GSSAccumulator acc: metricsData.get("CoolingDevice")){ 
     222                        for(DCwormsAccumulator acc: metricsData.get("CoolingDevice")){ 
    224223                                coolingDevicePower = coolingDevicePower + acc.getSum(); 
    225224                        } 
    … …  
    237236                         
    238237                        double roomPower = 0; 
    239                         for(GSSAccumulator acc: metricsData.get("Room")){ 
     238                        for(DCwormsAccumulator acc: metricsData.get("Room")){ 
    240239                                roomPower = roomPower + acc.getSum(); 
    241240                        } 
    … …  
    252251                try{ 
    253252                        double itComputingEnergy = 0; 
    254                         for(GSSAccumulator acc: metricsData.get("Processor_CALC")){ 
     253                        for(DCwormsAccumulator acc: metricsData.get("Processor_CALC")){ 
    255254                                itComputingEnergy = itComputingEnergy + acc.getSum(); 
    256255                        } 

  • DCWoRMS/branches/coolemall/src/simulator/stats/MetricsCalculator.java

    r1299 r1396  
    1010        public List<MetricsStats> calulateMetrics(); 
    1111         
    12         public void addMetricsData(String resourceTypeName, GSSAccumulator resourceEnergyAccumulator); 
     12        public void addMetricsData(String resourceTypeName, DCwormsAccumulator resourceEnergyAccumulator); 
    1313         
    14         public Map<String, List<GSSAccumulator>> getMetricsData(); 
     14        public Map<String, List<DCwormsAccumulator>> getMetricsData(); 
    1515         
    1616} 

  • DCWoRMS/branches/coolemall/src/simulator/stats/SimulationStatistics.java

    r477 r1396  
    4444        public String getOutputFolderName(); 
    4545 
    46         public GSSAccumulator getStats(String resourcesTotalLoad); 
     46        public DCwormsAccumulator getStats(String resourcesTotalLoad); 
    4747 
    4848        public boolean accumulatedStats(); 

  • DCWoRMS/branches/coolemall/src/simulator/stats/StatisticsInfo.java

    r477 r1396  
    99 
    1010        /** The mean value */ 
    11         protected GSSAccumulator mean; 
     11        protected DCwormsAccumulator mean; 
    1212        /** The standard deviation value */ 
    13         protected GSSAccumulator stdev; 
     13        protected DCwormsAccumulator stdev; 
    1414        /** The minimal value */ 
    15         protected GSSAccumulator max; 
     15        protected DCwormsAccumulator max; 
    1616        /** The maximal value */ 
    17         protected GSSAccumulator min; 
     17        protected DCwormsAccumulator min; 
    1818        /** 
    1919         * @param mean 
    … …  
    2222         * @param min 
    2323         */ 
    24         public StatisticsInfo(GSSAccumulator mean, GSSAccumulator stdev, GSSAccumulator max, GSSAccumulator min) { 
     24        public StatisticsInfo(DCwormsAccumulator mean, DCwormsAccumulator stdev, DCwormsAccumulator max, DCwormsAccumulator min) { 
    2525                this.mean = mean; 
    2626                this.stdev = stdev; 
    … …  
    3131         * @return the maximal value 
    3232         */ 
    33         public GSSAccumulator getMax() { 
     33        public DCwormsAccumulator getMax() { 
    3434                return max; 
    3535        } 
    … …  
    3737         * @return the mean value 
    3838         */ 
    39         public GSSAccumulator getMean() { 
     39        public DCwormsAccumulator getMean() { 
    4040                return mean; 
    4141        } 
    … …  
    4343         * @return the minimal value 
    4444         */ 
    45         public GSSAccumulator getMin() { 
     45        public DCwormsAccumulator getMin() { 
    4646                return min; 
    4747        } 
    … …  
    4949         * @return the standard deviation value 
    5050         */ 
    51         public GSSAccumulator getStdev() { 
     51        public DCwormsAccumulator getStdev() { 
    5252                return stdev; 
    5353        } 

  • DCWoRMS/branches/coolemall/src/simulator/stats/implementation/AccumulatedResourceStats.java

    r477 r1396  
    11package simulator.stats.implementation; 
    22 
    3 import simulator.stats.GSSAccumulator; 
     3import simulator.stats.DCwormsAccumulator; 
    44import simulator.stats.implementation.out.StatsSerializer; 
    55 
    … …  
    1212 
    1313        // accumulated resource statistic 
    14         protected GSSAccumulator resourceLoad; 
    15         protected GSSAccumulator resourceReservationLoad; 
     14        protected DCwormsAccumulator resourceLoad; 
     15        protected DCwormsAccumulator resourceReservationLoad; 
    1616        protected String resourceName; 
    1717 
    … …  
    2121        public AccumulatedResourceStats(String resourceName) { 
    2222                this.resourceName = resourceName; 
    23                 this.resourceLoad = new GSSAccumulator(); 
    24                 this.resourceReservationLoad = new GSSAccumulator(); 
     23                this.resourceLoad = new DCwormsAccumulator(); 
     24                this.resourceReservationLoad = new DCwormsAccumulator(); 
    2525        } 
    2626 
    … …  
    3737        } 
    3838 
    39         public GSSAccumulator getResourceLoad() { 
     39        public DCwormsAccumulator getResourceLoad() { 
    4040                return this.resourceLoad; 
    4141        } 
    4242 
    43         public GSSAccumulator getResourceReservationLoad() { 
     43        public DCwormsAccumulator getResourceReservationLoad() { 
    4444                return this.resourceReservationLoad; 
    4545        } 

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

    r1374 r1396  
    5959import schedframe.ExecutablesList; 
    6060import schedframe.SimulatedEnvironment; 
    61 import schedframe.exceptions.ResourceException; 
     61import schedframe.resources.CustomResourceType; 
    6262import schedframe.resources.ResourceType; 
    63 import schedframe.resources.UserResourceType; 
    6463import schedframe.resources.computing.ComputingResource; 
    65 import schedframe.resources.computing.Processor; 
    6664import schedframe.resources.computing.extensions.Extension; 
    6765import schedframe.resources.computing.extensions.ExtensionList; 
    … …  
    6967import schedframe.resources.computing.profiles.energy.EnergyExtension; 
    7068import schedframe.resources.computing.profiles.energy.MeasurementHistory; 
    71 import schedframe.resources.computing.profiles.energy.airthroughput.AirFlowValue; 
     69import schedframe.resources.computing.profiles.energy.airthroughput.AirflowValue; 
    7270import schedframe.resources.computing.profiles.energy.power.PowerUsage; 
    7371import schedframe.resources.computing.profiles.energy.thermal.TemperatureValue; 
    … …  
    8078import schedframe.resources.units.StandardResourceUnitName; 
    8179import schedframe.scheduling.ExecutionHistoryItem; 
    82 import schedframe.scheduling.ResourceHistoryItem; 
     80import schedframe.scheduling.ResourceItem; 
    8381import schedframe.scheduling.Scheduler; 
    8482import schedframe.scheduling.manager.tasks.JobRegistry; 
    … …  
    9189import simulator.GenericUser; 
    9290import simulator.stats.CoolEmAllMetricsCalculator; 
     91import simulator.stats.DCwormsAccumulator; 
    9392import simulator.stats.DCwormsMetricsCalculator; 
    94 import simulator.stats.GSSAccumulator; 
    9593import simulator.stats.MetricsCalculator; 
    9694import simulator.stats.SimulationStatistics; 
    … …  
    124122        protected static final String RESOURCEUTILIZATION_STATISTICS_OUTPUT_FILE_NAME = "ResourceUtilization.txt"; 
    125123        protected static final String ENERGYUSAGE_STATISTICS_OUTPUT_FILE_NAME = "EnergyUsage.txt"; 
    126         protected static final String AIRFLOW_STATISTICS_OUTPUT_FILE_NAME = "AirThroughput.txt"; 
     124        protected static final String AIRFLOW_STATISTICS_OUTPUT_FILE_NAME = "Airflow.txt"; 
    127125        protected static final String TEMPERATURE_STATISTICS_OUTPUT_FILE_NAME = "Temperature.txt"; 
    128126        protected static final String USEFUL_WORK_STATISTICS_OUTPUT_FILE_NAME = "UsefulWork.txt"; 
    … …  
    144142 
    145143        protected GSSAccumulatorsStats accStats; 
    146         protected Map<String, GSSAccumulator> statsData; 
     144        protected Map<String, DCwormsAccumulator> statsData; 
    147145         
    148146        protected GenericUser users; 
    … …  
    232230                task_processorsMap = new HashMap<String, Set<ComputingResource>>(); 
    233231                accStats = new GSSAccumulatorsStats(); 
    234                 statsData = new HashMap<String, GSSAccumulator>(); 
     232                statsData = new HashMap<String, DCwormsAccumulator>(); 
    235233                 
    236234                this.serializer = new StringSerializer();                
    … …  
    298296                                cStats.add(Stats.chartEnergy); 
    299297                        cStats.add(Stats.textAirFlow); 
    300                         if(ArrayUtils.contains(configuration.resForAirFlowChart, resourceTypeName)) 
     298                        if(ArrayUtils.contains(configuration.resForAirflowChart, resourceTypeName)) 
    301299                                cStats.add(Stats.chartAirFlow); 
    302300                        cStats.add(Stats.textTemperature); 
    … …  
    420418                List<ComputingResource> compResources = null; 
    421419                for(String resourceTypeName: resourceController.getComputingResourceLayers()){ 
    422                         GSSAccumulator resourceEnergyAccumulator = new GSSAccumulator(); 
    423                         GSSAccumulator maxResourceEnergyAccumulator = new GSSAccumulator(); 
    424                         GSSAccumulator calculationsEnergyAccumulator = new GSSAccumulator(); 
     420                        DCwormsAccumulator resourceEnergyAccumulator = new DCwormsAccumulator(); 
     421                        DCwormsAccumulator maxResourceEnergyAccumulator = new DCwormsAccumulator(); 
     422                        DCwormsAccumulator calculationsEnergyAccumulator = new DCwormsAccumulator(); 
    425423                        compResources = new ArrayList<ComputingResource>(); 
    426424                        for(ComputingResource compRes: resourceController.getComputingResources() ){ 
    427                                 compResources.addAll(compRes.getDescendantsByType(new UserResourceType(resourceTypeName))); 
     425                                compResources.addAll(compRes.getDescendantsByType(new CustomResourceType(resourceTypeName))); 
    428426                        } 
    429427                        if(resourceController.getComputingResources().get(0).getType().getName().equals(resourceTypeName)) 
    … …  
    526524                                                 
    527525                                                for(Device device: compResource.getResourceCharacteristic().getDevices()){ 
    528                                                         GSSAccumulator devAccumulator = new GSSAccumulator(); 
     526                                                        DCwormsAccumulator devAccumulator = new DCwormsAccumulator(); 
    529527                                                        ResourcePowerStats deviceEnergyUsage = gatherResourcePowerConsumptionStats(device); 
    530528                                                        deviceEnergyUsage.setMeanValue(calculateMeanValue(deviceEnergyUsage)); 
    … …  
    592590                                                        } 
    593591                                                         
    594                                                         if(ArrayUtils.contains(configuration.resForAirFlowChart, device.getType().getName())){ 
     592                                                        if(ArrayUtils.contains(configuration.resForAirflowChart, device.getType().getName())){ 
    595593                                                                if (configuration.creatediagrams_resairflow) { 
    596594                                                                        createResourceAirFlowDiagramData(deviceAirFlow); 
    … …  
    767765 
    768766 
    769                         LinkedList<ResourceHistoryItem> resourceHistory = exec.getAllocatedResources(); 
     767                        LinkedList<ResourceItem> resourceHistory = exec.getAllocatedResources(); 
    770768                        if(resourceHistory.size() == 0) 
    771769                                continue; 
    … …  
    805803 
    806804                                        try{ 
    807                                                 double usefulWork = execTask.getResourceConsumptionProfile().getUsefulWork()/pes.size(); 
     805                                                double usefulWork = execTask.getExecutionProfile().getUsefulWork()/pes.size(); 
    808806                                                //double usefulWork = gatherUsefulWorkStats(pe).getValue(); 
    809                                                 GSSAccumulator uwAcc; 
     807                                                DCwormsAccumulator uwAcc; 
    810808                                                if(metCalc.getMetricsData().containsKey("UW_" + pe.getFullName())){ 
    811809                                                        uwAcc = metCalc.getMetricsData().get("UW_" + pe.getFullName()).get(0); 
    812810                                                        uwAcc.add(usefulWork); 
    813811                                                } else { 
    814                                                         uwAcc = new GSSAccumulator(); 
     812                                                        uwAcc = new DCwormsAccumulator(); 
    815813                                                        uwAcc.add(usefulWork); 
    816814                                                        metCalc.addMetricsData("UW_" + pe.getFullName(), uwAcc); 
    … …  
    832830                        Executable exec = (Executable) execTask; 
    833831 
    834                         LinkedList<ResourceHistoryItem> resourceHistory = exec.getAllocatedResources(); 
     832                        LinkedList<ResourceItem> resourceHistory = exec.getAllocatedResources(); 
    835833                        if(resourceHistory.size() == 0) 
    836834                                continue; 
    837835 
    838836                        for(int i = 0; i < resourceHistory .size(); i++){ 
    839                                 ResourceHistoryItem resHistItem = resourceHistory.get(i); 
     837                                ResourceItem resHistItem = resourceHistory.get(i); 
    840838                                Map<ResourceUnitName, ResourceUnit> res = resHistItem.getResourceUnits(); 
    841839                                ResourceUnit resUnit = res.get(StandardResourceUnitName.PE); 
    842840                                //ProcessingElements pes = (ProcessingElements) resUnit ; 
    843                                 LinkedList<ExecutionHistoryItem> execHistory = exec.getExecHistory(); 
     841                                LinkedList<ExecutionHistoryItem> execHistory = exec.getExecutionHistory(); 
    844842                                long st = -1, et; 
    845843                                for(int j = 0; j < execHistory .size(); j++){ 
    … …  
    893891 
    894892                                                                try{ 
    895                                                                         double usefulWork = execTask.getResourceConsumptionProfile().getUsefulWork()/pes.size(); 
     893                                                                        double usefulWork = execTask.getExecutionProfile().getUsefulWork()/pes.size(); 
    896894                                                                        usefulWork = ((et - st) / (1000 * getExecutionTime(execTask))) * usefulWork; 
    897                                                                         GSSAccumulator uwAcc; 
     895                                                                        DCwormsAccumulator uwAcc; 
    898896                                                                        if(metCalc.getMetricsData().containsKey("UW_" + pe.getFullName())){ 
    899897                                                                                uwAcc = metCalc.getMetricsData().get("UW_" + pe.getFullName()).get(0); 
    900898                                                                                uwAcc.add(usefulWork); 
    901899                                                                        } else { 
    902                                                                                 uwAcc = new GSSAccumulator(); 
     900                                                                                uwAcc = new DCwormsAccumulator(); 
    903901                                                                                uwAcc.add(usefulWork); 
    904902                                                                                metCalc.addMetricsData("UW_" + pe.getFullName(), uwAcc); 
    … …  
    922920                long previousTimestamp = 0; 
    923921                int previousStatus = DCWormsTags.CREATED; 
    924                 for(ExecutionHistoryItem execHistItem: execTask.getExecHistory()){ 
     922                for(ExecutionHistoryItem execHistItem: execTask.getExecutionHistory()){ 
    925923                        if(previousStatus == DCWormsTags.INEXEC){ 
    926924                                executionTime = executionTime  + (execHistItem.getTimeStamp().getMillis()/1000 - previousTimestamp); 
    … …  
    10331031                JobRegistry jr = new JobRegistryImpl(compResource.getFullName()); 
    10341032                for(ExecTask task: jr.getFinishedTasks()){ 
    1035                         usefulWork = usefulWork + task.getResourceConsumptionProfile().getUsefulWork(); 
     1033                        usefulWork = usefulWork + task.getExecutionProfile().getUsefulWork(); 
    10361034                } 
    10371035                ResourceUsefulWorkStats usefulWorkStats = new ResourceUsefulWorkStats(compResource.getFullName(), compResource.getType(), usageType, usefulWork, endSimulationTime); 
    … …  
    11751173                                        if(ee.getAirFlowProfile() == null) 
    11761174                                                break; 
    1177                                         List<AirFlowValue> airFlowHistory = ee.getAirFlowProfile().getAirThroughputHistory(); 
     1175                                        List<AirflowValue> airFlowHistory = ee.getAirFlowProfile().getAirflowHistory(); 
    11781176                                        if(airFlowHistory.size() == 0) 
    11791177                                                break; 
    11801178                                        long endSimulationTime = DateTimeUtilsExt.currentTimeMillis(); 
    1181                                         airFlowHistory.add(new AirFlowValue(endSimulationTime, ee.getAirFlowProfile().getAirThroughputHistory().get(ee.getAirFlowProfile().getAirThroughputHistory().size()-1).getValue())); 
    1182                                         for(AirFlowValue af:airFlowHistory){ 
     1179                                        airFlowHistory.add(new AirflowValue(endSimulationTime, ee.getAirFlowProfile().getAirflowHistory().get(ee.getAirFlowProfile().getAirflowHistory().size()-1).getValue())); 
     1180                                        for(AirflowValue af:airFlowHistory){ 
    11831181                                                airFlow.put(af.getTimestamp(), af.getValue()); 
    11841182                                        } 
    … …  
    14021400                                resourceAirFlowDiagram = getResourceDynamicDiagram(resourceAirFlowDiagrams.get(resType), simulationTime, chartName, 
    14031401                                                subtitle, axisName); 
    1404                                 if (!saveXYPlotChart(resourceAirFlowDiagram, fileName + "AirThroughput_" + resType)) 
     1402                                if (!saveXYPlotChart(resourceAirFlowDiagram, fileName + "Airflow_" + resType)) 
    14051403                                        return false; 
    14061404                        } 
    … …  
    20402038        } 
    20412039 
    2042         public GSSAccumulator getStats(String name) { 
     2040        public DCwormsAccumulator getStats(String name) { 
    20432041                return statsData.get(name); 
    20442042        } 

  • DCWoRMS/branches/coolemall/src/simulator/stats/implementation/GSSAccumulatorsStats.java

    r1277 r1396  
    11package simulator.stats.implementation; 
    22 
    3 import simulator.stats.GSSAccumulator; 
     3import simulator.stats.DCwormsAccumulator; 
    44import simulator.stats.implementation.out.StatsSerializer; 
    55 
    66public class GSSAccumulatorsStats implements StatsInterface { 
    77 
    8         public GSSAccumulator meanTotalOccupancy; 
    9         public GSSAccumulator meanTotalLoad; 
    10         public GSSAccumulator meanQueueLength; 
    11         public GSSAccumulator meanEnergyUsage; 
    12         public GSSAccumulator meanAirFlow; 
    13         public GSSAccumulator meanTemperature; 
     8        public DCwormsAccumulator meanTotalOccupancy; 
     9        public DCwormsAccumulator meanTotalLoad; 
     10        public DCwormsAccumulator meanQueueLength; 
     11        public DCwormsAccumulator meanEnergyUsage; 
     12        public DCwormsAccumulator meanAirFlow; 
     13        public DCwormsAccumulator meanTemperature; 
    1414 
    15         public GSSAccumulator meanTaskStartTime; 
    16         public GSSAccumulator meanTaskCompletionTime; 
    17         public GSSAccumulator meanTaskExecutionTime; 
    18         public GSSAccumulator meanTaskWaitingTime; 
    19         public GSSAccumulator meanTaskFlowTime; 
    20         public GSSAccumulator lateness; 
    21         public GSSAccumulator tardiness; 
    22         public GSSAccumulator delayedTasks; 
    23         public GSSAccumulator failedRequests; 
    24         public GSSAccumulator makespan; 
     15        public DCwormsAccumulator meanTaskStartTime; 
     16        public DCwormsAccumulator meanTaskCompletionTime; 
     17        public DCwormsAccumulator meanTaskExecutionTime; 
     18        public DCwormsAccumulator meanTaskWaitingTime; 
     19        public DCwormsAccumulator meanTaskFlowTime; 
     20        public DCwormsAccumulator lateness; 
     21        public DCwormsAccumulator tardiness; 
     22        public DCwormsAccumulator delayedTasks; 
     23        public DCwormsAccumulator failedRequests; 
     24        public DCwormsAccumulator makespan; 
    2525 
    2626        private String[] headers = { "Resource name", "mean", "stdev", "variance", 
    … …  
    2828 
    2929        public GSSAccumulatorsStats() { 
    30                 meanTotalOccupancy = new GSSAccumulator(); 
    31                 meanTotalLoad = new GSSAccumulator(); 
    32                 meanQueueLength = new GSSAccumulator(); 
    33                 meanEnergyUsage = new GSSAccumulator();  
    34                 meanAirFlow = new GSSAccumulator();  
    35                 meanTemperature = new GSSAccumulator();  
     30                meanTotalOccupancy = new DCwormsAccumulator(); 
     31                meanTotalLoad = new DCwormsAccumulator(); 
     32                meanQueueLength = new DCwormsAccumulator(); 
     33                meanEnergyUsage = new DCwormsAccumulator();  
     34                meanAirFlow = new DCwormsAccumulator();  
     35                meanTemperature = new DCwormsAccumulator();  
    3636                 
    37                 meanTaskStartTime = new GSSAccumulator(); 
    38                 meanTaskCompletionTime = new GSSAccumulator(); 
    39                 meanTaskExecutionTime = new GSSAccumulator(); 
    40                 meanTaskWaitingTime = new GSSAccumulator(); 
    41                 meanTaskFlowTime = new GSSAccumulator(); 
    42                 lateness = new GSSAccumulator(); 
    43                 tardiness = new GSSAccumulator(); 
    44                 delayedTasks = new GSSAccumulator(); 
    45                 failedRequests = new GSSAccumulator(); 
    46                 makespan = new GSSAccumulator(); 
     37                meanTaskStartTime = new DCwormsAccumulator(); 
     38                meanTaskCompletionTime = new DCwormsAccumulator(); 
     39                meanTaskExecutionTime = new DCwormsAccumulator(); 
     40                meanTaskWaitingTime = new DCwormsAccumulator(); 
     41                meanTaskFlowTime = new DCwormsAccumulator(); 
     42                lateness = new DCwormsAccumulator(); 
     43                tardiness = new DCwormsAccumulator(); 
     44                delayedTasks = new DCwormsAccumulator(); 
     45                failedRequests = new DCwormsAccumulator(); 
     46                makespan = new DCwormsAccumulator(); 
    4747        } 
    4848 

  • DCWoRMS/branches/coolemall/src/simulator/stats/implementation/JobStats.java

    r477 r1396  
    11package simulator.stats.implementation; 
    22 
    3 import java.io.PrintStream; 
    4  
    5 import simulator.stats.GSSAccumulator; 
     3import simulator.stats.DCwormsAccumulator; 
    64import simulator.stats.implementation.out.StatsSerializer; 
    75 
    … …  
    1412 
    1513        protected String jobID; 
    16         protected GSSAccumulator meanTaskCompletionTime; 
    17         protected GSSAccumulator meanTaskExecutionTime; 
    18         protected GSSAccumulator meanTaskStartTime; 
    19         protected GSSAccumulator meanTaskFlowTime; 
    20         protected GSSAccumulator meanTaskWaitingTime; 
    21         protected GSSAccumulator meanTaskGQ_WaitingTime; 
    22         protected GSSAccumulator lateness; 
    23         protected GSSAccumulator tardiness; 
    24         protected GSSAccumulator makespan; 
     14        protected DCwormsAccumulator meanTaskCompletionTime; 
     15        protected DCwormsAccumulator meanTaskExecutionTime; 
     16        protected DCwormsAccumulator meanTaskStartTime; 
     17        protected DCwormsAccumulator meanTaskFlowTime; 
     18        protected DCwormsAccumulator meanTaskWaitingTime; 
     19        protected DCwormsAccumulator meanTaskGQ_WaitingTime; 
     20        protected DCwormsAccumulator lateness; 
     21        protected DCwormsAccumulator tardiness; 
     22        protected DCwormsAccumulator makespan; 
    2523 
    2624        JobStats(String jobID) { 
    … …  
    3533 
    3634        private void init() { 
    37                 this.meanTaskCompletionTime = new GSSAccumulator(); 
    38                 this.meanTaskExecutionTime = new GSSAccumulator(); 
    39                 this.meanTaskStartTime = new GSSAccumulator(); 
    40                 this.meanTaskFlowTime = new GSSAccumulator(); 
    41                 this.meanTaskWaitingTime = new GSSAccumulator(); 
    42                 this.meanTaskGQ_WaitingTime = new GSSAccumulator(); 
    43                 this.lateness = new GSSAccumulator(); 
    44                 this.tardiness = new GSSAccumulator(); 
    45                 this.makespan = new GSSAccumulator(); 
     35                this.meanTaskCompletionTime = new DCwormsAccumulator(); 
     36                this.meanTaskExecutionTime = new DCwormsAccumulator(); 
     37                this.meanTaskStartTime = new DCwormsAccumulator(); 
     38                this.meanTaskFlowTime = new DCwormsAccumulator(); 
     39                this.meanTaskWaitingTime = new DCwormsAccumulator(); 
     40                this.meanTaskGQ_WaitingTime = new DCwormsAccumulator(); 
     41                this.lateness = new DCwormsAccumulator(); 
     42                this.tardiness = new DCwormsAccumulator(); 
     43                this.makespan = new DCwormsAccumulator(); 
    4644        } 
    4745 
    … …  
    5048        } 
    5149 
    52         public GSSAccumulator getMeanTaskCompletionTime() { 
     50        public DCwormsAccumulator getMeanTaskCompletionTime() { 
    5351                return meanTaskCompletionTime; 
    5452        } 
    5553 
    56         public GSSAccumulator getMeanTaskExecutionTime() { 
     54        public DCwormsAccumulator getMeanTaskExecutionTime() { 
    5755                return meanTaskExecutionTime; 
    5856        } 
    5957 
    60         public GSSAccumulator getMeanTaskStartTime() { 
     58        public DCwormsAccumulator getMeanTaskStartTime() { 
    6159                return meanTaskStartTime; 
    6260        } 
    6361 
    64         public GSSAccumulator getMeanTaskFlowTime() { 
     62        public DCwormsAccumulator getMeanTaskFlowTime() { 
    6563                return meanTaskFlowTime; 
    6664        } 
    6765 
    68         public GSSAccumulator getMeanTaskWaitingTime() { 
     66        public DCwormsAccumulator getMeanTaskWaitingTime() { 
    6967                return meanTaskWaitingTime; 
    7068        } 
    7169 
    72         public GSSAccumulator getMeanTaskGQ_WaitingTime() { 
     70        public DCwormsAccumulator getMeanTaskGQ_WaitingTime() { 
    7371                return meanTaskGQ_WaitingTime; 
    7472        } 
    7573 
    76         public GSSAccumulator getLateness() { 
     74        public DCwormsAccumulator getLateness() { 
    7775                return lateness; 
    7876        } 
    7977 
    80         public GSSAccumulator getTardiness() { 
     78        public DCwormsAccumulator getTardiness() { 
    8179                return tardiness; 
    8280        } 
    8381 
    84         public GSSAccumulator getMakespan() { 
     82        public DCwormsAccumulator getMakespan() { 
    8583                return makespan; 
    8684        } 

  • DCWoRMS/branches/coolemall/src/simulator/stats/implementation/ResourceHistoryStats.java

    r1207 r1396  
    33import java.util.List; 
    44 
    5 import schedframe.resources.ResourceHistoryChanges; 
     5import schedframe.resources.ResourceHistoryItem; 
    66import simulator.stats.implementation.out.StatsSerializer; 
    77 
    … …  
    1010        private String[] headers = {"timestamp", "resourceName", "operation", "parameter" }; 
    1111 
    12         protected List<ResourceHistoryChanges> resHistChanges; 
     12        protected List<ResourceHistoryItem> resHist; 
    1313         
    14         public ResourceHistoryStats(List<ResourceHistoryChanges> resHistChanges) { 
    15                 super(); 
    16                 this.resHistChanges = resHistChanges; 
     14        public ResourceHistoryStats(List<ResourceHistoryItem> resHist) { 
     15                this.resHist = resHist; 
    1716        } 
    18  
    1917 
    2018        public Object serialize(StatsSerializer serializer) { 
    … …  
    2624        } 
    2725 
    28  
    29         public List<ResourceHistoryChanges> getResHistChanges() { 
    30                 return resHistChanges; 
     26        public List<ResourceHistoryItem> getResourceHistory() { 
     27                return resHist; 
    3128        } 
    3229} 

  • DCWoRMS/branches/coolemall/src/simulator/stats/implementation/TaskStats.java

    r1362 r1396  
    108108                long previousTimestamp = 0;              
    109109                int previousStatus = DCWormsTags.CREATED; 
    110                 for(ExecutionHistoryItem execHistItem: task.getExecHistory()){ 
     110                for(ExecutionHistoryItem execHistItem: task.getExecutionHistory()){ 
    111111                        if(previousStatus == DCWormsTags.INEXEC){ 
    112112                                executionTime = executionTime  + (execHistItem.getTimeStamp().getMillis()/1000 - previousTimestamp); 

  • DCWoRMS/branches/coolemall/src/simulator/stats/implementation/out/CoolEmAllStringSerializer.java

    r1207 r1396  
    88 
    99import schedframe.resources.CoolEmAllResourceType; 
    10 import schedframe.resources.ResourceHistoryChanges; 
     10import schedframe.resources.ResourceHistoryItem; 
    1111import schedframe.resources.StandardResourceType; 
    1212import simulator.stats.implementation.MetricsStats; 
    … …  
    311311                df.setGroupingUsed(false); 
    312312                 
    313                 for(ResourceHistoryChanges rhc: arg.getResHistChanges()){ 
     313                for(ResourceHistoryItem rhc: arg.getResourceHistory()){ 
    314314                        buffer.append(rhc.getTimestamp()); 
    315315                        buffer.append(fieldSeparator); 
    316316                        buffer.append(rhc.getResourceName()); 
    317317                        buffer.append(fieldSeparator); 
    318                         buffer.append(rhc.getOperation()); 
     318                        buffer.append(rhc.getAction()); 
    319319                        buffer.append(fieldSeparator); 
    320320                        buffer.append(rhc.getParamter()); 
Note: See TracChangeset for help on using the changeset viewer.