Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Make semaphores visible from MSG
[simgrid.git] / src / xbt / log.c
index 334d289..c560de6 100644 (file)
@@ -1,6 +1,6 @@
 /* log - a generic logging facility in the spirit of log4j                  */
 
-/* Copyright (c) 2004, 2005, 2006, 2007, 2008, 2009, 2010. The SimGrid Team.
+/* Copyright (c) 2004-2011. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
 #include "xbt/sysdep.h"
 #include "xbt/log_private.h"
 #include "xbt/dynar.h"
+#include "xbt/xbt_os_thread.h"
 
-XBT_PUBLIC_DATA(int) (*xbt_pid) ();
 int xbt_log_no_loc = 0;         /* if set to true (with --log=no_loc), file localization will be omitted (for tesh tests) */
+static xbt_os_rmutex_t log_cat_init_mutex = NULL;
 
 /** \addtogroup XBT_log
  *
@@ -98,7 +99,7 @@ controlled by the <i>priority</i> concept (which should maybe be renamed to
 <i>severity</i>).
 
 Empirically, the user can specify that he wants to see every debugging message
-of GRAS while only being interested into the messages at level "error" or
+of MSG while only being interested into the messages at level "error" or
 higher about the XBT internals.
 
 \subsection log_app 1.3 Message appenders
@@ -182,14 +183,10 @@ compile with the -Wall option, gcc will warn you for unmatched arguments, ie
 when you pass a pointer to a string where an integer was specified by the
 format. This is usually a good idea.
 
-Because some C compilers do not support vararg macros, there is a version of
-the macro for any number of arguments from 0 to 6. The macro name ends with
-the total number of arguments.
-
 Here is an example of the most basic type of macro. This is a logging
 request with priority <i>warning</i>.
 
-<code>CLOG5(MyCat, gras_log_priority_warning, "Values are: %d and '%s'", 5,
+<code>XBT_CLOG(MyCat, xbt_log_priority_warning, "Values are: %d and '%s'", 5,
 "oops");</code>
 
 A logging request is said to be enabled if its priority is higher than or
@@ -202,7 +199,7 @@ example, one of the standard priorities is used, then there is a convenience
 macro that is typically used instead. For example, the above example is
 equivalent to the shorter:
 
-<code>CWARN4(MyCat, "Values are: %d and '%s'", 5, "oops");</code>
+<code>XBT_CWARN(MyCat, "Values are: %d and '%s'", 5, "oops");</code>
 
 \section log_API_isenabled 2.3 Checking if a particular category/priority is enabled
 
@@ -220,7 +217,7 @@ If \ref XBT_LOG_NEW_DEFAULT_SUBCATEGORY(MyCat, Parent) or
 \ref XBT_LOG_NEW_DEFAULT_CATEGORY(MyCat) is used to create the
 category, then the even shorter form can be used:
 
-<code>WARN3("Values are: %s and '%d'", 5, "oops");</code>
+<code>XBT_WARN("Values are: %s and '%d'", 5, "oops");</code>
 
 Only one default category can be created per file, though multiple
 non-defaults can be created and used.
@@ -230,28 +227,21 @@ non-defaults can be created and used.
 First of all, each module should register its own category into the categories
 tree using \ref XBT_LOG_NEW_DEFAULT_SUBCATEGORY.
 
-Then, logging should be done with the DEBUG<n>, VERB<n>, INFO<n>, WARN<n>,
-ERROR<n> or CRITICAL<n> macro families (such as #DEBUG10, #VERB10,
-#INFO10, #WARN10, #ERROR10 and #CRITICAL10). For each group, there is at
-least 11 different macros (like DEBUG0, DEBUG1, DEBUG2, DEBUG3, DEBUG4 and
-DEBUG5, DEBUG6, DEBUG7, DEBUG8, DEBUG9, DEBUG10), only differing in the number of arguments passed along the format.
-This is because we want SimGrid itself to keep compilable on ancient
-compiler not supporting variable number of arguments to macros. But we
-should provide a macro simpler to use for the users not interested in SP3
-machines (FIXME).
+Then, logging should be done with the #XBT_DEBUG, #XBT_VERB, #XBT_INFO,
+#XBT_WARN, #XBT_ERROR and #XBT_CRITICAL macros.
 
 Under GCC, these macro check there arguments the same way than printf does. So,
 if you compile with -Wall, the following code will issue a warning:
-<code>DEBUG2("Found %s (id %f)", some_string, a_double)</code>
+<code>XBT_DEBUG("Found %s (id %d)", some_string, a_double)</code>
 
 If you want to specify the category to log onto (for example because you
 have more than one category per file, add a C before the name of the log
-producing macro (ie, use #CDEBUG10, #CVERB10, #CINFO10, #CWARN10, #CERROR10 and
-#CCRITICAL10 and friends), and pass the category name as first argument.
+producing macro (ie, use #XBT_CDEBUG, #XBT_CVERB, #XBT_CINFO, #XBT_CWARN,
+#XBT_CERROR and #XBT_CCRITICAL and friends), and pass the category name as
+first argument.
 
 The TRACE priority is not used the same way than the other. You should use
-the #XBT_IN, XBT_IN<n> (up to #XBT_IN5), #XBT_OUT and #XBT_HERE macros
-instead.
+the #XBT_IN, #XBT_OUT and #XBT_HERE macros instead.
 
 \section log_API_example 2.6 Example of use
 
@@ -265,27 +255,24 @@ XBT_LOG_NEW_CATEGORY(VSS);
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(SA, VSS);
 
 int main() {
-       / * Now set the parent's priority.  (the string would typcially be a runtime option) * /
+       / * Now set the parent's priority.  (the string would typically be a runtime option) * /
        xbt_log_control_set("SA.thresh:3");
 
        / * This request is enabled, because WARNING >= INFO. * /
-       CWARN0(VSS, "Low fuel level.");
+       XBT_CWARN(VSS, "Low fuel level.");
 
        / * This request is disabled, because DEBUG < INFO. * /
-       CDEBUG0(VSS, "Starting search for nearest gas station.");
+       XBT_CDEBUG(VSS, "Starting search for nearest gas station.");
 
        / * The default category SA inherits its priority from VSS. Thus,
           the following request is enabled because INFO >= INFO.  * /
-       INFO0("Located nearest gas station.");
+       XBT_INFO("Located nearest gas station.");
 
        / * This request is disabled, because DEBUG < INFO. * /
-       DEBUG0("Exiting gas station search");
+       XBT_DEBUG("Exiting gas station search");
 }
 \endverbatim
 
-Another example can be found in the relevant part of the GRAS tutorial:
-\ref GRAS_tut_tour_logs.
-
 \section log_user 3. User interface
 
 \section log_use_conf 3.1 Configuration
@@ -293,24 +280,45 @@ Another example can be found in the relevant part of the GRAS tutorial:
 Although rarely done, it is possible to configure the logs during
 program initialization by invoking the xbt_log_control_set() method
 manually. A more conventional way is to use the --log command line
-argument. xbt_init() (called by MSG_init(), gras_init() and friends)
+argument. xbt_init() (called by MSG_init() and friends)
 checks and deals properly with such arguments.
 
-The following command line arguments exist, but are deprecated and
-may disappear in the future: --xbt-log, --gras-log, --msg-log and
---surf-log.
-
 \subsection log_use_conf_thres 3.1.1 Threshold configuration
 
 The most common setting is to control which logging event will get
 displayed by setting a threshold to each category through the
-<tt>thres</tt> keyword.
+<tt>threshold</tt> keyword.
 
-For example, \verbatim --log=root.thres:debug\endverbatim will make
+For example, \verbatim --log=root.threshold:debug\endverbatim will make
 SimGrid <b>extremely</b> verbose while \verbatim
 --log=root.thres:critical\endverbatim should shut it almost
 completely off.
 
+Note that the <tt>threshold</tt> keyword can be abbreviated here. For example,
+all the following notations have the same result.
+\verbatim
+--log=root.threshold:debug
+--log=root.threshol:debug
+--log=root.thresho:debug
+--log=root.thresh:debug
+--log=root.thres:debug
+--log=root.thre:debug
+--log=root.thr:debug
+--log=root.th:debug
+--log=root.t:debug
+--log=root.:debug     <--- That's obviously really ugly, but it actually works.
+\endverbatim
+
+The full list of recognized thresholds is the following:
+
+ - trace: enter and return of some functions
+ - debug: crufty output
+ - verbose: verbose output for the user wanting more
+ - info: output about the regular functionning
+ - warning: minor issue encountered
+ - error: issue encountered
+ - critical: major issue encountered 
+
 \subsection log_use_conf_multi 3.1.2 Passing several settings
 
 You can provide several of those arguments to change the setting of several
@@ -343,7 +351,7 @@ Here are the existing format directives:
  - %%p: Priority name (LOG4J compatible)
 
  - %%h: Hostname (SimGrid extension)
- - %%P: Process name (SimGrid extension)
+ - %%P: Process name (SimGrid extension -- note that with SMPI this is the integer value of the process rank)
  - %%t: Thread "name" (LOG4J compatible -- actually the address of the thread in memory)
  - %%i: Process PID (SimGrid extension -- this is a 'i' as in 'i'dea)
 
@@ -364,18 +372,25 @@ Here are the existing format directives:
 
 
 If you want to mimic the simple layout with the format one, you would use this
-format: '[%%h:%%i:(%%I) %%r] %%l: [%%c/%%p] %%m%%n'. This is not completely correct
+format: '[%%h:%%i:(%%i) %%r] %%l: [%%c/%%p] %%m%%n'. This is not completely correct
 because the simple layout do not display the message location for messages at
-priority INFO (thus, the fmt is '[%%h:%%i:(%%I) %%r] %%l: [%%c/%%p] %%m%%n' in this
+priority INFO (thus, the fmt is '[%%h:%%i:(%%i) %%r] [%%c/%%p] %%m%%n' in this
 case). Moreover, if there is no process name (ie, messages coming from the
 library itself, or test programs doing strange things) do not display the
 process identity (thus, fmt is '[%%r] %%l: [%%c/%%p] %%m%%n' in that case, and '[%%r]
 [%%c/%%p] %%m%%n' if they are at priority INFO).
 
-For now, there is only one format modifier: the precision field. You
-can for example specify %.4r to get the application age with 4
-numbers after the radix. Another limitation is that you cannot set
-specific layouts to the several priorities.
+For now, there is only two format modifiers: the precision and the
+width fields. You can for example specify %.4r to get the application
+age with 4 numbers after the radix, or %15p to get the process name
+on 15 columns. Finally, you can specify %10.6r to get the time on at
+most 10 columns, with 6 numbers after the radix. 
+
+Note that when specifying the width, it is filled with spaces. That
+is to say that for example %5r in your format is converted to "% 5f"
+for printf (note the extra space); there is no way to fill the empty
+columns with 0 (ie, pass "%05f" to printf). Another limitation is
+that you cannot set specific layouts to the several priorities.
 
 \subsection log_use_conf_app 3.1.4 Category appender
 
@@ -423,10 +438,10 @@ requires an a single comparison of a static variable to a constant.
 
 There is also compile time constant, \ref XBT_LOG_STATIC_THRESHOLD, which
 causes all logging requests with a lower priority to be optimized to 0 cost
-by the compiler. By setting it to gras_log_priority_infinite, all logging
+by the compiler. By setting it to xbt_log_priority_infinite, all logging
 requests are statically disabled at compile time and cost nothing. Released executables
 <i>might</i>  be compiled with (note that it will prevent users to debug their problems)
-\verbatim-DXBT_LOG_STATIC_THRESHOLD=gras_log_priority_infinite\endverbatim
+\verbatim-DXBT_LOG_STATIC_THRESHOLD=xbt_log_priority_infinite\endverbatim
 
 Compiling with the \verbatim-DNLOG\endverbatim option disables all logging
 requests at compilation time while the \verbatim-DNDEBUG\endverbatim disables
@@ -460,19 +475,15 @@ The default appender function currently prints to stderr, and the only other
 existing one writes to the specified file. More would be needed, like the one
 able to send the logs to a remote dedicated server.
 This is on our TODO list for quite a while now, but your help would be
-welcome here, too.
-
-
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              *//*' */
-
+welcome here, too. */
 
 xbt_log_appender_t xbt_log_default_appender = NULL;     /* set in log_init */
 xbt_log_layout_t xbt_log_default_layout = NULL; /* set in log_init */
 
 typedef struct {
   char *catname;
-  e_xbt_log_priority_t thresh;
   char *fmt;
+  e_xbt_log_priority_t thresh;
   int additivity;
   xbt_log_appender_t appender;
 } s_xbt_log_setting_t, *xbt_log_setting_t;
