Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Make semaphores visible from MSG
[simgrid.git] / src / xbt / log.c
index eb1f4f7..c560de6 100644 (file)
@@ -24,7 +24,6 @@
 #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;
 
@@ -100,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
@@ -187,7 +186,7 @@ format. This is usually a good idea.
 Here is an example of the most basic type of macro. This is a logging
 request with priority <i>warning</i>.
 
-<code>XBT_CLOG(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
@@ -256,7 +255,7 @@ 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. * /
@@ -274,9 +273,6 @@ int main() {
 }
 \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
@@ -284,23 +280,36 @@ 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. The full list of recognized thresholds is the following:
+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
@@ -342,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)
 
@@ -429,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
@@ -514,13 +523,6 @@ s_xbt_log_category_t _XBT_LOGV(XBT_LOG_ROOT_CAT) = {
       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");
 
@@ -540,166 +542,169 @@ 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() */
 
-  /* amok */
-  XBT_LOG_CONNECT(amok_bw, amok);
-  XBT_LOG_CONNECT(amok_bw_sat, amok_bw);
-  XBT_LOG_CONNECT(amok_pm, amok);
-
-  /* gras */
-  XBT_LOG_CONNECT(gras_modules, gras);
-  XBT_LOG_CONNECT(gras_msg, gras);
-  XBT_LOG_CONNECT(gras_msg_read, gras_msg);
-  XBT_LOG_CONNECT(gras_msg_rpc, gras_msg);
-  XBT_LOG_CONNECT(gras_timer, gras);
-  XBT_LOG_CONNECT(gras_trp, gras);
-  XBT_LOG_CONNECT(gras_trp_file, gras_trp);
-  XBT_LOG_CONNECT(gras_virtu, gras);
-  XBT_LOG_CONNECT(gras_virtu_emul, gras_virtu);
-  XBT_LOG_CONNECT(gras_virtu_process, gras_virtu);
-
   /* xbt */
-  XBT_LOG_CONNECT(graphxml_parse, xbt);
-  XBT_LOG_CONNECT(log, xbt);
-  XBT_LOG_CONNECT(mm_diff, xbt);
-  XBT_LOG_CONNECT(module, xbt);
-  XBT_LOG_CONNECT(peer, xbt);
-  XBT_LOG_CONNECT(replay, xbt);
-  XBT_LOG_CONNECT(strbuff, xbt);
-  XBT_LOG_CONNECT(xbt_cfg, xbt);
-  XBT_LOG_CONNECT(xbt_dict, xbt);
-  XBT_LOG_CONNECT(xbt_dict_cursor, xbt_dict);
-  XBT_LOG_CONNECT(xbt_dict_elm, xbt_dict);
+  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, xbt_dict);
+  XBT_LOG_CONNECT(xbt_dict_multi);
 #endif
-  XBT_LOG_CONNECT(xbt_ddt, xbt);
-  XBT_LOG_CONNECT(xbt_ddt_cbps, xbt_ddt);
-  XBT_LOG_CONNECT(xbt_ddt_convert, xbt_ddt);
-  XBT_LOG_CONNECT(xbt_ddt_create, xbt_ddt);
-  XBT_LOG_CONNECT(xbt_ddt_exchange, xbt_ddt);
-  XBT_LOG_CONNECT(xbt_ddt_parse, xbt_ddt);
-  XBT_LOG_CONNECT(xbt_ddt_lexer, xbt_ddt_parse);
-  XBT_LOG_CONNECT(xbt_dyn, xbt);
-  XBT_LOG_CONNECT(xbt_ex, xbt);
-  XBT_LOG_CONNECT(xbt_fifo, xbt);
-  XBT_LOG_CONNECT(xbt_graph, xbt);
-  XBT_LOG_CONNECT(xbt_lib, xbt);
-  XBT_LOG_CONNECT(xbt_mallocator, xbt);
-
-  XBT_LOG_CONNECT(xbt_matrix, xbt);
-  XBT_LOG_CONNECT(xbt_parmap, xbt);
-  XBT_LOG_CONNECT(xbt_parmap_unit, xbt_parmap);
-  XBT_LOG_CONNECT(xbt_queue, xbt);
-  XBT_LOG_CONNECT(xbt_set, xbt);
-  XBT_LOG_CONNECT(xbt_sync, xbt);
-  XBT_LOG_CONNECT(xbt_sync_os, xbt);
-  XBT_LOG_CONNECT(xbt_trp, xbt);
-  XBT_LOG_CONNECT(xbt_trp_meas, xbt_trp);
-  XBT_LOG_CONNECT(xbt_trp_tcp, xbt_trp);
+  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 */
 
-  /* gras (sg) */
-  XBT_LOG_CONNECT(gras_trp_sg, gras_trp);
-
   /* bindings */
 #ifdef HAVE_LUA
-  XBT_LOG_CONNECT(lua, bindings);
-  XBT_LOG_CONNECT(lua_comm, bindings);
-  XBT_LOG_CONNECT(lua_host, bindings);
-  XBT_LOG_CONNECT(lua_platf, bindings);
-  XBT_LOG_CONNECT(lua_process, bindings);
-  XBT_LOG_CONNECT(lua_state_cloner, bindings);
-  XBT_LOG_CONNECT(lua_task, bindings);
-  XBT_LOG_CONNECT(lua_utils, bindings);
+  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_paje_trace, instr);
-  XBT_LOG_CONNECT(instr_smpi, instr);
-  XBT_LOG_CONNECT(instr_surf, instr);
+  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(jed_out, jedule);
-  XBT_LOG_CONNECT(jed_sd, jedule);
+  XBT_LOG_CONNECT(jedule);
+  XBT_LOG_CONNECT(jed_out);
+  XBT_LOG_CONNECT(jed_sd);
 #endif
 
   /* mc */
 #ifdef HAVE_MC
