G4Profiler Class Reference

#include <G4Profiler.hh>

Data Structures
struct	ArgumentParser

Public Types
using	array_type = std::array< bool, G4ProfileType::TypeEnd >

Static Public Member Functions
static void	Configure (ArgumentParser &, const std::vector< std::string > &args)
static void	Configure (ArgumentParser &, int argc, char **argv)
static void	Configure (const std::vector< std::string > &args)
static void	Configure (int argc, char **argv)
static void	Finalize ()
static bool	GetEnabled (size_t v)
static bool	GetPerEvent ()
static void	SetEnabled (size_t v, bool val)
static void	SetPerEvent (bool val)

Static Private Member Functions
static array_type &	GetEnabled ()
static bool &	GetPerEventImpl ()

Detailed Description

Definition at line 92 of file G4Profiler.hh.

Member Typedef Documentation

array_type

using G4Profiler::array_type = std::array<bool, G4ProfileType::TypeEnd>

Definition at line 95 of file G4Profiler.hh.

Member Function Documentation

Configure() [1/4]

void G4Profiler::Configure ( ArgumentParser &  parser, const std::vector< std::string > &  args  )

static

Definition at line 105 of file G4Profiler.cc.

{
#if defined(GEANT4_USE_TIMEMORY)
  using parser_t     = ArgumentParser;
  using parser_err_t = typename parser_t::result_type;
 
  if(args.empty())
    return;
 
  static std::mutex mtx;
  std::unique_lock<std::mutex> lk(mtx);
 
  static auto tid = std::this_thread::get_id();
  if(std::this_thread::get_id() != tid)
    return;
 
  // std::cout << "Arguments:";
  // for(auto itr : args)
  //  std::cout << " " << itr;
  // std::cout << std::endl;
 
  auto help_action = [](parser_t& p) {
    p.print_help();
    exit(EXIT_FAILURE);
  };
 
  parser.enable_help();
  parser.on_error([=](parser_t& p, parser_err_t _err) {
    std::cerr << _err << std::endl;
    help_action(p);
  });
 
  auto get_bool = [](const std::string& _str, bool _default) {
    if(_str.empty())
      return _default;
    using namespace std::regex_constants;
    const auto regex_config = egrep | icase;
    if(std::regex_match(_str, std::regex("on|true|yes|1", regex_config)))
      return true;
    else if(std::regex_match(_str, std::regex("off|false|no|0", regex_config)))
      return false;
    return _default;
  };
  //
  //  Collection control
  //
  parser.add_argument()
    .names({ "-p", "--profile" })
    .description("Profiler modes")
    .choices({ "run", "event", "track", "step", "user" })
    .action([&](parser_t& p) {
      using namespace std::regex_constants;
      const auto regex_config = egrep | icase;
      for(auto&& itr : p.get<std::vector<std::string>>("profile"))
      {
        if(std::regex_match(itr, std::regex("run", regex_config)))
          G4Profiler::SetEnabled(G4ProfileType::Run, true);
        else if(std::regex_match(itr, std::regex("event", regex_config)))
          G4Profiler::SetEnabled(G4ProfileType::Event, true);
        else if(std::regex_match(itr, std::regex("track", regex_config)))
          G4Profiler::SetEnabled(G4ProfileType::Track, true);
        else if(std::regex_match(itr, std::regex("step", regex_config)))
          G4Profiler::SetEnabled(G4ProfileType::Step, true);
        else if(std::regex_match(itr, std::regex("user", regex_config)))
          G4Profiler::SetEnabled(G4ProfileType::User, true);
      }
    });
  //
  //  Component controls
  //
  parser.add_argument()
    .names({ "-r", "--run-components" })
    .description("Components for run profiling (see 'timemory-avail -s')")
    .action([&](parser_t& p) {
      G4RunProfiler::reset();
      tim::configure<G4RunProfiler>(
        p.get<std::vector<std::string>>("run-components"));
    });
  parser.add_argument()
    .names({ "-e", "--event-components" })
    .description("Components for event profiling (see 'timemory-avail -s')")
    .action([&](parser_t& p) {
      G4EventProfiler::reset();
      tim::configure<G4EventProfiler>(
        p.get<std::vector<std::string>>("event-components"));
    });
  parser.add_argument()
    .names({ "-t", "--track-components" })
    .description("Components for track profiling (see 'timemory-avail -s')")
    .action([&](parser_t& p) {
      G4TrackProfiler::reset();
      tim::configure<G4TrackProfiler>(
        p.get<std::vector<std::string>>("track-components"));
    });
  parser.add_argument()
    .names({ "-s", "--step-components" })
    .description("Components for step profiling (see 'timemory-avail -s')")
    .action([&](parser_t& p) {
      G4StepProfiler::reset();
      tim::configure<G4StepProfiler>(
        p.get<std::vector<std::string>>("step-components"));
    });
  parser.add_argument()
    .names({ "-u", "--user-components" })
    .description("Components for user profiling (see 'timemory-avail -s')")
    .action([&](parser_t& p) {
      G4StepProfiler::reset();
      tim::configure<G4UserProfiler>(
        p.get<std::vector<std::string>>("user-components"));
    });
  //
  //  Display controls
  //
  parser.add_argument()
    .names({ "-H", "--hierarchy", "--tree" })
    .description("Display the results as a call-stack hierarchy.")
    .max_count(1)
    .action([&](parser_t& p) {
      tim::settings::flat_profile() =
        !get_bool(p.get<std::string>("tree"), true);
    });
  parser.add_argument()
    .names({ "-F", "--flat" })
    .description("Display the results as a flat call-stack")
    .max_count(1)
    .action([&](parser_t& p) {
      tim::settings::flat_profile() =
        get_bool(p.get<std::string>("flat"), true);
    });
  parser.add_argument()
    .names({ "-T", "--timeline" })
    .description(
      "Do not merge duplicate entries at the same call-stack position")
    .max_count(1)
    .action([&](parser_t& p) {
      tim::settings::timeline_profile() =
        get_bool(p.get<std::string>("timeline"), true);
    });
  parser.add_argument()
    .names({ "--per-thread" })
    .description(
      "Display the results for each individual thread (default: aggregation)")
    .max_count(1)
    .action([&](parser_t& p) {
      tim::settings::flat_profile() =
        get_bool(p.get<std::string>("per-thread"), true);
    });
  parser.add_argument()
    .names({ "--per-event" })
    .description("Each G4Event is a unique entry")
    .max_count(1)
    .action([&](parser_t& p) {
      tim::settings::timeline_profile() =
        get_bool(p.get<std::string>("per-event"), true);
    });
  //
  //  Output controls
  //
  parser.add_argument()
    .names({ "-D", "--dart" })
    .description("Enable Dart output (CTest/CDash data tracking)")
    .max_count(1)
    .action([&](parser_t& p) {
      tim::settings::dart_output() = get_bool(p.get<std::string>("dart"), true);
    });
  parser.add_argument()
    .names({ "-J", "--json" })
    .description("Enable JSON output")
    .max_count(1)
    .action([&](parser_t& p) {
      tim::settings::json_output() = get_bool(p.get<std::string>("json"), true);
    });
  parser.add_argument()
    .names({ "-P", "--plot" })
    .description("Plot the JSON output")
    .max_count(1)
    .action([&](parser_t& p) {
      tim::settings::plot_output() = get_bool(p.get<std::string>("plot"), true);
    });
  parser.add_argument()
    .names({ "-X", "--text" })
    .description("Enable TEXT output")
    .max_count(1)
    .action([&](parser_t& p) {
      tim::settings::text_output() = get_bool(p.get<std::string>("text"), true);
    });
  parser.add_argument()
    .names({ "-C", "--cout" })
    .description("Enable output to terminal")
    .max_count(1)
    .action([&](parser_t& p) {
      tim::settings::cout_output() = get_bool(p.get<std::string>("cout"), true);
    });
  parser.add_argument()
    .names({ "-O", "--output-path" })
    .description("Set the output directory")
    .count(1)
    .action([&](parser_t& p) {
      tim::settings::output_path() = p.get<std::string>("output-path");
    });
  parser.add_argument()
    .names({ "-W", "--hw-counters" })
    .description(
      "Set the hardware counters to collect (see 'timemory-avail -H')")
    .action([&](parser_t& p) {
      tim::settings::papi_events() = p.get<std::string>("hw-counters");
    });
 
  tim::settings::time_output() = true;
  tim::settings::time_format() = "%F_%I.%M_%p";
 
  auto err = parser.parse(args);
  if(err)
  {
    std::cout << "Error! " << err << std::endl;
    help_action(parser);
  }
 
#else
  G4Impl::consume_parameters(parser, args);
#endif
}