@@ -484,8 +495,7 @@ static void _free_setting(void *s)
   xbt_log_setting_t set = *(xbt_log_setting_t *) s;
   if (set) {
     free(set->catname);
-    if (set->fmt)
-      free(set->fmt);
+    free(set->fmt);
     free(set);
   }
 }
@@ -506,19 +516,13 @@ const char *xbt_log_priority_names[8] = {
 
 s_xbt_log_category_t _XBT_LOGV(XBT_LOG_ROOT_CAT) = {
   NULL /*parent */ , NULL /* firstChild */ , NULL /* nextSibling */ ,
-      "root", xbt_log_priority_uninitialized /* threshold */ ,
+      "root", "The common ancestor for all categories",
+      0 /*initialized */, xbt_log_priority_uninitialized /* threshold */ ,
       0 /* isThreshInherited */ ,
       NULL /* appender */ , NULL /* layout */ ,
       0                         /* additivity */
 };
 
-XBT_LOG_NEW_CATEGORY(xbt, "All XBT categories (simgrid toolbox)");
-XBT_LOG_NEW_CATEGORY(surf, "All SURF categories");
-XBT_LOG_NEW_CATEGORY(msg, "All MSG categories");
-XBT_LOG_NEW_CATEGORY(simix, "All SIMIX categories");
-XBT_LOG_NEW_CATEGORY(mc, "All MC categories");
-XBT_LOG_NEW_CATEGORY(bindings, "All bindings categories");
-
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(log, xbt,
                                 "Loggings from the logging mechanism itself");
 
@@ -530,48 +534,225 @@ void xbt_log_preinit(void)
   xbt_log_default_layout = xbt_log_layout_simple_new(NULL);
   _XBT_LOGV(XBT_LOG_ROOT_CAT).appender = xbt_log_default_appender;
   _XBT_LOGV(XBT_LOG_ROOT_CAT).layout = xbt_log_default_layout;
+  log_cat_init_mutex = xbt_os_rmutex_init();
+}
+
+static void xbt_log_connect_categories(void)
+{
+  /* Connect our log channels: that must be done manually under windows */
+  /* Also permit that they are correctly listed by xbt_log_help_categories() */
+
+  /* xbt */
+  XBT_LOG_CONNECT(xbt);
+  XBT_LOG_CONNECT(graphxml_parse);
+  XBT_LOG_CONNECT(log);
+#if HAVE_MMAP
+  XBT_LOG_CONNECT(mm_diff);
+#endif
+  XBT_LOG_CONNECT(module);
+  XBT_LOG_CONNECT(peer);
+  XBT_LOG_CONNECT(replay);
+  XBT_LOG_CONNECT(strbuff);
+  XBT_LOG_CONNECT(xbt_cfg);
+  XBT_LOG_CONNECT(xbt_dict);
+  XBT_LOG_CONNECT(xbt_dict_cursor);
+  XBT_LOG_CONNECT(xbt_dict_elm);
+#ifdef XBT_USE_DEPRECATED
+  XBT_LOG_CONNECT(xbt_dict_multi);
+#endif
+  XBT_LOG_CONNECT(xbt_dyn);
+  XBT_LOG_CONNECT(xbt_ex);
+  XBT_LOG_CONNECT(xbt_fifo);
+  XBT_LOG_CONNECT(xbt_graph);
+  XBT_LOG_CONNECT(xbt_heap);
+  XBT_LOG_CONNECT(xbt_lib);
+  XBT_LOG_CONNECT(xbt_mallocator);
+  XBT_LOG_CONNECT(xbt_matrix);
+  XBT_LOG_CONNECT(xbt_parmap);
+  XBT_LOG_CONNECT(xbt_queue);
+  XBT_LOG_CONNECT(xbt_set);
+  XBT_LOG_CONNECT(xbt_sync);
+  XBT_LOG_CONNECT(xbt_sync_os);
+
+#ifdef simgrid_EXPORTS
+  /* The following categories are only defined in libsimgrid */
+
+  /* bindings */
+#ifdef HAVE_LUA
+  XBT_LOG_CONNECT(bindings);
+  XBT_LOG_CONNECT(lua);
+  XBT_LOG_CONNECT(lua_comm);
+  XBT_LOG_CONNECT(lua_host);
+  XBT_LOG_CONNECT(lua_platf);
+  XBT_LOG_CONNECT(lua_process);
+  XBT_LOG_CONNECT(lua_state_cloner);
+  XBT_LOG_CONNECT(lua_task);
+  XBT_LOG_CONNECT(lua_utils);
+#endif
+
+  /* instr */
+#ifdef HAVE_TRACING
+  XBT_LOG_CONNECT(instr);
+  XBT_LOG_CONNECT(instr_api);
+  XBT_LOG_CONNECT(instr_config);
+  XBT_LOG_CONNECT(instr_msg);
+  XBT_LOG_CONNECT(instr_msg_process);
+  XBT_LOG_CONNECT(instr_msg_vm);
+  XBT_LOG_CONNECT(instr_paje_containers);
+  XBT_LOG_CONNECT(instr_paje_header);
+  XBT_LOG_CONNECT(instr_paje_trace);
+  XBT_LOG_CONNECT(instr_paje_types);
+  XBT_LOG_CONNECT(instr_paje_values);
+  XBT_LOG_CONNECT(instr_resource);
+  XBT_LOG_CONNECT(instr_routing);
+  XBT_LOG_CONNECT(instr_sd);
+  XBT_LOG_CONNECT(instr_surf);
+#endif
+
+  /* jedule */
+#ifdef HAVE_JEDULE
+  XBT_LOG_CONNECT(jedule);
+  XBT_LOG_CONNECT(jed_out);
+  XBT_LOG_CONNECT(jed_sd);
+#endif
+
+  /* mc */
+#ifdef HAVE_MC
+  XBT_LOG_CONNECT(mc);
+  XBT_LOG_CONNECT(mc_checkpoint);
+  XBT_LOG_CONNECT(mc_compare);
+  XBT_LOG_CONNECT(mc_dpor);
+  XBT_LOG_CONNECT(mc_global);
+  XBT_LOG_CONNECT(mc_liveness);
+  XBT_LOG_CONNECT(mc_memory);
+  XBT_LOG_CONNECT(mc_memory_map);
+  XBT_LOG_CONNECT(mc_request);
+#endif
+
+  /* msg */
+  XBT_LOG_CONNECT(msg);
+  XBT_LOG_CONNECT(msg_action);
+  XBT_LOG_CONNECT(msg_gos);
+  XBT_LOG_CONNECT(msg_io);
+  XBT_LOG_CONNECT(msg_kernel);
+  XBT_LOG_CONNECT(msg_mailbox);
+  XBT_LOG_CONNECT(msg_new_API);
+  XBT_LOG_CONNECT(msg_process);
+  XBT_LOG_CONNECT(msg_synchro);
+  XBT_LOG_CONNECT(msg_task);
+  XBT_LOG_CONNECT(msg_vm);
+   
+  /* simdag */
+  XBT_LOG_CONNECT(sd);
+  XBT_LOG_CONNECT(sd_daxparse);
+#ifdef HAVE_GRAPHVIZ
+  XBT_LOG_CONNECT(sd_dotparse);
+#endif
+  XBT_LOG_CONNECT(sd_kernel);
+  XBT_LOG_CONNECT(sd_task);
+  XBT_LOG_CONNECT(sd_workstation);
+
+  /* simix */
+  XBT_LOG_CONNECT(simix);
+  XBT_LOG_CONNECT(simix_context);
+  XBT_LOG_CONNECT(simix_deployment);
+  XBT_LOG_CONNECT(simix_environment);
+  XBT_LOG_CONNECT(simix_host);
+  XBT_LOG_CONNECT(simix_io);
+  XBT_LOG_CONNECT(simix_kernel);
+  XBT_LOG_CONNECT(simix_network);
+  XBT_LOG_CONNECT(simix_new_api);
+  XBT_LOG_CONNECT(simix_process);
+  XBT_LOG_CONNECT(simix_smurf);
+  XBT_LOG_CONNECT(simix_synchro);
+
+  /* smpi */
+  /* SMPI categories are connected in smpi_global.c */
+
+  /* surf */
+  XBT_LOG_CONNECT(surf);
+  XBT_LOG_CONNECT(platf_generator);
+  XBT_LOG_CONNECT(random);
+  XBT_LOG_CONNECT(surf_config);
+  XBT_LOG_CONNECT(surf_cpu);
+  XBT_LOG_CONNECT(surf_cpu_ti);
+  XBT_LOG_CONNECT(surf_kernel);
+  XBT_LOG_CONNECT(surf_lagrange);
+  XBT_LOG_CONNECT(surf_lagrange_dichotomy);
+  XBT_LOG_CONNECT(surf_maxmin);
+  XBT_LOG_CONNECT(surf_network);
+  XBT_LOG_CONNECT(surf_new_model);
+#ifdef HAVE_GTNETS
+  XBT_LOG_CONNECT(surf_network_gtnets);
+  XBT_LOG_CONNECT(surf_network_gtnets_interface);
+  XBT_LOG_CONNECT(surf_network_gtnets_simulator);
+  XBT_LOG_CONNECT(surf_network_gtnets_topology);
+#endif
+#ifdef HAVE_NS3
+  XBT_LOG_CONNECT(surf_network_ns3);
+  XBT_LOG_CONNECT(interface_ns3);
+  XBT_LOG_CONNECT(simulator_ns3);
+#endif
+  XBT_LOG_CONNECT(surf_parse);
+  XBT_LOG_CONNECT(surf_route);
+  XBT_LOG_CONNECT(surf_routing_generic);
+  XBT_LOG_CONNECT(surf_route_cluster);
+  XBT_LOG_CONNECT(surf_route_dijkstra);
+  XBT_LOG_CONNECT(surf_route_floyd);
+  XBT_LOG_CONNECT(surf_route_full);
+  XBT_LOG_CONNECT(surf_route_none);
+  XBT_LOG_CONNECT(surf_route_vivaldi);
+  XBT_LOG_CONNECT(surf_storage);
+  XBT_LOG_CONNECT(surf_trace);
+  XBT_LOG_CONNECT(surf_workstation);
+
+#endif /* simgrid_EXPORTS */
 }
 
