| The Gaudi Framework v27r1

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

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 <iostream>
8 #include <iomanip>
9 #include <string>
10 #include <algorithm>
11 #include <functional>
12 #include <fstream>
13 #include <iomanip>
14 // ============================================================================
15 // GaudiKernel
16 // ============================================================================
17 #include "GaudiKernel/Kernel.h"
18 #include "GaudiKernel/StatusCode.h"
19 #include "GaudiKernel/IChronoStatSvc.h"
20 #include "GaudiKernel/MsgStream.h"
21 #include "GaudiKernel/ChronoEntity.h"
22 #include "GaudiKernel/StatEntity.h"
23 #include "GaudiKernel/Stat.h"
24 #include "GaudiKernel/IIncidentSvc.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 {
47 template <typename S, typename T>
48 inline bool operator() ( const std::pair<S*,T*>& p1,
49 const std::pair<S*,T*>& p2) const
50 {
51 auto e1 = p1.first;
52 auto e2 = p2.first;
53 return ( !e1 || !e2 ) || *e1<*e2 ;
54 }
55 } CompareFirstOfPointerPair {} ;
56 // ============================================================================
57 // Constructor
58 // ============================================================================
59 ChronoStatSvc::ChronoStatSvc
60 ( const std::string& name, ISvcLocator* svcloc )
61 : base_class( name , svcloc )
62 //
63 // the header row
64 , m_header ( " Counter | # | sum | mean/eff^* | rms/err^* | min | max |")
65 // format for regular statistical printout rows
66 , m_format1 ( " %|-15.15s|%|17t||%|10d| |%|11.7g| |%|#11.5g| |%|#11.5g| |%|#12.5g| |%|#12.5g| |" )
67 // format for "efficiency" statistical printout rows
68 , m_format2 ( "*%|-15.15s|%|17t||%|10d| |%|11.5g| |(%|#9.7g| +- %|-#9.7g|)%%| ------- | ------- |" )
69 {
71 declareProperty ( "ChronoPrintOutTable" ,
72 m_chronoTableFlag = true );
74 declareProperty ( "ChronoDestinationCout" ,
75 m_chronoCoutFlag = false );
77 declareProperty ( "ChronoPrintLevel" ,
78 m_intChronoPrintLevel = MSG::INFO );
81 declareProperty ( "ChronoTableToBeOrdered" ,
82 m_chronoOrderFlag = true );
84 declareProperty ( "PrintUserTime" ,
85 m_printUserTime = true );
87 declareProperty ( "PrintSystemTime" ,
88 m_printSystemTime = false );
90 declareProperty ( "PrintEllapsedTime" ,
91 m_printEllapsedTime = false );
94 declareProperty ( "StatPrintOutTable" ,
95 m_statTableFlag = true );
97 declareProperty ( "StatDestinationCout" ,
98 m_statCoutFlag = false );
100 declareProperty ( "StatPrintLevel" ,
101 m_intStatPrintLevel = MSG::INFO );
104 declareProperty ( "StatTableToBeOrdered" ,
105 m_statOrderFlag = true );
106
107 // specify the number of events to be skipped by the memory auditor
108 // in order to better spot memory leak
109 declareProperty ( "NumberOfSkippedEventsForMemStat" ,
110 m_numberOfSkippedEventsForMemStat = -1 ) ;
111
112 declareProperty( "AsciiStatsOutputFile",
113 m_statsOutFileName = "",
114 "Name of the output file storing the stats. If empty, no"
115 " statistics will be saved (default)" );
116
117 declareProperty
118 ( "StatTableHeader" , m_header ,
119 "The header row for the output Stat-table" ) ;
120 declareProperty
121 ( "RegularRowFormat" , m_format1 ,
122 "The format for the regular row in the output Stat-table" ) ;
123 declareProperty
124 ( "EfficiencyRowFormat" , m_format2 ,
125 "The format for the regular row in the output Stat-table" ) ;
126 declareProperty
127 ( "UseEfficiencyRowFormat" , m_useEffFormat ,
128 "Use the special format for printout of efficiency counters" ) ;
129
130 declareProperty
131 ( "PerEventFile", m_perEventFile="",
132 "File name for per-event deltas" );
133
134 }
135 // ============================================================================
136 // Compound assignment operator.
137 // ============================================================================
138 void ChronoStatSvc::merge ( const ChronoStatSvc& css){
139
140 // Add the content of the maps, leave the rest unchanged
141
142 // Merge Chronomaps
143 for (auto& item : css.m_chronoEntities){
144 const IChronoStatSvc::ChronoTag& key = item.first;
145 const ChronoEntity& val = item.second;
146 if (m_chronoEntities.count(key))
147 m_chronoEntities[key]+=val;
148 else
149 m_chronoEntities.insert (std::pair<IChronoStatSvc::ChronoTag,ChronoEntity>(key,val));
150 }
151
152 // Merge StatMaps
153 for (auto& item : css.m_statEntities){
154 const IChronoStatSvc::StatTag& key = item.first;
155 const StatEntity& val = item.second;
156 if (m_statEntities.count(key))
157 m_statEntities[key]+=val;
158 else
159 m_statEntities.insert (std::pair<IChronoStatSvc::StatTag,StatEntity>(key,val));
160 }
161
162 }
163 // ============================================================================
164 // Implementation of IService::initialize()
165 // ============================================================================
166 StatusCode ChronoStatSvc::initialize()
167 {
168 StatusCode sc = Service::initialize();
169 if ( sc.isFailure() ) return sc;
171 // Set my own properties
172 sc = setProperties();
173
174 if (sc.isFailure()) {
175 error() << "setting my properties" << endmsg;
176 return StatusCode::FAILURE;
177 }
178
179 // only add an EndEvent listener if per-event output requested
180 if (!m_perEventFile.empty()) {
181 m_ofd.open(m_perEventFile);
182 if (!m_ofd.is_open()) {
183 error() << "unable to open per-event output file \""
184 << m_perEventFile << "\"" << endmsg;
185 return StatusCode::FAILURE;
186 } else {
187 auto ii = serviceLocator()->service<IIncidentSvc>("IncidentSvc");
188 if ( !ii) {
189 error() << "Unable to find IncidentSvc" << endmsg;
190 return StatusCode::FAILURE;
191 }
192 ii->addListener(this, IncidentType::EndEvent);
193 }
194 }
195
196 info() << " Number of skipped events for MemStat"
197 << m_numberOfSkippedEventsForMemStat << endmsg ;
198
202 m_statPrintLevel =
203 ( MSG::FATAL < m_intStatPrintLevel ) ? MSG::FATAL :
204 ( MSG::NIL > m_intStatPrintLevel ) ? MSG::NIL :
205 ( MSG::Level ) m_intStatPrintLevel ;
207 m_chronoPrintLevel =
208 ( MSG::FATAL < m_intChronoPrintLevel ) ? MSG::FATAL :
209 ( MSG::NIL > m_intChronoPrintLevel ) ? MSG::NIL :
210 ( MSG::Level ) m_intChronoPrintLevel ;
212 if( m_chronoTableFlag &&
213 !m_printUserTime &&
214 !m_printSystemTime &&
215 !m_printEllapsedTime ) { m_printUserTime = true ; }
217 if( m_printUserTime ||
218 m_printSystemTime ||
219 m_printEllapsedTime ) { m_chronoTableFlag = true ; }
222 chronoStart( name() ) ;
224 return StatusCode::SUCCESS;
225 }
226 // ============================================================================
227 // Implementation of IService::finalize()
228 // ============================================================================
229 StatusCode ChronoStatSvc::finalize()
230 {
231 std::string local = name()+".finalize()";
233 MsgStream main_log( msgSvc() , local );
236 chronoStop( name() ) ;
237
238 if (m_ofd.is_open()) {
239 debug() << "writing per-event timing data to '" << m_perEventFile << "'" << endmsg;
240 for (const auto& itr:m_perEvtTime) {
241 m_ofd << itr.first.substr(0,itr.first.length()-8 ) << " ";
242 for (const auto& itt:itr.second) {
243 m_ofd << " " << (long int)(itt);
244 }
245 m_ofd << std::endl;
246 }
247
248 m_ofd.close();
249 }
250
253 if ( m_chronoTableFlag &&
254 !m_chronoEntities.empty() &&
255 ( m_printUserTime || m_printSystemTime ) )
256 {
258 MsgStream log( msgSvc() , "*****Chrono*****" );
259 const std::string stars( ( m_chronoCoutFlag ) ? 126 : 100 , '*' );
260 if( m_chronoCoutFlag )
261 {
262 std::cout << stars << std::endl;
263 std::cout << local << " The Final CPU consumption (Chrono) Table "
264 << ( m_chronoOrderFlag ? "(ordered)" : "(not ordered)" ) << std::endl;
265 std::cout << stars << std::endl;
266 }
267 else
268 {
269 log << (MSG::Level) m_chronoPrintLevel
270 << stars << endmsg;
271 log << (MSG::Level) m_chronoPrintLevel
272 << " The Final CPU consumption ( Chrono ) Table "
273 << ( m_chronoOrderFlag ? "(ordered)" : "(not ordered)" ) << endmsg;
274 log << (MSG::Level) m_chronoPrintLevel << stars << endmsg;
275 }
277 { // prepare container for printing
278 std::vector<std::pair<ChronoEntity*,const ChronoTag*>> tmpCont;
279 tmpCont.reserve(m_chronoEntities.size());
280 for( auto& it : m_chronoEntities )
281 { tmpCont.emplace_back( &it.second , &it.first ) ; }
282 // sort it
283 if( m_chronoOrderFlag ) std::sort( tmpCont.begin(), tmpCont.end(),
284 CompareFirstOfPointerPair );
285 // print User Time statistics
286 if( m_printUserTime )
287 {
288 for( auto iter = tmpCont.begin() ; tmpCont.end() != iter ; ++iter )
289 {
290 //
291 ChronoEntity* entity = iter->first ; if( !entity ) { continue ; }
292 const ChronoTag* tag = iter->second ; if( !tag ) { continue ; }
293 entity->stop();
295 if ( m_chronoCoutFlag )
297 { std::cout << *tag << "\t" << entity->outputUserTime () << std::endl ; }
298 else
299 {
300 MsgStream(msgSvc(), *tag)
301 << m_chronoPrintLevel << entity->outputUserTime () << endmsg ;
302 }
303 //
304 }
305 }
307 if( m_printSystemTime )
308 {
311 if ( m_printUserTime && m_chronoCoutFlag )
312 { std::cout << stars << std::endl; }
313 else if ( m_printUserTime && !m_chronoCoutFlag )
314 { log << (MSG::Level) m_chronoPrintLevel << stars << endmsg; }
316 for( auto iter = tmpCont.begin() ; tmpCont.end() != iter ; ++iter )
317 {
319 ChronoEntity* entity = iter->first ; if( !entity ) { continue ; }
320 const ChronoTag* tag = iter->second ; if( !tag ) { continue ; }
321 entity->stop();
323 if ( m_chronoCoutFlag )
325 { std::cout << *tag << "\t" << entity->outputSystemTime() << std::endl ; }
326 else
327 {
328 MsgStream(msgSvc(), *tag)
329 << m_chronoPrintLevel << entity->outputSystemTime() << endmsg ;
330 }
331 //
332 }
333 }
335 if( m_printEllapsedTime )
336 {
339 if ( ( m_printUserTime || m_printSystemTime ) && m_chronoCoutFlag )
340 { std::cout << stars << std::endl; }
341 else if ( ( m_printUserTime || m_printSystemTime ) && !m_chronoCoutFlag )
342 { log << (MSG::Level) m_chronoPrintLevel << stars << endmsg; }
344 for( const auto& i : tmpCont )
345 {
347 ChronoEntity* entity = i.first ; if( !entity ) { continue ; }
348 const ChronoTag* tag = i.second ; if( !tag ) { continue ; }
349 entity->stop();
351 if ( m_chronoCoutFlag )
353 { std::cout << *tag << "\t" << entity->outputElapsedTime() << std::endl ; }
354 else
355 {
356 MsgStream(msgSvc(), *tag)
357 << m_chronoPrintLevel << entity->outputElapsedTime() << endmsg ;
358 }
359 //
360 }
361 }
363 tmpCont.clear();
364 }
366 if( m_chronoCoutFlag ) { std::cout << stars << std::endl; }
367 else { log << m_chronoPrintLevel << stars << endmsg; }
368 }
369
371
373 if ( m_statTableFlag ) { printStats () ; }
374
375 if ( !m_statsOutFileName.value().empty() ) {
376 saveStats();
377 }
378
379 main_log << MSG::INFO << " Service finalized successfully " << endmsg;
380
381 return Service::finalize();
382 }
383 // ============================================================================
384 // Implementation of IChronoStatSvc::chronoStart
385 // ============================================================================
386 ChronoEntity*
387 ChronoStatSvc::chronoStart
388 ( const ChronoTag& chronoTag )
389 {
390 ChronoEntity& entity = m_chronoEntities [ chronoTag ] ;
391 entity.start() ;
392 return &entity ;
393 }
394 // ============================================================================
395 // Implementation of IChronoStatSvc::chronoStop
396 // ============================================================================
397 const ChronoEntity*
398 ChronoStatSvc::chronoStop
399 ( const IChronoStatSvc::ChronoTag& chronoTag )
400 {
401 ChronoEntity& entity = m_chronoEntities [ chronoTag ] ;
402 entity.stop() ;
403 return &entity ;
404 }
405 // ============================================================================
406 // Implementation of IChronoStatSvc::chronoDelta
407 // ============================================================================
408 IChronoStatSvc::ChronoTime
409 ChronoStatSvc::chronoDelta
410 ( const IChronoStatSvc::ChronoTag& chronoTag,
411 IChronoStatSvc::ChronoType theType )
412 {
413 return m_chronoEntities[ chronoTag ].delta( theType );
414 }
415 // ============================================================================
416 // Implementation of IChronoStatSvc::chronoPrint
417 // ============================================================================
418 void ChronoStatSvc::chronoPrint
419 ( const IChronoStatSvc::ChronoTag& chronoTag )
420 {
421 MsgStream log ( msgSvc() , chronoTag );
422 if( m_printUserTime ) {
423 log << (MSG::Level) m_chronoPrintLevel
424 << m_chronoEntities[ chronoTag ].outputUserTime ()
425 << endmsg;
426 }
427 if( m_printSystemTime ) {
428 log << (MSG::Level) m_chronoPrintLevel
429 << m_chronoEntities[ chronoTag ].outputSystemTime()
430 << endmsg;
431 }
432 }
433 // ============================================================================
434 // Implementation of IChronoSvc::chronoStatus
435 // ============================================================================
436 IChronoStatSvc::ChronoStatus
437 ChronoStatSvc::chronoStatus
438 ( const IChronoStatSvc::ChronoTag& chronoTag )
439 { return m_chronoEntities[ chronoTag ].status(); }
440 // ============================================================================
441 // Implementation of IChronoStatSvc::stat
442 // ============================================================================
443 void ChronoStatSvc::stat
444 ( const IChronoStatSvc::StatTag & statTag ,
445 const IChronoStatSvc::StatFlag & statFlag )
446 {
447 auto theIter=m_statEntities.find(statTag);
448
449 StatEntity * theStat=nullptr ;
450 // if new entity, specify the number of events to be skipped
451 if (theIter==m_statEntities.end()){
452 // new stat entity
453 StatEntity& theSe = m_statEntities[ statTag ];
454 theStat=& theSe;
455 theStat->setnEntriesBeforeReset(m_numberOfSkippedEventsForMemStat);
456 }
457 else
458 {
459 //existing stat entity
460 theStat=&theIter->second;
461 }
462
463 theStat->addFlag ( statFlag ) ;
464 }
465 // ============================================================================
466 // Implementation of IChronoStatSvc::statPrint
467 // ============================================================================
468 void ChronoStatSvc::statPrint
469 ( const IChronoStatSvc::StatTag& statTag )
470 {
471 MsgStream log ( msgSvc() , statTag ) ;
472 log << (MSG::Level) m_statPrintLevel << m_statEntities[ statTag ] << endmsg;
473 }
474 // ============================================================================
475 /* extract the chrono entity for the given tag (name)
476 * @see IChronoStatSvc
477 * @param t chrono tag(name)
478 * @return pointer to chrono entity
479 */
480 // ============================================================================
481 const ChronoEntity* ChronoStatSvc::chrono
482 ( const IChronoStatSvc::ChronoTag& t ) const
483 {
484 auto it = m_chronoEntities.find ( t ) ;
485 return m_chronoEntities.end() != it ? &(it->second) : nullptr;
486 }
487 // ============================================================================
488 /* extract the stat entity for the given tag (name)
489 * @see IChronoStatSvc
490 * @param t stat tag(name)
491 * @return pointer to stat entity
492 */
493 // ============================================================================
494 const StatEntity* ChronoStatSvc::stat
495 ( const IChronoStatSvc::StatTag& t ) const
496 {
497 auto it = m_statEntities.find ( t ) ;
498 return m_statEntities.end() != it ? &(it->second) : nullptr;
499 }
500 // ============================================================================
501 // dump all the statistics into an ASCII file
502 // ============================================================================
503 void ChronoStatSvc::saveStats()
504 {
505 std::ofstream out( m_statsOutFileName.value(),
506 std::ios_base::out | std::ios_base::trunc );
507 if ( !out.good() ) {
508 info()
509 << "Could not open the output file for writing chrono statistics ["
510 << m_statsOutFileName.value() << "]"
511 << endmsg;
512 return;
513 } else {
514 // format it our way
515 out << std::scientific << std::setprecision(8) ;
516 }
517
518 // ChronoEntity
519 std::vector<std::pair<const ChronoEntity*, const ChronoTag*> > chronos;
520 chronos.reserve(m_chronoEntities.size() );
521 std::transform( std::begin(m_chronoEntities), std::end(m_chronoEntities),
522 std::back_inserter(chronos),
523 [](ChronoMap::const_reference i)
524 { return std::make_pair( &i.second, &i.first ); } );
525
526 // sort it
527 std::sort( std::begin(chronos) ,
528 std::end(chronos) ,
529 CompareFirstOfPointerPair );
530
531 // print User Time statistics
532 for( const auto& iter : chronos ) {
533 //
534 const ChronoEntity* entity = iter.first;
535 if( !entity ) { continue ; }
536
537 const ChronoTag* tag = iter.second ;
538 if( !tag ) { continue ; }
539
540 // create an entry in the .INI-like table
541 out << "\n[" << *tag << "]\n";
542
543 // user
544 out << "cpu_user_total = " << entity->uTotalTime() << "\n";
545 out << "cpu_user_min = " << entity->uMinimalTime() << "\n";
546 out << "cpu_user_mean = " << entity->uMeanTime() << "\n";
547 out << "cpu_user_RMS = " << entity->uRMSTime() << "\n";
548 out << "cpu_user_max = " << entity->uMaximalTime() << "\n";
549 out << "cpu_user_nbr = " << entity->nOfMeasurements() << "\n";
550
551 // system
552 out << "\n"; // just for clarity
553 out << "cpu_system_total = " << entity->kTotalTime() << "\n";
554 out << "cpu_system_min = " << entity->kMinimalTime() << "\n";
555 out << "cpu_system_mean = " << entity->kMeanTime() << "\n";
556 out << "cpu_system_RMS = " << entity->kRMSTime() << "\n";
557 out << "cpu_system_max = " << entity->kMaximalTime() << "\n";
558 out << "cpu_system_nbr = " << entity->nOfMeasurements() << "\n";
559
560 // real
561 out << "\n"; // just for clarity
562 out << "cpu_real_total = " << entity->eTotalTime() << "\n";
563 out << "cpu_real_min = " << entity->eMinimalTime() << "\n";
564 out << "cpu_real_mean = " << entity->eMeanTime() << "\n";
565 out << "cpu_real_RMS = " << entity->eRMSTime() << "\n";
566 out << "cpu_real_max = " << entity->eMaximalTime() << "\n";
567 out << "cpu_real_nbr = " << entity->nOfMeasurements() << "\n";
568
569 }
570
571 out << std::endl;
572 }
573 // ============================================================================
574 // print the "Stat" part of the ChronoStatSvc
575 // ============================================================================
576 void ChronoStatSvc::printStats()
577 {
579 if ( m_statEntities.empty() ) { return ; }
580
581 MsgStream log ( msgSvc() , "******Stat******" ) ;
583 const std::string stars( ( m_statCoutFlag ) ? 126 : 100 , '*' ) ;
585 if ( m_statCoutFlag )
586 {
587 std::cout << stars << std::endl;
588 std::cout << " The Final stat Table "
589 << ( m_statOrderFlag ? "(ordered)" : "(not ordered)" ) << std::endl;
590 std::cout << stars << std::endl;
591 }
592 else
593 {
594 log << m_statPrintLevel << stars << endmsg;
595 log << m_statPrintLevel << " The Final stat Table "
596 << ( m_statOrderFlag ? "(ordered)" : "(not ordered)" ) << endmsg;
597 log << m_statPrintLevel << stars << endmsg;
598 }
599
600 {
601 // prepare container for printing
602 typedef std::pair<const StatEntity*,const StatTag*> SPair;
603 typedef std::vector<SPair> SCont;
604 SCont tmpCont;
605 std::transform( std::begin(m_statEntities), std::end(m_statEntities),
606 std::back_inserter(tmpCont),
607 [](StatMap::const_reference i)
608 { return std::make_pair( &i.second, &i.first); } );
609 // sort it
610 if ( m_statOrderFlag ) std::sort( tmpCont.begin(), tmpCont.end(),
611 CompareFirstOfPointerPair );
612 // print the table header
613 if ( m_statCoutFlag ) { std::cout << m_header << std::endl ; }
614 else { log << m_statPrintLevel << m_header << endmsg ; }
615
616 // loop over counters and print them:
617 for ( const auto& iter : tmpCont ) {
619 const StatEntity* entity = iter.first ;
620 if ( !entity ) { continue ; }
621 const StatTag* tag = iter.second ;
622 if ( !tag ) { continue ; }
623 if ( m_statCoutFlag )
625 {
626 std::cout
627 << Gaudi::Utils::formatAsTableRow
628 ( *tag , *entity , m_useEffFormat , m_format1 , m_format2 )
629 << std::endl;
630 }
631 else
632 {
633 log
634 << m_statPrintLevel
635 << Gaudi::Utils::formatAsTableRow
636 ( *tag , *entity , m_useEffFormat , m_format1 , m_format2 )
637 << endmsg ;
638 }
639 }
640 tmpCont.clear();
641 }
643 if ( m_statCoutFlag ) { std::cout << stars << std::endl; }
644 else { log << m_statPrintLevel << stars << endmsg; }
645 }
646
647 // ============================================================================
648
649 void ChronoStatSvc::handle(const Incident& /* inc */) {
650
651 if (! m_ofd.is_open()) return;
652
653 for (const auto& itr:m_chronoEntities) {
654 if (itr.first.find(":Execute") == std::string::npos) continue;
655
656 auto itm = m_perEvtTime.find(itr.first);
657 if (itm == m_perEvtTime.end()) {
658 m_perEvtTime[itr.first] = { itr.second.delta(IChronoSvc::ELAPSED) };
659 } else {
660 itm->second.push_back( itr.second.delta(IChronoSvc::ELAPSED) );
661 }
662 }
663 }
664
665 // ============================================================================
666 // The END
667 // ============================================================================
ChronoEntity::outputElapsedTime
std::string outputElapsedTime() const
print the chrono ;
Definition: ChronoEntity.cpp:110
ChronoStatSvc::m_useEffFormat
bool m_useEffFormat
flag to use the special "efficiency" format
Definition: ChronoStatSvc.h:190
ChronoStatSvc::m_intStatPrintLevel
int m_intStatPrintLevel
level of info printing
Definition: ChronoStatSvc.h:170
ChronoEntity::kMaximalTime
double kMaximalTime() const
maximal measurement for kernel time
Definition: ChronoEntity.h:219
MsgStream
Definition of the MsgStream class used to transmit messages.
Definition: MsgStream.h:24
Service::initialize
StatusCode initialize() override
Definition: Service.cpp:68
Service::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Retrieve pointer to service locator.
Definition: Service.cpp:324
Kernel.h
std::string::empty
T empty(T...args)
ChronoEntity::uMinimalTime
double uMinimalTime() const
minimal measurement for user time
Definition: ChronoEntity.h:198
ChronoStatSvc::m_chronoOrderFlag
bool m_chronoOrderFlag
flag for formattion the final statistic table
Definition: ChronoStatSvc.h:155
ISvcLocator
The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to loc...
Definition: ISvcLocator.h:25
std::ofstream::open
T open(T...args)
ChronoStatSvc::m_printUserTime
bool m_printUserTime
flag for printing User quantities
Definition: ChronoStatSvc.h:157
ChronoEntity::uTotalTime
double uTotalTime() const
total user time
Definition: ChronoEntity.h:229
ChronoStatSvc::chronoStatus
virtual ChronoStatus chronoStatus(const IChronoStatSvc::ChronoTag &chronoTag) override
Implementation of IChronoStatSvc::chronoStatus.
Definition: ChronoStatSvc.cpp:438
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:28
Service::finalize
StatusCode finalize() override
Definition: Service.cpp:193
MsgStream.h
ana.itm
tuple itm
Definition: ana.py:57
CommonMessagingBase::info
MsgStream & info() const
shortcut for the method msgStream(MSG::INFO)
Definition: CommonMessaging.h:124
ChronoStatSvc::m_statEntities
StatMap m_statEntities
stat part
Definition: ChronoStatSvc.h:167
ChronoStatSvc::m_printEllapsedTime
bool m_printEllapsedTime
flag for printing Ellapsed quantities
Definition: ChronoStatSvc.h:161
Gaudi.Configuration.log
tuple log
Definition: Configuration.py:13
ChronoEntity
a small helper class for implementation of ChronoStatSvc service, It also could be used as some local...
Definition: ChronoEntity.h:21
ChronoStatSvc::m_header
std::string m_header
the header row
Definition: ChronoStatSvc.h:184
ChronoStatSvc::chronoDelta
virtual IChronoStatSvc::ChronoTime chronoDelta(const IChronoStatSvc::ChronoTag &chronoTag, IChronoStatSvc::ChronoType theType) override
Implementation of IchronoStatSvc::chronoDelta.
Definition: ChronoStatSvc.cpp:410
ChronoEntity::kTotalTime
double kTotalTime() const
total Kernel time
Definition: ChronoEntity.h:234
std::endl
T endl(T...args)
ChronoStatSvc::m_statsOutFileName
StringProperty m_statsOutFileName
Name of the output file where we'll dump the stats.
Definition: ChronoStatSvc.h:181
ChronoStatSvc.h
ChronoStatSvc::stat
virtual void stat(const IChronoStatSvc::StatTag &statTag, const IChronoStatSvc::StatFlag &statFlag) override
Implementation of IChronoStatSvc::stat add statistical information to the entity , tagged by its name.
Definition: ChronoStatSvc.cpp:444
ChronoEntity::uRMSTime
double uRMSTime() const
r.m.s User Time
Definition: ChronoEntity.h:270
std::vector::end
T end(T...args)
ChronoEntity::kMinimalTime
double kMinimalTime() const
minimal measurement for kernel time
Definition: ChronoEntity.h:204
ChronoEntity::eMinimalTime
double eMinimalTime() const
minimal measurement for elapsed time
Definition: ChronoEntity.h:209
HiveAlgSequencer.p2
tuple p2
Definition: HiveAlgSequencer.py:23
ChronoEntity::kRMSTime
double kRMSTime() const
r.m.s Kernel Time
Definition: ChronoEntity.h:265
merge_files.sc
int sc
Definition: merge_files.py:167
ChronoStatSvc::statPrint
virtual void statPrint(const IChronoStatSvc::ChronoTag &statTag) override
prints (using message service) info about statistical entity, tagged by its name
Definition: ChronoStatSvc.cpp:469
ChronoStatSvc::m_numberOfSkippedEventsForMemStat
long m_numberOfSkippedEventsForMemStat
Definition: ChronoStatSvc.h:164
ChronoEntity::outputSystemTime
std::string outputSystemTime() const
print the chrono ;
Definition: ChronoEntity.cpp:98
ChronoEntity::start
IChronoSvc::ChronoStatus start()
start the current chrono
Definition: ChronoEntity.cpp:47
ChronoStatSvc::m_format2
std::string m_format2
format for "efficiency" statistical printout rows
Definition: ChronoStatSvc.h:188
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
ChronoStatSvc::m_chronoTableFlag
bool m_chronoTableFlag
flag for printing the final table
Definition: ChronoStatSvc.h:151
DECLARE_COMPONENT
#define DECLARE_COMPONENT(type)
Definition: PluginService.h:36
Gaudi::Utils::formatAsTableRow
GAUDI_API std::string formatAsTableRow(const StatEntity &counter, const bool flag, const std::string &format1=" |%|7d| |%|11.7g| |%|#11.5g| |%|#10.5g| |%|#10.5g| |%|#10.5g| |", const std::string &format2="*|%|7d| |%|11.5g| |(%|#9.7g| +- %|-#8.6g|)%%| ----- | ----- |")
print the counter in a form of the table row
Definition: StatEntity.cpp:299
ChronoStatSvc::m_intChronoPrintLevel
int m_intChronoPrintLevel
level of info printing
Definition: ChronoStatSvc.h:148
std::string
STL class.
StatEntity::setnEntriesBeforeReset
void setnEntriesBeforeReset(unsigned long nEntriesBeforeReset)
DR specify number of entry before reset.
Definition: StatEntity.cpp:219
HepRndm::Engine
Definition: HepRndmEngine.h:25
ChronoStatSvc::printStats
void printStats()
Definition: ChronoStatSvc.cpp:576
MSG::FATAL
Definition: IMessageSvc.h:22
ChronoEntity::kMeanTime
double kMeanTime() const
average Kernel Time
Definition: ChronoEntity.h:250
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:78
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition: Service.cpp:319
MSG::Level
Level
Definition: IMessageSvc.h:15
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:118
std::ofstream
STL class.
ChronoEntity::eMeanTime
double eMeanTime() const
average Elapsed Time
Definition: ChronoEntity.h:260
ChronoStatSvc::merge
void merge(const ChronoStatSvc &css)
Compound assignment operator.
Definition: ChronoStatSvc.cpp:138
ChronoStatSvc::ChronoStatSvc
ChronoStatSvc()=delete
ChronoStatSvc::saveStats
void saveStats()
dump the statistics into an ASCII file for offline processing
Definition: ChronoStatSvc.cpp:503
StatusCode::FAILURE
Definition: StatusCode.h:29
ChronoStatSvc::m_statOrderFlag
bool m_statOrderFlag
flag for formattion the final statistic table
Definition: ChronoStatSvc.h:177
IIncidentSvc.h
CompareFirstOfPointerPair
constexpr struct CompareFirstOfPointerPair_t CompareFirstOfPointerPair
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
MsgStream::clear
void clear(STATE_TYPE _i=std::ios_base::failbit)
Definition: MsgStream.h:222
ChronoStatSvc::m_perEvtTime
TimeMap m_perEvtTime
Definition: ChronoStatSvc.h:193
std::ofstream::close
T close(T...args)
ChronoStatSvc::chronoStop
virtual const ChronoEntity * chronoStop(const IChronoStatSvc::ChronoTag &chronoTag) override
Implementation of IChronoStatSvc::chronoStop.
Definition: ChronoStatSvc.cpp:399
MSG::NIL
Definition: IMessageSvc.h:16
std::make_pair
T make_pair(T...args)
ChronoEntity::eRMSTime
double eRMSTime() const
r.m.s Elapsed Time
Definition: ChronoEntity.h:275
std::vector::clear
T clear(T...args)
ChronoStatSvc::m_ofd
std::ofstream m_ofd
Definition: ChronoStatSvc.h:195
ChronoStatSvc::m_statTableFlag
bool m_statTableFlag
flag for printing the final table
Definition: ChronoStatSvc.h:173
PropertyWithValue::value
const TYPE & value() const
explicit conversion
Definition: Property.h:341
StatEntity::addFlag
unsigned long addFlag(const double Flag)
add a flag
Definition: StatEntity.h:412
Service::setProperties
StatusCode setProperties()
Method for setting declared properties to the values specified for the job.
Definition: Service.cpp:363
IChronoSvc::ELAPSED
Definition: IChronoSvc.h:57
std::map::count
T count(T...args)
std::scientific
T scientific(T...args)
ChronoStatSvc::m_chronoPrintLevel
MSG::Level m_chronoPrintLevel
Definition: ChronoStatSvc.h:149
ChronoStatSvc::initialize
StatusCode initialize() override
Implementation of IService::initialize()
Definition: ChronoStatSvc.cpp:166
std::pair
std::map::insert
T insert(T...args)
ChronoEntity::uMeanTime
double uMeanTime() const
average User Time
Definition: ChronoEntity.h:255
ChronoEntity::outputUserTime
std::string outputUserTime() const
print the chrono ;
Definition: ChronoEntity.cpp:85
std::map::find
T find(T...args)
std::map::size
T size(T...args)
e2
HepRndm::Engine< TripleRand > e2
Definition: HepRndmEngines.cpp:203
std::vector
STL class.
ChronoStatSvc::m_statCoutFlag
bool m_statCoutFlag
flag for destination of the t he final table
Definition: ChronoStatSvc.h:175
CommonMessagingBase::debug
MsgStream & debug() const
shortcut for the method msgStream(MSG::DEBUG)
Definition: CommonMessaging.h:127
ChronoStatSvc::m_printSystemTime
bool m_printSystemTime
flag for printing System quantities
Definition: ChronoStatSvc.h:159
std::vector::begin
T begin(T...args)
ChronoStatSvc::handle
void handle(const Incident &incident) override
Definition: ChronoStatSvc.cpp:649
std::back_inserter
T back_inserter(T...args)
ChronoEntity::eMaximalTime
double eMaximalTime() const
maximal measurement for elapsed time
Definition: ChronoEntity.h:224
Incident
Base class for all Incidents (computing events).
Definition: Incident.h:17
ChronoStatSvc::chronoStart
virtual ChronoEntity * chronoStart(const IChronoStatSvc::ChronoTag &chronoTag) override
Implementation of IChronoStatSvc::chronoStart.
Definition: ChronoStatSvc.cpp:388
StatEntity.h
ChronoStatSvc::m_perEventFile
std::string m_perEventFile
Definition: ChronoStatSvc.h:194
ana.item
tuple item
print s1,s2
Definition: ana.py:146
CommonMessaging
Definition: CommonMessaging.h:58
CommonMessagingBase::msgSvc
SmartIF< IMessageSvc > & msgSvc() const
The standard message service.
Definition: CommonMessaging.h:73
Stat.h
CompareFirstOfPointerPair_t
Definition: ChronoStatSvc.cpp:45
ChronoEntity::nOfMeasurements
unsigned long nOfMeasurements() const
number of chrono measurements
Definition: ChronoEntity.h:194
IChronoStatSvc.h
ChronoStatSvc::m_statPrintLevel
MSG::Level m_statPrintLevel
Definition: ChronoStatSvc.h:171
std::sort
T sort(T...args)
std::transform
T transform(T...args)
StatusCode.h
ChronoStatSvc::m_chronoCoutFlag
bool m_chronoCoutFlag
flag for destination of the the final table
Definition: ChronoStatSvc.h:153
StatEntity
The basic counter used for Monitoring purposes.
Definition: StatEntity.h:64
std::ofstream::is_open
T is_open(T...args)
MSG::INFO
Definition: IMessageSvc.h:19
ChronoEntity::stop
IChronoSvc::ChronoStatus stop()
stop the chrono
Definition: ChronoEntity.cpp:63
ChronoEntity::uMaximalTime
double uMaximalTime() const
maximal measurement for user time
Definition: ChronoEntity.h:214
HiveAlgSequencer.p1
tuple p1
Definition: HiveAlgSequencer.py:22
std::setprecision
T setprecision(T...args)
ChronoEntity.h
ana.i
list i
Definition: ana.py:128
std::cout
ChronoEntity::eTotalTime
double eTotalTime() const
total Elapsed time
Definition: ChronoEntity.h:239
ChronoStatSvc::chronoPrint
virtual void chronoPrint(const IChronoStatSvc::ChronoTag &chronoTag) override
Implementation of IChronoStatSvc::chronoPrint.
Definition: ChronoStatSvc.cpp:419
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244
IIncidentSvc
The interface implemented by the IncidentSvc service.
Definition: IIncidentSvc.h:21
ChronoStatSvc::m_format1
std::string m_format1
format for regular statistical printout rows
Definition: ChronoStatSvc.h:186
ChronoStatSvc
The Chrono & Stat Sservice: service implements the IChronoStatSvc interface and provides the basic ch...
Definition: ChronoStatSvc.h:33
std::vector::reserve
T reserve(T...args)
ForwardSchedulerSimpleTest.msgSvc
tuple msgSvc
Definition: ForwardSchedulerSimpleTest.py:112
ChronoStatSvc::m_chronoEntities
ChronoMap m_chronoEntities
chrono part
Definition: ChronoStatSvc.h:146
std::vector::emplace_back
T emplace_back(T...args)
ChronoStatSvc::finalize
StatusCode finalize() override
Implementation of IService::finalize()
Definition: ChronoStatSvc.cpp:229
ChronoStatSvc::chrono
virtual const ChronoEntity * chrono(const IChronoStatSvc::ChronoTag &t) const override
extract the chrono entity for the given tag (name)
Definition: ChronoStatSvc.cpp:482