G4ProfilerMessenger Class Reference

#include <G4ProfilerMessenger.hh>

Inheritance diagram for G4ProfilerMessenger:

Public Member Functions
	G4ProfilerMessenger ()
	~G4ProfilerMessenger () override
	G4ProfilerMessenger (const G4ProfilerMessenger &)=delete
G4ProfilerMessenger &	operator= (const G4ProfilerMessenger &)=delete
	G4ProfilerMessenger (G4ProfilerMessenger &&)=default
G4ProfilerMessenger &	operator= (G4ProfilerMessenger &&)=default
void	SetNewValue (G4UIcommand *, G4String) override
Public Member Functions inherited from G4UImessenger
	G4UImessenger ()=default
	G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
virtual	~G4UImessenger ()
virtual G4String	GetCurrentValue (G4UIcommand *command)
G4bool	CommandsShouldBeInMaster () const

Additional Inherited Members
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
G4String	LtoS (G4long l)
G4String	DtoS (G4double a)
G4String	BtoS (G4bool b)
G4int	StoI (const G4String &s)
G4long	StoL (const G4String &s)
G4double	StoD (const G4String &s)
G4bool	StoB (G4String s)
void	AddUIcommand (G4UIcommand *newCommand)
void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
template<typename T >
T *	CreateCommand (const G4String &cname, const G4String &dsc)
Protected Attributes inherited from G4UImessenger
G4UIdirectory *	baseDir = nullptr
G4String	baseDirName = ""
G4bool	commandsShouldBeInMaster = false

Detailed Description

Definition at line 47 of file G4ProfilerMessenger.hh.

Constructor & Destructor Documentation

G4ProfilerMessenger() [1/3]

G4ProfilerMessenger::G4ProfilerMessenger

(

)

Definition at line 43 of file G4ProfilerMessenger.cc.

{
  profileDirectory = new G4UIdirectory("/profiler/");
  profileDirectory->SetGuidance("Profiler controls.");
 
  profileOutputDirectory = new G4UIdirectory("/profiler/output/");
  profileOutputDirectory->SetGuidance("Control the output modes of the profiler.");
 
#define CREATE_DIR(IDX, DIR, GUIDANCE)              \
  profileTypeDirs.at(IDX) = new G4UIdirectory(DIR); \
  profileTypeDirs.at(IDX)->SetGuidance(GUIDANCE)
 
  CREATE_DIR(Type::Run, "/profiler/run/", "Profiler controls at the G4Run level");
  CREATE_DIR(Type::Event, "/profiler/event/", "Profiler controls at the G4Event level");
  CREATE_DIR(Type::Track, "/profiler/track/", "Profiler controls at the G4Track level");
  CREATE_DIR(Type::Step, "/profiler/step/", "Profiler controls at the G4Step level");
  CREATE_DIR(Type::User, "/profiler/user/", "Profiler controls within user code");
 
#define SET_ENABLED_CMD(IDX, CMD, CMDLINE, DEFAULT, GUIDANCE)        \
  profileEnableCmds.at(IDX).second = CMDLINE;                        \
  profileEnableCmds.at(IDX).first = new G4UIcmdWithABool(CMD, this); \
  profileEnableCmds.at(IDX).first->SetDefaultValue(DEFAULT);         \
  profileEnableCmds.at(IDX).first->SetGuidance(GUIDANCE);            \
  profileEnableCmds.at(IDX).first->AvailableForStates(G4State_PreInit, G4State_Idle)
 
  SET_ENABLED_CMD(Type::Run, "/profiler/run/enable", "run", true, "Record metrics for each G4Run");
  SET_ENABLED_CMD(Type::Event, "/profiler/event/enable", "event", true,
                  "Record metrics for each G4Event");
  SET_ENABLED_CMD(Type::Track, "/profiler/track/enable", "track", false,
                  "Record metrics for each G4Track");
  SET_ENABLED_CMD(Type::Step, "/profiler/step/enable", "step", false,
                  "Record metrics for each G4Step");
  SET_ENABLED_CMD(Type::User, "/profiler/user/enable", "user", true,
                  "Record metrics for user specified profiling instances");
 
#define SET_COMPONENTS_CMD(IDX, CMD, CMDLINE, DEFAULTS, GUIDANCE)    \
  profileCompCmds.at(IDX).second = CMDLINE;                          \
  profileCompCmds.at(IDX).first = new G4UIcmdWithAString(CMD, this); \
  profileCompCmds.at(IDX).first->SetDefaultValue(DEFAULTS);          \
  profileCompCmds.at(IDX).first->SetGuidance(GUIDANCE);              \
  profileCompCmds.at(IDX).first->AvailableForStates(G4State_PreInit, G4State_Idle)
 
  G4String comps = "wall_clock, cpu_clock, cpu_util, peak_rss";
 
  SET_COMPONENTS_CMD(Type::Run, "/profiler/run/components", "--run-components", comps,
                     "Measurment types to record for each G4Run (see `timemory-avail -s`)");
  SET_COMPONENTS_CMD(Type::Event, "/profiler/event/components", "--event-components", comps,
                     "Measurment types to record for each G4Event (see `timemory-avail -s`)");
  SET_COMPONENTS_CMD(Type::Track, "/profiler/track/components", "--track-components", comps,
                     "Measurment types to record for each G4Track (see `timemory-avail -s`)");
  SET_COMPONENTS_CMD(Type::Step, "/profiler/step/components", "--step-components", comps,
                     "Measurment types to record for each G4Step (see `timemory-avail -s`)");
  SET_COMPONENTS_CMD(Type::User, "/profiler/user/components", "--user-components", comps,
                     "Measurment types to record for user specified profiling "
                     "instances (see `timemory-avail -s`)");
 
#define SET_OUTPUT_CMD(CMD, CMDLINE, DEFAULT, GUIDANCE)                     \
  profileGeneralCmds.push_back({new G4UIcmdWithABool(CMD, this), CMDLINE}); \
  profileGeneralCmds.back().first->SetDefaultValue(DEFAULT);                \
  profileGeneralCmds.back().first->SetGuidance(GUIDANCE);                   \
  profileGeneralCmds.back().first->AvailableForStates(G4State_PreInit, G4State_Idle)
 
  SET_OUTPUT_CMD("/profiler/output/dart", "--dart", false,
                 "Enabled Dart output (CTest/CDash data tracking)");
  SET_OUTPUT_CMD("/profiler/output/json", "--json", true, "Enabled JSON output");
  SET_OUTPUT_CMD("/profiler/output/text", "--text", true, "Enabled text output");
  SET_OUTPUT_CMD("/profiler/output/cout", "--cout", false, "Enabled output to console");
  SET_OUTPUT_CMD("/profiler/output/plot", "--plot", false, "Enabled plotting JSON output");
 
  SET_OUTPUT_CMD("/profiler/tree", "--tree", true,
                 "Display the results as a call-stack hierarchy.");
  SET_OUTPUT_CMD("/profiler/flat", "--flat", false, "Display the results as a flat call-stack");
  SET_OUTPUT_CMD("/profiler/timeline", "--timeline", false,
                 "Do not merge duplicate entries at the same call-stack "
                 "position. May be combined with tree or flat profiles.");
  SET_OUTPUT_CMD("/profiler/per_thread", "--per-thread", false,
                 "Display the results for each individual thread (default: aggregation)");
  SET_OUTPUT_CMD("/profiler/per_event", "--per-event", false,
                 "Display the results for each individual G4event (default: aggregation)");
}