+static void xbt_log_help(void);
+static void xbt_log_help_categories(void);
+
 /** @brief Get all logging settings from the command line
  *
  * xbt_log_control_set() is called on each string we got from cmd line
  */
 void xbt_log_init(int *argc, char **argv)
 {
+  unsigned help_requested = 0;  /* 1: logs; 2: categories */
   int i, j;
   char *opt;
 
   //    _XBT_LOGV(log).threshold = xbt_log_priority_debug; /* uncomment to set the LOG category to debug directly */
 
-  /* Set logs and init log submodule */
-  for (i = 1; i < *argc; i++) {
-    if (!strncmp(argv[i], "--log=", strlen("--log=")) ||
-        !strncmp(argv[i], "--gras-log=", strlen("--gras-log=")) ||
-        !strncmp(argv[i], "--surf-log=", strlen("--surf-log=")) ||
-        !strncmp(argv[i], "--msg-log=", strlen("--msg-log=")) ||
-        !strncmp(argv[i], "--simix-log=", strlen("--simix-log=")) ||
-        !strncmp(argv[i], "--xbt-log=", strlen("--xbt-log="))) {
-
-      if (strncmp(argv[i], "--log=", strlen("--log=")))
-        WARN2
-            ("Option %.*s is deprecated and will disapear in the future. Use --log instead.",
-             (int) (strchr(argv[i], '=') - argv[i]), argv[i]);
+  xbt_log_connect_categories();
 
+  /* Set logs and init log submodule */
+  for (j = i = 1; i < *argc; i++) {
+    if (!strncmp(argv[i], "--log=", strlen("--log="))) {
       opt = strchr(argv[i], '=');
       opt++;
       xbt_log_control_set(opt);
-      DEBUG1("Did apply '%s' as log setting", opt);
-      /*remove this from argv */
-
-      for (j = i + 1; j < *argc; j++) {
-        argv[j - 1] = argv[j];
-      }
-
-      argv[j - 1] = NULL;
-      (*argc)--;
-      i--;                      /* compensate effect of next loop incrementation */
+      XBT_DEBUG("Did apply '%s' as log setting", opt);
+    } else if (!strcmp(argv[i], "--help-logs")) {
+      help_requested |= 1;
+    } else if (!strcmp(argv[i], "--help-log-categories")) {
+      help_requested |= 2;
+    } else {
+      argv[j++] = argv[i];
     }
   }
+  if (j < *argc) {
+    argv[j] = NULL;
+    *argc = j;
+  }
+
+  if (help_requested) {
+    if (help_requested & 1)
+      xbt_log_help();
+    if (help_requested & 2)
+      xbt_log_help_categories();
+    exit(0);
+  }
 }
 
 static void log_cat_exit(xbt_log_category_t cat)
@@ -595,39 +776,74 @@ static void log_cat_exit(xbt_log_category_t cat)
 
 void xbt_log_postexit(void)
 {
-  VERB0("Exiting log");
+  XBT_VERB("Exiting log");
+  xbt_os_rmutex_destroy(log_cat_init_mutex);
   xbt_dynar_free(&xbt_log_settings);
   log_cat_exit(&_XBT_LOGV(XBT_LOG_ROOT_CAT));
 }
 
+ /* Size of the static string in which we  build the log string */
+#define XBT_LOG_STATIC_BUFFER_SIZE 2048
+/* Minimum size of the dynamic string in which we build the log string
+   (should be greater than XBT_LOG_STATIC_BUFFER_SIZE) */
+#define XBT_LOG_DYNAMIC_BUFFER_SIZE 4096
+
 void _xbt_log_event_log(xbt_log_event_t ev, const char *fmt, ...)
 {
-
   xbt_log_category_t cat = ev->cat;
 
-  va_start(ev->ap, fmt);
-  va_start(ev->ap_copy, fmt);
-  while (1) {
+  xbt_assert(ev->priority >= 0,
+             "Negative logging priority naturally forbidden");
+  xbt_assert(ev->priority < sizeof(xbt_log_priority_names),
+             "Priority %d is greater than the biggest allowed value",
+             ev->priority);
+
+  do {
     xbt_log_appender_t appender = cat->appender;
-    if (appender != NULL) {
-      xbt_assert1(cat->layout,
-                  "No valid layout for the appender of category %s",
-                  cat->name);
-      cat->layout->do_layout(cat->layout, ev, fmt, appender);
+
+    if (!appender)
+      continue;                 /* No appender, try next */
+
+    xbt_assert(cat->layout,
+               "No valid layout for the appender of category %s", cat->name);
+
+    /* First, try with a static buffer */
+    if (XBT_LOG_STATIC_BUFFER_SIZE) {
+      char buff[XBT_LOG_STATIC_BUFFER_SIZE];
+      int done;
+      ev->buffer = buff;
+      ev->buffer_size = sizeof buff;
+      va_start(ev->ap, fmt);
+      done = cat->layout->do_layout(cat->layout, ev, fmt);
+      va_end(ev->ap);
+      if (done) {
+        appender->do_append(appender, buff);
+        continue;               /* Ok, that worked: go next */
+      }
     }
-    if (!cat->additivity)
-      break;
 
-    cat = cat->parent;
-  }
-  va_end(ev->ap);
-  va_end(ev->ap_copy);
+    /* The static buffer was too small, use a dynamically expanded one */
+    ev->buffer_size = XBT_LOG_DYNAMIC_BUFFER_SIZE;
+    ev->buffer = xbt_malloc(ev->buffer_size);
+    while (1) {
+      int done;
+      va_start(ev->ap, fmt);
+      done = cat->layout->do_layout(cat->layout, ev, fmt);
+      va_end(ev->ap);
+      if (done)
+        break;                  /* Got it */
+      ev->buffer_size *= 2;
+      ev->buffer = xbt_realloc(ev->buffer, ev->buffer_size);
+    }
+    appender->do_append(appender, ev->buffer);
+    xbt_free(ev->buffer);
 
-#ifdef _XBT_WIN32
-  free(ev->buffer);
-#endif
+  } while (cat->additivity && (cat = cat->parent, 1));
 }
 
+#undef XBT_LOG_DYNAMIC_BUFFER_SIZE
+#undef XBT_LOG_STATIC_BUFFER_SIZE
+
 /* NOTE:
  *
  * The standard logging macros use _XBT_LOG_ISENABLED, which calls
@@ -648,7 +864,7 @@ static void _xbt_log_cat_apply_set(xbt_log_category_t category,
   if (setting->thresh != xbt_log_priority_uninitialized) {
     xbt_log_threshold_set(category, setting->thresh);
 
-    DEBUG3("Apply settings for category '%s': set threshold to %s (=%d)",
+    XBT_DEBUG("Apply settings for category '%s': set threshold to %s (=%d)",
            category->name, xbt_log_priority_names[category->threshold],
            category->threshold);
   }
@@ -656,14 +872,14 @@ static void _xbt_log_cat_apply_set(xbt_log_category_t category,
   if (setting->fmt) {
     xbt_log_layout_set(category, xbt_log_layout_format_new(setting->fmt));
 
-    DEBUG2("Apply settings for category '%s': set format to %s",
+    XBT_DEBUG("Apply settings for category '%s': set format to %s",
            category->name, setting->fmt);
   }
 
   if (setting->additivity != -1) {
     xbt_log_additivity_set(category, setting->additivity);
 
-    DEBUG2("Apply settings for category '%s': set additivity to %s",
+    XBT_DEBUG("Apply settings for category '%s': set additivity to %s",
            category->name, (setting->additivity ? "on" : "off"));
   }
   if (setting->appender) {
@@ -671,7 +887,7 @@ static void _xbt_log_cat_apply_set(xbt_log_category_t category,
     if (!category->layout)
       xbt_log_layout_set(category, xbt_log_layout_simple_new(NULL));
     category->additivity = 0;
-    DEBUG2("Set %p as appender of category '%s'",
+    XBT_DEBUG("Set %p as appender of category '%s'",
            setting->appender, category->name);
   }
 #undef _xbt_log_cat_init
@@ -687,18 +903,28 @@ int _xbt_log_cat_init(xbt_log_category_t category,
 {
 #define _xbt_log_cat_init(a, b) (0)
 
+  if (log_cat_init_mutex != NULL) {
+    xbt_os_rmutex_acquire(log_cat_init_mutex);
+  }
+
+  if (category->initialized) {
+    if (log_cat_init_mutex != NULL) {
+      xbt_os_rmutex_release(log_cat_init_mutex);
+    }
+    return priority >= category->threshold;
+  }
+
   unsigned int cursor;
   xbt_log_setting_t setting = NULL;
   int found = 0;
 
-  DEBUG3("Initializing category '%s' (firstChild=%s, nextSibling=%s)",
+  XBT_DEBUG("Initializing category '%s' (firstChild=%s, nextSibling=%s)",
          category->name,
          (category->firstChild ? category->firstChild->name : "none"),
          (category->nextSibling ? category->nextSibling->name : "none"));
 
   if (category == &_XBT_LOGV(XBT_LOG_ROOT_CAT)) {
     category->threshold = xbt_log_priority_info;
-    /* xbt_log_priority_debug */ ;
     category->appender = xbt_log_default_appender;
     category->layout = xbt_log_default_layout;
   } else {
@@ -706,11 +932,10 @@ int _xbt_log_cat_init(xbt_log_category_t category,
     if (!category->parent)
       category->parent = &_XBT_LOGV(XBT_LOG_ROOT_CAT);
 
-    DEBUG3("Set %s (%s) as father of %s ",
+    XBT_DEBUG("Set %s (%s) as father of %s ",
            category->parent->name,
-           (category->parent->threshold == xbt_log_priority_uninitialized ?
-            "uninited" : xbt_log_priority_names[category->
-                                                parent->threshold]),
+           (category->parent->initialized ?
+            xbt_log_priority_names[category->parent->threshold] : "uninited"),
            category->name);
     xbt_log_parent_set(category, category->parent);
 
@@ -728,7 +953,7 @@ int _xbt_log_cat_init(xbt_log_category_t category,
         cpp = cpp->nextSibling;
       }
 
-      DEBUG3("Childs of %s: %s; nextSibling: %s",
+      XBT_DEBUG("Children of %s: %s; nextSibling: %s",
              category->parent->name, res,
              (category->parent->nextSibling ?
               category->parent->nextSibling->name : "none"));
@@ -739,32 +964,32 @@ int _xbt_log_cat_init(xbt_log_category_t category,
   }
 
   /* Apply the control */
-  if (!xbt_log_settings)
-    return priority >= category->threshold;
-
-  xbt_assert0(category, "NULL category");
-  xbt_assert(category->name);
-
-  xbt_dynar_foreach(xbt_log_settings, cursor, setting) {
-    xbt_assert0(setting, "Damnit, NULL cat in the list");
-    xbt_assert1(setting->catname, "NULL setting(=%p)->catname",
-                (void *) setting);
-
-    if (!strcmp(setting->catname, category->name)) {
-
-      found = 1;
-
-      _xbt_log_cat_apply_set(category, setting);
-
-      xbt_dynar_cursor_rm(xbt_log_settings, &cursor);
+  if (xbt_log_settings) {
+    xbt_assert(category, "NULL category");
+    xbt_assert(category->name);
+
+    xbt_dynar_foreach(xbt_log_settings, cursor, setting) {
+      xbt_assert(setting, "Damnit, NULL cat in the list");
+      xbt_assert(setting->catname, "NULL setting(=%p)->catname",
+                 (void *) setting);
+
+      if (!strcmp(setting->catname, category->name)) {
+        found = 1;
+        _xbt_log_cat_apply_set(category, setting);
+        xbt_dynar_cursor_rm(xbt_log_settings, &cursor);
+      }
     }
-  }
 
-  if (!found)
-    DEBUG3("Category '%s': inherited threshold = %s (=%d)",
-           category->name, xbt_log_priority_names[category->threshold],
-           category->threshold);
+    if (!found)
+      XBT_DEBUG("Category '%s': inherited threshold = %s (=%d)",
+                category->name, xbt_log_priority_names[category->threshold],
+                category->threshold);
+  }
 
+  category->initialized = 1;
+  if (log_cat_init_mutex != NULL) {
+    xbt_os_rmutex_release(log_cat_init_mutex);
+  }
   return priority >= category->threshold;
 
 #undef _xbt_log_cat_init
@@ -772,17 +997,13 @@ int _xbt_log_cat_init(xbt_log_category_t category,
 
 void xbt_log_parent_set(xbt_log_category_t cat, xbt_log_category_t parent)
 {
+  xbt_assert(cat, "NULL category to be given a parent");
+  xbt_assert(parent, "The parent category of %s is NULL", cat->name);
 
-  xbt_assert0(cat, "NULL category to be given a parent");
-  xbt_assert1(parent, "The parent category of %s is NULL", cat->name);
+  /* if the category is initialized, unlink from current parent */
+  if (cat->initialized) {
 
-  /*
-   * if the threshold is initialized
-   * unlink from current parent
-   */
-  if (cat->threshold != xbt_log_priority_uninitialized) {
-
-    xbt_log_category_t *cpp = &parent->firstChild;
+    xbt_log_category_t *cpp = &cat->parent->firstChild;
 
     while (*cpp != cat && *cpp != NULL) {
       cpp = &(*cpp)->nextSibling;
@@ -797,16 +1018,12 @@ void xbt_log_parent_set(xbt_log_category_t cat, xbt_log_category_t parent)
 
   parent->firstChild = cat;
 
-  if (parent->threshold == xbt_log_priority_uninitialized) {
-
-    _xbt_log_cat_init(parent,
-                      xbt_log_priority_uninitialized /* ignored */ );
-  }
+  if (!parent->initialized)
+    _xbt_log_cat_init(parent, xbt_log_priority_uninitialized /* ignored */ );
 
   cat->threshold = parent->threshold;
 
   cat->isThreshInherited = 1;
-
 }
 
 static void _set_inherited_thresholds(xbt_log_category_t cat)
@@ -817,7 +1034,7 @@ static void _set_inherited_thresholds(xbt_log_category_t cat)
   for (; child != NULL; child = child->nextSibling) {
     if (child->isThreshInherited) {
       if (cat != &_XBT_LOGV(log))
-        VERB3("Set category threshold of %s to %s (=%d)",
+        XBT_VERB("Set category threshold of %s to %s (=%d)",
               child->name, xbt_log_priority_names[cat->threshold],
               cat->threshold);
       child->threshold = cat->threshold;
@@ -852,7 +1069,7 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string)
 
   if (!*control_string)
     return set;
-  DEBUG1("Parse log setting '%s'", control_string);
+  XBT_DEBUG("Parse log setting '%s'", control_string);
 
   control_string += strspn(control_string, " ");
   name = control_string;
@@ -862,10 +1079,10 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string)
   eq = control_string;
   control_string += strcspn(control_string, " ");
 
-  xbt_assert1(*dot == '.' && (*eq == '=' || *eq == ':'),
+  xbt_assert(*dot == '.' && (*eq == '=' || *eq == ':'),
               "Invalid control string '%s'", control_string);
 
-  if (!strncmp(dot + 1, "thresh", (size_t) (eq - dot - 1))) {
+  if (!strncmp(dot + 1, "threshold", (size_t) (eq - dot - 1))) {
     int i;
     char *neweq = xbt_strdup(eq + 1);
     char *p = neweq - 1;
@@ -876,17 +1093,17 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string)
       }
     }
 
-    DEBUG1("New priority name = %s", neweq);
+    XBT_DEBUG("New priority name = %s", neweq);
     for (i = 0; i < xbt_log_priority_infinite; i++) {
       if (!strncmp(xbt_log_priority_names[i], neweq, p - eq)) {
-        DEBUG1("This is priority %d", i);
+        XBT_DEBUG("This is priority %d", i);
         break;
       }
     }
     if (i < xbt_log_priority_infinite) {
       set->thresh = (e_xbt_log_priority_t) i;
     } else {
-      THROW1(arg_error, 0,
+      THROWF(arg_error, 0,
              "Unknown priority name: %s (must be one of: trace,debug,verbose,info,warning,error,critical)",
              eq + 1);
     }
@@ -917,7 +1134,7 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string)
     if (!strncmp(neweq, "file:", 5)) {
       set->appender = xbt_log_appender_file_new(neweq + 5);
     } else {
-      THROW1(arg_error, 0, "Unknown appender log type: '%s'", neweq);
+      THROWF(arg_error, 0, "Unknown appender log type: '%s'", neweq);
     }
     free(neweq);
   } else if (!strncmp(dot + 1, "fmt", (size_t) (eq - dot - 1))) {
@@ -925,14 +1142,14 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string)
   } else {
     char buff[512];
     snprintf(buff, min(512, eq - dot), "%s", dot + 1);
-    THROW1(arg_error, 0, "Unknown setting of the log category: '%s'",
+    THROWF(arg_error, 0, "Unknown setting of the log category: '%s'",
            buff);
   }
   set->catname = (char *) xbt_malloc(dot - name + 1);
 
   memcpy(set->catname, name, dot - name);
   set->catname[dot - name] = '\0';      /* Just in case */
-  DEBUG1("This is for cat '%s'", set->catname);
+  XBT_DEBUG("This is for cat '%s'", set->catname);
 
   return set;
 }
@@ -942,14 +1159,14 @@ static xbt_log_category_t _xbt_log_cat_searchsub(xbt_log_category_t cat,
 {
   xbt_log_category_t child, res;
 
-  DEBUG4("Search '%s' into '%s' (firstChild='%s'; nextSibling='%s')", name,
+  XBT_DEBUG("Search '%s' into '%s' (firstChild='%s'; nextSibling='%s')", name,
          cat->name, (cat->firstChild ? cat->firstChild->name : "none"),
          (cat->nextSibling ? cat->nextSibling->name : "none"));
   if (!strcmp(cat->name, name))
     return cat;
 
   for (child = cat->firstChild; child != NULL; child = child->nextSibling) {
-    DEBUG1("Dig into %s", child->name);
+    XBT_DEBUG("Dig into %s", child->name);
     res = _xbt_log_cat_searchsub(child, name);
     if (res)
       return res;
@@ -992,7 +1209,7 @@ void xbt_log_control_set(const char *control_string)
 
   if (!control_string)
     return;
-  DEBUG1("Parse log settings '%s'", control_string);
+  XBT_DEBUG("Parse log settings '%s'", control_string);
 
   /* Special handling of no_loc request, which asks for any file localization to be omitted (for tesh runs) */
   if (!strcmp(control_string, "no_loc")) {
@@ -1007,7 +1224,7 @@ void xbt_log_control_set(const char *control_string)
   /* split the string, and remove empty entries */
   set_strings = xbt_str_split_quoted(control_string);
 
-  if (xbt_dynar_length(set_strings) == 0) {     /* vicious user! */
+  if (xbt_dynar_is_empty(set_strings)) {     /* vicious user! */
     xbt_dynar_free(&set_strings);
     return;
   }
@@ -1022,13 +1239,13 @@ void xbt_log_control_set(const char *control_string)
         _xbt_log_cat_searchsub(&_XBT_LOGV(XBT_LOG_ROOT_CAT), set->catname);
 
     if (cat) {
-      DEBUG0("Apply directly");
+      XBT_DEBUG("Apply directly");
       _xbt_log_cat_apply_set(cat, set);
       _free_setting((void *) &set);
     } else {
 
-      DEBUG0("Store for further application");
-      DEBUG1("push %p to the settings", (void *) set);
+      XBT_DEBUG("Store for further application");
+      XBT_DEBUG("push %p to the settings", (void *) set);
       xbt_dynar_push(xbt_log_settings, &set);
     }
   }
@@ -1047,25 +1264,130 @@ void xbt_log_appender_set(xbt_log_category_t cat, xbt_log_appender_t app)
 
 void xbt_log_layout_set(xbt_log_category_t cat, xbt_log_layout_t lay)
 {
+#define _xbt_log_cat_init(a, b) (0)
   if (!cat->appender) {
-    VERB1
+    XBT_VERB
         ("No appender to category %s. Setting the file appender as default",
          cat->name);
     xbt_log_appender_set(cat, xbt_log_appender_file_new(NULL));
   }
-  if (cat->layout && cat != &_XBT_LOGV(root)) {
-    /* better leak the default layout than check every categories to
-       change it */
+  if (cat->layout) {
     if (cat->layout->free_) {
       cat->layout->free_(cat->layout);
-      free(cat->layout);
     }
+    free(cat->layout);
   }
   cat->layout = lay;
   xbt_log_additivity_set(cat, 0);
+#undef _xbt_log_cat_init
 }
 
 void xbt_log_additivity_set(xbt_log_category_t cat, int additivity)
 {
   cat->additivity = additivity;
 }
+
+static void xbt_log_help(void)
+{
+  printf(
+"Description of the logging output:\n"
+"\n"
+"   Threshold configuration: --log=CATEGORY_NAME.thres:PRIORITY_LEVEL\n"
+"      CATEGORY_NAME: defined in code with function 'XBT_LOG_NEW_CATEGORY'\n"
+"      PRIORITY_LEVEL: the level to print (trace,debug,verbose,info,warning,error,critical)\n"
+"         -> trace: enter and return of some functions\n"
+"         -> debug: crufty output\n"
+"         -> verbose: verbose output for the user wanting more\n"
+"         -> info: output about the regular functionning\n"
+"         -> warning: minor issue encountered\n"
+"         -> error: issue encountered\n"
+"         -> critical: major issue encountered\n"
+"\n"
+"   Format configuration: --log=CATEGORY_NAME.fmt:OPTIONS\n"
+"      OPTIONS may be:\n"
+"         -> %%%%: the %% char\n"
+"         -> %%n: platform-dependent line separator (LOG4J compatible)\n"
+"         -> %%e: plain old space (SimGrid extension)\n"
+"\n"
+"         -> %%m: user-provided message\n"
+"\n"
+"         -> %%c: Category name (LOG4J compatible)\n"
+"         -> %%p: Priority name (LOG4J compatible)\n"
+"\n"
+"         -> %%h: Hostname (SimGrid extension)\n"
+"         -> %%P: Process name (SimGrid extension)\n"
+"         -> %%t: Thread \"name\" (LOG4J compatible -- actually the address of the thread in memory)\n"
+"         -> %%i: Process PID (SimGrid extension -- this is a 'i' as in 'i'dea)\n"
+"\n"
+"         -> %%F: file name where the log event was raised (LOG4J compatible)\n"
+"         -> %%l: location where the log event was raised (LOG4J compatible, like '%%F:%%L' -- this is a l as in 'l'etter)\n"
+"         -> %%L: line number where the log event was raised (LOG4J compatible)\n"
+"         -> %%M: function name (LOG4J compatible -- called method name here of course).\n"
+"                 Defined only when using gcc because there is no __FUNCTION__ elsewhere.\n"
+"\n"
+"         -> %%b: full backtrace (Called %%throwable in LOG4J). Defined only under windows or when using the GNU libc because\n"
+"                 backtrace() is not defined elsewhere, and we only have a fallback for windows boxes, not mac ones for example.\n"
+"         -> %%B: short backtrace (only the first line of the %%b). Called %%throwable{short} in LOG4J; defined where %%b is.\n"
+"\n"
+"         -> %%d: date (UNIX-like epoch)\n"
+"         -> %%r: application age (time elapsed since the beginning of the application)\n"
+"\n"
+"   Miscellaneous:\n"
+"      --help-log-categories    Display the current hierarchy of log categories.\n"
+"      --log=no_loc             Don't print file names in messages (for tesh tests).\n"
+"\n"
+    );
+}
+
+static int xbt_log_cat_cmp(const void *pa, const void *pb)
+{
+  xbt_log_category_t a = *(xbt_log_category_t *)pa;
+  xbt_log_category_t b = *(xbt_log_category_t *)pb;
+  return strcmp(a->name, b->name);
+}
+
+static void xbt_log_help_categories_rec(xbt_log_category_t category,
+                                        const char *prefix)
+{
+  char *this_prefix;
+  char *child_prefix;
+  xbt_dynar_t dynar;
+  unsigned i;
+  xbt_log_category_t cat;
+
+  if (!category)
+    return;
+
+  if (category->parent) {
+    this_prefix = bprintf("%s \\_ ", prefix);
+    child_prefix = bprintf("%s |  ", prefix);
+  } else {
+    this_prefix = xbt_strdup(prefix);
+    child_prefix = xbt_strdup(prefix);
+  }
+
+  dynar = xbt_dynar_new(sizeof(xbt_log_category_t), NULL);
+  for (cat = category ; cat != NULL; cat = cat->nextSibling)
+    xbt_dynar_push_as(dynar, xbt_log_category_t, cat);
+
+  xbt_dynar_sort(dynar, xbt_log_cat_cmp);
+
+  for (i = 0; i < xbt_dynar_length(dynar); i++) {
+    if (i == xbt_dynar_length(dynar) - 1 && category->parent)
+      *strrchr(child_prefix, '|') = ' ';
+    cat = xbt_dynar_get_as(dynar, i, xbt_log_category_t);
+    printf("%s%s: %s\n", this_prefix, cat->name, cat->description);
+    xbt_log_help_categories_rec(cat->firstChild, child_prefix);
+  }
+
+  xbt_dynar_free(&dynar);
+  xbt_free(this_prefix);
+  xbt_free(child_prefix);
+}
+
+static void xbt_log_help_categories(void)
+{
+  printf("Current log category hierarchy:\n");
+  xbt_log_help_categories_rec(&_XBT_LOGV(XBT_LOG_ROOT_CAT), "   ");
+  printf("\n");
+}