X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/4bc164b792f5425df23352ecc603745e61f730ec..40803b27ba5bcb382dfcd593885313a975bafd89:/src/xbt/log.c diff --git a/src/xbt/log.c b/src/xbt/log.c index d3166af0e7..c560de6d9f 100644 --- a/src/xbt/log.c +++ b/src/xbt/log.c @@ -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 priority concept (which should maybe be renamed to severity). 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 warning. -XBT_CLOG(MyCat, gras_log_priority_warning, "Values are: %d and '%s'", 5, +XBT_CLOG(MyCat, xbt_log_priority_warning, "Values are: %d and '%s'", 5, "oops"); 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 -thres keyword. +threshold keyword. -For example, \verbatim --log=root.thres:debug\endverbatim will make +For example, \verbatim --log=root.threshold:debug\endverbatim will make SimGrid extremely 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 threshold 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 might 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,164 +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); - - /* sd */ - XBT_LOG_CONNECT(sd_daxparse, sd); - XBT_LOG_CONNECT(sd_dotparse, sd); - XBT_LOG_CONNECT(sd_kernel, sd); - XBT_LOG_CONNECT(sd_task, sd); - XBT_LOG_CONNECT(sd_workstation, sd); + 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_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 */ } @@ -717,6 +724,8 @@ void xbt_log_init(int *argc, char **argv) // _XBT_LOGV(log).threshold = xbt_log_priority_debug; /* uncomment to set the LOG category to debug directly */ + xbt_log_connect_categories(); + /* Set logs and init log submodule */ for (j = i = 1; i < *argc; i++) { if (!strncmp(argv[i], "--log=", strlen("--log="))) { @@ -737,8 +746,6 @@ void xbt_log_init(int *argc, char **argv) *argc = j; } - xbt_log_connect_categories(); - if (help_requested) { if (help_requested & 1) xbt_log_help(); @@ -946,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")); @@ -1075,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; @@ -1324,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" ); } @@ -1351,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);