X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/3203ed1f4fb6f4617e94d5351661ba07e8b8f833..53860f96b2c6dd3174461e623f80c2f2086fd7f9:/src/xbt/log.c diff --git a/src/xbt/log.c b/src/xbt/log.c index 0ce0cd4552..829ba05fc0 100644 --- a/src/xbt/log.c +++ b/src/xbt/log.c @@ -11,489 +11,26 @@ #include /* snprintf */ #include /* snprintf */ -#include "src/portable.h" /* to get a working stdarg.h */ +#include "src/internal_config.h" #include "src/xbt_modinter.h" -#include "xbt/misc.h" +#include "src/xbt/log_private.h" +#include "xbt/asserts.h" +#include "xbt/dynar.h" #include "xbt/ex.h" +#include "xbt/misc.h" #include "xbt/str.h" #include "xbt/sysdep.h" -#include "src/xbt/log_private.h" -#include "xbt/dynar.h" #include "xbt/xbt_os_thread.h" -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; +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_mutex_t log_cat_init_mutex = NULL; /** \addtogroup XBT_log * - * This section describes the API to the log functions used - * everywhere in this project. - -\section XBT_log_toc Table of contents - - - \ref log_overview - - \ref log_cat - - \ref log_pri - - \ref log_app - - \ref log_hist - - \ref log_API - - \ref log_API_cat - - \ref log_API_pri - - \ref log_API_isenabled - - \ref log_API_subcat - - \ref log_API_easy - - \ref log_API_example - - \ref log_user - - \ref log_use_conf - - \ref log_use_conf_thres - - \ref log_use_conf_multi - - \ref log_use_conf_fmt - - \ref log_use_conf_app - - \ref log_use_conf_add - - \ref log_use_misc - - \ref log_internals - - \ref log_in_perf - - \ref log_in_app - - \ref XBT_log_cats - -\section log_overview 1. Introduction - -This module is in charge of handling the log messages of every SimGrid -program. The main design goal are: - - - configurability: the user can choose at runtime what messages to show and - what to hide, as well as how messages get displayed. - - ease of use: both to the programmer (using preprocessor macros black magic) - and to the user (with command line options) - - performances: logging shouldn't slow down the program when turned off, for example - - deal with distributed settings: SimGrid programs are [often] distributed ones, - and the logging mechanism allows to syndicate each and every log source into the same place. - At least, its design would allow to, once we write the last missing pieces - -There is three main concepts in SimGrid's logging mechanism: category, -priority and appender. These three concepts work together to -enable developers to log messages according to message type and priority, and -to control at runtime how these messages are formatted and where they are -reported. - -\subsection log_cat 1.1 Category hierarchy - -The first and foremost advantage of any logging API over plain printf() -resides in its ability to disable certain log statements while allowing -others to print unhindered. This capability assumes that the logging space, -that is, the space of all possible logging statements, is categorized -according to some developer-chosen criteria. - -This observation led to choosing category as the central concept of the -system. In a certain sense, they can be considered as logging topics or -channels. - -\subsection log_pri 1.2 Logging priorities - -The user can naturally declare interest into this or that logging category, but -he also can specify the desired level of details for each of them. This is -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 MSG while only being interested into the messages at level "error" or -higher about the XBT internals. - -\subsection log_app 1.3 Message appenders - -The message appenders are the elements in charge of actually displaying the -message to the user. For now, four appenders exist: -- the default one prints stuff on stderr -- file sends the data to a single file -- rollfile overwrites the file when the file grows too large -- splitfile creates new files with a specific maximum size - -Other are planed (such as the one sending everything to a remote server) -One day, for sure ;) - -\subsection log_lay 1.4 Message layouts - -The message layouts are the elements in charge of choosing how each message -will look like. Their result is a string which is then passed to the appender -attached to the category to be displayed. - -For now, there is two layouts: The simple one, which is good for most cases, -and another one allowing users to specify the format they want. -\ref log_use_conf provides more info on this. - -\subsection log_hist 1.5 History of this module - -Historically, this module is an adaptation of the log4c project, which is dead -upstream, and which I was given the permission to fork under the LGPL licence -by the log4c's authors. The log4c project itself was loosely based on the -Apache project's Log4J, which also inspired Log4CC, Log4py and so on. Our work -differs somehow from these projects anyway, because the C programming language -is not object oriented. - -\section log_API 2. Programmer interface - -\subsection log_API_cat 2.1 Constructing the category hierarchy - -Every category is declared by providing a name and an optional -parent. If no parent is explicitly named, the root category, LOG_ROOT_CAT is -the category's parent. - -A category is created by a macro call at the top level of a file. A -category can be created with any one of the following macros: - - - \ref XBT_LOG_NEW_CATEGORY(MyCat,desc); Create a new root - - \ref XBT_LOG_NEW_SUBCATEGORY(MyCat, ParentCat,desc); - Create a new category being child of the category ParentCat - - \ref XBT_LOG_NEW_DEFAULT_CATEGORY(MyCat,desc); - Like XBT_LOG_NEW_CATEGORY, but the new category is the default one - in this file - - \ref XBT_LOG_NEW_DEFAULT_SUBCATEGORY(MyCat, ParentCat,desc); - Like XBT_LOG_NEW_SUBCATEGORY, but the new category is the default one - in this file - -The parent cat can be defined in the same file or in another file (in -which case you want to use the \ref XBT_LOG_EXTERNAL_CATEGORY macro to make -it visible in the current file), but each category may have only one -definition. Likewise, you can use a category defined in another file as -default one using \ref XBT_LOG_EXTERNAL_DEFAULT_CATEGORY - -Typically, there will be a Category for each module and sub-module, so you -can independently control logging for each module. - -For a list of all existing categories, please refer to the \ref XBT_log_cats -section. This file is generated automatically from the SimGrid source code, so -it should be complete and accurate. - -\section log_API_pri 2.2 Declaring message priority - -A category may be assigned a threshold priority. The set of priorities are -defined by the \ref e_xbt_log_priority_t enum. All logging request under -this priority will be discarded. - -If a given category is not assigned a threshold priority, then it inherits -one from its closest ancestor with an assigned threshold. To ensure that all -categories can eventually inherit a threshold, the root category always has -an assigned threshold priority. - -Logging requests are made by invoking a logging macro on a category. All of -the macros have a printf-style format string followed by arguments. If you -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. - -Here is an example of the most basic type of macro. This is a logging -request with priority warning. - -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 -equal to the threshold priority of its category. Otherwise, the request is -said to be disabled. A category without an assigned priority will inherit -one from the hierarchy. - -It is possible to use any non-negative integer as a priority. If, as in the -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: - -XBT_CWARN(MyCat, "Values are: %d and '%s'", 5, "oops"); - -\section log_API_isenabled 2.3 Checking if a particular category/priority is enabled - -It is sometimes useful to check whether a particular category is -enabled at a particular priority. One example is when you want to do -some extra computation to prepare a nice debugging message. There is -no use of doing so if the message won't be used afterward because -debugging is turned off. - -Doing so is extremely easy, thanks to the XBT_LOG_ISENABLED(category, priority). - -\section log_API_subcat 2.4 Using a default category (the easy interface) - -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: - -XBT_WARN("Values are: %s and '%d'", 5, "oops"); - -Only one default category can be created per file, though multiple -non-defaults can be created and used. - -\section log_API_easy 2.5 Putting all together: the easy interface - -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 #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: -XBT_DEBUG("Found %s (id %d)", some_string, a_double) - -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 #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_OUT and #XBT_HERE macros instead. - -\section log_API_example 2.6 Example of use - -Here is a more complete example: - -\verbatim -#include "xbt/log.h" - -/ * create a category and a default subcategory * / -XBT_LOG_NEW_CATEGORY(VSS); -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(SA, VSS); - -int main() { - / * 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. * / - XBT_CWARN(VSS, "Low fuel level."); - - / * This request is disabled, because DEBUG < INFO. * / - 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. * / - XBT_INFO("Located nearest gas station."); - - / * This request is disabled, because DEBUG < INFO. * / - XBT_DEBUG("Exiting gas station search"); -} -\endverbatim - -\section log_user 3. User interface - -\section log_use_conf 3.1 Configuration - -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() and friends) -checks and deals properly with such arguments. - -\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 -threshold keyword. - -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. - -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 - - 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 -categories, they will be applied from left to right. So, -\verbatim --log="root.thres:debug root.thres:critical"\endverbatim should -disable almost any logging. - -Note that the quotes on above line are mandatory because there is a space in -the argument, so we are protecting ourselves from the shell, not from SimGrid. -We could also reach the same effect with this: -\verbatim --log=root.thres:debug --log=root.thres:critical\endverbatim - -\subsection log_use_conf_fmt 3.1.3 Format configuration - -As with SimGrid 3.3, it is possible to control the format of log -messages. This is done through the fmt keyword. For example, -\verbatim --log=root.fmt:%m\endverbatim reduces the output to the -user-message only, removing any decoration such as the date, or the -process ID, everything. - -Here are the existing format directives: - - - %%: the % char - - %%n: platform-dependent line separator (LOG4J compatible) - - %%e: plain old space (SimGrid extension) - - - %%m: user-provided message - - - %%c: Category name (LOG4J compatible) - - %%p: Priority name (LOG4J compatible) - - - %%h: Hostname (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) - - - %%F: file name where the log event was raised (LOG4J compatible) - - %%l: location where the log event was raised (LOG4J compatible, like '%%F:%%L' -- this is a l as in 'l'etter) - - %%L: line number where the log event was raised (LOG4J compatible) - - %%M: function name (LOG4J compatible -- called method name here of course). - Defined only when using gcc because there is no __FUNCTION__ elsewhere. - - - %%b: full backtrace (Called %%throwable in LOG4J). - Defined only under windows or when using the GNU libc because backtrace() is not defined - elsewhere, and we only have a fallback for windows boxes, not mac ones for example. - - %%B: short backtrace (only the first line of the %%b). - Called %%throwable{short} in LOG4J; defined where %%b is. - - - %%d: date (UNIX-like epoch) - - %%r: application age (time elapsed since the beginning of the application) - - -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 -because the simple layout do not display the message location for messages at -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 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 - -As with SimGrid 3.3, it is possible to control the appender of log -messages. This is done through the app keyword. For example, -\verbatim --log=root.app:file:mylogfile\endverbatim redirects the output -to the file mylogfile. - -For splitfile appender, the format is -\verbatim --log=root.app:splitfile:size:mylogfile_%.format\endverbatim - -The size is in bytes, and the % wildcard will be replaced by the number of the -file. If no % is present, it will be appended at the end. - -rollfile appender is also available, it can be used as -\verbatim --log=root.app:rollfile:size:mylogfile\endverbatim -When the file grows to be larger than the size, it will be emptied and new log -events will be sent at its beginning - -Any appender setup this way have its own layout format (simple one by default), -so you may have to change it too afterward. Moreover, the additivity of the log category -is also set to false to prevent log event displayed by this appender to "leak" to any other -appender higher in the hierarchy. If it is not what you wanted, you can naturally change it -manually. - -\subsection log_use_conf_add 3.1.5 Category additivity - -The add keyword allows to specify the additivity of a -category (see \ref log_in_app). '0', '1', 'no', 'yes', 'on' -and 'off' are all valid values, with 'yes' as default. - -The following example resets the additivity of the xbt category to true (which is its default value). -\verbatim --log=xbt.add:yes\endverbatim - -\section log_use_misc 3.2 Misc and Caveats - - - Do not use any of the macros that start with '_'. - - Log4J has a 'rolling file appender' which you can select with a run-time - option and specify the max file size. This would be a nice default for - non-kernel applications. - - Careful, category names are global variables. - - When writing a log format, you often want to use spaces. If you don't - protect these spaces, they are used as configuration elements separators. - For example, if you want to remove the date from the logs, you want to pass the following - argument on the command line. The outer quotes are here to protect the string from the shell - interpretation while the inner ones are there to prevent simgrid from splitting the string - in several log parameters (that would be invalid). - \verbatim --log="'root.fmt:%l: [%p/%c]: %m%n'"\endverbatim - Another option is to use the SimGrid-specific format directive \%e for - spaces, like in the following. - \verbatim --log="root.fmt:%l:%e[%p/%c]:%e%m%n"\endverbatim - -\section log_internals 4. Internal considerations - -This module is a mess of macro black magic, and when it goes wrong, -SimGrid studently loose its ability to explain its problems. When -messing around this module, I often find useful to define -XBT_LOG_MAYDAY (which turns it back to good old printf) for the time -of finding what's going wrong. But things are quite verbose when -everything is enabled... - -\section log_in_perf 4.1 Performance - -Except for the first invocation of a given category, a disabled logging request -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 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=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 -the requests of priority below INFO. - -\todo Logging performance *may* be improved further by improving the message -propagation from appender to appender in the category tree. - -\section log_in_app 4.2 Appenders - -Each category has an optional appender. An appender is a pointer to a -structure which starts with a pointer to a do_append() function. do_append() -prints a message to a log. - -When a category is passed a message by one of the logging macros, the -category performs the following actions: - - - if the category has an appender, the message is passed to the - appender's do_append() function, - - if additivity is true for the category, the message is passed to - the category's parent. Additivity is true by default, and can be - controlled by xbt_log_additivity_set() or something like --log=root.add:1 (see \ref log_use_conf_add). - Also, when you add an appender to a category, its additivity is automatically turned to off. - Turn it back on afterward if it is not what you wanted. - -By default, only the root category have an appender, and any other category has -its additivity set to true. This causes all messages to be logged by the root -category's appender. - -The default appender function currently prints to stderr -*/ + * For more information, please refer to @ref outcomes_logs Section. + */ 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 */ @@ -504,7 +41,9 @@ typedef struct { e_xbt_log_priority_t thresh; int additivity; xbt_log_appender_t appender; -} s_xbt_log_setting_t, *xbt_log_setting_t; +} s_xbt_log_setting_t; + +typedef s_xbt_log_setting_t* xbt_log_setting_t; static xbt_dynar_t xbt_log_settings = NULL; @@ -518,8 +57,7 @@ static void _free_setting(void *s) } } -static void _xbt_log_cat_apply_set(xbt_log_category_t category, - xbt_log_setting_t setting); +static void _xbt_log_cat_apply_set(xbt_log_category_t category, xbt_log_setting_t setting); const char *xbt_log_priority_names[8] = { "NONE", @@ -541,8 +79,7 @@ s_xbt_log_category_t _XBT_LOGV(XBT_LOG_ROOT_CAT) = { 0 /* additivity */ }; -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(log, xbt, - "Loggings from the logging mechanism itself"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(log, xbt, "Loggings from the logging mechanism itself"); /* create the default appender and install it in the root category, which were already created (damnit. Too slow little beetle) */ @@ -552,7 +89,7 @@ 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(); + log_cat_init_mutex = xbt_os_mutex_init(); } static void xbt_log_connect_categories(void) @@ -562,30 +99,22 @@ static void xbt_log_connect_categories(void) /* xbt */ XBT_LOG_CONNECT(xbt); - XBT_LOG_CONNECT(graphxml_parse); XBT_LOG_CONNECT(log); 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_backtrace); + XBT_LOG_CONNECT(xbt_exception); 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_memory_map); 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); @@ -593,16 +122,11 @@ static void xbt_log_connect_categories(void) /* The following categories are only defined in libsimgrid */ /* bindings */ -#ifdef HAVE_LUA - XBT_LOG_CONNECT(bindings); +#if SIMGRID_HAVE_LUA 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); + XBT_LOG_CONNECT(lua_debug); #endif /* instr */ @@ -611,7 +135,6 @@ static void xbt_log_connect_categories(void) 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); @@ -619,43 +142,37 @@ static void xbt_log_connect_categories(void) 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); - XBT_LOG_CONNECT(instr_trace); - XBT_LOG_CONNECT(instr_TI_trace); /* jedule */ -#ifdef HAVE_JEDULE +#if SIMGRID_HAVE_JEDULE XBT_LOG_CONNECT(jedule); - XBT_LOG_CONNECT(jed_out); XBT_LOG_CONNECT(jed_sd); #endif /* mc */ -#ifdef HAVE_MC +#if SIMGRID_HAVE_MC XBT_LOG_CONNECT(mc); XBT_LOG_CONNECT(mc_checkpoint); XBT_LOG_CONNECT(mc_comm_determinism); XBT_LOG_CONNECT(mc_compare); - XBT_LOG_CONNECT(mc_diff); XBT_LOG_CONNECT(mc_dwarf); XBT_LOG_CONNECT(mc_hash); - XBT_LOG_CONNECT(mc_ignore); - XBT_LOG_CONNECT(mcer_ignore); XBT_LOG_CONNECT(mc_liveness); XBT_LOG_CONNECT(mc_memory); - XBT_LOG_CONNECT(mc_memory_map); XBT_LOG_CONNECT(mc_page_snapshot); XBT_LOG_CONNECT(mc_request); XBT_LOG_CONNECT(mc_safety); - XBT_LOG_CONNECT(mc_visited); + XBT_LOG_CONNECT(mc_VisitedState); XBT_LOG_CONNECT(mc_client); XBT_LOG_CONNECT(mc_client_api); XBT_LOG_CONNECT(mc_comm_pattern); XBT_LOG_CONNECT(mc_process); XBT_LOG_CONNECT(mc_protocol); + XBT_LOG_CONNECT(mc_Channel); + XBT_LOG_CONNECT(mc_ModelChecker); XBT_LOG_CONNECT(mc_RegionSnaphot); - XBT_LOG_CONNECT(mc_server); + XBT_LOG_CONNECT(mc_Session); XBT_LOG_CONNECT(mc_state); #endif XBT_LOG_CONNECT(mc_global); @@ -673,16 +190,27 @@ static void xbt_log_connect_categories(void) XBT_LOG_CONNECT(msg_synchro); XBT_LOG_CONNECT(msg_task); XBT_LOG_CONNECT(msg_vm); + + /* s4u */ + XBT_LOG_CONNECT(s4u); + XBT_LOG_CONNECT(s4u_activity); + XBT_LOG_CONNECT(s4u_actor); + XBT_LOG_CONNECT(s4u_netzone); + XBT_LOG_CONNECT(s4u_channel); + XBT_LOG_CONNECT(s4u_comm); + XBT_LOG_CONNECT(s4u_file); + /* sg */ + XBT_LOG_CONNECT(sg_host); + /* simdag */ XBT_LOG_CONNECT(sd); XBT_LOG_CONNECT(sd_daxparse); -#ifdef HAVE_GRAPHVIZ +#if 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); @@ -696,15 +224,12 @@ static void xbt_log_connect_categories(void) XBT_LOG_CONNECT(simix_process); XBT_LOG_CONNECT(simix_popping); XBT_LOG_CONNECT(simix_synchro); - XBT_LOG_CONNECT(simix_vm); /* 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_cas); @@ -715,7 +240,7 @@ static void xbt_log_connect_categories(void) XBT_LOG_CONNECT(surf_lagrange_dichotomy); XBT_LOG_CONNECT(surf_maxmin); XBT_LOG_CONNECT(surf_network); -#ifdef HAVE_NS3 +#if SIMGRID_HAVE_NS3 XBT_LOG_CONNECT(ns3); #endif XBT_LOG_CONNECT(surf_parse); @@ -723,6 +248,7 @@ static void xbt_log_connect_categories(void) XBT_LOG_CONNECT(surf_routing_generic); XBT_LOG_CONNECT(surf_route_cluster); XBT_LOG_CONNECT(surf_route_cluster_torus); + XBT_LOG_CONNECT(surf_route_cluster_dragonfly); XBT_LOG_CONNECT(surf_route_dijkstra); XBT_LOG_CONNECT(surf_route_fat_tree); XBT_LOG_CONNECT(surf_route_floyd); @@ -733,7 +259,7 @@ static void xbt_log_connect_categories(void) XBT_LOG_CONNECT(surf_trace); XBT_LOG_CONNECT(surf_vm); XBT_LOG_CONNECT(surf_host); - + #endif /* simgrid_EXPORTS */ } @@ -747,10 +273,12 @@ static void xbt_log_help_categories(void); void xbt_log_init(int *argc, char **argv) { unsigned help_requested = 0; /* 1: logs; 2: categories */ - int i, j; + int i; + int j; char *opt; - // _XBT_LOGV(log).threshold = xbt_log_priority_debug; /* uncomment to set the LOG category to debug directly */ + /* uncomment to set the LOG category to debug directly */ + // _XBT_LOGV(log).threshold = xbt_log_priority_debug; xbt_log_connect_categories(); @@ -762,9 +290,9 @@ void xbt_log_init(int *argc, char **argv) xbt_log_control_set(opt); XBT_DEBUG("Did apply '%s' as log setting", opt); } else if (!strcmp(argv[i], "--help-logs")) { - help_requested |= 1; + help_requested |= 1U; } else if (!strcmp(argv[i], "--help-log-categories")) { - help_requested |= 2; + help_requested |= 2U; } else { argv[j++] = argv[i]; } @@ -805,7 +333,7 @@ static void log_cat_exit(xbt_log_category_t cat) void xbt_log_postexit(void) { XBT_VERB("Exiting log"); - xbt_os_rmutex_destroy(log_cat_init_mutex); + xbt_os_mutex_destroy(log_cat_init_mutex); xbt_dynar_free(&xbt_log_settings); log_cat_exit(&_XBT_LOGV(XBT_LOG_ROOT_CAT)); } @@ -820,10 +348,8 @@ void _xbt_log_event_log(xbt_log_event_t ev, const char *fmt, ...) { xbt_log_category_t cat = ev->cat; - 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", + 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 { @@ -832,17 +358,15 @@ void _xbt_log_event_log(xbt_log_event_t ev, const char *fmt, ...) if (!appender) continue; /* No appender, try next */ - xbt_assert(cat->layout, - "No valid layout for the appender of category %s", cat->name); + 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); + int done = cat->layout->do_layout(cat->layout, ev, fmt); va_end(ev->ap); if (done) { appender->do_append(appender, buff); @@ -854,9 +378,8 @@ void _xbt_log_event_log(xbt_log_event_t ev, const char *fmt, ...) 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); + int done = cat->layout->do_layout(cat->layout, ev, fmt); va_end(ev->ap); if (done) break; /* Got it */ @@ -874,18 +397,15 @@ void _xbt_log_event_log(xbt_log_event_t ev, const char *fmt, ...) /* NOTE: * - * The standard logging macros use _XBT_LOG_ISENABLED, which calls - * _xbt_log_cat_init(). Thus, if we want to avoid an infinite - * recursion, we can not use the standard logging macros in - * _xbt_log_cat_init(), and in all functions called from it. + * The standard logging macros use _XBT_LOG_ISENABLED, which calls _xbt_log_cat_init(). Thus, if we want to avoid an + * infinite recursion, we can not use the standard logging macros in _xbt_log_cat_init(), and in all functions called + * from it. * - * To circumvent the problem, we define the macro_xbt_log_init() as - * (0) for the length of the affected functions, and we do not forget - * to undefine it at the end! + * To circumvent the problem, we define the macro_xbt_log_init() as (0) for the length of the affected functions, and + * we do not forget to undefine it at the end! */ -static void _xbt_log_cat_apply_set(xbt_log_category_t category, - xbt_log_setting_t setting) +static void _xbt_log_cat_apply_set(xbt_log_category_t category, xbt_log_setting_t setting) { #define _xbt_log_cat_init(a, b) (0) @@ -893,15 +413,13 @@ static void _xbt_log_cat_apply_set(xbt_log_category_t category, xbt_log_threshold_set(category, setting->thresh); XBT_DEBUG("Apply settings for category '%s': set threshold to %s (=%d)", - category->name, xbt_log_priority_names[category->threshold], - category->threshold); + category->name, xbt_log_priority_names[category->threshold], category->threshold); } if (setting->fmt) { xbt_log_layout_set(category, xbt_log_layout_format_new(setting->fmt)); - XBT_DEBUG("Apply settings for category '%s': set format to %s", - category->name, setting->fmt); + XBT_DEBUG("Apply settings for category '%s': set format to %s", category->name, setting->fmt); } if (setting->additivity != -1) { @@ -915,39 +433,32 @@ 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; - XBT_DEBUG("Set %p as appender of category '%s'", - setting->appender, category->name); + XBT_DEBUG("Set %p as appender of category '%s'", setting->appender, category->name); } #undef _xbt_log_cat_init } /* - * This gets called the first time a category is referenced and performs the - * initialization. + * This gets called the first time a category is referenced and performs the initialization. * Also resets threshold to inherited! */ -int _xbt_log_cat_init(xbt_log_category_t category, - e_xbt_log_priority_t priority) +int _xbt_log_cat_init(xbt_log_category_t category, e_xbt_log_priority_t priority) { #define _xbt_log_cat_init(a, b) (0) - if (log_cat_init_mutex != NULL) { - xbt_os_rmutex_acquire(log_cat_init_mutex); - } + if (log_cat_init_mutex != NULL) + xbt_os_mutex_acquire(log_cat_init_mutex); if (category->initialized) { - if (log_cat_init_mutex != NULL) { - xbt_os_rmutex_release(log_cat_init_mutex); - } + if (log_cat_init_mutex != NULL) + xbt_os_mutex_release(log_cat_init_mutex); return priority >= category->threshold; } unsigned int cursor; xbt_log_setting_t setting = NULL; - int found = 0; - XBT_DEBUG("Initializing category '%s' (firstChild=%s, nextSibling=%s)", - category->name, + XBT_DEBUG("Initializing category '%s' (firstChild=%s, nextSibling=%s)", category->name, (category->firstChild ? category->firstChild->name : "none"), (category->nextSibling ? category->nextSibling->name : "none")); @@ -956,19 +467,17 @@ int _xbt_log_cat_init(xbt_log_category_t category, category->appender = xbt_log_default_appender; category->layout = xbt_log_default_layout; } else { - if (!category->parent) category->parent = &_XBT_LOGV(XBT_LOG_ROOT_CAT); - XBT_DEBUG("Set %s (%s) as father of %s ", - category->parent->name, - (category->parent->initialized ? - xbt_log_priority_names[category->parent->threshold] : "uninited"), + XBT_DEBUG("Set %s (%s) as father of %s ", category->parent->name, + (category->parent->initialized ? xbt_log_priority_names[category->parent->threshold] : "uninited"), category->name); xbt_log_parent_set(category, category->parent); if (XBT_LOG_ISENABLED(log, xbt_log_priority_debug)) { - char *buf, *res = NULL; + char *buf; + char *res = NULL; xbt_log_category_t cpp = category->parent->firstChild; while (cpp) { if (res) { @@ -981,25 +490,22 @@ int _xbt_log_cat_init(xbt_log_category_t category, cpp = cpp->nextSibling; } - XBT_DEBUG("Children of %s: %s; nextSibling: %s", - category->parent->name, res, - (category->parent->nextSibling ? - category->parent->nextSibling->name : "none")); + XBT_DEBUG("Children of %s: %s; nextSibling: %s", category->parent->name, res, + (category->parent->nextSibling ? category->parent->nextSibling->name : "none")); free(res); } - } /* Apply the control */ if (xbt_log_settings) { xbt_assert(category, "NULL category"); xbt_assert(category->name); + int found = 0; 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); + xbt_assert(setting->catname, "NULL setting(=%p)->catname", (void *) setting); if (!strcmp(setting->catname, category->name)) { found = 1; @@ -1010,14 +516,12 @@ int _xbt_log_cat_init(xbt_log_category_t category, if (!found) XBT_DEBUG("Category '%s': inherited threshold = %s (=%d)", - category->name, xbt_log_priority_names[category->threshold], - category->threshold); + 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); - } + if (log_cat_init_mutex != NULL) + xbt_os_mutex_release(log_cat_init_mutex); return priority >= category->threshold; #undef _xbt_log_cat_init @@ -1030,7 +534,6 @@ void xbt_log_parent_set(xbt_log_category_t cat, xbt_log_category_t parent) /* if the category is initialized, unlink from current parent */ if (cat->initialized) { - xbt_log_category_t *cpp = &cat->parent->firstChild; while (*cpp != cat && *cpp != NULL) { @@ -1056,38 +559,31 @@ void xbt_log_parent_set(xbt_log_category_t cat, xbt_log_category_t parent) static void _set_inherited_thresholds(xbt_log_category_t cat) { - xbt_log_category_t child = cat->firstChild; for (; child != NULL; child = child->nextSibling) { if (child->isThreshInherited) { if (cat != &_XBT_LOGV(log)) XBT_VERB("Set category threshold of %s to %s (=%d)", - child->name, xbt_log_priority_names[cat->threshold], - cat->threshold); + child->name, xbt_log_priority_names[cat->threshold], cat->threshold); child->threshold = cat->threshold; _set_inherited_thresholds(child); } } - - } -void xbt_log_threshold_set(xbt_log_category_t cat, - e_xbt_log_priority_t threshold) +void xbt_log_threshold_set(xbt_log_category_t cat, e_xbt_log_priority_t threshold) { cat->threshold = threshold; cat->isThreshInherited = 0; _set_inherited_thresholds(cat); - } static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string) { const char *orig_control_string = control_string; xbt_log_setting_t set = xbt_new(s_xbt_log_setting_t, 1); - const char *name, *dot, *eq; set->catname = NULL; set->thresh = xbt_log_priority_uninitialized; @@ -1100,15 +596,13 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string) XBT_DEBUG("Parse log setting '%s'", control_string); control_string += strspn(control_string, " "); - name = control_string; - control_string += strcspn(control_string, ".= "); - dot = control_string; + const char *name = control_string; + control_string += strcspn(control_string, ".:= "); + const char *dot = control_string; control_string += strcspn(control_string, ":= "); - eq = control_string; - control_string += strcspn(control_string, " "); + const char *eq = control_string; - if(*dot != '.' && (*eq == '=' || *eq == ':')) - xbt_die ("Invalid control string '%s'", orig_control_string); + xbt_assert(*dot == '.' || (*eq != '=' && *eq != ':'), "Invalid control string '%s'", orig_control_string); if (!strncmp(dot + 1, "threshold", (size_t) (eq - dot - 1))) { int i; @@ -1131,22 +625,20 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string) if(ithresh = (e_xbt_log_priority_t) i; } else { THROWF(arg_error, 0, - "Unknown priority name: %s (must be one of: trace,debug,verbose,info,warning,error,critical)", - eq + 1); + "Unknown priority name: %s (must be one of: trace,debug,verbose,info,warning,error,critical)", eq + 1); } free(neweq); } else if (!strncmp(dot + 1, "add", (size_t) (eq - dot - 1)) || !strncmp(dot + 1, "additivity", (size_t) (eq - dot - 1))) { - char *neweq = xbt_strdup(eq + 1); char *p = neweq - 1; @@ -1155,8 +647,7 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string) *p -= 'a' - 'A'; } } - if (!strcmp(neweq, "ON") || !strcmp(neweq, "YES") - || !strcmp(neweq, "1")) { + if (!strcmp(neweq, "ON") || !strcmp(neweq, "YES") || !strcmp(neweq, "1")) { set->additivity = 1; } else { set->additivity = 0; @@ -1164,15 +655,14 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string) free(neweq); } else if (!strncmp(dot + 1, "app", (size_t) (eq - dot - 1)) || !strncmp(dot + 1, "appender", (size_t) (eq - dot - 1))) { - char *neweq = xbt_strdup(eq + 1); if (!strncmp(neweq, "file:", 5)) { set->appender = xbt_log_appender_file_new(neweq + 5); }else if (!strncmp(neweq, "rollfile:", 9)) { - set->appender = xbt_log_appender2_file_new(neweq + 9,1); + set->appender = xbt_log_appender2_file_new(neweq + 9,1); }else if (!strncmp(neweq, "splitfile:", 10)) { - set->appender = xbt_log_appender2_file_new(neweq + 10,0); + set->appender = xbt_log_appender2_file_new(neweq + 10,0); } else { THROWF(arg_error, 0, "Unknown appender log type: '%s'", neweq); } @@ -1181,9 +671,8 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string) set->fmt = xbt_strdup(eq + 1); } else { char buff[512]; - snprintf(buff, min(512, eq - dot), "%s", dot + 1); - THROWF(arg_error, 0, "Unknown setting of the log category: '%s'", - buff); + snprintf(buff, MIN(512, eq - dot), "%s", dot + 1); + xbt_die("Unknown setting of the log category: '%s'", buff); } set->catname = (char *) xbt_malloc(dot - name + 1); @@ -1194,10 +683,10 @@ static xbt_log_setting_t _xbt_log_parse_setting(const char *control_string) return set; } -static xbt_log_category_t _xbt_log_cat_searchsub(xbt_log_category_t cat, - char *name) +static xbt_log_category_t _xbt_log_cat_searchsub(xbt_log_category_t cat, char *name) { - xbt_log_category_t child, res; + xbt_log_category_t child; + xbt_log_category_t res; XBT_DEBUG("Search '%s' into '%s' (firstChild='%s'; nextSibling='%s')", name, cat->name, (cat->firstChild ? cat->firstChild->name : "none"), @@ -1223,20 +712,16 @@ static xbt_log_category_t _xbt_log_cat_searchsub(xbt_log_category_t cat, * * ( [category] "." [keyword] ":" value (" ")... )... * - * where [category] is one the category names (see \ref XBT_log_cats for - * a complete list of the ones defined in the SimGrid library) - * and keyword is one of the following: + * where [category] is one the category names (see \ref XBT_log_cats for a complete list of the ones defined in the + * SimGrid library) and keyword is one of the following: * * - thres: category's threshold priority. Possible values: * TRACE,DEBUG,VERBOSE,INFO,WARNING,ERROR,CRITICAL - * - add or additivity: whether the logging actions must be passed to - * the parent category. + * - add or additivity: whether the logging actions must be passed to the parent category. * Possible values: 0, 1, no, yes, on, off. * Default value: yes. * - fmt: the format to use. See \ref log_use_conf_fmt for more information. - * - app or appender: the appender to use. See \ref log_use_conf_app for more - * information. - * + * - app or appender: the appender to use. See \ref log_use_conf_app for more information. */ void xbt_log_control_set(const char *control_string) { @@ -1258,8 +743,7 @@ void xbt_log_control_set(const char *control_string) } /* some initialization if this is the first time that this get called */ if (xbt_log_settings == NULL) - xbt_log_settings = xbt_dynar_new(sizeof(xbt_log_setting_t), - _free_setting); + xbt_log_settings = xbt_dynar_new(sizeof(xbt_log_setting_t), _free_setting); /* split the string, and remove empty entries */ set_strings = xbt_str_split_quoted(control_string); @@ -1269,21 +753,18 @@ void xbt_log_control_set(const char *control_string) return; } - /* Parse each entry and either use it right now (if the category was already - created), or store it for further use */ + /* Parse each entry and either use it right now (if the category was already created), or store it for further use */ xbt_dynar_foreach(set_strings, cpt, str) { xbt_log_category_t cat = NULL; set = _xbt_log_parse_setting(str); - cat = - _xbt_log_cat_searchsub(&_XBT_LOGV(XBT_LOG_ROOT_CAT), set->catname); + cat = _xbt_log_cat_searchsub(&_XBT_LOGV(XBT_LOG_ROOT_CAT), set->catname); if (cat) { XBT_DEBUG("Apply directly"); _xbt_log_cat_apply_set(cat, set); _free_setting((void *) &set); } else { - XBT_DEBUG("Store for further application"); XBT_DEBUG("push %p to the settings", (void *) set); xbt_dynar_push(xbt_log_settings, &set); @@ -1306,9 +787,7 @@ 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) { - XBT_VERB - ("No appender to category %s. Setting the file appender as default", - cat->name); + 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) { @@ -1386,12 +865,10 @@ static int xbt_log_cat_cmp(const void *pa, const void *pb) return strcmp(a->name, b->name); } -static void xbt_log_help_categories_rec(xbt_log_category_t category, - const char *prefix) +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; @@ -1406,16 +883,15 @@ static void xbt_log_help_categories_rec(xbt_log_category_t category, child_prefix = xbt_strdup(prefix); } - dynar = xbt_dynar_new(sizeof(xbt_log_category_t), NULL); + xbt_dynar_t 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++) { + xbt_dynar_foreach(dynar, i, cat){ 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); }