Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4Profiler.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26// G4Profiler class implementation
27//
28// Author: J.Madsen (LBL), Aug 2020
29// --------------------------------------------------------------------
30
31#include "G4Profiler.hh"
32#include "G4TiMemory.hh"
33
34#if defined(GEANT4_USE_TIMEMORY)
35# include <timemory/runtime/configure.hpp>
36#endif
37
38#include <regex>
39#include <thread>
40
41//---------------------------------------------------------------------------//
42
43typename G4Profiler::array_type& G4Profiler::GetEnabled()
44{
45 static array_type _instance = []() {
46 array_type _tmp{};
47 _tmp.fill(false);
48 // environment settings introduce the defaults
49 // but will be overridden by messenger and/or command line
50 _tmp.at(G4ProfileType::Run) = G4GetEnv<bool>("G4PROFILE_RUN", true);
51 _tmp.at(G4ProfileType::Event) = G4GetEnv<bool>("G4PROFILE_EVENT", false);
52 _tmp.at(G4ProfileType::Track) = G4GetEnv<bool>("G4PROFILE_TRACK", false);
53 _tmp.at(G4ProfileType::Step) = G4GetEnv<bool>("G4PROFILE_STEP", false);
54 _tmp.at(G4ProfileType::User) = G4GetEnv<bool>("G4PROFILE_USER", true);
55 return _tmp;
56 }();
57 return _instance;
58}
59
60//---------------------------------------------------------------------------//
61
62void G4Profiler::Configure(int argc, char** argv)
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}
74//---------------------------------------------------------------------------//
75
76void G4Profiler::Configure(ArgumentParser& parser, int argc, char** argv)
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}
88
89//---------------------------------------------------------------------------//
90
91void G4Profiler::Configure(const std::vector<std::string>& args)
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}
102
103//---------------------------------------------------------------------------//
104
105void G4Profiler::Configure(ArgumentParser& parser,
106 const std::vector<std::string>& args)
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}
328
329//---------------------------------------------------------------------------//
330
331void G4Profiler::Finalize()
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}
352
353//---------------------------------------------------------------------------//
354
355template <size_t Ct>
356template <int Idx>
357typename G4ProfilerConfig<Ct>::template PersistentSettings<Idx>&
358G4ProfilerConfig<Ct>::GetPersistentFallback()
359{
360 // G4RunManager::ConfigureProfilers() assigns defaults to these lambdas
361 // based on environment variables. The users should (generally) not modify
362 // these.
363 static PersistentSettings<Idx> _instance = PersistentSettings<Idx>{};
364 return _instance;
365}
366
367//---------------------------------------------------------------------------//
368
369template <size_t Ct>
370template <int Idx>
371typename G4ProfilerConfig<Ct>::template PersistentSettings<Idx>&
372G4ProfilerConfig<Ct>::GetPersistent()
373{
374 //
375 // The pointers here automatically initialize on the first
376 // invocation on a thread and a reference is returned so they
377 // can be cleanly "leaked" at the application termination. Assignment
378 // is thread-safe and this scheme avoids having to deal with getters
379 // and setters. It is designed such that we can set defaults but
380 // the user can override them at any time.
381 //
382 // the first global instance copies from the fallback rountines, which are
383 // assigned defaults in G4RunManager::ConfigureProfilers() but if the user
384 // assigns new settings before creating G4RunManager, those defaults will
385 // be ignored
386 static auto* _instance =
387 new PersistentSettings<Idx>(GetPersistentFallback<Idx>());
388 static thread_local PersistentSettings<Idx>* _tlinstance = [=]() {
389 static std::mutex mtx;
390 std::unique_lock<std::mutex> lk(mtx);
391 // If this is the primary thread, just return the global instance from
392 // above. Modifying that instance will result in all threads created later
393 // to inherit those settings
394 static bool _first = true;
395 if(_first)
396 { // below uses comma operator to assign to false before return
397 return ((_first = false), _instance);
398 }
399 // if not first, make a copy from the primary thread
400 return new PersistentSettings<Idx>(*_instance);
401 }();
402 return *_tlinstance;
403}
404
405// ----------------------------------------------------------------------
406
407template <size_t Cat>
408G4ProfilerConfig<Cat>::~G4ProfilerConfig()
409{
410 delete m_bundle;
411}
412
413//----------------------------------------------------------------------------//
414// primary (utilized) versions
415//
416template <size_t Cat>
417typename G4ProfilerConfig<Cat>::QueryHandler_t
418G4ProfilerConfig<Cat>::GetQueryFunctor()
419{
420 return QueryHandler_t{ GetPersistent<G4ProfileOp::Query>().m_functor };
421}
422
423//----------------------------------------------------------------------------//
424
425template <size_t Cat>
426typename G4ProfilerConfig<Cat>::LabelHandler_t
427G4ProfilerConfig<Cat>::GetLabelFunctor()
428{
429 return LabelHandler_t{ GetPersistent<G4ProfileOp::Label>().m_functor };
430}
431
432//----------------------------------------------------------------------------//
433
434template <size_t Cat>
435typename G4ProfilerConfig<Cat>::ToolHandler_t
436G4ProfilerConfig<Cat>::GetToolFunctor()
437{
438 return ToolHandler_t{ GetPersistent<G4ProfileOp::Tool>().m_functor };
439}
440
441//----------------------------------------------------------------------------//
442// fallback versions
443//
444template <size_t Cat>
445typename G4ProfilerConfig<Cat>::QueryHandler_t
446G4ProfilerConfig<Cat>::GetFallbackQueryFunctor()
447{
448 return QueryHandler_t{
449 GetPersistentFallback<G4ProfileOp::Query>().m_functor
450 };
451}
452
453//----------------------------------------------------------------------------//
454
455template <size_t Cat>
456typename G4ProfilerConfig<Cat>::LabelHandler_t
457G4ProfilerConfig<Cat>::GetFallbackLabelFunctor()
458{
459 return LabelHandler_t{
460 GetPersistentFallback<G4ProfileOp::Label>().m_functor
461 };
462}
463
464//----------------------------------------------------------------------------//
465
466template <size_t Cat>
467typename G4ProfilerConfig<Cat>::ToolHandler_t
468G4ProfilerConfig<Cat>::GetFallbackToolFunctor()
469{
470 return ToolHandler_t{ GetPersistentFallback<G4ProfileOp::Tool>().m_functor };
471}
472
473//---------------------------------------------------------------------------//
474
475class G4Run;
476class G4Event;
477class G4Track;
478class G4Step;
479
480using G4ProfType = G4ProfileType;
481using RunProfConfig = G4ProfilerConfig<G4ProfType::Run>;
482using EventProfConfig = G4ProfilerConfig<G4ProfType::Event>;
483using TrackProfConfig = G4ProfilerConfig<G4ProfType::Track>;
484using StepProfConfig = G4ProfilerConfig<G4ProfType::Step>;
485using UserProfConfig = G4ProfilerConfig<G4ProfType::User>;
486
487//---------------------------------------------------------------------------//
488
489// force instantiations
490template class G4ProfilerConfig<G4ProfType::Run>;
491template class G4ProfilerConfig<G4ProfType::Event>;
492template class G4ProfilerConfig<G4ProfType::Track>;
493template class G4ProfilerConfig<G4ProfType::Step>;
494template class G4ProfilerConfig<G4ProfType::User>;
495template G4ProfilerConfig<G4ProfType::Run>::G4ProfilerConfig(const G4Run*);
496template G4ProfilerConfig<G4ProfType::Event>::G4ProfilerConfig(const G4Event*);
497template G4ProfilerConfig<G4ProfType::Track>::G4ProfilerConfig(const G4Track*);
498template G4ProfilerConfig<G4ProfType::Step>::G4ProfilerConfig(const G4Step*);
499template G4ProfilerConfig<G4ProfileType::User>::G4ProfilerConfig(
500 const std::string&);
501
502#define G4PROFILE_INSTANTIATION(TYPE) \
503 template TYPE::PersistentSettings<G4ProfileOp::Query>& \
504 TYPE::GetPersistentFallback<G4ProfileOp::Query>(); \
505 template TYPE::PersistentSettings<G4ProfileOp::Label>& \
506 TYPE::GetPersistentFallback<G4ProfileOp::Label>(); \
507 template TYPE::PersistentSettings<G4ProfileOp::Tool>& \
508 TYPE::GetPersistentFallback<G4ProfileOp::Tool>(); \
509 \
510 template TYPE::PersistentSettings<G4ProfileOp::Query>& \
511 TYPE::GetPersistent<G4ProfileOp::Query>(); \
512 template TYPE::PersistentSettings<G4ProfileOp::Label>& \
513 TYPE::GetPersistent<G4ProfileOp::Label>(); \
514 template TYPE::PersistentSettings<G4ProfileOp::Tool>& \
515 TYPE::GetPersistent<G4ProfileOp::Tool>();
516
517G4PROFILE_INSTANTIATION(RunProfConfig)
518G4PROFILE_INSTANTIATION(EventProfConfig)
519G4PROFILE_INSTANTIATION(TrackProfConfig)
520G4PROFILE_INSTANTIATION(StepProfConfig)
521G4PROFILE_INSTANTIATION(UserProfConfig)
522
523//---------------------------------------------------------------------------//
524
525#if !defined(GEANT4_USE_TIMEMORY)
526# define TIMEMORY_WEAK_PREFIX
527# define TIMEMORY_WEAK_POSTFIX
528#endif
529
530//---------------------------------------------------------------------------//
531
532extern "C"
533{
534 // this allows the default setup to be overridden by linking
535 // in an custom extern C function into the application
536 TIMEMORY_WEAK_PREFIX
537 void G4ProfilerInit(void) TIMEMORY_WEAK_POSTFIX;
538
539 // this gets executed when the library gets loaded
540 void G4ProfilerInit(void)
541 {
542#ifdef GEANT4_USE_TIMEMORY
543
544 // guard against re-initialization
545 static bool _once = false;
546 if(_once)
547 return;
548 _once = true;
549
550 puts(">>> G4ProfilerInit <<<");
551
552 //
553 // the default settings
554 //
555 // large profiles can take a very long time to plot
556 tim::settings::plot_output() = false;
557 // large profiles can take quite a bit of console space
558 tim::settings::cout_output() = false;
559 // this creates a subdirectory with the timestamp of the run
560 tim::settings::time_output() = false;
561 // see `man 3 strftime` for formatting keys
562 tim::settings::time_format() = "%F_%I.%M_%p";
563 // set the default precision for timing
564 tim::settings::timing_precision() = 6;
565 // set the minimum width for outputs
566 tim::settings::width() = 12;
567 // set dart reports (when enabled) to only print the first entry
568 tim::settings::dart_count() = 1;
569 // set dart reports (when enabled) to use the component label
570 // instead of the string identifer of the entry, e.g.
571 // >>> G4Run/0 ... peak_rss ... 50 MB would report
572 // 'peak_rss 50 MB' not 'G4Run/0 50 MB'
573 tim::settings::dart_label() = true;
574
575 // allow environment overrides of the defaults
576 tim::settings::parse();
577#endif
578 }
579} // extern "C"
580
581//---------------------------------------------------------------------------//
582
583#ifdef GEANT4_USE_TIMEMORY
584namespace
585{
586 static bool profiler_is_initialized = (G4ProfilerInit(), true);
587}
588#endif
589
590//---------------------------------------------------------------------------//
G4ProfilerInit
TIMEMORY_WEAK_PREFIX void G4ProfilerInit(void) TIMEMORY_WEAK_POSTFIX
Definition: G4Profiler.cc:540
G4PROFILE_INSTANTIATION
#define G4PROFILE_INSTANTIATION(TYPE)
Definition: G4Profiler.cc:502
TIMEMORY_WEAK_PREFIX
#define TIMEMORY_WEAK_PREFIX
Definition: G4Profiler.cc:526
TIMEMORY_WEAK_POSTFIX
#define TIMEMORY_WEAK_POSTFIX
Definition: G4Profiler.cc:527
G4ProfilerConfig::LabelHandler_t
FuncHandler< this_type, LabelFunc_t, std::string > LabelHandler_t
Definition: G4Profiler.hh:398
G4ProfilerConfig::GetFallbackQueryFunctor
static QueryHandler_t GetFallbackQueryFunctor()
Definition: G4Profiler.cc:446
G4ProfilerConfig::ToolHandler_t
FuncHandler< this_type, ToolFunc_t, type * > ToolHandler_t
Definition: G4Profiler.hh:399
G4ProfilerConfig::GetToolFunctor
static ToolHandler_t GetToolFunctor()
Definition: G4Profiler.cc:436
G4ProfilerConfig::GetFallbackToolFunctor
static ToolHandler_t GetFallbackToolFunctor()
Definition: G4Profiler.cc:468
G4ProfilerConfig::GetQueryFunctor
static QueryHandler_t GetQueryFunctor()
Definition: G4Profiler.cc:418
G4ProfilerConfig::GetLabelFunctor
static LabelHandler_t GetLabelFunctor()
Definition: G4Profiler.cc:427
G4ProfilerConfig::GetFallbackLabelFunctor
static LabelHandler_t GetFallbackLabelFunctor()
Definition: G4Profiler.cc:457
G4ProfilerConfig::G4ProfilerConfig
G4ProfilerConfig()=default
G4ProfilerConfig::QueryHandler_t
FuncHandler< this_type, QueryFunc_t, bool > QueryHandler_t
Definition: G4Profiler.hh:397
G4Profiler::Configure
static void Configure(const std::vector< std::string > &args)
Definition: G4Profiler.cc:91
G4Profiler::SetEnabled
static void SetEnabled(size_t v, bool val)
Definition: G4Profiler.hh:113
G4Profiler::array_type
std::array< bool, G4ProfileType::TypeEnd > array_type
Definition: G4Profiler.hh:95
G4Profiler::GetEnabled
static bool GetEnabled(size_t v)
Definition: G4Profiler.hh:112
G4Profiler::Finalize
static void Finalize()
Definition: G4Profiler.cc:331
G4Run
Definition: G4Run.hh:49
G4Step
Definition: G4Step.hh:62