G4RunManager.cc File Reference

#include <sstream>
#include "G4Timer.hh"
#include "G4MTRunManagerKernel.hh"
#include "G4RunManager.hh"
#include "G4RunManagerKernel.hh"
#include "G4WorkerRunManagerKernel.hh"
#include "G4ApplicationState.hh"
#include "G4Material.hh"
#include "G4ParallelWorldProcessStore.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessTable.hh"
#include "G4ProductionCutsTable.hh"
#include "G4Run.hh"
#include "G4RunMessenger.hh"
#include "G4SDManager.hh"
#include "G4StateManager.hh"
#include "G4TiMemory.hh"
#include "G4UImanager.hh"
#include "G4UnitsTable.hh"
#include "G4UserRunAction.hh"
#include "G4UserWorkerInitialization.hh"
#include "G4UserWorkerThreadInitialization.hh"
#include "G4VPersistencyManager.hh"
#include "G4VScoreNtupleWriter.hh"
#include "G4VUserActionInitialization.hh"
#include "G4VUserDetectorConstruction.hh"
#include "G4VUserPhysicsList.hh"
#include "G4VUserPrimaryGeneratorAction.hh"
#include "G4VVisManager.hh"
#include "G4ios.hh"
#include "Randomize.hh"
#include "G4Profiler.hh"
#include "G4HCofThisEvent.hh"
#include "G4ParallelWorldProcess.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
#include "G4ScoringManager.hh"
#include "G4TransportationManager.hh"
#include "G4VHitsCollection.hh"
#include "G4VScoringMesh.hh"
#include "G4ScoringBox.hh"
#include "G4ScoringCylinder.hh"
#include "G4LogicalVolume.hh"
#include "G4SmartVoxelHeader.hh"
#include "G4SmartVoxelStat.hh"
#include "G4VPhysicalVolume.hh"
#include "G4AssemblyStore.hh"
#include "G4GeometryManager.hh"
#include "G4LogicalVolumeStore.hh"
#include "G4PhysicalVolumeStore.hh"
#include "G4RegionStore.hh"
#include "G4SolidStore.hh"

Go to the source code of this file.

Macros
#define	TIMEMORY_WEAK_PREFIX
#define	TIMEMORY_WEAK_POSTFIX

Functions
TIMEMORY_WEAK_PREFIX void	G4RunProfilerInit (void) TIMEMORY_WEAK_POSTFIX
void	G4ProfilerInit (void)

Macro Definition Documentation

TIMEMORY_WEAK_POSTFIX

#define TIMEMORY_WEAK_POSTFIX

Definition at line 1212 of file G4RunManager.cc.

TIMEMORY_WEAK_PREFIX

#define TIMEMORY_WEAK_PREFIX

Definition at line 1211 of file G4RunManager.cc.

Function Documentation

G4ProfilerInit()

void G4ProfilerInit

(

void

)

Definition at line 540 of file G4Profiler.cc.

  {
#ifdef GEANT4_USE_TIMEMORY
 
    // guard against re-initialization
    static bool _once = false;
    if(_once)
      return;
    _once = true;
 
    puts(">>> G4ProfilerInit <<<");
 
    //
    // the default settings
    //
    // large profiles can take a very long time to plot
    tim::settings::plot_output() = false;
    // large profiles can take quite a bit of console space
    tim::settings::cout_output() = false;
    // this creates a subdirectory with the timestamp of the run
    tim::settings::time_output() = false;
    // see `man 3 strftime` for formatting keys
    tim::settings::time_format() = "%F_%I.%M_%p";
    // set the default precision for timing
    tim::settings::timing_precision() = 6;
    // set the minimum width for outputs
    tim::settings::width() = 12;
    // set dart reports (when enabled) to only print the first entry
    tim::settings::dart_count() = 1;
    // set dart reports (when enabled) to use the component label
    // instead of the string identifer of the entry, e.g.
    // >>> G4Run/0 ... peak_rss ... 50 MB would report
    // 'peak_rss 50 MB' not 'G4Run/0 50 MB'
    tim::settings::dart_label() = true;
 
    // allow environment overrides of the defaults
    tim::settings::parse();
#endif
  }

Referenced by G4RunProfilerInit().

G4RunProfilerInit()

void G4RunProfilerInit

(

void

)

