G4ProfilerMessenger Class Reference

#include <G4ProfilerMessenger.hh>

Inheritance diagram for G4ProfilerMessenger:

Public Member Functions
	G4ProfilerMessenger ()
	~G4ProfilerMessenger () override
	G4ProfilerMessenger (const G4ProfilerMessenger &)=delete
	G4ProfilerMessenger (G4ProfilerMessenger &&)=default
G4ProfilerMessenger &	operator= (const G4ProfilerMessenger &)=delete
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)
virtual void	SetNewValue (G4UIcommand *command, G4String newValue)
G4bool	operator== (const G4UImessenger &messenger) const
G4bool	operator!= (const G4UImessenger &messenger) const
G4bool	CommandsShouldBeInMaster () const

Additional Inherited Members
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
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 49 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 148 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 172 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);
      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