Line data    Source code

       1             : // The libMesh Finite Element Library.
       2             : // Copyright (C) 2002-2025 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
       3             : 
       4             : // This library is free software; you can redistribute it and/or
       5             : // modify it under the terms of the GNU Lesser General Public
       6             : // License as published by the Free Software Foundation; either
       7             : // version 2.1 of the License, or (at your option) any later version.
       8             : 
       9             : // This library is distributed in the hope that it will be useful,
      10             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      12             : // Lesser General Public License for more details.
      13             : 
      14             : // You should have received a copy of the GNU Lesser General Public
      15             : // License along with this library; if not, write to the Free Software
      16             : // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
      17             : 
      18             : 
      19             : 
      20             : #ifndef LIBMESH_LIBMESH_LOGGING_H
      21             : #define LIBMESH_LIBMESH_LOGGING_H
      22             : 
      23             : 
      24             : // The library configuration options
      25             : #include "libmesh/libmesh_common.h"
      26             : 
      27             : #include "libmesh/perf_log.h"
      28             : 
      29             : // Two-level macro substitution trick, used to construct a unique
      30             : // variable name for a given line.
      31             : #define TOKENPASTE(x, y) x ## y
      32             : #define TOKENPASTE2(x, y) TOKENPASTE(x, y)
      33             : 
      34             : namespace libMesh
      35             : {
      36             : 
      37             : 
      38             : // Forward declaration, required when included
      39             : // in perf_log.{C,h} because the preceding
      40             : // #include "libmesh/perf_log.h" is ineffective.
      41             : // Multiple inclusion avoidance problem...
      42             : // LIBMESH_PERF_LOG_H already #define'd, but the
      43             : // class has not been declared yet!.
      44             : class PerfLog;
      45             : 
      46             : /**
      47             :  * A \p PerfLog object to log performance.  If the library is configured
      48             :  * with \p --enable-perflog then it will log key functions.
      49             :  */
      50             : extern PerfLog perflog;
      51             : 
      52             : 
      53             : /**
      54             :  * Used for logging something that naturally lasts as long as some
      55             :  * enclosing scope, such as the current function.  Makes it very easy
      56             :  * to handle multiple return scenarios, since the event is popped in
      57             :  * the destructor.  Should not be used directly, instead use the
      58             :  * LOG_SCOPE macro, which resolves to nothing at compile time if
      59             :  * logging is disabled.
      60             :  *
      61             :  * \author John Peterson
      62             :  * \date 2016
      63             :  */
      64             : struct PerfItem
      65             : {
      66    72696991 :   PerfItem(const char * label,
      67             :            const char * header,
      68             :            bool enabled=true,
      69    72696991 :            PerfLog * my_perflog=&perflog) :
      70             :     _label(label),
      71             :     _header(header),
      72             :     _enabled(enabled),
      73    72696991 :     _perflog(*my_perflog)
      74             :   {
      75    79842753 :     if (_enabled)
      76   136783900 :       _perflog.fast_push(label, header);
      77    72696991 :   }
      78             : 
      79    72696991 :   ~PerfItem()
      80    72696991 :   {
      81    79842753 :     if (_enabled)
      82   136783900 :       _perflog.fast_pop(_label, _header);
      83    72696991 :   }
      84             : 
      85             : private:
      86             :   const char * _label;
      87             :   const char * _header;
      88             :   bool _enabled;
      89             :   PerfLog & _perflog;
      90             : };
      91             : 
      92             : 
      93             : 
      94             : } // namespace libMesh
      95             : 
      96             : 
      97             : 
      98             : // Macros for performance logging.  This allows us
      99             : // to add performance monitors to the code without
     100             : // impacting performance when performance logging
     101             : // is disabled.
     102             : #ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING
     103             : 
     104             : #  define START_LOG(a,b)   { libMesh::perflog.push(a,b); }
     105             : #  define STOP_LOG(a,b)    { libMesh::perflog.pop(a,b); }
     106             : #  define LOG_SCOPE(a,b)   libMesh::PerfItem TOKENPASTE2(perf_item_, __LINE__)(a,b);
     107             : #  define LOG_SCOPE_IF(a,b,enabled)   libMesh::PerfItem TOKENPASTE2(perf_item_, __LINE__)(a,b,enabled);
     108             : #  define LOG_SCOPE_WITH(a,b,logger)   libMesh::PerfItem TOKENPASTE2(perf_item_, __LINE__)(a,b,true,&logger);
     109             : 
     110             : #else
     111             : 
     112             : #  define START_LOG(a,b)   {}
     113             : #  define STOP_LOG(a,b)    {}
     114             : #  define PALIBMESH_USE_LOG(a,b)   {}
     115             : #  define RESTART_LOG(a,b) {}
     116             : #  define LOG_SCOPE(a,b)   {}
     117             : #  define LOG_SCOPE_IF(a,b,enabled) {}
     118             : #  define LOG_SCOPE_WITH(a,b,logger) {}
     119             : 
     120             : #endif
     121             : 
     122             : // If performance logging is disabled, the LOG_SCOPE(a,b) will be a no-op.
     123             : #define LOG_CALL(a,b,X)   \
     124             :   do {                    \
     125             :     LOG_SCOPE(a,b);       \
     126             :     X;                    \
     127             :   } while (0)
     128             : 
     129             : 
     130             : 
     131             : 
     132             : #endif // LIBMESH_LIBMESH_LOGGING_H