source: DCWoRMS/branches/coolemall/src/simulator/stats/implementation/out/StringSerializer.java @ 1434

Revision 1434, 18.7 KB checked in by wojtekp, 11 years ago (diff)
  • Property svn:mime-type set to text/plain
Line 
1package simulator.stats.implementation.out;
2
3
4import java.util.Map;
5
6import org.apache.commons.logging.Log;
7import org.apache.commons.logging.LogFactory;
8
9import simulator.DataCenterWorkloadSimulator;
10import simulator.stats.implementation.AccumulatedResourceStats;
11import simulator.stats.implementation.GSSAccumulatorsStats;
12import simulator.stats.implementation.JobStats;
13import simulator.stats.implementation.MetricsStats;
14import simulator.stats.implementation.ResourceAirflowStats;
15import simulator.stats.implementation.ResourceAvailabilityStats;
16import simulator.stats.implementation.ResourceHistoryStats;
17import simulator.stats.implementation.ResourcePowerStats;
18import simulator.stats.implementation.ResourceStats;
19import simulator.stats.implementation.ResourceTemperatureStats;
20import simulator.stats.implementation.ResourceUsageStats;
21import simulator.stats.implementation.ResourceUsefulWorkStats;
22import simulator.stats.implementation.TaskStats;
23
24/**
25 *
26 * @author Marcin Krystek, Jarek Szymczak
27 *
28 */
29public class StringSerializer extends AbstractStringSerializer {
30
31        private Log log = LogFactory.getLog(StringSerializer.class);
32
33        public String visit(TaskStats taskStats) {
34                StringBuffer buffer = null;
35
36                if(printedHeaders.add("taskStats")) {
37                        buffer = new StringBuffer(520);
38                        String[] headers = taskStats.getHeaders();
39                        if (headers.length >= 10) {
40
41                                for(int i = 0; i < 10; i++)
42                                {
43                                        buffer.append(headers[i]);
44                                        buffer.append(fieldSeparator);
45                                }
46                               
47                                if (this.useExtended) {
48                                       
49                                        for(int i = 10; i < headers.length; i++)
50                                        {
51                                                buffer.append(headers[i]);
52                                                buffer.append(fieldSeparator);
53                                        }
54                                }
55
56                        } else {
57                                buffer.append(headers.toString());
58                        }
59                        buffer.append(System.getProperty("line.separator"));
60                } else {
61                        buffer = new StringBuffer(260);
62                }
63               
64                buffer.append(taskStats.getJobID());
65                buffer.append(fieldSeparator);
66                buffer.append(taskStats.getTaskID());
67                buffer.append(fieldSeparator);
68                buffer.append(taskStats.getUserDN());
69                buffer.append(fieldSeparator);
70                buffer.append(taskStats.getResName());
71                buffer.append(fieldSeparator);
72                buffer.append(taskStats.getCpuCnt());
73                buffer.append(fieldSeparator);
74                buffer.append(Double.valueOf(taskStats.getExecStartDate()).longValue());
75                buffer.append(fieldSeparator);
76                buffer.append(Double.valueOf(taskStats.getExecFinishDate()).longValue());
77                buffer.append(fieldSeparator);
78                buffer.append(Double.valueOf(taskStats.getExecEndDate()).longValue());
79                buffer.append(fieldSeparator);
80                buffer.append(Double.valueOf(taskStats.getGB_SubDate()).longValue());
81                buffer.append(fieldSeparator);
82                buffer.append(Double.valueOf(taskStats.getLB_SubDate()).longValue());
83                buffer.append(fieldSeparator);
84                if (this.useExtended) {
85                        buffer.append(Double.valueOf(taskStats.getCompletionTime())
86                                        .longValue());
87                        buffer.append(fieldSeparator);
88                        buffer.append(Double.valueOf(taskStats.getExecStartTime()).longValue());
89                        buffer.append(fieldSeparator);
90                        buffer.append(Double.valueOf(taskStats.getExecutionTime()).longValue());
91                        buffer.append(fieldSeparator);
92                        buffer.append(Double.valueOf(taskStats.getReadyTime()).longValue());
93                        buffer.append(fieldSeparator);
94                        buffer.append(Double.valueOf(taskStats.getStartTime()).longValue());
95                        buffer.append(fieldSeparator);
96                        buffer.append(Double.valueOf(taskStats.getFlowTime()).longValue());
97                        buffer.append(fieldSeparator);
98                        buffer.append(Double.valueOf(taskStats.getWaitingTime()).longValue());
99                        buffer.append(fieldSeparator);
100                        buffer.append(Double.valueOf(taskStats.getGQ_WaitingTime())
101                                        .longValue());
102                        buffer.append(fieldSeparator);
103                        buffer.append(Double.valueOf(taskStats.getLateness()).longValue());
104                        buffer.append(fieldSeparator);
105                        buffer.append(Double.valueOf(taskStats.getTardiness()).longValue());
106                        buffer.append(fieldSeparator);
107                        buffer.append(Double.valueOf(taskStats.getReservationStartDate())
108                                        .longValue());
109                        buffer.append(fieldSeparator);
110                        buffer.append(Double.valueOf(taskStats.getReservationFinishDate())
111                                        .longValue());
112                        buffer.append(fieldSeparator);
113                        buffer.append(taskStats.getHostName());
114                        buffer.append(fieldSeparator);
115                        buffer.append(taskStats.getProcessingElementsName());
116                        buffer.append(fieldSeparator);
117                        buffer.append(0);
118                        buffer.append(fieldSeparator);
119                        buffer.append(taskStats.getExecName());
120                        buffer.append(fieldSeparator);
121                }
122               
123               
124                return buffer.toString();
125        }
126
127        public String visit(JobStats jobStats) {
128               
129                StringBuffer buffer = null;
130
131                if(printedHeaders.add("jobStats")) {
132                        buffer = new StringBuffer(200);
133                        String[] headers = jobStats.getHeaders();
134                        for(int i = 0; i < headers.length; i++)
135                        {
136                                buffer.append(headers[i]);
137                                buffer.append(fieldSeparator);
138                        }
139                        buffer.append(System.getProperty("line.separator"));
140                } else {
141                        buffer = new StringBuffer(100);
142                }
143               
144                buffer.append(jobStats.getJobID());
145                buffer.append(fieldSeparator);
146                buffer.append(defaultNumberFormat
147                                .format(jobStats.getMeanTaskCompletionTime().getMean()));
148                buffer.append(fieldSeparator);
149                buffer.append(defaultNumberFormat
150                                .format(jobStats.getMeanTaskExecutionTime().getMean()));
151                buffer.append(fieldSeparator);
152                buffer.append(defaultNumberFormat
153                                .format(jobStats.getMeanTaskStartTime().getMean()));
154                buffer.append(fieldSeparator);
155                buffer.append(defaultNumberFormat
156                                .format(jobStats.getMeanTaskFlowTime().getMean()));
157                buffer.append(fieldSeparator);
158                buffer.append(defaultNumberFormat
159                                .format(jobStats.getMeanTaskWaitingTime().getMean()));
160                buffer.append(fieldSeparator);
161                buffer.append(defaultNumberFormat
162                                .format(jobStats.getMeanTaskGQ_WaitingTime().getMean()));
163                buffer.append(fieldSeparator);
164                buffer.append(defaultNumberFormat
165                                .format(jobStats.getTardiness().getMean()));
166                buffer.append(fieldSeparator);
167                buffer.append(defaultNumberFormat
168                                .format(jobStats.getLateness().getMean()));
169                buffer.append(fieldSeparator);
170                buffer.append(defaultNumberFormat
171                                .format(jobStats.getMakespan().getMean()));
172                buffer.append(fieldSeparator);
173               
174                return buffer.toString();
175        }
176       
177        public String visit(ResourceStats resourceStats){
178               
179                StringBuffer buffer = null;
180
181                if(printedHeaders.add("resourceStats")) {
182                        buffer = new StringBuffer(600);
183                        String[] headers = resourceStats.getHeaders();
184                        for(int i = 0; i < headers.length; i++)
185                        {
186                                buffer.append(headers[i]);
187                                buffer.append(fieldSeparator);
188                        }
189                        buffer.append(System.getProperty("line.separator"));
190                } else {
191                        buffer = new StringBuffer(300);
192                }
193               
194                buffer.append(resourceStats.getResourceName());
195                buffer.append(fieldSeparator);
196
197                buffer.append(resourceStats.getMemory());
198                buffer.append(fieldSeparator);
199
200                buffer.append(resourceStats.getCpucnt());
201                buffer.append(fieldSeparator);
202
203                buffer.append(resourceStats.getCpuspeed());
204                buffer.append(fieldSeparator);
205
206                buffer.append(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT
207                                .format(resourceStats.getQueueLength()));
208                buffer.append(fieldSeparator);
209
210                /*Map<String, Double> processorsLoad = resourceStats.getProcessorsLoad();
211                for (String processorName : processorsLoad.keySet()) {
212
213                        Double load = processorsLoad.get(processorName);
214                        buffer.append(processorName);
215                        buffer.append(" ");
216                        buffer.append(GridSchedulingSimulator.DFAULT_NUMBER_FORMAT
217                                                        .format(load));
218                        buffer.append(":");
219
220                }*/
221
222                buffer.append(fieldSeparator);
223                Map<String, Double> processorsReservationLoad = resourceStats
224                                .getProcessorsReservationLoad();
225                for (String processorName : processorsReservationLoad.keySet()) {
226
227                        Double reservationLoad = processorsReservationLoad
228                                        .get(processorName);
229                        buffer.append(processorName);
230                        buffer.append(" ");
231                        buffer.append(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT
232                                        .format(reservationLoad));
233                        buffer.append(":");
234                }
235                buffer.append(fieldSeparator);
236                return buffer.toString();
237        }
238       
239        public String visit(AccumulatedResourceStats accResStats){
240               
241                StringBuffer buffer = null;
242
243                if(printedHeaders.add("accResStats")) {
244                        buffer = new StringBuffer(340);
245                        String[] headers = accResStats.getHeaders();
246                        for(int i = 0; i < headers.length; i++)
247                        {
248                                buffer.append(headers[i]);
249                                buffer.append(fieldSeparator);
250                        }
251                        buffer.append(System.getProperty("line.separator"));
252                } else {
253                        buffer = new StringBuffer(170);
254                }
255               
256                buffer.append(accResStats.getResourceName());
257                buffer.append(fieldSeparator);
258                buffer.append("load");
259                buffer.append(accResStats.getResourceLoad().toString());
260                buffer.append(System.getProperty("line.separator"));
261                buffer.append(accResStats.getResourceName());
262                buffer.append(fieldSeparator);
263                buffer.append("reservationload");
264                buffer.append(accResStats.getResourceReservationLoad().toString());
265                buffer.append(System.getProperty("line.separator"));
266               
267                return buffer.toString();
268        }
269
270        public Object visit(ResourceUsageStats resourceUsageStats) {
271                Map<Long, Double> resourceUsage = resourceUsageStats.getHistory();
272                String metricName = "utlization";
273                int mapSize = resourceUsage.size();
274                /*
275                 * FIXME:
276                 * Integer.MAX_VALUE = 2147483647. We assume, that each line contains
277                 * max 30 signs - this gives max 71582788 lines. If resourceUsage map
278                 * contains more elements then we have a problem, because content of
279                 * resourceUsage map will not fit in the buffer.
280                 * This will need further attention in the future.
281                 */
282                int maxSize = (Integer.MAX_VALUE / 30 ) - 1;
283                if(mapSize >= maxSize){
284                        log.error("Resource usage data is to long to fit in the buffer.");
285                        return null;
286                }
287               
288                int size = 30 * resourceUsage.size();
289               
290                StringBuffer buffer = null;
291
292                if(printedHeaders.add(resourceUsageStats.getUsageType())) {
293                        buffer = new StringBuffer(size + 42);
294                        String[] headers = resourceUsageStats.getHeaders();
295                        /*for(int i = 0; i < headers.length; i++)
296                        {
297                                buffer.append(headers[i]);
298                                buffer.append(fieldSeparator);
299                        }
300                        buffer.append(System.getProperty("line.separator"));*/
301                } else {
302                        buffer = new StringBuffer(size);
303                }
304               
305               
306                for (Long timestamp : resourceUsage.keySet()) {
307                       
308                        buffer.append(metricName);
309                        buffer.append(fieldSeparator);
310                        buffer.append(resourceUsageStats.getResourceName());
311                        buffer.append(fieldSeparator);
312                        Double value = resourceUsage.get(timestamp);
313                        buffer.append(timestamp);
314                        buffer.append(fieldSeparator);
315                        buffer.append(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT
316                                        .format(value));
317                        buffer.append(fieldSeparator);
318                        buffer.append(System.getProperty("line.separator"));
319
320                }
321               
322                if(resourceUsage.size() > 0){
323                        buffer.append("mean: " + resourceUsageStats.getMeanValue());
324                        buffer.append(System.getProperty("line.separator"));   
325                }
326                return buffer.toString();
327        }
328
329        public Object visit(ResourcePowerStats resourceEnergyStats) {
330                Map<Long, Double> resourceEnergy = resourceEnergyStats.getHistory();
331                String metricName = "powerConsumption";
332                int mapSize = resourceEnergy.size();
333                /*
334                 * FIXME:
335                 * Integer.MAX_VALUE = 2147483647. We assume, that each line contains
336                 * max 30 signs - this gives max 71582788 lines. If resourceUsage map
337                 * contains more elements then we have a problem, because content of
338                 * resourceUsage map will not fit in the buffer.
339                 * This will need further attention in the future.
340                 */
341                int maxSize = (Integer.MAX_VALUE / 30 ) - 1;
342                if(mapSize >= maxSize){
343                        log.error("Resource usage data is to long to fit in the buffer.");
344                        return null;
345                }
346               
347                int size = 30 * resourceEnergy.size();
348               
349                StringBuffer buffer = null;
350
351                if(printedHeaders.add(resourceEnergyStats.getUsageType())) {
352                        buffer = new StringBuffer(size + 42);
353                        String[] headers = resourceEnergyStats.getHeaders();
354                        /*for(int i = 0; i < headers.length; i++)
355                        {
356                                buffer.append(headers[i]);
357                                buffer.append(fieldSeparator);
358                        }
359                        buffer.append(System.getProperty("line.separator"));*/
360                } else {
361                        buffer = new StringBuffer(size);
362                }
363               
364               
365                for (Long timestamp : resourceEnergy.keySet()) {
366                       
367                        buffer.append(metricName);
368                        buffer.append(fieldSeparator);
369                        buffer.append(resourceEnergyStats.getResourceName());
370                        buffer.append(fieldSeparator);
371                        Double value = resourceEnergy.get(timestamp);
372                        buffer.append(timestamp);
373                        buffer.append(fieldSeparator);
374                        buffer.append(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT
375                                        .format(value));
376                        buffer.append(fieldSeparator);
377                        buffer.append(System.getProperty("line.separator"));
378
379                }
380
381                if(resourceEnergy.size() > 0) {
382                        buffer.append("mean: "+resourceEnergyStats.getMeanValue() + " sum: " +resourceEnergyStats.getSumValue());
383                        buffer.append(System.getProperty("line.separator"));   
384                }
385
386                return buffer.toString();
387        }
388
389        public Object visit(ResourceAirflowStats resourceAirFlowStats) {
390                Map<Long, Double> resourceAirFlow = resourceAirFlowStats.getHistory();
391                String metricName = "airFlow";
392                int mapSize = resourceAirFlow.size();
393                /*
394                 * FIXME:
395                 * Integer.MAX_VALUE = 2147483647. We assume, that each line contains
396                 * max 30 signs - this gives max 71582788 lines. If resourceUsage map
397                 * contains more elements then we have a problem, because content of
398                 * resourceUsage map will not fit in the buffer.
399                 * This will need further attention in the future.
400                 */
401                int maxSize = (Integer.MAX_VALUE / 30 ) - 1;
402                if(mapSize >= maxSize){
403                        log.error("Resource usage data is to long to fit in the buffer.");
404                        return null;
405                }
406               
407                int size = 30 * resourceAirFlow.size();
408               
409                StringBuffer buffer = null;
410
411                if(printedHeaders.add(resourceAirFlowStats.getUsageType())) {
412                        buffer = new StringBuffer(size + 42);
413                        String[] headers = resourceAirFlowStats.getHeaders();
414                        /*for(int i = 0; i < headers.length; i++)
415                        {
416                                buffer.append(headers[i]);
417                                buffer.append(fieldSeparator);
418                        }
419                        buffer.append(System.getProperty("line.separator"));*/
420                } else {
421                        buffer = new StringBuffer(size);
422                }
423               
424               
425                for (Long timestamp : resourceAirFlow.keySet()) {
426                       
427                        buffer.append(metricName);
428                        buffer.append(fieldSeparator);
429                        buffer.append(resourceAirFlowStats.getResourceName());
430                        buffer.append(fieldSeparator);
431                        Double value = resourceAirFlow.get(timestamp);
432                        buffer.append(timestamp);
433                        buffer.append(fieldSeparator);
434                        buffer.append(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT
435                                        .format(value));
436                        buffer.append(fieldSeparator);
437                        buffer.append(System.getProperty("line.separator"));
438
439                }
440
441                if(resourceAirFlow.size() > 0) {
442                        buffer.append("mean: "+resourceAirFlowStats.getMeanValue());
443                        buffer.append(System.getProperty("line.separator"));   
444                }
445
446                return buffer.toString();
447        }
448       
449        public Object visit(ResourceTemperatureStats resourceTemperatureStats) {
450                Map<Long, Double> resourceTemperature = resourceTemperatureStats.getHistory();
451                String metricName = "temperature";
452                int mapSize = resourceTemperature.size();
453                /*
454                 * FIXME:
455                 * Integer.MAX_VALUE = 2147483647. We assume, that each line contains
456                 * max 30 signs - this gives max 71582788 lines. If resourceUsage map
457                 * contains more elements then we have a problem, because content of
458                 * resourceUsage map will not fit in the buffer.
459                 * This will need further attention in the future.
460                 */
461                int maxSize = (Integer.MAX_VALUE / 30 ) - 1;
462                if(mapSize >= maxSize){
463                        log.error("Resource temperature data is to long to fit in the buffer.");
464                        return null;
465                }
466               
467                int size = 30 * resourceTemperature.size();
468               
469                StringBuffer buffer = null;
470
471                if(printedHeaders.add(resourceTemperatureStats.getUsageType())) {
472                        buffer = new StringBuffer(size + 42);
473                        /*String[] headers = resourceTemperatureStats.getHeaders();
474                        for(int i = 0; i < headers.length; i++)
475                        {
476                                buffer.append(headers[i]);
477                                buffer.append(fieldSeparator);
478                        }
479                        buffer.append(System.getProperty("line.separator"));*/
480                } else {
481                        buffer = new StringBuffer(size);
482                }
483               
484               
485                for (Long timestamp : resourceTemperature.keySet()) {
486                       
487                        buffer.append(metricName);
488                        buffer.append(fieldSeparator);
489                        buffer.append(resourceTemperatureStats.getResourceName());
490                        buffer.append(fieldSeparator);
491                        Double value = resourceTemperature.get(timestamp);
492                        buffer.append(timestamp);
493                        buffer.append(fieldSeparator);
494                        buffer.append(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT
495                                        .format(value));
496                        buffer.append(fieldSeparator);
497                        buffer.append(System.getProperty("line.separator"));
498
499                }
500
501                if(resourceTemperature.size() > 0) {
502                        buffer.append("mean: "+resourceTemperatureStats.getMeanValue());
503                        buffer.append(System.getProperty("line.separator"));   
504                }
505
506                return buffer.toString();
507        }
508
509
510        public Object visit(GSSAccumulatorsStats accStats) {
511
512                StringBuffer buffer = null;
513
514                if(printedHeaders.add("accStats")) {
515                        buffer = new StringBuffer(2800);
516                        String[] headers = accStats.getHeaders();
517                        for(int i = 0; i < headers.length; i++)
518                        {
519                                buffer.append(headers[i]);
520                                buffer.append(fieldSeparator);
521                        }
522                        buffer.append(System.getProperty("line.separator"));
523                } else {
524                        buffer = new StringBuffer(1400);
525                }
526               
527                buffer.append("Delayed tasks");
528                buffer.append(accStats.delayedTasks);
529                buffer.append(System.getProperty("line.separator"));
530                buffer.append("Failed requests (tasks)");
531                buffer.append(accStats.failedRequests);
532                buffer.append(System.getProperty("line.separator"));
533                buffer.append("Makespan");
534                buffer.append(accStats.makespan);
535                buffer.append(System.getProperty("line.separator"));
536                buffer.append("Resources queue length");
537                buffer.append(accStats.meanQueueLength);
538                buffer.append(System.getProperty("line.separator"));
539                buffer.append("Resources total load");
540                buffer.append(accStats.meanTotalLoad);
541                buffer.append(System.getProperty("line.separator"));
542                buffer.append("Energy usage");
543                buffer.append(accStats.meanEnergyUsage);
544                buffer.append(System.getProperty("line.separator"));
545                buffer.append("Task completion time");
546                buffer.append(accStats.meanTaskCompletionTime);
547                buffer.append(System.getProperty("line.separator"));
548                buffer.append("Task execution time");
549                buffer.append(accStats.meanTaskExecutionTime);
550                buffer.append(System.getProperty("line.separator"));
551                buffer.append("Task start time");
552                buffer.append(accStats.meanTaskStartTime);
553                buffer.append(System.getProperty("line.separator"));
554                buffer.append("Task flow time");
555                buffer.append(accStats.meanTaskFlowTime);
556                buffer.append(System.getProperty("line.separator"));
557                buffer.append("Task waiting time");
558                buffer.append(accStats.meanTaskWaitingTime);
559                buffer.append(System.getProperty("line.separator"));
560                buffer.append("Task lateness");
561                buffer.append(accStats.lateness);
562                buffer.append(System.getProperty("line.separator"));
563                buffer.append("Task tardiness");
564                buffer.append(accStats.tardiness);
565               
566                return buffer.toString();
567        }
568
569        public Object visit(MetricsStats metricsStats) {
570                StringBuffer buffer = new StringBuffer(300);
571                return buffer.toString();
572        }
573
574        public Object visit(ResourceHistoryStats arg) {
575                StringBuffer buffer = new StringBuffer(300);
576                return buffer.toString();
577        }
578
579        public Object visit(ResourceUsefulWorkStats arg) {
580                StringBuffer buffer = new StringBuffer(300);
581                return buffer.toString();
582        }
583
584        public Object visit(ResourceAvailabilityStats arg) {
585                StringBuffer buffer = new StringBuffer(300);
586                return buffer.toString();
587        }
588
589
590}
Note: See TracBrowser for help on using the repository browser.