X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/9a444de20a7545d1c3d10bd242f317febded25c4..ebd7bcbf3470561e0d7d251e73476c04ed3c1ad3:/src/xbt/log.c diff --git a/src/xbt/log.c b/src/xbt/log.c index fdbe8b875a..8c78678619 100644 --- a/src/xbt/log.c +++ b/src/xbt/log.c @@ -473,8 +473,8 @@ 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; @@ -486,8 +486,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); } } @@ -508,7 +507,8 @@ 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 */ @@ -535,6 +535,173 @@ void xbt_log_preinit(void) 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() */ + + /* 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); +#ifdef XBT_USE_DEPRECATED + XBT_LOG_CONNECT(xbt_dict_multi, xbt_dict); +#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); + +#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); +#endif + + /* instr */ +#ifdef HAVE_TRACING + XBT_LOG_CONNECT(instr_paje_trace, instr); + XBT_LOG_CONNECT(instr_smpi, instr); + XBT_LOG_CONNECT(instr_surf, instr); +#endif + + /* jedule */ +#ifdef HAVE_JEDULE + XBT_LOG_CONNECT(jed_out, jedule); + XBT_LOG_CONNECT(jed_sd, jedule); +#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); +#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); + + /* 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); + + /* 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); +#ifdef HAVE_GTNETS + XBT_LOG_CONNECT(surf_network_gtnets, surf); +#endif +#ifdef HAVE_NS3 + XBT_LOG_CONNECT(surf_network_ns3, surf); +#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); + +#endif /* simgrid_EXPORTS */ +} + /** @brief Get all logging settings from the command line * * xbt_log_control_set() is called on each string we got from cmd line @@ -547,34 +714,22 @@ 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 */ /* 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="))) - XBT_WARN - ("Option %.*s is deprecated and will disapear in the future. Use --log instead.", - (int) (strchr(argv[i], '=') - argv[i]), argv[i]); - + for (j = i = 1; i < *argc; i++) { + if (!strncmp(argv[i], "--log=", strlen("--log="))) { opt = strchr(argv[i], '='); opt++; xbt_log_control_set(opt); XBT_DEBUG("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 */ + } else { + argv[j++] = argv[i]; } } + if (j < *argc) { + argv[j] = NULL; + *argc = j; + } + + xbt_log_connect_categories(); } static void log_cat_exit(xbt_log_category_t cat) @@ -604,10 +759,11 @@ void xbt_log_postexit(void) log_cat_exit(&_XBT_LOGV(XBT_LOG_ROOT_CAT)); } -#define XBT_LOG_STATIC_BUFFER_SIZE 2048 /* Size of the static string in which we - * build the log string */ -#define XBT_LOG_DYNAMIC_BUFFER_SIZE 256 /* Minimum size of the dynamic string in - * which we build the log string */ + /* 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, ...) { @@ -644,8 +800,7 @@ void _xbt_log_event_log(xbt_log_event_t ev, const char *fmt, ...) } /* The static buffer was too small, use a dynamically expanded one */ - ev->buffer_size = MAX(2 * XBT_LOG_STATIC_BUFFER_SIZE, - XBT_LOG_DYNAMIC_BUFFER_SIZE); + ev->buffer_size = XBT_LOG_DYNAMIC_BUFFER_SIZE; ev->buffer = xbt_malloc(ev->buffer_size); while (1) { int done; @@ -729,7 +884,7 @@ int _xbt_log_cat_init(xbt_log_category_t category, xbt_os_rmutex_acquire(log_cat_init_mutex); } - if (category->threshold != xbt_log_priority_uninitialized) { + if (category->initialized) { if (log_cat_init_mutex != NULL) { xbt_os_rmutex_release(log_cat_init_mutex); } @@ -747,7 +902,6 @@ int _xbt_log_cat_init(xbt_log_category_t category, 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 { @@ -757,9 +911,8 @@ int _xbt_log_cat_init(xbt_log_category_t category, 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); @@ -788,36 +941,29 @@ int _xbt_log_cat_init(xbt_log_category_t category, } /* Apply the control */ - if (!xbt_log_settings) { - if (log_cat_init_mutex != NULL) { - xbt_os_rmutex_release(log_cat_init_mutex); + 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); + } } - return priority >= category->threshold; - } - - 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) + XBT_DEBUG("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); } @@ -831,13 +977,10 @@ 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); - /* - * if the threshold is initialized - * unlink from current parent - */ - if (cat->threshold != xbt_log_priority_uninitialized) { + /* if the category is initialized, unlink from current parent */ + if (cat->initialized) { - xbt_log_category_t *cpp = &parent->firstChild; + xbt_log_category_t *cpp = &cat->parent->firstChild; while (*cpp != cat && *cpp != NULL) { cpp = &(*cpp)->nextSibling; @@ -852,11 +995,8 @@ 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; @@ -1061,7 +1201,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; } @@ -1123,3 +1263,104 @@ void xbt_log_additivity_set(xbt_log_category_t cat, int additivity) { cat->additivity = additivity; } + +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" + ); +} + +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 = bprintf("%s", prefix); + child_prefix = bprintf("%s", 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); +} + +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"); +}