-  XBT_LOG_CONNECT(mc_checkpoint, mc);
-  XBT_LOG_CONNECT(mc_dpor, mc);
-  XBT_LOG_CONNECT(mc_global, mc);
-  XBT_LOG_CONNECT(mc_liveness, mc);
-  XBT_LOG_CONNECT(mc_memory, mc);
-  XBT_LOG_CONNECT(mc_memory_map, mc);
-  XBT_LOG_CONNECT(mc_request, 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_action, msg);
-  XBT_LOG_CONNECT(msg_gos, msg);
-  XBT_LOG_CONNECT(msg_kernel, msg);
-  XBT_LOG_CONNECT(msg_mailbox, msg);
-  XBT_LOG_CONNECT(msg_process, msg);
-  XBT_LOG_CONNECT(msg_task, 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_daxparse, sd);
+  XBT_LOG_CONNECT(sd);
+  XBT_LOG_CONNECT(sd_daxparse);
 #ifdef HAVE_GRAPHVIZ
-  XBT_LOG_CONNECT(sd_dotparse, sd);
+  XBT_LOG_CONNECT(sd_dotparse);
 #endif
-  XBT_LOG_CONNECT(sd_kernel, sd);
-  XBT_LOG_CONNECT(sd_task, sd);
-  XBT_LOG_CONNECT(sd_workstation, sd);
+  XBT_LOG_CONNECT(sd_kernel);
+  XBT_LOG_CONNECT(sd_task);
+  XBT_LOG_CONNECT(sd_workstation);
 
   /* simix */
-  XBT_LOG_CONNECT(simix_context, simix);
-  XBT_LOG_CONNECT(simix_deployment, simix);
-  XBT_LOG_CONNECT(simix_environment, simix);
-  XBT_LOG_CONNECT(simix_host, simix);
-  XBT_LOG_CONNECT(simix_io, simix);
-  XBT_LOG_CONNECT(simix_kernel, simix);
-  XBT_LOG_CONNECT(simix_network, simix);
-  XBT_LOG_CONNECT(simix_process, simix);
-  XBT_LOG_CONNECT(simix_smurf, simix);
-  XBT_LOG_CONNECT(simix_synchro, 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(random, surf);
-  XBT_LOG_CONNECT(surf_config, surf);
-  XBT_LOG_CONNECT(surf_cpu, surf);
-  XBT_LOG_CONNECT(surf_cpu_ti, surf);
-  XBT_LOG_CONNECT(surf_kernel, surf);
-  XBT_LOG_CONNECT(surf_lagrange, surf);
-  XBT_LOG_CONNECT(surf_lagrange_dichotomy, surf_lagrange);
-  XBT_LOG_CONNECT(surf_maxmin, surf);
-  XBT_LOG_CONNECT(surf_network, 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, surf);
+  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, surf);
+  XBT_LOG_CONNECT(surf_network_ns3);
+  XBT_LOG_CONNECT(interface_ns3);
+  XBT_LOG_CONNECT(simulator_ns3);
 #endif
-  XBT_LOG_CONNECT(surf_parse, surf);
-  XBT_LOG_CONNECT(surf_route, surf);
-  XBT_LOG_CONNECT(surf_routing_generic, surf_route);
-  XBT_LOG_CONNECT(surf_route_cluster, surf);
-  XBT_LOG_CONNECT(surf_route_dijkstra, surf);
-  XBT_LOG_CONNECT(surf_route_floyd, surf);
-  XBT_LOG_CONNECT(surf_route_full, surf);
-  XBT_LOG_CONNECT(surf_route_none, surf);
-  XBT_LOG_CONNECT(surf_route_rulebased, surf);
-  XBT_LOG_CONNECT(surf_route_vivaldi, surf);
-  XBT_LOG_CONNECT(surf_storage, surf);
-  XBT_LOG_CONNECT(surf_trace, surf);
-  XBT_LOG_CONNECT(surf_workstation, surf);
+  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 */
 }
@@ -948,7 +953,7 @@ int _xbt_log_cat_init(xbt_log_category_t category,
         cpp = cpp->nextSibling;
       }
 
-      XBT_DEBUG("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"));
@@ -1077,7 +1082,7 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string)
   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;
@@ -1326,6 +1331,10 @@ static void xbt_log_help(void)
 "\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"
     );
 }
@@ -1353,8 +1362,8 @@ static void xbt_log_help_categories_rec(xbt_log_category_t category,
     this_prefix = bprintf("%s \\_ ", prefix);
     child_prefix = bprintf("%s |  ", prefix);
   } else {
-    this_prefix = bprintf("%s", prefix);
-    child_prefix = bprintf("%s", prefix);
+    this_prefix = xbt_strdup(prefix);
+    child_prefix = xbt_strdup(prefix);
   }
 
   dynar = xbt_dynar_new(sizeof(xbt_log_category_t), NULL);