Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Throw unimplemented.
[simgrid.git] / src / instr / instr_config.c
1 /* Copyright (c) 2010-2013. The SimGrid Team.
2  * All rights reserved.                                                     */
3
4 /* This program is free software; you can redistribute it and/or modify it
5   * under the terms of the license (GNU LGPL) which comes with this package. */
6
7 #include "instr/instr_private.h"
8 #include "simgrid/sg_config.h"
9 #include "surf/surf.h"
10
11 #ifdef HAVE_TRACING
12
13 XBT_LOG_NEW_CATEGORY(instr, "Logging the behavior of the tracing system (used for Visualization/Analysis of simulations)");
14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY (instr_config, instr, "Configuration");
15
16 #define OPT_TRACING               "tracing"
17 #define OPT_TRACING_PLATFORM      "tracing/platform"
18 #define OPT_TRACING_TOPOLOGY      "tracing/platform/topology"
19 #define OPT_TRACING_SMPI          "tracing/smpi"
20 #define OPT_TRACING_SMPI_GROUP    "tracing/smpi/group"
21 #define OPT_TRACING_SMPI_COMPUTING "tracing/smpi/computing"
22 #define OPT_TRACING_SMPI_INTERNALS "tracing/smpi/internals"
23 #define OPT_TRACING_DISPLAY_SIZES  "tracing/smpi/display_sizes"
24 #define OPT_TRACING_FORMAT        "tracing/smpi/format"
25 #define OPT_TRACING_FORMAT_TI_ONEFILE "tracing/smpi/format/ti_one_file"
26 #define OPT_TRACING_CATEGORIZED   "tracing/categorized"
27 #define OPT_TRACING_UNCATEGORIZED "tracing/uncategorized"
28 #define OPT_TRACING_MSG_PROCESS   "tracing/msg/process"
29 #define OPT_TRACING_MSG_VM        "tracing/msg/vm"
30 #define OPT_TRACING_FILENAME      "tracing/filename"
31 #define OPT_TRACING_BUFFER        "tracing/buffer"
32 #define OPT_TRACING_ONELINK_ONLY  "tracing/onelink_only"
33 #define OPT_TRACING_DISABLE_DESTROY "tracing/disable_destroy"
34 #define OPT_TRACING_BASIC         "tracing/basic"
35 #define OPT_TRACING_COMMENT       "tracing/comment"
36 #define OPT_TRACING_COMMENT_FILE  "tracing/comment_file"
37 #define OPT_VIVA_UNCAT_CONF      "viva/uncategorized"
38 #define OPT_VIVA_CAT_CONF        "viva/categorized"
39 #define OPT_TRACING_DISABLE_LINK        "tracing/disable_link"
40 #define OPT_TRACING_DISABLE_POWER       "tracing/disable_power"
41
42 static int trace_enabled;
43 static int trace_platform;
44 static int trace_platform_topology;
45 static int trace_smpi_enabled;
46 static int trace_smpi_grouped;
47 static int trace_smpi_computing;
48 static int trace_view_internals;
49 static int trace_categorized;
50 static int trace_uncategorized;
51 static int trace_msg_process_enabled;
52 static int trace_msg_vm_enabled;
53 static int trace_buffer;
54 static int trace_onelink_only;
55 static int trace_disable_destroy;
56 static int trace_basic;
57 static int trace_display_sizes = 0;
58 static int trace_disable_link;
59 static int trace_disable_power;
60
61 static int trace_configured = 0;
62 static int trace_active = 0;
63
64
65
66 static void TRACE_getopts(void)
67 {
68   trace_enabled = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING);
69   trace_platform = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_PLATFORM);
70   trace_platform_topology = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_TOPOLOGY);
71   trace_smpi_enabled = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_SMPI);
72   trace_smpi_grouped = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_SMPI_GROUP);
73   trace_smpi_computing = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_SMPI_COMPUTING);
74   trace_view_internals = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_SMPI_INTERNALS);
75   trace_categorized = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_CATEGORIZED);
76   trace_uncategorized = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_UNCATEGORIZED);
77   trace_msg_process_enabled = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_MSG_PROCESS);
78   trace_msg_vm_enabled = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_MSG_VM);
79   trace_buffer = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_BUFFER);
80   trace_onelink_only = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_ONELINK_ONLY);
81   trace_disable_destroy = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_DISABLE_DESTROY);
82   trace_basic = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_BASIC);
83   trace_display_sizes = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_DISPLAY_SIZES);
84   trace_disable_link = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_DISABLE_LINK);
85   trace_disable_power = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_DISABLE_POWER);
86 }
87
88 static xbt_dynar_t TRACE_start_functions = NULL;
89 void TRACE_add_start_function(void (*func) ())
90 {
91   if (TRACE_start_functions == NULL)
92     TRACE_start_functions = xbt_dynar_new(sizeof(void (*)()), NULL);
93   xbt_dynar_push(TRACE_start_functions, &func);
94 }
95
96 int TRACE_start()
97 {
98   TRACE_getopts();
99
100   // tracing system must be:
101   //    - enabled (with --cfg=tracing:yes)
102   //    - already configured (TRACE_global_init already called)
103   if (TRACE_is_enabled() && TRACE_is_configured()) {
104     XBT_DEBUG("Tracing starts");
105
106     /* init the tracing module to generate the right output */
107     /* open internal buffer */
108     TRACE_init();
109
110     /* open the trace file(s) */
111     const char* format = sg_cfg_get_string(OPT_TRACING_FORMAT);
112     XBT_DEBUG("Tracing format %s\n", format);
113     if(!strcmp(format, "Paje")){
114       TRACE_paje_init();
115       TRACE_paje_start();
116     }else if (!strcmp(format, "TI")){
117       TRACE_TI_init();
118       TRACE_TI_start();
119     }else{
120       xbt_die("Unknown trace format :%s ", format);
121     }
122
123     /* activate trace */
124     if (trace_active == 1) {
125       THROWF(tracing_error, 0, "Tracing is already active");
126     }
127     trace_active = 1;
128     XBT_DEBUG("Tracing is on");
129
130     /* other trace initialization */
131     created_categories = xbt_dict_new_homogeneous(xbt_free);
132     declared_marks = xbt_dict_new_homogeneous(xbt_free);
133     user_host_variables = xbt_dict_new_homogeneous(xbt_free);
134     user_vm_variables = xbt_dict_new_homogeneous (xbt_free);
135     user_link_variables = xbt_dict_new_homogeneous(xbt_free);
136
137     if (TRACE_start_functions != NULL) {
138       void (*func) ();
139       unsigned int iter = xbt_dynar_length(TRACE_start_functions);
140       xbt_dynar_foreach(TRACE_start_functions, iter, func) {
141         func();
142       }
143     }
144   }
145   xbt_dynar_free(&TRACE_start_functions);
146   return 0;
147 }
148
149 static xbt_dynar_t TRACE_end_functions = NULL;
150 void TRACE_add_end_function(void (*func) (void))
151 {
152   if (TRACE_end_functions == NULL)
153     TRACE_end_functions = xbt_dynar_new(sizeof(void (*)(void)), NULL);
154   xbt_dynar_push(TRACE_end_functions, &func);
155 }
156
157 int TRACE_end()
158 {
159   int retval;
160   if (!trace_active) {
161     retval = 1;
162   } else {
163     retval = 0;
164
165     TRACE_generate_viva_uncat_conf();
166     TRACE_generate_viva_cat_conf();
167
168     /* dump trace buffer */
169     TRACE_last_timestamp_to_dump = surf_get_clock();
170     TRACE_paje_dump_buffer(1);
171
172     /* destroy all data structures of tracing (and free) */
173     PJ_container_free_all();
174     PJ_type_free_all();
175     PJ_container_release();
176     PJ_type_release();
177
178     if (TRACE_end_functions != NULL) {
179       void (*func) (void);
180       unsigned int iter;
181       xbt_dynar_foreach(TRACE_end_functions, iter, func) {
182         func();
183       }
184     }
185
186     xbt_dict_free(&user_link_variables);
187     xbt_dict_free(&user_host_variables);
188     xbt_dict_free(&user_vm_variables);
189     xbt_dict_free(&declared_marks);
190     xbt_dict_free(&created_categories);
191
192     /* close the trace files */
193     const char* format = sg_cfg_get_string(OPT_TRACING_FORMAT);
194     XBT_DEBUG("Tracing format %s\n", format);
195     if(!strcmp(format, "Paje")){
196       TRACE_paje_end();
197     }else if (!strcmp(format, "TI")){
198       TRACE_TI_end();
199     }else{
200       xbt_die("Unknown trace format :%s ", format);
201     }
202     /* close internal buffer */
203     TRACE_finalize();
204     /* de-activate trace */
205     trace_active = 0;
206     XBT_DEBUG("Tracing is off");
207     XBT_DEBUG("Tracing system is shutdown");
208   }
209   xbt_dynar_free(&TRACE_start_functions); /* useful when exiting early */
210   xbt_dynar_free(&TRACE_end_functions);
211   return retval;
212 }
213
214 int TRACE_needs_platform (void)
215 {
216   return TRACE_msg_process_is_enabled() ||
217          TRACE_msg_vm_is_enabled() ||
218          TRACE_categorized() ||
219          TRACE_uncategorized() ||
220          TRACE_platform () ||
221          (TRACE_smpi_is_enabled() && TRACE_smpi_is_grouped());
222 }
223
224 int TRACE_is_enabled(void)
225 {
226   return trace_enabled;
227 }
228
229 int TRACE_platform(void)
230 {
231   return trace_platform;
232 }
233
234 int TRACE_platform_topology(void)
235 {
236   return trace_platform_topology;
237 }
238
239 int TRACE_is_configured(void)
240 {
241   return trace_configured;
242 }
243
244 int TRACE_smpi_is_enabled(void)
245 {
246   return (trace_smpi_enabled || TRACE_smpi_is_grouped())
247     && TRACE_is_enabled();
248 }
249
250 int TRACE_smpi_is_grouped(void)
251 {
252   return trace_smpi_grouped;
253 }
254
255 int TRACE_smpi_is_computing(void)
256 {
257   return trace_smpi_computing;
258 }
259
260 int TRACE_smpi_view_internals(void)
261 {
262   return trace_view_internals;
263 }
264
265 int TRACE_categorized (void)
266 {
267   return trace_categorized;
268 }
269
270 int TRACE_uncategorized (void)
271 {
272   return trace_uncategorized;
273 }
274
275 int TRACE_msg_process_is_enabled(void)
276 {
277   return trace_msg_process_enabled && TRACE_is_enabled();
278 }
279
280 int TRACE_msg_vm_is_enabled(void)
281 {
282   return trace_msg_vm_enabled && TRACE_is_enabled();
283 }
284
285 int TRACE_disable_link(void)
286 {
287   return trace_disable_link && TRACE_is_enabled();
288 }
289
290 int TRACE_disable_power(void)
291 {
292   return trace_disable_power && TRACE_is_enabled();
293 }
294
295 int TRACE_buffer (void)
296 {
297   return trace_buffer && TRACE_is_enabled();
298 }
299
300 int TRACE_onelink_only (void)
301 {
302   return trace_onelink_only && TRACE_is_enabled();
303 }
304
305 int TRACE_disable_destroy (void)
306 {
307   return trace_disable_destroy && TRACE_is_enabled();
308 }
309
310 int TRACE_basic (void)
311 {
312   return trace_basic && TRACE_is_enabled();
313 }
314
315 int TRACE_display_sizes (void)
316 {
317    return trace_display_sizes && trace_smpi_enabled && TRACE_is_enabled();
318 }
319
320 char *TRACE_get_comment (void)
321 {
322   return xbt_cfg_get_string(_sg_cfg_set, OPT_TRACING_COMMENT);
323 }
324
325 char *TRACE_get_comment_file (void)
326 {
327   return xbt_cfg_get_string(_sg_cfg_set, OPT_TRACING_COMMENT_FILE);
328 }
329
330 char *TRACE_get_filename(void)
331 {
332   return xbt_cfg_get_string(_sg_cfg_set, OPT_TRACING_FILENAME);
333 }
334
335 char *TRACE_get_viva_uncat_conf (void)
336 {
337   return xbt_cfg_get_string(_sg_cfg_set, OPT_VIVA_UNCAT_CONF);
338 }
339
340 char *TRACE_get_viva_cat_conf (void)
341 {
342   return xbt_cfg_get_string(_sg_cfg_set, OPT_VIVA_CAT_CONF);
343 }
344
345 void TRACE_global_init(int *argc, char **argv)
346 {
347   /* name of the tracefile */
348   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_FILENAME,
349                    "Trace file created by the instrumented SimGrid.",
350                    xbt_cfgelm_string, 1, 1, NULL, NULL);
351   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_TRACING_FILENAME, "simgrid.trace");
352
353   /* tracing */
354   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING,
355                    "Enable Tracing.",
356                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
357   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING, "no");
358
359   /* register platform in the trace */
360   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_PLATFORM,
361                    "Register the platform in the trace as a hierarchy.",
362                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
363   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_PLATFORM, "no");
364
365   /* register platform in the trace */
366   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_TOPOLOGY,
367                    "Register the platform topology in the trace as a graph.",
368                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
369   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_TOPOLOGY, "yes");
370
371   /* smpi */
372   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI,
373                    "Tracing of the SMPI interface.",
374                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
375   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_SMPI, "no");
376
377   /* smpi grouped */
378   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI_GROUP,
379                    "Group MPI processes by host.",
380                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
381   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_SMPI_GROUP, "no");
382
383   /* smpi computing */
384   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI_COMPUTING,
385                    "Generate states for timing out of SMPI parts of the application",
386                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
387   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_SMPI_COMPUTING, "no");
388
389   /* smpi internals */
390   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI_INTERNALS,
391                    "View internal messages sent by Collective communications in SMPI",
392                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
393   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_SMPI_INTERNALS, "no");
394
395   /* tracing categorized resource utilization traces */
396   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_CATEGORIZED,
397                    "Tracing categorized resource utilization of hosts and links.",
398                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
399   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_CATEGORIZED, "no");
400
401   /* tracing uncategorized resource utilization */
402   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_UNCATEGORIZED,
403                    "Tracing uncategorized resource utilization of hosts and links.",
404                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
405   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_UNCATEGORIZED, "no");
406
407   /* msg process */
408   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_MSG_PROCESS,
409                    "Tracing of MSG process behavior.",
410                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
411   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_MSG_PROCESS, "no");
412
413   /* msg process */
414   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_MSG_VM,
415                    "Tracing of MSG process behavior.",
416                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
417   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_MSG_VM, "no");
418
419   /* disable tracing link */
420   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISABLE_LINK,
421                    "Do not trace link bandwidth and latency.",
422                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
423   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_DISABLE_LINK, "no");
424
425   /* disable tracing link */
426   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISABLE_POWER,
427                    "Do not trace host power.",
428                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
429   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_DISABLE_POWER, "no");
430
431
432   /* tracing buffer */
433   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_BUFFER,
434                    "Buffer trace events to put them in temporal order.",
435                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
436   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_BUFFER, "yes");
437
438   /* tracing one link only */
439   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_ONELINK_ONLY,
440                    "Use only routes with one link to trace platform.",
441                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
442   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_ONELINK_ONLY, "no");
443
444   /* disable destroy */
445   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISABLE_DESTROY,
446                    "Disable platform containers destruction.",
447                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
448   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_DISABLE_DESTROY, "no");
449
450   /* basic -- Avoid extended events (impoverished trace file) */
451   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_BASIC,
452                    "Avoid extended events (impoverished trace file).",
453                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
454   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_BASIC, "no");
455
456   /* display_sizes -- Extended events with message size information */
457   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISPLAY_SIZES,
458                    "(smpi only for now) Extended events with message size information",
459                    xbt_cfgelm_boolean, 0, 1, NULL, NULL);
460   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_DISPLAY_SIZES, "no");
461
462   /* format -- Switch the ouput format of Tracing */
463   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_FORMAT,
464                    "(smpi only for now) Switch the ouput format of Tracing",
465                    xbt_cfgelm_string, 1, 1, NULL, NULL);
466   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_TRACING_FORMAT, "Paje");
467
468
469   /* format -- Switch the ouput format of Tracing */
470   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_FORMAT_TI_ONEFILE,
471                    "(smpi only for now) For replay format only : output to one file only",
472                    xbt_cfgelm_boolean, 1, 1, NULL, NULL);
473   xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_FORMAT_TI_ONEFILE, "no");
474
475   /* comment */
476   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_COMMENT,
477                    "Comment to be added on the top of the trace file.",
478                    xbt_cfgelm_string, 1, 1, NULL, NULL);
479   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_TRACING_COMMENT, "");
480
481   /* comment_file */
482   xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_COMMENT_FILE,
483                    "The contents of the file are added to the top of the trace file as comment.",
484                    xbt_cfgelm_string, 1, 1, NULL, NULL);
485   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_TRACING_COMMENT_FILE, "");
486
487   /* Viva graph configuration for uncategorized tracing */
488   xbt_cfg_register(&_sg_cfg_set, OPT_VIVA_UNCAT_CONF,
489                    "Viva Graph configuration file for uncategorized resource utilization traces.",
490                    xbt_cfgelm_string, 1, 1, NULL, NULL);
491   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_VIVA_UNCAT_CONF, "");
492
493   /* Viva graph configuration for uncategorized tracing */
494   xbt_cfg_register(&_sg_cfg_set, OPT_VIVA_CAT_CONF,
495                    "Viva Graph configuration file for categorized resource utilization traces.",
496                    xbt_cfgelm_string, 1, 1, NULL, NULL);
497   xbt_cfg_setdefault_string(_sg_cfg_set, OPT_VIVA_CAT_CONF, "");
498
499   /* instrumentation can be considered configured now */
500   trace_configured = 1;
501 }
502
503 static void print_line (const char *option, const char *desc, const char *longdesc, int detailed)
504 {
505   char str[INSTR_DEFAULT_STR_SIZE];
506   snprintf (str, INSTR_DEFAULT_STR_SIZE, "--cfg=%s ", option);
507
508   int len = strlen (str);
509   printf ("%s%*.*s %s\n", str, 30-len, 30-len, "", desc);
510   if (!!longdesc && detailed){
511     printf ("%s\n\n", longdesc);
512   }
513 }
514
515 void TRACE_help (int detailed)
516 {
517   printf(
518       "Description of the tracing options accepted by this simulator:\n\n");
519   print_line (OPT_TRACING, "Enable the tracing system",
520       "  It activates the tracing system and register the simulation platform\n"
521       "  in the trace file. You have to enable this option to others take effect.",
522       detailed);
523   print_line (OPT_TRACING_CATEGORIZED, "Trace categorized resource utilization",
524       "  It activates the categorized resource utilization tracing. It should\n"
525       "  be enabled if tracing categories are used by this simulator.",
526       detailed);
527   print_line (OPT_TRACING_UNCATEGORIZED, "Trace uncategorized resource utilization",
528       "  It activates the uncategorized resource utilization tracing. Use it if\n"
529       "  this simulator do not use tracing categories and resource use have to be\n"
530       "  traced.",
531       detailed);
532   print_line (OPT_TRACING_FILENAME, "Filename to register traces",
533       "  A file with this name will be created to register the simulation. The file\n"
534       "  is in the Paje format and can be analyzed using Viva, Paje, and PajeNG visualization\n"
535       "  tools. More information can be found in these webpages:\n"
536       "     http://github.com/schnorr/viva/\n"
537       "     http://github.com/schnorr/pajeng/\n"
538       "     http://paje.sourceforge.net/",
539       detailed);
540   print_line (OPT_TRACING_SMPI, "Trace the MPI Interface (SMPI)",
541       "  This option only has effect if this simulator is SMPI-based. Traces the MPI\n"
542       "  interface and generates a trace that can be analyzed using Gantt-like\n"
543       "  visualizations. Every MPI function (implemented by SMPI) is transformed in a\n"
544       "  state, and point-to-point communications can be analyzed with arrows.",
545       detailed);
546   print_line (OPT_TRACING_SMPI_GROUP, "Group MPI processes by host (SMPI)",
547       "  This option only has effect if this simulator is SMPI-based. The processes\n"
548       "  are grouped by the hosts where they were executed.",
549       detailed);
550   print_line (OPT_TRACING_SMPI_COMPUTING, "Generates a \" Computing \" State",
551       "  This option aims at tracing computations in the application, outside SMPI\n"
552       "  to allow further study of simulated or real computation time",
553       detailed);
554   print_line (OPT_TRACING_SMPI_INTERNALS, "Generates tracing events corresponding",
555       "  to point-to-point messages sent by collective communications",
556       detailed);
557   print_line (OPT_TRACING_MSG_PROCESS, "Trace processes behavior (MSG)",
558       "  This option only has effect if this simulator is MSG-based. It traces the\n"
559       "  behavior of all categorized MSG processes, grouping them by hosts. This option\n"
560       "  can be used to track process location if this simulator has process migration.",
561       detailed);
562   print_line (OPT_TRACING_BUFFER, "Buffer events to put them in temporal order",
563       "  This option put some events in a time-ordered buffer using the insertion\n"
564       "  sort algorithm. The process of acquiring and releasing locks to access this\n"
565       "  buffer and the cost of the sorting algorithm make this process slow. The\n"
566       "  simulator performance can be severely impacted if this option is activated,\n"
567       "  but you are sure to get a trace file with events sorted.",
568       detailed);
569   print_line (OPT_TRACING_ONELINK_ONLY, "Consider only one link routes to trace platform",
570       "  This option changes the way SimGrid register its platform on the trace file.\n"
571       "  Normally, the tracing considers all routes (no matter their size) on the\n"
572       "  platform file to re-create the resource topology. If this option is activated,\n"
573       "  only the routes with one link are used to register the topology within an AS.\n"
574       "  Routes among AS continue to be traced as usual.",
575       detailed);
576   print_line (OPT_TRACING_DISABLE_DESTROY, "Disable platform containers destruction",
577       "  Disable the destruction of containers at the end of simulation. This can be\n"
578       "  used with simulators that have a different notion of time (different from\n"
579       "  the simulated time).",
580       detailed);
581   print_line (OPT_TRACING_BASIC, "Avoid extended events (impoverished trace file).",
582       "  Some visualization tools are not able to parse correctly the Paje file format.\n"
583       "  Use this option if you are using one of these tools to visualize the simulation\n"
584       "  trace. Keep in mind that the trace might be incomplete, without all the\n"
585       "  information that would be registered otherwise.",
586       detailed);
587   print_line (OPT_TRACING_DISPLAY_SIZES, "Only works for SMPI now. Add message size information",
588       "Message size (in bytes) is added to links, and to states. For collectives, the displayed value \n"
589       "is the more relevant to the collective (total sent by the process, usually)",
590       detailed);
591   print_line (OPT_TRACING_FORMAT, "Only works for SMPI now. Switch output format",
592       "Default format is Paje. Time independent traces are also supported, \n"
593       "to output traces that can later be used by the trace replay tool",
594       detailed);
595   print_line (OPT_TRACING_FORMAT_TI_ONEFILE, "Only works for SMPI now, and TI output format",
596       "By default, each process outputs to a separate file, inside a filename_files folder \n"
597       "By setting this option to yes, all processes will output to only one file \n"
598       "This is meant to avoid opening thousands of files with large simulations",
599       detailed);
600   print_line (OPT_TRACING_COMMENT, "Comment to be added on the top of the trace file.",
601       "  Use this to add a comment line to the top of the trace file.",
602       detailed);
603   print_line (OPT_TRACING_COMMENT_FILE, "File contents added to trace file as comment.",
604       "  Use this to add the contents of a file to the top of the trace file as comment.",
605       detailed);
606   print_line (OPT_VIVA_UNCAT_CONF, "Generate a graph configuration for Viva",
607       "  This option can be used in all types of simulators build with SimGrid\n"
608       "  to generate a uncategorized resource utilization graph to be used as\n"
609       "  configuration for the Viva visualization tool. This option\n"
610       "  can be used with tracing/categorized:1 and tracing:1 options to\n"
611       "  analyze an unmodified simulator before changing it to contain\n"
612       "  categories.",
613       detailed);
614   print_line (OPT_VIVA_CAT_CONF, "Generate an uncategorized graph configuration for Viva",
615       "  This option can be used if this simulator uses tracing categories\n"
616       "  in its code. The file specified by this option holds a graph configuration\n"
617       "  file for the Viva visualization tool that can be used to analyze a categorized\n"
618       "  resource utilization.",
619       detailed);
620   print_line (OPT_TRACING_TOPOLOGY, "Register the platform topology as a graph",
621         "  This option (enabled by default) can be used to disable the tracing of\n"
622         "  the platform topology in the trace file. Sometimes, such task is really\n"
623         "  time consuming, since it must get the route from each host ot other hosts\n"
624         "  within the same Autonomous System (AS).",
625         detailed);
626 }
627
628 static void output_types (const char *name, xbt_dynar_t types, FILE *file)
629 {
630   unsigned int i;
631   fprintf (file, "  %s = (", name);
632   for (i = xbt_dynar_length(types); i > 0; i--) {
633     char *type = *(char**)xbt_dynar_get_ptr(types, i - 1);
634     fprintf (file, "\"%s\"", type);
635     if (i - 1 > 0){
636       fprintf (file, ",");
637     }else{
638       fprintf (file, ");\n");
639     }
640   }
641   xbt_dynar_free (&types);
642 }
643
644 static void output_categories (const char *name, xbt_dynar_t cats, FILE *file)
645 {
646   unsigned int i;
647   fprintf (file, "    values = (");
648   for (i = xbt_dynar_length(cats); i > 0; i--) {
649     char *cat = *(char**)xbt_dynar_get_ptr(cats, i - 1);
650     fprintf (file, "\"%s%s\"", name, cat);
651     if (i - 1 > 0){
652       fprintf (file, ",");
653     }else{
654       fprintf (file, ");\n");
655     }
656   }
657   xbt_dynar_free (&cats);
658 }
659
660 static void uncat_configuration (FILE *file)
661 {
662   //register NODE and EDGE types
663   output_types ("node", TRACE_get_node_types(), file);
664   output_types ("edge", TRACE_get_edge_types(), file);
665   fprintf (file, "\n");
666
667   //configuration for all nodes
668   fprintf (file,
669       "  host = {\n"
670       "    type = \"square\";\n"
671       "    size = \"power\";\n"
672       "    values = (\"power_used\");\n"
673       "  };\n"
674       "  link = {\n"
675       "    type = \"rhombus\";\n"
676       "    size = \"bandwidth\";\n"
677       "    values = (\"bandwidth_used\");\n"
678       "  };\n");
679   //close
680 }
681
682 static void cat_configuration (FILE *file)
683 {
684   //register NODE and EDGE types
685   output_types ("node", TRACE_get_node_types(), file);
686   output_types ("edge", TRACE_get_edge_types(), file);
687   fprintf (file, "\n");
688
689   //configuration for all nodes
690   fprintf (file,
691            "  host = {\n"
692            "    type = \"square\";\n"
693            "    size = \"power\";\n");
694   output_categories ("p", TRACE_get_categories(), file);
695   fprintf (file,
696            "  };\n"
697            "  link = {\n"
698            "    type = \"rhombus\";\n"
699            "    size = \"bandwidth\";\n");
700   output_categories ("b", TRACE_get_categories(), file);
701   fprintf (file, "  };\n");
702   //close
703 }
704
705 static void generate_uncat_configuration (const char *output, const char *name, int brackets)
706 {
707   if (output && strlen(output) > 0){
708     FILE *file = fopen (output, "w");
709     if (file == NULL){
710       THROWF (system_error, 1, "Unable to open file (%s) for writing %s graph "
711           "configuration (uncategorized).", output, name);
712     }
713
714     if (brackets) fprintf (file, "{\n");
715     uncat_configuration (file);
716     if (brackets) fprintf (file, "}\n");
717     fclose (file);
718   }
719 }
720
721 static void generate_cat_configuration (const char *output, const char *name, int brackets)
722 {
723   if (output && strlen(output) > 0){
724     //check if we do have categories declared
725     if (xbt_dict_is_empty(created_categories)){
726       XBT_INFO("No categories declared, ignoring generation of %s graph configuration", name);
727       return;
728     }
729
730     FILE *file = fopen (output, "w");
731     if (file == NULL){
732       THROWF (system_error, 1, "Unable to open file (%s) for writing %s graph "
733           "configuration (categorized).", output, name);
734     }
735
736     if (brackets) fprintf (file, "{\n");
737     cat_configuration (file);
738     if (brackets) fprintf (file, "}\n");
739     fclose (file);
740   }
741 }
742
743 void TRACE_generate_viva_uncat_conf (void)
744 {
745   generate_uncat_configuration (TRACE_get_viva_uncat_conf (), "viva", 0);
746 }
747
748 void TRACE_generate_viva_cat_conf (void)
749 {
750   generate_cat_configuration (TRACE_get_viva_cat_conf(), "viva", 0);
751 }
752
753 static int previous_trace_state = -1;
754
755 void instr_pause_tracing (void)
756 {
757   previous_trace_state = trace_enabled;
758   if (!TRACE_is_enabled()){
759     XBT_DEBUG ("Tracing is already paused, therefore do nothing.");
760   }else{
761     XBT_DEBUG ("Tracing is being paused.");
762   }
763   trace_enabled = 0;
764   XBT_DEBUG ("Tracing is paused.");
765 }
766
767 void instr_resume_tracing (void)
768 {
769   if (TRACE_is_enabled()){
770     XBT_DEBUG ("Tracing is already running while trying to resume, therefore do nothing.");
771   }else{
772     XBT_DEBUG ("Tracing is being resumed.");
773   }
774
775   if (previous_trace_state != -1){
776     trace_enabled = previous_trace_state;
777   }else{
778     trace_enabled = 1;
779   }
780   XBT_DEBUG ("Tracing is resumed.");
781   previous_trace_state = -1;
782 }
783
784 #undef OPT_TRACING
785 #undef OPT_TRACING_PLATFORM
786 #undef OPT_TRACING_TOPOLOGY
787 #undef OPT_TRACING_SMPI
788 #undef OPT_TRACING_SMPI_GROUP
789 #undef OPT_TRACING_CATEGORIZED
790 #undef OPT_TRACING_UNCATEGORIZED
791 #undef OPT_TRACING_MSG_PROCESS
792 #undef OPT_TRACING_FILENAME
793 #undef OPT_TRACING_BUFFER
794 #undef OPT_TRACING_ONELINK_ONLY
795 #undef OPT_TRACING_DISABLE_DESTROY
796 #undef OPT_TRACING_BASIC
797 #undef OPT_TRACING_COMMENT
798 #undef OPT_TRACING_COMMENT_FILE
799 #undef OPT_VIVA_UNCAT_CONF
800 #undef OPT_VIVA_CAT_CONF
801
802 #endif /* HAVE_TRACING */