| The Gaudi Framework v32r1 (f65d50dc)

ChronoStatSvc.cpp
Go to the documentation of this file.
1 #ifdef _WIN32
2 # pragma warning( disable : 4786 )
3 #endif
4 // ============================================================================
5 // STD & STL
6 // ============================================================================
7 #include <algorithm>
8 #include <fstream>
9 #include <functional>
10 #include <iomanip>
11 #include <iostream>
12 #include <string>
13 // ============================================================================
14 // GaudiKernel
15 // ============================================================================
16 #include "GaudiKernel/ChronoEntity.h"
17 #include "GaudiKernel/IChronoStatSvc.h"
18 #include "GaudiKernel/IHiveWhiteBoard.h"
19 #include "GaudiKernel/IIncidentSvc.h"
20 #include "GaudiKernel/Kernel.h"
21 #include "GaudiKernel/MsgStream.h"
22 #include "GaudiKernel/Stat.h"
23 #include "GaudiKernel/StatEntity.h"
24 #include "GaudiKernel/StatusCode.h"
25 // ============================================================================
27 // ============================================================================
28 #include "ChronoStatSvc.h"
29 // ============================================================================
32 // ============================================================================
33 DECLARE_COMPONENT( ChronoStatSvc )
34 // ============================================================================
41 // ============================================================================
42 // ============================================================================
43 // comparison functor
44 // ============================================================================
45 constexpr struct CompareFirstOfPointerPair_t {
46 template <typename S, typename T>
47 inline bool operator()( const std::pair<S*, T*>& p1, const std::pair<S*, T*>& p2 ) const {
48 auto e1 = p1.first;
49 auto e2 = p2.first;
50 return ( !e1 || !e2 ) || *e1 < *e2;
51 }
52 } CompareFirstOfPointerPair{};
53 // ============================================================================
54 // Compound assignment operator.
55 // ============================================================================
56 void ChronoStatSvc::merge( const ChronoStatSvc& css ) {
57
58 // Add the content of the maps, leave the rest unchanged
59
60 lock_t lock( m_mutex );
61 lock_t otherLock( css.m_mutex );
62
63 // Merge Chronomaps
64 for ( auto& item : css.m_chronoEntities ) {
65 const IChronoStatSvc::ChronoTag& key = item.first;
66 const ChronoEntity& val = item.second;
67 if ( m_chronoEntities.count( key ) )
68 m_chronoEntities[key] += val;
69 else
70 m_chronoEntities.insert( std::pair<IChronoStatSvc::ChronoTag, ChronoEntity>( key, val ) );
71 }
72
73 // Merge StatMaps
74 for ( auto& item : css.m_statEntities ) {
75 const IChronoStatSvc::StatTag& key = item.first;
76 const StatEntity& val = item.second;
77 if ( m_statEntities.count( key ) )
78 m_statEntities[key] += val;
79 else
80 m_statEntities.emplace( key, val );
81 }
82 }
83 // ============================================================================
84 // Implementation of IService::initialize()
85 // ============================================================================
86 StatusCode ChronoStatSvc::initialize() {
87 StatusCode sc = Service::initialize();
88 if ( sc.isFailure() ) return sc;
90 // Set my own properties
91 sc = setProperties();
92
93 if ( sc.isFailure() ) {
94 error() << "setting my properties" << endmsg;
95 return StatusCode::FAILURE;
96 }
97
98 // only add an EndEvent listener if per-event output requested
99 if ( !m_perEventFile.empty() ) {
100 m_ofd.open( m_perEventFile );
101 if ( !m_ofd.is_open() ) {
102 error() << "unable to open per-event output file \"" << m_perEventFile << "\"" << endmsg;
103 return StatusCode::FAILURE;
104 } else {
105 auto ii = serviceLocator()->service<IIncidentSvc>( "IncidentSvc" );
106 if ( !ii ) {
107 error() << "Unable to find IncidentSvc" << endmsg;
108 return StatusCode::FAILURE;
109 }
110 ii->addListener( this, IncidentType::EndEvent );
111 }
112 }
113
114 if ( m_chronoTableFlag && !m_printUserTime && !m_printSystemTime && !m_printEllapsedTime ) { m_printUserTime = true; }
116 if ( m_printUserTime || m_printSystemTime || m_printEllapsedTime ) { m_chronoTableFlag = true; }
119 chronoStart( name() );
121 return StatusCode::SUCCESS;
122 }
123 // ============================================================================
124 // Implementation of IService::finalize()
125 // ============================================================================
126 StatusCode ChronoStatSvc::finalize() {
127 std::string local = name() + ".finalize()";
129 MsgStream main_log( msgSvc(), local );
132 chronoStop( name() );
133
134 if ( m_ofd.is_open() ) {
135 debug() << "writing per-event timing data to '" << m_perEventFile << "'" << endmsg;
136 for ( const auto& itr : m_perEvtTime ) {
137 m_ofd << itr.first.substr( 0, itr.first.length() - 8 ) << " ";
138 for ( const auto& itt : itr.second ) { m_ofd << " " << (long int)( itt ); }
139 m_ofd << std::endl;
140 }
141
142 m_ofd.close();
143 }
144
147 if ( m_chronoTableFlag && !m_chronoEntities.empty() && ( m_printUserTime || m_printSystemTime ) ) {
149 MsgStream log( msgSvc(), "*****Chrono*****" );
150 const std::string stars( ( m_chronoCoutFlag ) ? 126 : 100, '*' );
151 if ( m_chronoCoutFlag ) {
152 std::cout << stars << std::endl;
153 if ( isMT() ) { std::cout << "WARNING: MT job; statistics are unreliable" << std::endl; }
154 std::cout << local << " The Final CPU consumption (Chrono) Table "
155 << ( m_chronoOrderFlag ? "(ordered)" : "(not ordered)" ) << std::endl;
156 std::cout << stars << std::endl;
157 } else {
158 log << m_chronoPrintLevel << stars << endmsg;
159 if ( isMT() ) { log << m_chronoPrintLevel << "WARNING: MT job; statistics are unreliable" << endmsg; }
160 log << m_chronoPrintLevel << " The Final CPU consumption ( Chrono ) Table "
161 << ( m_chronoOrderFlag ? "(ordered)" : "(not ordered)" ) << endmsg;
162 log << m_chronoPrintLevel << stars << endmsg;
163 }
165 { // prepare container for printing
166 std::vector<std::pair<ChronoEntity*, const ChronoTag*>> tmpCont;
167 tmpCont.reserve( m_chronoEntities.size() );
168 for ( auto& it : m_chronoEntities ) { tmpCont.emplace_back( &it.second, &it.first ); }
169 // sort it
170 if ( m_chronoOrderFlag ) std::sort( tmpCont.begin(), tmpCont.end(), CompareFirstOfPointerPair );
171 // print User Time statistics
172 if ( m_printUserTime ) {
173 for ( auto iter = tmpCont.begin(); tmpCont.end() != iter; ++iter ) {
174 //
175 ChronoEntity* entity = iter->first;
176 if ( !entity ) { continue; }
177 const ChronoTag* tag = iter->second;
178 if ( !tag ) { continue; }
179 entity->stop();
181 if ( m_chronoCoutFlag )
183 {
184 std::cout << *tag << "\t" << entity->outputUserTime() << std::endl;
185 } else
186 {
187 MsgStream( msgSvc(), *tag ) << m_chronoPrintLevel << entity->outputUserTime() << endmsg;
188 }
189 //
190 }
191 }
193 if ( m_printSystemTime ) {
196 if ( m_printUserTime && m_chronoCoutFlag ) {
197 std::cout << stars << std::endl;
198 } else if ( m_printUserTime && !m_chronoCoutFlag ) {
199 log << m_chronoPrintLevel << stars << endmsg;
200 }
202 for ( auto iter = tmpCont.begin(); tmpCont.end() != iter; ++iter ) {
204 ChronoEntity* entity = iter->first;
205 if ( !entity ) { continue; }
206 const ChronoTag* tag = iter->second;
207 if ( !tag ) { continue; }
208 entity->stop();
210 if ( m_chronoCoutFlag )
212 {
213 std::cout << *tag << "\t" << entity->outputSystemTime() << std::endl;
214 } else
215 {
216 MsgStream( msgSvc(), *tag ) << m_chronoPrintLevel << entity->outputSystemTime() << endmsg;
217 }
218 //
219 }
220 }
222 if ( m_printEllapsedTime ) {
225 if ( ( m_printUserTime || m_printSystemTime ) && m_chronoCoutFlag ) {
226 std::cout << stars << std::endl;
227 } else if ( ( m_printUserTime || m_printSystemTime ) && !m_chronoCoutFlag ) {
228 log << m_chronoPrintLevel << stars << endmsg;
229 }
231 for ( const auto& i : tmpCont ) {
233 ChronoEntity* entity = i.first;
234 if ( !entity ) { continue; }
235 const ChronoTag* tag = i.second;
236 if ( !tag ) { continue; }
237 entity->stop();
239 if ( m_chronoCoutFlag )
241 {
242 std::cout << *tag << "\t" << entity->outputElapsedTime() << std::endl;
243 } else
244 {
245 MsgStream( msgSvc(), *tag ) << m_chronoPrintLevel << entity->outputElapsedTime() << endmsg;
246 }
247 //
248 }
249 }
251 tmpCont.clear();
252 }
254 if ( m_chronoCoutFlag ) {
255 std::cout << stars << std::endl;
256 } else {
257 log << m_chronoPrintLevel << stars << endmsg;
258 }
259 }
260
262
264 if ( m_statTableFlag ) { printStats(); }
265
266 if ( !m_statsOutFileName.value().empty() ) { saveStats(); }
267
268 main_log << MSG::INFO << " Service finalized successfully " << endmsg;
269
270 return Service::finalize();
271 }
272 // ============================================================================
273 // Implementation of IChronoStatSvc::chronoStart
274 // ============================================================================
275 ChronoEntity* ChronoStatSvc::chronoStart( const ChronoTag& chronoTag ) {
276 ChronoEntity& entity = getEntity( chronoTag );
277 entity.start();
278 return &entity;
279 }
280 // ============================================================================
281 // Implementation of IChronoStatSvc::chronoStop
282 // ============================================================================
283 const ChronoEntity* ChronoStatSvc::chronoStop( const IChronoStatSvc::ChronoTag& chronoTag ) {
284 ChronoEntity& entity = getEntity( chronoTag );
285 entity.stop();
286 return &entity;
287 }
288 // ============================================================================
289 // Implementation of IChronoStatSvc::chronoDelta
290 // ============================================================================
291 IChronoStatSvc::ChronoTime ChronoStatSvc::chronoDelta( const IChronoStatSvc::ChronoTag& chronoTag,
292 IChronoStatSvc::ChronoType theType ) {
293 return getEntity( chronoTag ).delta( theType );
294 }
295 // ============================================================================
296 // Implementation of IChronoStatSvc::chronoPrint
297 // ============================================================================
298 void ChronoStatSvc::chronoPrint( const IChronoStatSvc::ChronoTag& chronoTag ) {
299 MsgStream log( msgSvc(), chronoTag );
300 if ( m_printUserTime ) { log << m_chronoPrintLevel << getEntity( chronoTag ).outputUserTime() << endmsg; }
301 if ( m_printSystemTime ) { log << m_chronoPrintLevel << getEntity( chronoTag ).outputSystemTime() << endmsg; }
302 }
303 // ============================================================================
304 // Implementation of IChronoSvc::chronoStatus
305 // ============================================================================
306 IChronoStatSvc::ChronoStatus ChronoStatSvc::chronoStatus( const IChronoStatSvc::ChronoTag& chronoTag ) {
307 return getEntity( chronoTag ).status();
308 }
309 // ============================================================================
310 // Implementation of IChronoStatSvc::stat
311 // ============================================================================
312 void ChronoStatSvc::stat( const IChronoStatSvc::StatTag& statTag, const IChronoStatSvc::StatFlag& statFlag ) {
313 auto theIter = m_statEntities.find( statTag );
314
315 StatEntity* theStat = nullptr;
316 // if new entity, specify the number of events to be skipped
317 if ( theIter == m_statEntities.end() ) {
318 // new stat entity
319 StatEntity& theSe = m_statEntities[statTag];
320 theStat = &theSe;
321 } else {
322 // existing stat entity
323 theStat = &theIter->second;
324 }
325
326 theStat->addFlag( statFlag );
327 }
328 // ============================================================================
329 // Implementation of IChronoStatSvc::statPrint
330 // ============================================================================
331 void ChronoStatSvc::statPrint( const IChronoStatSvc::StatTag& statTag ) {
332 MsgStream log( msgSvc(), statTag );
333 log << m_statPrintLevel << m_statEntities[statTag] << endmsg;
334 }
335 // ============================================================================
336 /* extract the chrono entity for the given tag (name)
337 * @see IChronoStatSvc
338 * @param t chrono tag(name)
339 * @return pointer to chrono entity
340 */
341 // ============================================================================
342 const ChronoEntity* ChronoStatSvc::chrono( const IChronoStatSvc::ChronoTag& t ) const {
343 lock_t lock( m_mutex );
344 auto it = m_chronoEntities.find( t );
345 return m_chronoEntities.end() != it ? &( it->second ) : nullptr;
346 }
347 // ============================================================================
348 /* extract the stat entity for the given tag (name)
349 * @see IChronoStatSvc
350 * @param t stat tag(name)
351 * @return pointer to stat entity
352 */
353 // ============================================================================
354 StatEntity* ChronoStatSvc::stat( const IChronoStatSvc::StatTag& t ) {
355 auto it = m_statEntities.find( t );
356 return m_statEntities.end() != it ? &( it->second ) : nullptr;
357 }
358 // ============================================================================
359 // dump all the statistics into an ASCII file
360 // ============================================================================
361 void ChronoStatSvc::saveStats() {
362 std::ofstream out( m_statsOutFileName.value(), std::ios_base::out | std::ios_base::trunc );
363 if ( !out.good() ) {
364 info() << "Could not open the output file for writing chrono statistics [" << m_statsOutFileName.value() << "]"
365 << endmsg;
366 return;
367 } else {
368 // format it our way
369 out << std::scientific << std::setprecision( 8 );
370 }
371
372 // ChronoEntity
373 std::vector<std::pair<const ChronoEntity*, const ChronoTag*>> chronos;
374 {
375 lock_t lock( m_mutex );
376 chronos.reserve( m_chronoEntities.size() );
377 std::transform( std::begin( m_chronoEntities ), std::end( m_chronoEntities ), std::back_inserter( chronos ),
378 []( ChronoMap::const_reference i ) { return std::make_pair( &i.second, &i.first ); } );
379 }
380
381 // sort it
382 std::sort( std::begin( chronos ), std::end( chronos ), CompareFirstOfPointerPair );
383
384 // print User Time statistics
385 for ( const auto& iter : chronos ) {
386 //
387 const ChronoEntity* entity = iter.first;
388 if ( !entity ) { continue; }
389
390 const ChronoTag* tag = iter.second;
391 if ( !tag ) { continue; }
392
393 // create an entry in the .INI-like table
394 out << "\n[" << *tag << "]\n";
395
396 // user
397 out << "cpu_user_total = " << entity->uTotalTime() << "\n";
398 out << "cpu_user_min = " << entity->uMinimalTime() << "\n";
399 out << "cpu_user_mean = " << entity->uMeanTime() << "\n";
400 out << "cpu_user_RMS = " << entity->uRMSTime() << "\n";
401 out << "cpu_user_max = " << entity->uMaximalTime() << "\n";
402 out << "cpu_user_nbr = " << entity->nOfMeasurements() << "\n";
403
404 // system
405 out << "\n"; // just for clarity
406 out << "cpu_system_total = " << entity->kTotalTime() << "\n";
407 out << "cpu_system_min = " << entity->kMinimalTime() << "\n";
408 out << "cpu_system_mean = " << entity->kMeanTime() << "\n";
409 out << "cpu_system_RMS = " << entity->kRMSTime() << "\n";
410 out << "cpu_system_max = " << entity->kMaximalTime() << "\n";
411 out << "cpu_system_nbr = " << entity->nOfMeasurements() << "\n";
412
413 // real
414 out << "\n"; // just for clarity
415 out << "cpu_real_total = " << entity->eTotalTime() << "\n";
416 out << "cpu_real_min = " << entity->eMinimalTime() << "\n";
417 out << "cpu_real_mean = " << entity->eMeanTime() << "\n";
418 out << "cpu_real_RMS = " << entity->eRMSTime() << "\n";
419 out << "cpu_real_max = " << entity->eMaximalTime() << "\n";
420 out << "cpu_real_nbr = " << entity->nOfMeasurements() << "\n";
421 }
422
423 out << std::endl;
424 }
425 // ============================================================================
426 // Test if we're running in an MT job.
427 // ============================================================================
428 bool ChronoStatSvc::isMT() const {
429 bool isMT = false;
430 if ( m_hiveWhiteBoardSvc.retrieve().isFailure() ) {
431 error() << "Cannot retrieve HiveWhiteBoardSvc";
432 } else {
433 // In non-MT mode, `EventDataSvc' does not have an IHiveWhiteBoard interface.
434 const SmartIF<IHiveWhiteBoard> wb( m_hiveWhiteBoardSvc.get() );
435 if ( wb && wb->getNumberOfStores() > 1 ) { isMT = true; }
436 }
437 return isMT;
438 }
439 // ============================================================================
440 // print the "Stat" part of the ChronoStatSvc
441 // ============================================================================
442 void ChronoStatSvc::printStats() {
444 if ( m_statEntities.empty() ) { return; }
445
446 MsgStream log( msgSvc(), "******Stat******" );
448 const std::string stars( ( m_statCoutFlag ) ? 126 : 100, '*' );
450 if ( m_statCoutFlag ) {
451 std::cout << stars << std::endl;
452 if ( isMT() ) { std::cout << "WARNING: MT job; statistics are unreliable" << std::endl; }
453 std::cout << " The Final stat Table " << ( m_statOrderFlag ? "(ordered)" : "(not ordered)" ) << std::endl;
454 std::cout << stars << std::endl;
455 } else {
456 log << m_statPrintLevel << stars << endmsg;
457 if ( isMT() ) { log << (MSG::Level)m_chronoPrintLevel << "WARNING: MT job; statistics are unreliable" << endmsg; }
458 log << m_statPrintLevel << " The Final stat Table " << ( m_statOrderFlag ? "(ordered)" : "(not ordered)" )
459 << endmsg;
460 log << m_statPrintLevel << stars << endmsg;
461 }
462
463 {
464 // prepare container for printing
465 typedef std::pair<const StatEntity*, const StatTag*> SPair;
466 typedef std::vector<SPair> SCont;
467 SCont tmpCont;
468 std::transform( std::begin( m_statEntities ), std::end( m_statEntities ), std::back_inserter( tmpCont ),
469 []( StatMap::const_reference i ) { return std::make_pair( &i.second, &i.first ); } );
470 // sort it
471 if ( m_statOrderFlag ) std::sort( tmpCont.begin(), tmpCont.end(), CompareFirstOfPointerPair );
472 // print the table header
473 if ( m_statCoutFlag ) {
474 std::cout << m_header.value() << std::endl;
475 } else {
476 log << m_statPrintLevel << m_header.value() << endmsg;
477 }
478
479 // loop over counters and print them:
480 for ( const auto& iter : tmpCont ) {
482 const StatEntity* entity = iter.first;
483 if ( !entity ) { continue; }
484 const StatTag* tag = iter.second;
485 if ( !tag ) { continue; }
486 if ( m_statCoutFlag ) {
488 entity->print( std::cout, true, *tag, m_useEffFormat, "%|-15.15s|%|17t|" );
489 } else {
490 std::ostringstream ost;
491 entity->print( ost, true, *tag, m_useEffFormat, "%|-15.15s|%|17t|" );
492 log << m_statPrintLevel << ost.str() << endmsg;
493 }
494 }
495 tmpCont.clear();
496 }
498 if ( m_statCoutFlag ) {
499 std::cout << stars << std::endl;
500 } else {
501 log << m_statPrintLevel << stars << endmsg;
502 }
503 }
504
505 // ============================================================================
506
507 void ChronoStatSvc::handle( const Incident& /* inc */ ) {
508
509 if ( !m_ofd.is_open() ) return;
510
511 lock_t lock( m_mutex );
512 for ( const auto& itr : m_chronoEntities ) {
513 if ( itr.first.find( ":Execute" ) == std::string::npos ) continue;
514
515 auto itm = m_perEvtTime.find( itr.first );
516 if ( itm == m_perEvtTime.end() ) {
517 m_perEvtTime[itr.first] = {itr.second.delta( IChronoSvc::ELAPSED )};
518 } else {
519 itm->second.push_back( itr.second.delta( IChronoSvc::ELAPSED ) );
520 }
521 }
522 }
523
524 // ============================================================================
525 // The END
526 // ============================================================================
ChronoStatSvc::getEntity
ChronoEntity & getEntity(const ChronoTag &chronoTag)
Definition: ChronoStatSvc.h:136
MsgStream
Definition of the MsgStream class used to transmit messages.
Definition: MsgStream.h:24
Service::initialize
StatusCode initialize() override
Definition: Service.cpp:60
SmartIF< IHiveWhiteBoard >
Service::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Retrieve pointer to service locator.
Definition: Service.cpp:277
Kernel.h
std::map::empty
T empty(T... args)
std::ofstream::open
T open(T... args)
ChronoEntity::eRMSTime
double eRMSTime() const
r.m.s Elapsed Time
Definition: ChronoEntity.h:245
CommonMessagingBase::msgSvc
const SmartIF< IMessageSvc > & msgSvc() const
The standard message service.
Definition: CommonMessaging.h:68
ChronoStatSvc::chronoStatus
ChronoStatus chronoStatus(const IChronoStatSvc::ChronoTag &chronoTag) override
Implementation of IChronoStatSvc::chronoStatus.
Definition: ChronoStatSvc.cpp:306
ChronoStatSvc::m_header
Gaudi::Property< std::string > m_header
Definition: ChronoStatSvc.h:185
Service::finalize
StatusCode finalize() override
Definition: Service.cpp:164
MsgStream.h
ChronoStatSvc::m_statEntities
StatMap m_statEntities
stat part
Definition: ChronoStatSvc.h:157
ChronoEntity
a small helper class for implementation of ChronoStatSvc service, It also could be used as some local...
Definition: ChronoEntity.h:21
ChronoEntity::delta
IChronoSvc::ChronoTime delta(IChronoSvc::ChronoType type) const
return the last delta-time of type "type"
Definition: ChronoEntity.h:261
ChronoStatSvc::m_statCoutFlag
Gaudi::Property< bool > m_statCoutFlag
Definition: ChronoStatSvc.h:174
ChronoStatSvc::chronoDelta
IChronoStatSvc::ChronoTime chronoDelta(const IChronoStatSvc::ChronoTag &chronoTag, IChronoStatSvc::ChronoType theType) override
Implementation of IchronoStatSvc::chronoDelta.
Definition: ChronoStatSvc.cpp:291
std::endl
T endl(T... args)
ChronoStatSvc::m_chronoOrderFlag
Gaudi::Property< bool > m_chronoOrderFlag
Definition: ChronoStatSvc.h:168
StatusCode::SUCCESS
constexpr static const auto SUCCESS
Definition: StatusCode.h:85
ChronoStatSvc::m_printUserTime
Gaudi::Property< bool > m_printUserTime
Definition: ChronoStatSvc.h:169
ChronoStatSvc.h
ChronoStatSvc::m_mutex
std::mutex m_mutex
Mutex protecting m_chronoEntities.
Definition: ChronoStatSvc.h:150
ChronoStatSvc::stat
void stat(const IChronoStatSvc::StatTag &statTag, const IChronoStatSvc::StatFlag &statFlag) override
Implementation of IChronoStatSvc::stat add statistical information to the entity ,...
Definition: ChronoStatSvc.cpp:312
ChronoEntity::uMinimalTime
double uMinimalTime() const
minimal measurement for user time
Definition: ChronoEntity.h:185
std::vector::end
T end(T... args)
CommonMessagingBase::info
MsgStream & info() const
shortcut for the method msgStream(MSG::INFO)
Definition: CommonMessaging.h:104
ChronoStatSvc::statPrint
void statPrint(const IChronoStatSvc::ChronoTag &statTag) override
prints (using message service) info about statistical entity, tagged by its name
Definition: ChronoStatSvc.cpp:331
ChronoEntity::start
IChronoSvc::ChronoStatus start()
start the current chrono
Definition: ChronoEntity.cpp:46
std::string
STL class.
DECLARE_COMPONENT
#define DECLARE_COMPONENT(type)
Definition: PluginServiceV1.h:46
HepRndm::Engine
Definition: HepRndmEngine.h:25
ChronoStatSvc::printStats
void printStats()
Definition: ChronoStatSvc.cpp:442
ChronoEntity::kRMSTime
double kRMSTime() const
r.m.s Kernel Time
Definition: ChronoEntity.h:237
ISvcLocator::service
StatusCode service(const Gaudi::Utils::TypeNameString &name, T *&svc, bool createIf=true)
Templated method to access a service by name.
Definition: ISvcLocator.h:76
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition: Service.cpp:274
MSG::Level
Level
Definition: IMessageSvc.h:15
std::ofstream
STL class.
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:98
ChronoEntity::eMaximalTime
double eMaximalTime() const
maximal measurement for elapsed time
Definition: ChronoEntity.h:205
ChronoStatSvc::merge
void merge(const ChronoStatSvc &css)
Compound assignment operator.
Definition: ChronoStatSvc.cpp:56
ChronoEntity::uTotalTime
double uTotalTime() const
total user time
Definition: ChronoEntity.h:209
ChronoStatSvc::m_useEffFormat
Gaudi::Property< bool > m_useEffFormat
Definition: ChronoStatSvc.h:189
ChronoStatSvc::saveStats
void saveStats()
dump the statistics into an ASCII file for offline processing
Definition: ChronoStatSvc.cpp:361
IIncidentSvc.h
CompareFirstOfPointerPair
constexpr struct CompareFirstOfPointerPair_t CompareFirstOfPointerPair
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:50
ChronoEntity::nOfMeasurements
unsigned long nOfMeasurements() const
number of chrono measurements
Definition: ChronoEntity.h:181
ChronoEntity::eMinimalTime
double eMinimalTime() const
minimal measurement for elapsed time
Definition: ChronoEntity.h:193
MsgStream::clear
void clear(STATE_TYPE _i=std::ios_base::failbit)
Definition: MsgStream.h:171
std::ostringstream
STL class.
ChronoStatSvc::m_perEvtTime
TimeMap m_perEvtTime
Definition: ChronoStatSvc.h:197
std::ofstream::close
T close(T... args)
ChronoStatSvc::chronoStop
const ChronoEntity * chronoStop(const IChronoStatSvc::ChronoTag &chronoTag) override
Implementation of IChronoStatSvc::chronoStop.
Definition: ChronoStatSvc.cpp:283
ServiceHandle::retrieve
StatusCode retrieve() const
Retrieve the Service.
Definition: ServiceHandle.h:70
ChronoEntity::uMeanTime
double uMeanTime() const
average User Time
Definition: ChronoEntity.h:229
ChronoStatSvc::m_statOrderFlag
Gaudi::Property< bool > m_statOrderFlag
Definition: ChronoStatSvc.h:179
ChronoEntity::kMeanTime
double kMeanTime() const
average Kernel Time
Definition: ChronoEntity.h:225
std::ostringstream::str
T str(T... args)
std::make_pair
T make_pair(T... args)
CommonMessagingBase::debug
MsgStream & debug() const
shortcut for the method msgStream(MSG::DEBUG)
Definition: CommonMessaging.h:107
ChronoStatSvc::m_chronoTableFlag
Gaudi::Property< bool > m_chronoTableFlag
Definition: ChronoStatSvc.h:161
ChronoEntity::eTotalTime
double eTotalTime() const
total Elapsed time
Definition: ChronoEntity.h:217
std::vector::clear
T clear(T... args)
ChronoStatSvc::m_hiveWhiteBoardSvc
ServiceHandle< IInterface > m_hiveWhiteBoardSvc
Definition: ChronoStatSvc.h:194
ChronoStatSvc::m_ofd
std::ofstream m_ofd
Definition: ChronoStatSvc.h:198
Service::setProperties
StatusCode setProperties()
Method for setting declared properties to the values specified for the job.
Definition: Service.cpp:280
IChronoSvc::ELAPSED
Definition: IChronoSvc.h:46
std::map::count
T count(T... args)
std::scientific
T scientific(T... args)
ChronoStatSvc::m_chronoPrintLevel
MSG::Level m_chronoPrintLevel
level of info printing
Definition: ChronoStatSvc.h:154
ChronoStatSvc::initialize
StatusCode initialize() override
Implementation of IService::initialize()
Definition: ChronoStatSvc.cpp:86
std::pair
ChronoStatSvc::m_printEllapsedTime
Gaudi::Property< bool > m_printEllapsedTime
Definition: ChronoStatSvc.h:171
ServiceHandle::get
T * get() const
Release the Service.
Definition: ServiceHandle.h:81
std::map::insert
T insert(T... args)
std::map::find
T find(T... args)
std::map::size
T size(T... args)
e2
HepRndm::Engine< TripleRand > e2
Definition: HepRndmEngines.cpp:194
std::vector
STL class.
std::lock_guard
ChronoEntity::kTotalTime
double kTotalTime() const
total Kernel time
Definition: ChronoEntity.h:213
IHiveWhiteBoard.h
std::vector::begin
T begin(T... args)
ChronoStatSvc::handle
void handle(const Incident &incident) override
Definition: ChronoStatSvc.cpp:507
std::back_inserter
T back_inserter(T... args)
ChronoStatSvc::m_statTableFlag
Gaudi::Property< bool > m_statTableFlag
Definition: ChronoStatSvc.h:172
Incident
Base class for all Incidents (computing events).
Definition: Incident.h:17
ChronoStatSvc::chronoStart
ChronoEntity * chronoStart(const IChronoStatSvc::ChronoTag &chronoTag) override
Implementation of IChronoStatSvc::chronoStart.
Definition: ChronoStatSvc.cpp:275
StatEntity.h
ChronoEntity::uMaximalTime
double uMaximalTime() const
maximal measurement for user time
Definition: ChronoEntity.h:197
ChronoEntity::kMinimalTime
double kMinimalTime() const
minimal measurement for kernel time
Definition: ChronoEntity.h:189
std::map::emplace
T emplace(T... args)
ChronoStatSvc::isMT
bool isMT() const
Definition: ChronoStatSvc.cpp:428
StatusCode::FAILURE
constexpr static const auto FAILURE
Definition: StatusCode.h:86
Stat.h
CompareFirstOfPointerPair_t
Definition: ChronoStatSvc.cpp:45
IChronoStatSvc.h
ChronoStatSvc::m_statsOutFileName
Gaudi::Property< std::string > m_statsOutFileName
Definition: ChronoStatSvc.h:181
ChronoStatSvc::m_statPrintLevel
MSG::Level m_statPrintLevel
level of info printing
Definition: ChronoStatSvc.h:159
ChronoStatSvc::m_chronoCoutFlag
Gaudi::Property< bool > m_chronoCoutFlag
Definition: ChronoStatSvc.h:163
std::sort
T sort(T... args)
std::transform
T transform(T... args)
StatusCode.h
StatusCode::isFailure
bool isFailure() const
Definition: StatusCode.h:130
ChronoEntity::eMeanTime
double eMeanTime() const
average Elapsed Time
Definition: ChronoEntity.h:233
CompareFirstOfPointerPair_t::operator()
bool operator()(const std::pair< S *, T * > &p1, const std::pair< S *, T * > &p2) const
Definition: ChronoStatSvc.cpp:47
std::ofstream::is_open
T is_open(T... args)
MSG::INFO
Definition: IMessageSvc.h:15
ChronoEntity::stop
IChronoSvc::ChronoStatus stop()
stop the chrono
Definition: ChronoEntity.cpp:61
std::setprecision
T setprecision(T... args)
ChronoEntity.h
ChronoEntity::kMaximalTime
double kMaximalTime() const
maximal measurement for kernel time
Definition: ChronoEntity.h:201
ChronoEntity::status
IChronoSvc::ChronoStatus status() const
return the status of chrono
Definition: ChronoEntity.h:177
std::cout
ChronoEntity::outputElapsedTime
std::string outputElapsedTime() const
print the chrono ;
Definition: ChronoEntity.cpp:95
ChronoEntity::uRMSTime
double uRMSTime() const
r.m.s User Time
Definition: ChronoEntity.h:241
ChronoStatSvc::chronoPrint
void chronoPrint(const IChronoStatSvc::ChronoTag &chronoTag) override
Implementation of IChronoStatSvc::chronoPrint.
Definition: ChronoStatSvc.cpp:298
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:192
IIncidentSvc
The interface implemented by the IncidentSvc service.
Definition: IIncidentSvc.h:23
ChronoEntity::outputUserTime
std::string outputUserTime() const
print the chrono ;
Definition: ChronoEntity.cpp:82
ChronoStatSvc
The Chrono & Stat Sservice: service implements the IChronoStatSvc interface and provides the basic ch...
Definition: ChronoStatSvc.h:37
ChronoEntity::outputSystemTime
std::string outputSystemTime() const
print the chrono ;
Definition: ChronoEntity.cpp:89
std::vector::reserve
T reserve(T... args)
Gaudi.Configuration.log
log
Definition: Configuration.py:13
ChronoStatSvc::m_chronoEntities
ChronoMap m_chronoEntities
chrono part
Definition: ChronoStatSvc.h:145
std::vector::emplace_back
T emplace_back(T... args)
ChronoStatSvc::m_printSystemTime
Gaudi::Property< bool > m_printSystemTime
Definition: ChronoStatSvc.h:170
ChronoStatSvc::finalize
StatusCode finalize() override
Implementation of IService::finalize()
Definition: ChronoStatSvc.cpp:126
ChronoStatSvc::m_perEventFile
Gaudi::Property< std::string > m_perEventFile
Definition: ChronoStatSvc.h:192
ChronoStatSvc::chrono
const ChronoEntity * chrono(const IChronoStatSvc::ChronoTag &t) const override
extract the chrono entity for the given tag (name)
Definition: ChronoStatSvc.cpp:342