source: DCWoRMS/trunk/src/simulator/stats/implementation/out/StringSerializer.java @ 805

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