References geant4_check_module_cycles::action, args, PTL::mpl::consume_parameters(), G4ProfileType::Event, g4zmq::exit(), G4AttDefStore::mutex, geant4_check_module_cycles::parser, g4tim::handler< Types >::reset(), G4ProfileType::Run, SetEnabled(), G4ProfileType::Step, G4ProfileType::Track, and G4ProfileType::User.

Configure() [2/4]

void G4Profiler::Configure ( ArgumentParser &  parser, int  argc, char **  argv  )

static

Definition at line 76 of file G4Profiler.cc.

{
#if defined(GEANT4_USE_TIMEMORY)
  tim::timemory_init(argc, argv);
  std::vector<std::string> _args;
  for(int i = 0; i < argc; ++i)
    _args.push_back(argv[i]);
  Configure(parser, _args);
#else
  G4Impl::consume_parameters(parser, argc, argv);
#endif
}

References Configure(), PTL::mpl::consume_parameters(), and geant4_check_module_cycles::parser.

Configure() [3/4]

void G4Profiler::Configure ( const std::vector< std::string > &  args )

static

Definition at line 91 of file G4Profiler.cc.

{
#if defined(GEANT4_USE_TIMEMORY)
  if(args.empty())
    return;
  ArgumentParser p{ args.at(0) };
  Configure(p, args);
#else
  G4Impl::consume_parameters(args);
#endif
}