~G4ProfilerMessenger()

G4ProfilerMessenger::~G4ProfilerMessenger ( )

override

Definition at line 126 of file G4ProfilerMessenger.cc.

{
  delete profileDirectory;
  delete profileOutputDirectory;
  for (auto& itr : profileTypeDirs) {
    delete itr;
  }
  for (auto& itr : profileEnableCmds) {
    delete itr.first;
  }
  for (auto& itr : profileGeneralCmds) {
    delete itr.first;
  }
  for (auto& itr : profileCompCmds) {
    delete itr.first;
  }
}

G4ProfilerMessenger() [2/3]

G4ProfilerMessenger::G4ProfilerMessenger ( const G4ProfilerMessenger & )

delete

G4ProfilerMessenger() [3/3]

G4ProfilerMessenger::G4ProfilerMessenger ( G4ProfilerMessenger && )

default

Member Function Documentation

operator=() [1/2]

G4ProfilerMessenger & G4ProfilerMessenger::operator= ( const G4ProfilerMessenger & )

delete

operator=() [2/2]

G4ProfilerMessenger & G4ProfilerMessenger::operator= ( G4ProfilerMessenger && )

default

SetNewValue()

void G4ProfilerMessenger::SetNewValue ( G4UIcommand * command, G4String value )

overridevirtual

Reimplemented from G4UImessenger.

Definition at line 146 of file G4ProfilerMessenger.cc.

{
  for (size_t i = 0; i < static_cast<size_t>(G4ProfileType::TypeEnd); ++i) {
    G4UIcmdWithABool* ui = profileEnableCmds.at(i).first;
    if (command == ui) {
      G4Profiler::SetEnabled(i, ui->GetNewBoolValue(value));
      return;
    }
  }
 
  // pass the commands to the timemory argparser
  std::vector<std::string> command_line = {"G4ProfilerMessenger"};
 
  for (auto& itr : profileGeneralCmds) {
    G4UIcmdWithABool* ui = itr.first;
    if (command == ui) {
      command_line.push_back(itr.second.c_str());
      command_line.push_back(value);
      break;
    }
  }
 
  for (auto& itr : profileCompCmds) {
    G4UIcmdWithAString* ui = itr.first;
    if (command == ui) {
      command_line.push_back(itr.second);
#if defined(GEANT4_USE_TIMEMORY)
      for (auto vitr : tim::delimit(value, ", ;"))
        command_line.push_back(vitr);
#endif
      break;
    }
  }
 
  if (command_line.size() > 1) {
    G4Profiler::Configure(command_line);
  }
}

---

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

• G4ProfilerMessenger.hh
• G4ProfilerMessenger.cc