Geant4 11.2.2
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Classes | Public Types | Static Public Member Functions | List of all members
G4Profiler Class Reference

#include <G4Profiler.hh>

Classes

struct  ArgumentParser
 

Public Types

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

Static Public Member Functions

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

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.

107{
108#if defined(GEANT4_USE_TIMEMORY)
109 using parser_t = ArgumentParser;
110 using parser_err_t = typename parser_t::result_type;
111
112 if(args.empty())
113 return;
114
115 static std::mutex mtx;
116 std::unique_lock<std::mutex> lk(mtx);
117
118 static auto tid = std::this_thread::get_id();
119 if(std::this_thread::get_id() != tid)
120 return;
121
122 // std::cout << "Arguments:";
123 // for(auto itr : args)
124 // std::cout << " " << itr;
125 // std::cout << std::endl;
126
127 auto help_action = [](parser_t& p) {
128 p.print_help();
129 exit(EXIT_FAILURE);
130 };
131
132 parser.enable_help();
133 parser.on_error([=](parser_t& p, parser_err_t _err) {
134 std::cerr << _err << std::endl;
135 help_action(p);
136 });
137
138 auto get_bool = [](const std::string& _str, bool _default) {
139 if(_str.empty())
140 return _default;
141 using namespace std::regex_constants;
142 const auto regex_config = egrep | icase;
143 if(std::regex_match(_str, std::regex("on|true|yes|1", regex_config)))
144 return true;
145 else if(std::regex_match(_str, std::regex("off|false|no|0", regex_config)))
146 return false;
147 return _default;
148 };
149 //
150 // Collection control
151 //
152 parser.add_argument()
153 .names({ "-p", "--profile" })
154 .description("Profiler modes")
155 .choices({ "run", "event", "track", "step", "user" })
156 .action([&](parser_t& p) {
157 using namespace std::regex_constants;
158 const auto regex_config = egrep | icase;
159 for(auto&& itr : p.get<std::vector<std::string>>("profile"))
160 {
161 if(std::regex_match(itr, std::regex("run", regex_config)))
162 G4Profiler::SetEnabled(G4ProfileType::Run, true);
163 else if(std::regex_match(itr, std::regex("event", regex_config)))
164 G4Profiler::SetEnabled(G4ProfileType::Event, true);
165 else if(std::regex_match(itr, std::regex("track", regex_config)))
166 G4Profiler::SetEnabled(G4ProfileType::Track, true);
167 else if(std::regex_match(itr, std::regex("step", regex_config)))
168 G4Profiler::SetEnabled(G4ProfileType::Step, true);
169 else if(std::regex_match(itr, std::regex("user", regex_config)))
170 G4Profiler::SetEnabled(G4ProfileType::User, true);
171 }
172 });
173 //
174 // Component controls
175 //
176 parser.add_argument()
177 .names({ "-r", "--run-components" })
178 .description("Components for run profiling (see 'timemory-avail -s')")
179 .action([&](parser_t& p) {
180 G4RunProfiler::reset();
181 tim::configure<G4RunProfiler>(
182 p.get<std::vector<std::string>>("run-components"));
183 });
184 parser.add_argument()
185 .names({ "-e", "--event-components" })
186 .description("Components for event profiling (see 'timemory-avail -s')")
187 .action([&](parser_t& p) {
188 G4EventProfiler::reset();
189 tim::configure<G4EventProfiler>(
190 p.get<std::vector<std::string>>("event-components"));
191 });
192 parser.add_argument()
193 .names({ "-t", "--track-components" })
194 .description("Components for track profiling (see 'timemory-avail -s')")
195 .action([&](parser_t& p) {
196 G4TrackProfiler::reset();
197 tim::configure<G4TrackProfiler>(
198 p.get<std::vector<std::string>>("track-components"));
199 });
200 parser.add_argument()
201 .names({ "-s", "--step-components" })
202 .description("Components for step profiling (see 'timemory-avail -s')")
203 .action([&](parser_t& p) {
204 G4StepProfiler::reset();
205 tim::configure<G4StepProfiler>(
206 p.get<std::vector<std::string>>("step-components"));
207 });
208 parser.add_argument()
209 .names({ "-u", "--user-components" })
210 .description("Components for user profiling (see 'timemory-avail -s')")
211 .action([&](parser_t& p) {
212 G4StepProfiler::reset();
213 tim::configure<G4UserProfiler>(
214 p.get<std::vector<std::string>>("user-components"));
215 });
216 //
217 // Display controls
218 //
219 parser.add_argument()
220 .names({ "-H", "--hierarchy", "--tree" })
221 .description("Display the results as a call-stack hierarchy.")
222 .max_count(1)
223 .action([&](parser_t& p) {
224 tim::settings::flat_profile() =
225 !get_bool(p.get<std::string>("tree"), true);
226 });
227 parser.add_argument()
228 .names({ "-F", "--flat" })
229 .description("Display the results as a flat call-stack")
230 .max_count(1)
231 .action([&](parser_t& p) {
232 tim::settings::flat_profile() =
233 get_bool(p.get<std::string>("flat"), true);
234 });
235 parser.add_argument()
236 .names({ "-T", "--timeline" })
237 .description(
238 "Do not merge duplicate entries at the same call-stack position")
239 .max_count(1)
240 .action([&](parser_t& p) {
241 tim::settings::timeline_profile() =
242 get_bool(p.get<std::string>("timeline"), true);
243 });
244 parser.add_argument()
245 .names({ "--per-thread" })
246 .description(
247 "Display the results for each individual thread (default: aggregation)")
248 .max_count(1)
249 .action([&](parser_t& p) {
250 tim::settings::flat_profile() =
251 get_bool(p.get<std::string>("per-thread"), true);
252 });
253 parser.add_argument()
254 .names({ "--per-event" })
255 .description("Each G4Event is a unique entry")
256 .max_count(1)
257 .action([&](parser_t& p) {
258 tim::settings::timeline_profile() =
259 get_bool(p.get<std::string>("per-event"), true);
260 });
261 //
262 // Output controls
263 //
264 parser.add_argument()
265 .names({ "-D", "--dart" })
266 .description("Enable Dart output (CTest/CDash data tracking)")
267 .max_count(1)
268 .action([&](parser_t& p) {
269 tim::settings::dart_output() = get_bool(p.get<std::string>("dart"), true);
270 });
271 parser.add_argument()
272 .names({ "-J", "--json" })
273 .description("Enable JSON output")
274 .max_count(1)
275 .action([&](parser_t& p) {
276 tim::settings::json_output() = get_bool(p.get<std::string>("json"), true);
277 });
278 parser.add_argument()
279 .names({ "-P", "--plot" })
280 .description("Plot the JSON output")
281 .max_count(1)
282 .action([&](parser_t& p) {
283 tim::settings::plot_output() = get_bool(p.get<std::string>("plot"), true);
284 });
285 parser.add_argument()
286 .names({ "-X", "--text" })
287 .description("Enable TEXT output")
288 .max_count(1)
289 .action([&](parser_t& p) {
290 tim::settings::text_output() = get_bool(p.get<std::string>("text"), true);
291 });
292 parser.add_argument()
293 .names({ "-C", "--cout" })
294 .description("Enable output to terminal")
295 .max_count(1)
296 .action([&](parser_t& p) {
297 tim::settings::cout_output() = get_bool(p.get<std::string>("cout"), true);
298 });
299 parser.add_argument()
300 .names({ "-O", "--output-path" })
301 .description("Set the output directory")
302 .count(1)
303 .action([&](parser_t& p) {
304 tim::settings::output_path() = p.get<std::string>("output-path");
305 });
306 parser.add_argument()
307 .names({ "-W", "--hw-counters" })
308 .description(
309 "Set the hardware counters to collect (see 'timemory-avail -H')")
310 .action([&](parser_t& p) {
311 tim::settings::papi_events() = p.get<std::string>("hw-counters");
312 });
313
314 tim::settings::time_output() = true;
315 tim::settings::time_format() = "%F_%I.%M_%p";
316
317 auto err = parser.parse(args);
318 if(err)
319 {
320 std::cout << "Error! " << err << std::endl;
321 help_action(parser);
322 }
323
324#else
325 G4Impl::consume_parameters(parser, args);
326#endif
327}
G4Profiler::SetEnabled
static void SetEnabled(size_t v, bool val)
Definition G4Profiler.hh:113