References args, Configure(), and PTL::mpl::consume_parameters().

Referenced by Configure(), G4RunManager::ConfigureProfilers(), and G4ProfilerMessenger::SetNewValue().

Configure() [4/4]

void G4Profiler::Configure ( int  argc, char **  argv  )

static

Definition at line 62 of file G4Profiler.cc.

{
#if defined(GEANT4_USE_TIMEMORY)
  tim::timemory_init(argc, argv);
  std::vector<std::string> _args;
  for(int i = 0; i < argc; ++i)
    _args.push_back(argv[i]);
  Configure(_args);
#else
  G4Impl::consume_parameters(argc, argv);
#endif
}

References Configure(), and PTL::mpl::consume_parameters().

Finalize()

void G4Profiler::Finalize ( )

static

Definition at line 331 of file G4Profiler.cc.

{
#if defined(GEANT4_USE_TIMEMORY)
  // generally safe to call multiple times but just in case
  // it is not necessary to call from worker threads, calling
  // once on master will merge any threads that accumulated
  // results. If a thread is destroyed, before finalize is
  // called on master thread, then it will merge itself into
  // the master thread before terminating. The biggest issue
  // is when finalize is never called on any threads (including
  // the master) so finalization happens after main exits. When
  // this happens, the order that data gets deleted is very
  // hard to predict so it commonly results in a segfault. Thus,
  // if the user does not call this function and does not
  // delete G4RunManager, a segfault is quite likely.
  static thread_local bool _once = false;
  if(!_once)
    tim::timemory_finalize();
  _once = true;
#endif
}

Referenced by G4MTRunManager::TerminateWorkers(), G4RunManager::~G4RunManager(), and G4TaskRunManager::~G4TaskRunManager().

GetEnabled() [1/2]

G4Profiler::array_type & G4Profiler::GetEnabled ( )

staticprivate

Definition at line 43 of file G4Profiler.cc.

{
  static array_type _instance = []() {
    array_type _tmp{};
    _tmp.fill(false);
    // environment settings introduce the defaults
    // but will be overridden by messenger and/or command line
    _tmp.at(G4ProfileType::Run)   = G4GetEnv<bool>("G4PROFILE_RUN", true);
    _tmp.at(G4ProfileType::Event) = G4GetEnv<bool>("G4PROFILE_EVENT", false);
    _tmp.at(G4ProfileType::Track) = G4GetEnv<bool>("G4PROFILE_TRACK", false);
    _tmp.at(G4ProfileType::Step)  = G4GetEnv<bool>("G4PROFILE_STEP", false);
    _tmp.at(G4ProfileType::User)  = G4GetEnv<bool>("G4PROFILE_USER", true);
    return _tmp;
  }();
  return _instance;
}

References G4ProfileType::Event, G4ProfileType::Run, G4ProfileType::Step, G4ProfileType::Track, and G4ProfileType::User.

Referenced by G4RunProfilerInit(), and SetEnabled().

GetEnabled() [2/2]

static bool G4Profiler::GetEnabled ( size_t  v )

inlinestatic

Definition at line 112 of file G4Profiler.hh.

{ return GetEnabled().at(v); }

References GetEnabled().

Referenced by GetEnabled().

GetPerEvent()

static bool G4Profiler::GetPerEvent ( )

inlinestatic

Definition at line 115 of file G4Profiler.hh.

{ return GetPerEventImpl(); }

References GetPerEventImpl().

Referenced by G4RunProfilerInit().

GetPerEventImpl()

static bool & G4Profiler::GetPerEventImpl ( )

inlinestaticprivate

Definition at line 120 of file G4Profiler.hh.

  {
    static bool _value = false;
    return _value;
  }

Referenced by GetPerEvent(), and SetPerEvent().

SetEnabled()

static void G4Profiler::SetEnabled ( size_t  v, bool  val  )

inlinestatic

Definition at line 113 of file G4Profiler.hh.

{ GetEnabled().at(v) = val; }

References GetEnabled().

Referenced by Configure(), and G4ProfilerMessenger::SetNewValue().

SetPerEvent()

static void G4Profiler::SetPerEvent ( bool  val )

inlinestatic

Definition at line 116 of file G4Profiler.hh.

{ GetPerEventImpl() = val; }

References GetPerEventImpl().

---

The documentation for this class was generated from the following files:

• source/global/management/include/G4Profiler.hh
• source/global/management/src/G4Profiler.cc