Definition at line 1227 of file G4RunManager.cc.

  {
#ifdef GEANT4_USE_TIMEMORY
    G4ProfilerInit();
 
    // guard against re-initialization
    static G4bool _once = false;
    if(_once)
      return;
    _once = true;
 
    puts(">>> G4RunProfilerInit <<<");
 
    using RunProfilerConfig   = G4ProfilerConfig<G4ProfileType::Run>;
    using EventProfilerConfig = G4ProfilerConfig<G4ProfileType::Event>;
    using TrackProfilerConfig = G4ProfilerConfig<G4ProfileType::Track>;
    using StepProfilerConfig  = G4ProfilerConfig<G4ProfileType::Step>;
    using UserProfilerConfig  = G4ProfilerConfig<G4ProfileType::User>;
 
    //
    // these are the default functions for evaluating whether
    // to start profiling
    //
    RunProfilerConfig::GetFallbackQueryFunctor() = [](const G4Run* _run) {
      return G4Profiler::GetEnabled(G4ProfileType::Run) && _run;
    };
 
    EventProfilerConfig::GetFallbackQueryFunctor() = [](const G4Event* _event) {
      return G4Profiler::GetEnabled(G4ProfileType::Event) && _event;
    };
 
    TrackProfilerConfig::GetFallbackQueryFunctor() = [](const G4Track* _track) {
      return G4Profiler::GetEnabled(G4ProfileType::Track) && _track &&
             _track->GetDynamicParticle();
    };
 
    StepProfilerConfig::GetFallbackQueryFunctor() = [](const G4Step* _step) {
      return G4Profiler::GetEnabled(G4ProfileType::Step) && _step &&
             _step->GetTrack();
    };
 
    UserProfilerConfig::GetFallbackQueryFunctor() =
      [](const std::string& _user) {
        return G4Profiler::GetEnabled(G4ProfileType::User) && !_user.empty();
      };
 
    //
    // these are the default functions which encode the profiling label.
    // Will not be called unless the query returned true
    //
    RunProfilerConfig::GetFallbackLabelFunctor() = [](const G4Run* _run) {
      return TIMEMORY_JOIN('/', "G4Run", _run->GetRunID());
    };
 
    EventProfilerConfig::GetFallbackLabelFunctor() =
      [](const G4Event* _event) -> std::string {
      if(G4Profiler::GetPerEvent())
        return TIMEMORY_JOIN('/', "G4Event", _event->GetEventID());
      else
        return "G4Event";
    };
 
    TrackProfilerConfig::GetFallbackLabelFunctor() = [](const G4Track* _track) {
      auto pdef = _track->GetDynamicParticle()->GetParticleDefinition();
      return TIMEMORY_JOIN('/', "G4Track", pdef->GetParticleName());
    };
 
    StepProfilerConfig::GetFallbackLabelFunctor() = [](const G4Step* _step) {
      auto pdef = _step->GetTrack()->GetParticleDefinition();
      return TIMEMORY_JOIN('/', "G4Step", pdef->GetParticleName());
    };
 
    UserProfilerConfig::GetFallbackLabelFunctor() =
      [](const std::string& _user) { return _user; };
 
    using RunTool   = typename RunProfilerConfig::type;
    using EventTool = typename EventProfilerConfig::type;
    using TrackTool = typename TrackProfilerConfig::type;
    using StepTool  = typename StepProfilerConfig::type;
    using UserTool  = typename UserProfilerConfig::type;
 
    RunProfilerConfig::GetFallbackToolFunctor() =
      [](const std::string& _label) { return new RunTool{ _label }; };
 
    EventProfilerConfig::GetFallbackToolFunctor() =
      [](const std::string& _label) { return new EventTool{ _label }; };
 
    TrackProfilerConfig::GetFallbackToolFunctor() =
      [](const std::string& _label) {
        return new TrackTool(_label, tim::scope::config(tim::scope::flat{}));
      };
 
    StepProfilerConfig::GetFallbackToolFunctor() =
      [](const std::string& _label) {
        return new StepTool(_label, tim::scope::config(tim::scope::flat{}));
      };
 
    UserProfilerConfig::GetFallbackToolFunctor() =
      [](const std::string& _label) { return new UserTool(_label); };
 
    auto comps = "wall_clock, cpu_clock, cpu_util, peak_rss";
    auto run_env_comps =
      tim::get_env<std::string>("G4PROFILE_RUN_COMPONENTS", comps);
    auto event_env_comps =
      tim::get_env<std::string>("G4PROFILE_EVENT_COMPONENTS", comps);
    auto track_env_comps =
      tim::get_env<std::string>("G4PROFILE_TRACK_COMPONENTS", comps);
    auto step_env_comps =
      tim::get_env<std::string>("G4PROFILE_STEP_COMPONENTS", comps);
    auto user_env_comps =
      tim::get_env<std::string>("G4PROFILE_USER_COMPONENTS", comps);
 
    tim::configure<G4RunProfiler>(run_env_comps);
    tim::configure<G4EventProfiler>(event_env_comps);
    tim::configure<G4TrackProfiler>(track_env_comps);
    tim::configure<G4StepProfiler>(step_env_comps);
    tim::configure<G4UserProfiler>(user_env_comps);
#endif
  }