◆ Configure() [2/4]

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

Definition at line 76 of file G4Profiler.cc.

77{
78#if defined(GEANT4_USE_TIMEMORY)
79 tim::timemory_init(argc, argv);
80 std::vector<std::string> _args;
81 for(int i = 0; i < argc; ++i)
82 _args.push_back(argv[i]);
83 Configure(parser, _args);
84#else
85 G4Impl::consume_parameters(parser, argc, argv);
86#endif
87}
G4Profiler::Configure
static void Configure(const std::vector< std::string > &args)
Definition G4Profiler.cc:91

◆ Configure() [3/4]

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

Definition at line 91 of file G4Profiler.cc.

92{
93#if defined(GEANT4_USE_TIMEMORY)
94 if(args.empty())
95 return;
96 ArgumentParser p{ args.at(0) };
97 Configure(p, args);
98#else
99 G4Impl::consume_parameters(args);
100#endif
101}

Referenced by Configure(), Configure(), 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.

63{
64#if defined(GEANT4_USE_TIMEMORY)
65 tim::timemory_init(argc, argv);
66 std::vector<std::string> _args;
67 for(int i = 0; i < argc; ++i)
68 _args.push_back(argv[i]);
69 Configure(_args);
70#else
71 G4Impl::consume_parameters(argc, argv);
72#endif
73}

◆ Finalize()

void G4Profiler::Finalize ( )
static

Definition at line 331 of file G4Profiler.cc.

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

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

◆ GetEnabled()

static bool G4Profiler::GetEnabled ( size_t v)
inlinestatic

Definition at line 112 of file G4Profiler.hh.

112{ return GetEnabled().at(v); }
G4Profiler::GetEnabled
static bool GetEnabled(size_t v)
Definition G4Profiler.hh:112

Referenced by GetEnabled(), and SetEnabled().

◆ GetPerEvent()

static bool G4Profiler::GetPerEvent ( )
inlinestatic

Definition at line 115 of file G4Profiler.hh.

115{ return GetPerEventImpl(); }

Referenced by G4RunProfilerInit().

◆ SetEnabled()

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

Definition at line 113 of file G4Profiler.hh.

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

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

◆ SetPerEvent()

static void G4Profiler::SetPerEvent ( bool val)
inlinestatic

Definition at line 116 of file G4Profiler.hh.

116{ GetPerEventImpl() = val; }
The documentation for this class was generated from the following files: