Updates requested in the PR:

  * move of includes to CPP file
  * rename of structures
  * unwrapped 'enabled' boolean from function to global scope
  * macro TMPROF_ENABLED() to TMPROF_ENABLED
  * making name and line const members
  * added default argument to enable function
  * Rename: tmprof_dump_in_json -> tmprof_dump_as_json
  * __tmprof_detail_add_record replaced by tmprof_detail_datat::create
  * push_back replaced by emplace_back
  * added getters to tmprof_detail_datat's attributes.
  * records list moved into the struct tmprof_detail_datat
  * added Doxygen tokens.
  * use of the time profiler only when TMPROF_ENABLED macro is set to 1.

Author: marek-trtik

src/taint-analysis/taint_security_scanner.cpp

@@ -337,7 +337,7 @@ bool taint_do_security_scan(
 
     logger.status() << "The security scanner has finished successfully."
       << messaget::eom;
-    tmprof_dump_in_json(
+    tmprof_dump_as_json(
       boost::filesystem::path(config.get_output_root_directory()) /
       "TMPROF.json");
     return true;

src/util/tmprof.cpp

@@ -1,54 +1,69 @@
+// Copyright 2018 Diffblue Limited. All Rights Reserved.
+
+/// \file
+/// Micro time profiler with code block granularity.
+
 #include <util/tmprof.h>
 #include <boost/filesystem.hpp>
+#include <iostream>
+#include <sstream>
 
-static bool &get_enabled_ref()
-{
-  static bool enabled = true;
-  return enabled;
-}
+static bool enabled = true;
 
 bool is_time_profiling_enabled()
 {
-  return get_enabled_ref();
+  return enabled;
 }
 
 void enable_time_profiling(const bool state)
 {
-  get_enabled_ref() = state;
+  enabled = state;
 }
 
-static std::list<__tmprof_detail_data> &get_records_list()
+std::list<tmprof_detail_datat> tmprof_detail_datat::records;
+
+tmprof_detail_datat *
+tmprof_detail_datat::create(const char *name, const unsigned long line)
 {
-  static std::list<__tmprof_detail_data> records;
-  return records;
+  records.emplace_back(name, line);
+  return &records.back();
 }
 
-__tmprof_detail_data *
-__tmprof_detail_add_record(const __tmprof_detail_data &data)
+void tmprof_detail_datat::on_hit(const double duration)
 {
-  get_records_list().push_back(data);
-  return &get_records_list().back();
+  total_time += duration;
+  if(max_time < duration)
+    max_time = duration;
+  ++hit_count;
 }
 
-void tmprof_dump_in_json(std::ostream &ostr)
+json_objectt tmprof_detail_datat::dump_as_json()
 {
   json_objectt root;
-  for(const auto &record : get_records_list())
-    if(record.hit_count != 0ULL)
+  for(const auto &record : records)
+    if(record.get_hit_count() != 0ULL)
     {
       json_objectt table;
-      table["total_time"] = json_numbert(std::to_string(record.total_time));
-      table["max_time"] = json_numbert(std::to_string(record.max_time));
-      table["hit_count"] = json_numbert(std::to_string(record.hit_count));
-      root[record.name + " [" + std::to_string(record.line) + "]"] = table;
+      table["total_time"] =
+        json_numbert(std::to_string(record.get_total_time()));
+      table["max_time"] = json_numbert(std::to_string(record.get_max_time()));
+      table["hit_count"] = json_numbert(std::to_string(record.get_hit_count()));
+      std::stringstream sstr;
+      sstr << record.get_name() << " [" << record.get_line() << "]";
+      root[sstr.str()] = table;
     }
-  ostr << root;
+  return root;
+}
+
+void tmprof_dump_as_json(std::ostream &ostr)
+{
+  ostr << tmprof_detail_datat::dump_as_json();
 }
 
-void tmprof_dump_in_json(const boost::filesystem::path &out_file_pathname)
+void tmprof_dump_as_json(const boost::filesystem::path &out_file_pathname)
 {
   if(!boost::filesystem::exists(out_file_pathname.parent_path()))
     boost::filesystem::create_directory(out_file_pathname.parent_path());
   std::ofstream ostr(out_file_pathname.native());
-  tmprof_dump_in_json(ostr);
+  tmprof_dump_as_json(ostr);
 }

src/util/tmprof.h

@@ -1,19 +1,27 @@
+// Copyright 2018 Diffblue Limited. All Rights Reserved.
+
+/// \file
+/// Micro time profiler with code block granularity.
+
 #ifndef CPROVER_SECURITY_ANALYSER_UTIL_TMPROF_H
 #define CPROVER_SECURITY_ANALYSER_UTIL_TMPROF_H
 
 #include <util/json.h>
 #include <boost/filesystem/path.hpp>
+#include <list>
 #include <chrono>
 #include <string>
-#include <list>
-#include <iostream>
+#include <iosfwd>
 
-/// Usage:
-///   In order to measure a time performance of a C++ block of code
-///   simply place 'TMPROF_BLOCK();' at the beginning of the block.
-///   (Do not forget to include this header file to the module.)
-/// Example:
+/// \remarks
+///   Usage:
+///     In order to measure a time performance of a C++ block of code
+///     simply place 'TMPROF_BLOCK();' at the beginning of the block.
+///     (Do not forget to include this header file to the module.)
+/// \remarks
+///   Example:
 ///   Let us assume you add TMPROF_BLOCK() calls to function 'foo()' as follows:
+/// \code
 ///   1  void foo()
 ///   2  {
 ///   3     TMPROF_BLOCK();  // This one will give us statistic of whole foo(),
@@ -31,10 +39,12 @@
 ///  15
 ///  16  int main()
 ///  17  {
-//// 18    foo();
+///  18    foo();
 ///  19    tmprof_dump_in_json(std::cout);
 ///  20  }
+/// \endcode
 ///  Then, the program will print to 'std::cout' JSON on this form:
+/// \code
 ///  {
 ///    {
 ///      "foo [3]": {
@@ -49,68 +59,111 @@
 ///      "total_time": 50
 ///    },
 ///  },
-///  NOTE: Recursive calls are trait as independent ones.
-///  NOTE: A C++ code block may have at most one TMPROF_BLOCK() call.
-///  NOTE: The implementation is NOT thread-safe.
-///  NOTE: You can temporarily disable time-profiler by calling:
-///           enable_time_profiling(false);
-///        To check enable/disable state of the time-profiler call:
-///           is_time_profiling_enabled();
-///        The time-profiler is enabled by default.
+/// \endcode
+///  \remarks
+///   In order to activate the system you need to set the value of the
+///   macro TMPROF_ENABLED below to 1.
+///  \remarks
+///   Recursive calls are treated as independent ones.
+///  \remarks
+///   A C++ code block may have at most one TMPROF_BLOCK() call.
+///  \remarks
+///   The implementation is NOT thread-safe.
+///  \remarks
+///   You can temporarily disable time-profiler by calling:
+///       enable_time_profiling(false);
+///   To check enable/disable state of the time-profiler call:
+///       is_time_profiling_enabled();
+///   The time-profiler is enabled by default.
 
+//#define TMPROF_ENABLED
+#ifdef TMPROF_ENABLED
 #define TMPROF_BLOCK()                                                         \
-  static __tmprof_detail_data* const __tmprof_detail_record_ptr =              \
-    __tmprof_detail_add_record(__tmprof_detail_data(__FUNCTION__,__LINE__));   \
-  const __tmprof_detail_on_hit  __tmprof_detail_hit(                           \
-    is_time_profiling_enabled() ? __tmprof_detail_record_ptr : nullptr)
+  static tmprof_detail_datat *const __tmprof_detail_record_ptr =               \
+    tmprof_detail_datat::create(__FUNCTION__, __LINE__);                       \
+  const tmprof_detail_on_hitt __tmprof_detail_hit(__tmprof_detail_record_ptr)
+#else
+#define TMPROF_BLOCK()
+#endif
 
 bool is_time_profiling_enabled();
-void enable_time_profiling(const bool state);
+void enable_time_profiling(const bool state = true);
 
-void tmprof_dump_in_json(std::ostream &ostr);
-void tmprof_dump_in_json(const boost::filesystem::path &out_file_pathname);
+void tmprof_dump_as_json(std::ostream &ostr);
+void tmprof_dump_as_json(const boost::filesystem::path &out_file_pathname);
 
 // Next follow PRIVATE IMPLEMENTATION DETAILS. Do not use them directly !!!
 
-struct __tmprof_detail_data
+struct tmprof_detail_datat
 {
-  __tmprof_detail_data(const std::string &name, const unsigned long line)
+  static tmprof_detail_datat *
+  create(const char *name, const unsigned long line);
+
+  tmprof_detail_datat(const char *const name, const unsigned long line)
     : name(name), line(line), total_time(0.0), max_time(0.0), hit_count(0ULL)
   {
   }
 
-  std::string name;
-  unsigned long line;
+  const char *get_name() const
+  {
+    return name;
+  }
+
+  const unsigned long get_line() const
+  {
+    return line;
+  }
+
+  double get_total_time() const
+  {
+    return total_time;
+  }
+
+  double get_max_time() const
+  {
+    return max_time;
+  }
+
+  unsigned long long get_hit_count() const
+  {
+    return hit_count;
+  }
+
+  void on_hit(const double duration);
+
+  static json_objectt dump_as_json();
+
+private:
+  const char *name;
+  const unsigned long line;
   double total_time;
   double max_time;
   unsigned long long hit_count;
+
+  static std::list<tmprof_detail_datat> records;
 };
 
-struct __tmprof_detail_on_hit
+struct tmprof_detail_on_hitt
 {
-  explicit __tmprof_detail_on_hit(__tmprof_detail_data *const data)
+  explicit tmprof_detail_on_hitt(tmprof_detail_datat *const data)
     : data(data), start_time(std::chrono::high_resolution_clock::now())
   {
   }
-  ~__tmprof_detail_on_hit()
+  ~tmprof_detail_on_hitt()
   {
-    if(data != nullptr)
+    if(is_time_profiling_enabled())
     {
       auto const duration =
         std::chrono::duration<double>(
           std::chrono::high_resolution_clock::now() - start_time)
           .count();
-      data->total_time += duration;
-      if(data->max_time < duration)
-        data->max_time = duration;
-      ++data->hit_count;
+      data->on_hit(duration);
     }
   }
-  __tmprof_detail_data *data;
+
+private:
+  tmprof_detail_datat *data;
   std::chrono::high_resolution_clock::time_point start_time;
 };
 
-__tmprof_detail_data *
-__tmprof_detail_add_record(const __tmprof_detail_data &data);
-
 #endif //CPROVER_SECURITY_ANALYSER_UTIL_TMPROF_H