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 // ============================================================================
34 // ============================================================================
41 // ============================================================================
42 // ============================================================================
43 // comparison functor
44 // ============================================================================
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  }
56 // ============================================================================
57 // Constructor
58 // ============================================================================
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 // ============================================================================
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 // ============================================================================
167 {
169  if ( sc.isFailure() ) return sc;
171  MsgStream log( msgSvc() , this->name() );
172 
173  // Set my own properties
174  sc = setProperties();
175 
176  if (sc.isFailure()) {
177  log << MSG::ERROR << "setting my properties" << endmsg;
178  return StatusCode::FAILURE;
179  }
180 
181  // only add an EndEvent listener if per-event output requested
182  if (!m_perEventFile.empty()) {
183  m_ofd.open(m_perEventFile);
184  if (!m_ofd.is_open()) {
185  log << MSG::ERROR << "unable to open per-event output file \""
186  << m_perEventFile << "\"" << endmsg;
187  return StatusCode::FAILURE;
188  } else {
189  auto ii = serviceLocator()->service<IIncidentSvc>("IncidentSvc");
190  if ( !ii) {
191  log << MSG::ERROR << "Unable to find IncidentSvc" << endmsg;
192  return StatusCode::FAILURE;
193  }
194  ii->addListener(this, IncidentType::EndEvent);
195  }
196  }
197 
198  log << MSG::INFO << " Number of skipped events for MemStat"
200 
214  if( m_chronoTableFlag &&
215  !m_printUserTime &&
217  !m_printEllapsedTime ) { m_printUserTime = true ; }
219  if( m_printUserTime ||
224  chronoStart( name() ) ;
226  return StatusCode::SUCCESS;
227 }
228 // ============================================================================
229 // Implementation of IService::finalize()
230 // ============================================================================
232 {
233  std::string local = name()+".finalize()";
235  MsgStream main_log( msgSvc() , local );
238  chronoStop( name() ) ;
239 
240  if (m_ofd.is_open()) {
241  MsgStream log(msgSvc(), name());
242  log << MSG::DEBUG << "writing per-event timing data to '" << m_perEventFile << "'" << endmsg;
243  for (const auto& itr:m_perEvtTime) {
244  m_ofd << itr.first.substr(0,itr.first.length()-8 ) << " ";
245  for (const auto& itt:itr.second) {
246  m_ofd << " " << (long int)(itt);
247  }
248  m_ofd << std::endl;
249  }
250 
251  m_ofd.close();
252  }
253 
256  if ( m_chronoTableFlag &&
257  !m_chronoEntities.empty() &&
259  {
261  MsgStream log( msgSvc() , "*****Chrono*****" );
262  const std::string stars( ( m_chronoCoutFlag ) ? 126 : 100 , '*' );
263  if( m_chronoCoutFlag )
264  {
265  std::cout << stars << std::endl;
266  std::cout << local << " The Final CPU consumption (Chrono) Table "
267  << ( m_chronoOrderFlag ? "(ordered)" : "(not ordered)" ) << std::endl;
268  std::cout << stars << std::endl;
269  }
270  else
271  {
273  << stars << endmsg;
275  << " The Final CPU consumption ( Chrono ) Table "
276  << ( m_chronoOrderFlag ? "(ordered)" : "(not ordered)" ) << endmsg;
277  log << (MSG::Level) m_chronoPrintLevel << stars << endmsg;
278  }
280  { // prepare container for printing
281  std::vector<std::pair<ChronoEntity*,const ChronoTag*>> tmpCont;
282  tmpCont.reserve(m_chronoEntities.size());
283  for( auto& it : m_chronoEntities )
284  { tmpCont.emplace_back( &it.second , &it.first ) ; }
285  // sort it
286  if( m_chronoOrderFlag ) std::sort( tmpCont.begin(), tmpCont.end(),
288  // print User Time statistics
289  if( m_printUserTime )
290  {
291  for( auto iter = tmpCont.begin() ; tmpCont.end() != iter ; ++iter )
292  {
293  //
294  ChronoEntity* entity = iter->first ; if( !entity ) { continue ; }
295  const ChronoTag* tag = iter->second ; if( !tag ) { continue ; }
296  entity->stop();
298  if ( m_chronoCoutFlag )
300  { std::cout << *tag << "\t" << entity->outputUserTime () << std::endl ; }
301  else
302  {
303  MsgStream(msgSvc(), *tag)
304  << m_chronoPrintLevel << entity->outputUserTime () << endmsg ;
305  }
306  //
307  }
308  }
310  if( m_printSystemTime )
311  {
315  { std::cout << stars << std::endl; }
316  else if ( m_printUserTime && !m_chronoCoutFlag )
317  { log << (MSG::Level) m_chronoPrintLevel << stars << endmsg; }
319  for( auto iter = tmpCont.begin() ; tmpCont.end() != iter ; ++iter )
320  {
322  ChronoEntity* entity = iter->first ; if( !entity ) { continue ; }
323  const ChronoTag* tag = iter->second ; if( !tag ) { continue ; }
324  entity->stop();
326  if ( m_chronoCoutFlag )
328  { std::cout << *tag << "\t" << entity->outputSystemTime() << std::endl ; }
329  else
330  {
331  MsgStream(msgSvc(), *tag)
332  << m_chronoPrintLevel << entity->outputSystemTime() << endmsg ;
333  }
334  //
335  }
336  }
338  if( m_printEllapsedTime )
339  {
343  { std::cout << stars << std::endl; }
344  else if ( ( m_printUserTime || m_printSystemTime ) && !m_chronoCoutFlag )
345  { log << (MSG::Level) m_chronoPrintLevel << stars << endmsg; }
347  for( const auto& i : tmpCont )
348  {
350  ChronoEntity* entity = i.first ; if( !entity ) { continue ; }
351  const ChronoTag* tag = i.second ; if( !tag ) { continue ; }
352  entity->stop();
354  if ( m_chronoCoutFlag )
356  { std::cout << *tag << "\t" << entity->outputElapsedTime() << std::endl ; }
357  else
358  {
359  MsgStream(msgSvc(), *tag)
360  << m_chronoPrintLevel << entity->outputElapsedTime() << endmsg ;
361  }
362  //
363  }
364  }
366  tmpCont.clear();
367  }
369  if( m_chronoCoutFlag ) { std::cout << stars << std::endl; }
370  else { log << m_chronoPrintLevel << stars << endmsg; }
371  }
372 
374 
376  if ( m_statTableFlag ) { printStats () ; }
377 
378  if ( !m_statsOutFileName.value().empty() ) {
379  saveStats();
380  }
381 
382  main_log << MSG::INFO << " Service finalized successfully " << endmsg;
383 
384  return Service::finalize();
385 }
386 // ============================================================================
387 // Implementation of IChronoStatSvc::chronoStart
388 // ============================================================================
391 ( const ChronoTag& chronoTag )
392 {
393  ChronoEntity& entity = m_chronoEntities [ chronoTag ] ;
394  entity.start() ;
395  return &entity ;
396 }
397 // ============================================================================
398 // Implementation of IChronoStatSvc::chronoStop
399 // ============================================================================
400 const ChronoEntity*
402 ( const IChronoStatSvc::ChronoTag& chronoTag )
403 {
404  ChronoEntity& entity = m_chronoEntities [ chronoTag ] ;
405  entity.stop() ;
406  return &entity ;
407 }
408 // ============================================================================
409 // Implementation of IChronoStatSvc::chronoDelta
410 // ============================================================================
411 IChronoStatSvc::ChronoTime
413 ( const IChronoStatSvc::ChronoTag& chronoTag,
414  IChronoStatSvc::ChronoType theType )
415 {
416  return m_chronoEntities[ chronoTag ].delta( theType );
417 }
418 // ============================================================================
419 // Implementation of IChronoStatSvc::chronoPrint
420 // ============================================================================
422 ( const IChronoStatSvc::ChronoTag& chronoTag )
423 {
424  MsgStream log ( msgSvc() , chronoTag );
425  if( m_printUserTime ) {
426  log << (MSG::Level) m_chronoPrintLevel
427  << m_chronoEntities[ chronoTag ].outputUserTime ()
428  << endmsg;
429  }
430  if( m_printSystemTime ) {
431  log << (MSG::Level) m_chronoPrintLevel
432  << m_chronoEntities[ chronoTag ].outputSystemTime()
433  << endmsg;
434  }
435 }
436 // ============================================================================
437 // Implementation of IChronoSvc::chronoStatus
438 // ============================================================================
439 IChronoStatSvc::ChronoStatus
441 ( const IChronoStatSvc::ChronoTag& chronoTag )
442 { return m_chronoEntities[ chronoTag ].status(); }
443 // ============================================================================
444 // Implementation of IChronoStatSvc::stat
445 // ============================================================================
447 ( const IChronoStatSvc::StatTag & statTag ,
448  const IChronoStatSvc::StatFlag & statFlag )
449 {
450  auto theIter=m_statEntities.find(statTag);
451 
452  StatEntity * theStat=nullptr ;
453  // if new entity, specify the number of events to be skipped
454  if (theIter==m_statEntities.end()){
455  // new stat entity
456  StatEntity& theSe = m_statEntities[ statTag ];
457  theStat=& theSe;
458  theStat->setnEntriesBeforeReset(m_numberOfSkippedEventsForMemStat);
459  }
460  else
461  {
462  //existing stat entity
463  theStat=&theIter->second;
464  }
465 
466  theStat->addFlag ( statFlag ) ;
467 }
468 // ============================================================================
469 // Implementation of IChronoStatSvc::statPrint
470 // ============================================================================
472 ( const IChronoStatSvc::StatTag& statTag )
473 {
474  MsgStream log ( msgSvc() , statTag ) ;
475  log << (MSG::Level) m_statPrintLevel << m_statEntities[ statTag ] << endmsg;
476 }
477 // ============================================================================
478 /* extract the chrono entity for the given tag (name)
479  * @see IChronoStatSvc
480  * @param t chrono tag(name)
481  * @return pointer to chrono entity
482  */
483 // ============================================================================
485 ( const IChronoStatSvc::ChronoTag& t ) const
486 {
487  auto it = m_chronoEntities.find ( t ) ;
488  return m_chronoEntities.end() != it ? &(it->second) : nullptr;
489 }
490 // ============================================================================
491 /* extract the stat entity for the given tag (name)
492  * @see IChronoStatSvc
493  * @param t stat tag(name)
494  * @return pointer to stat entity
495  */
496 // ============================================================================
498 ( const IChronoStatSvc::StatTag& t ) const
499 {
500  auto it = m_statEntities.find ( t ) ;
501  return m_statEntities.end() != it ? &(it->second) : nullptr;
502 }
503 // ============================================================================
504 // dump all the statistics into an ASCII file
505 // ============================================================================
507 {
508  std::ofstream out( m_statsOutFileName.value(),
509  std::ios_base::out | std::ios_base::trunc );
510  if ( !out.good() ) {
511  MsgStream msg( msgSvc() , name() );
512  msg << MSG::INFO
513  << "Could not open the output file for writing chrono statistics ["
514  << m_statsOutFileName.value() << "]"
515  << endmsg;
516  return;
517  } else {
518  // format it our way
519  out << std::scientific << std::setprecision(8) ;
520  }
521 
522  // ChronoEntity
523  std::vector<std::pair<const ChronoEntity*, const ChronoTag*> > chronos;
524  chronos.reserve(m_chronoEntities.size() );
526  std::back_inserter(chronos),
527  [](ChronoMap::const_reference i)
528  { return std::make_pair( &i.second, &i.first ); } );
529 
530  // sort it
531  std::sort( std::begin(chronos) ,
532  std::end(chronos) ,
534 
535  // print User Time statistics
536  for( const auto& iter : chronos ) {
537  //
538  const ChronoEntity* entity = iter.first;
539  if( !entity ) { continue ; }
540 
541  const ChronoTag* tag = iter.second ;
542  if( !tag ) { continue ; }
543 
544  // create an entry in the .INI-like table
545  out << "\n[" << *tag << "]\n";
546 
547  // user
548  out << "cpu_user_total = " << entity->uTotalTime() << "\n";
549  out << "cpu_user_min = " << entity->uMinimalTime() << "\n";
550  out << "cpu_user_mean = " << entity->uMeanTime() << "\n";
551  out << "cpu_user_RMS = " << entity->uRMSTime() << "\n";
552  out << "cpu_user_max = " << entity->uMaximalTime() << "\n";
553  out << "cpu_user_nbr = " << entity->nOfMeasurements() << "\n";
554 
555  // system
556  out << "\n"; // just for clarity
557  out << "cpu_system_total = " << entity->kTotalTime() << "\n";
558  out << "cpu_system_min = " << entity->kMinimalTime() << "\n";
559  out << "cpu_system_mean = " << entity->kMeanTime() << "\n";
560  out << "cpu_system_RMS = " << entity->kRMSTime() << "\n";
561  out << "cpu_system_max = " << entity->kMaximalTime() << "\n";
562  out << "cpu_system_nbr = " << entity->nOfMeasurements() << "\n";
563 
564  // real
565  out << "\n"; // just for clarity
566  out << "cpu_real_total = " << entity->eTotalTime() << "\n";
567  out << "cpu_real_min = " << entity->eMinimalTime() << "\n";
568  out << "cpu_real_mean = " << entity->eMeanTime() << "\n";
569  out << "cpu_real_RMS = " << entity->eRMSTime() << "\n";
570  out << "cpu_real_max = " << entity->eMaximalTime() << "\n";
571  out << "cpu_real_nbr = " << entity->nOfMeasurements() << "\n";
572 
573  }
574 
575  out << std::endl;
576 }
577 // ============================================================================
578 // print the "Stat" part of the ChronoStatSvc
579 // ============================================================================
581 {
583  if ( m_statEntities.empty() ) { return ; }
584 
585  MsgStream log ( msgSvc() , "******Stat******" ) ;
587  const std::string stars( ( m_statCoutFlag ) ? 126 : 100 , '*' ) ;
589  if ( m_statCoutFlag )
590  {
591  std::cout << stars << std::endl;
592  std::cout << " The Final stat Table "
593  << ( m_statOrderFlag ? "(ordered)" : "(not ordered)" ) << std::endl;
594  std::cout << stars << std::endl;
595  }
596  else
597  {
598  log << m_statPrintLevel << stars << endmsg;
599  log << m_statPrintLevel << " The Final stat Table "
600  << ( m_statOrderFlag ? "(ordered)" : "(not ordered)" ) << endmsg;
601  log << m_statPrintLevel << stars << endmsg;
602  }
603 
604  {
605  // prepare container for printing
606  typedef std::pair<const StatEntity*,const StatTag*> SPair;
607  typedef std::vector<SPair> SCont;
608  SCont tmpCont;
610  std::back_inserter(tmpCont),
611  [](StatMap::const_reference i)
612  { return std::make_pair( &i.second, &i.first); } );
613  // sort it
614  if ( m_statOrderFlag ) std::sort( tmpCont.begin(), tmpCont.end(),
616  // print the table header
617  if ( m_statCoutFlag ) { std::cout << m_header << std::endl ; }
618  else { log << m_statPrintLevel << m_header << endmsg ; }
619 
620  // loop over counters and print them:
621  for ( const auto& iter : tmpCont ) {
623  const StatEntity* entity = iter.first ;
624  if ( !entity ) { continue ; }
625  const StatTag* tag = iter.second ;
626  if ( !tag ) { continue ; }
627  if ( m_statCoutFlag )
629  {
630  std::cout
632  ( *tag , *entity , m_useEffFormat , m_format1 , m_format2 )
633  << std::endl;
634  }
635  else
636  {
637  log
640  ( *tag , *entity , m_useEffFormat , m_format1 , m_format2 )
641  << endmsg ;
642  }
643  }
644  tmpCont.clear();
645  }
647  if ( m_statCoutFlag ) { std::cout << stars << std::endl; }
648  else { log << m_statPrintLevel << stars << endmsg; }
649 }
650 
651 // ============================================================================
652 
653 void ChronoStatSvc::handle(const Incident& /* inc */) {
654 
655  if (! m_ofd.is_open()) return;
656 
657  for (const auto& itr:m_chronoEntities) {
658  if (itr.first.find(":Execute") == std::string::npos) continue;
659 
660  auto itm = m_perEvtTime.find(itr.first);
661  if (itm == m_perEvtTime.end()) {
662  m_perEvtTime[itr.first] = { itr.second.delta(IChronoSvc::ELAPSED) };
663  } else {
664  itm->second.push_back( itr.second.delta(IChronoSvc::ELAPSED) );
665  }
666  }
667 }
668 
669 // ============================================================================
670 // The END
671 // ============================================================================
std::string outputElapsedTime() const
print the chrono ;
bool m_useEffFormat
flag to use the special "efficiency" format
int m_intStatPrintLevel
level of info printing
double kMaximalTime() const
maximal measurement for kernel time
Definition: ChronoEntity.h:219
Definition of the MsgStream class used to transmit messages.
Definition: MsgStream.h:24
StatusCode initialize() override
Definition: Service.cpp:63
double uMinimalTime() const
minimal measurement for user time
Definition: ChronoEntity.h:198
bool m_chronoOrderFlag
flag for formattion the final statistic table
The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to loc...
Definition: ISvcLocator.h:25
bool m_printUserTime
flag for printing User quantities
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244
double uTotalTime() const
total user time
Definition: ChronoEntity.h:229
virtual ChronoStatus chronoStatus(const IChronoStatSvc::ChronoTag &chronoTag) override
Implementation of IChronoStatSvc::chronoStatus.
StatusCode finalize() override
Definition: Service.cpp:188
tuple itm
Definition: ana.py:57
StatMap m_statEntities
stat part
bool m_printEllapsedTime
flag for printing Ellapsed quantities
a small helper class for implementation of ChronoStatSvc service, It also could be used as some local...
Definition: ChronoEntity.h:21
std::string m_header
the header row
virtual IChronoStatSvc::ChronoTime chronoDelta(const IChronoStatSvc::ChronoTag &chronoTag, IChronoStatSvc::ChronoType theType) override
Implementation of IchronoStatSvc::chronoDelta.
auto begin(reverse_wrapper< T > &w)
Definition: reverse.h:45
double kTotalTime() const
total Kernel time
Definition: ChronoEntity.h:234
StringProperty m_statsOutFileName
Name of the output file where we'll dump the stats.
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.
double uRMSTime() const
r.m.s User Time
Definition: ChronoEntity.h:270
double kMinimalTime() const
minimal measurement for kernel time
Definition: ChronoEntity.h:204
double eMinimalTime() const
minimal measurement for elapsed time
Definition: ChronoEntity.h:209
double kRMSTime() const
r.m.s Kernel Time
Definition: ChronoEntity.h:265
virtual void statPrint(const IChronoStatSvc::ChronoTag &statTag) override
prints (using message service) info about statistical entity, tagged by its name
long m_numberOfSkippedEventsForMemStat
std::string outputSystemTime() const
print the chrono ;
IChronoSvc::ChronoStatus start()
start the current chrono
std::string m_format2
format for "efficiency" statistical printout rows
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
bool m_chronoTableFlag
flag for printing the final table
int m_intChronoPrintLevel
level of info printing
void setnEntriesBeforeReset(unsigned long nEntriesBeforeReset)
DR specify number of entry before reset.
Definition: StatEntity.cpp:219
double kMeanTime() const
average Kernel Time
Definition: ChronoEntity.h:250
double eMeanTime() const
average Elapsed Time
Definition: ChronoEntity.h:260
void merge(const ChronoStatSvc &css)
Compound assignment operator.
ChronoStatSvc()=delete
void saveStats()
dump the statistics into an ASCII file for offline processing
bool m_statOrderFlag
flag for formattion the final statistic table
constexpr struct CompareFirstOfPointerPair_t CompareFirstOfPointerPair
auto end(reverse_wrapper< T > &w)
Definition: reverse.h:47
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
void clear(STATE_TYPE _i=std::ios_base::failbit)
Definition: MsgStream.h:222
#define DECLARE_COMPONENT(type)
Definition: PluginService.h:36
TimeMap m_perEvtTime
virtual const ChronoEntity * chronoStop(const IChronoStatSvc::ChronoTag &chronoTag) override
Implementation of IChronoStatSvc::chronoStop.
double eRMSTime() const
r.m.s Elapsed Time
Definition: ChronoEntity.h:275
std::ofstream m_ofd
bool m_statTableFlag
flag for printing the final table
const TYPE & value() const
explicit conversion
Definition: Property.h:341
unsigned long addFlag(const double Flag)
add a flag
Definition: StatEntity.h:412
MSG::Level m_chronoPrintLevel
StatusCode initialize() override
Implementation of IService::initialize()
double uMeanTime() const
average User Time
Definition: ChronoEntity.h:255
std::string outputUserTime() const
print the chrono ;
bool m_statCoutFlag
flag for destination of the t he final table
bool m_printSystemTime
flag for printing System quantities
Base class used to extend a class implementing other interfaces.
Definition: extends.h:10
void handle(const Incident &incident) override
double eMaximalTime() const
maximal measurement for elapsed time
Definition: ChronoEntity.h:224
Base class for all Incidents (computing events).
Definition: Incident.h:16
virtual ChronoEntity * chronoStart(const IChronoStatSvc::ChronoTag &chronoTag) override
Implementation of IChronoStatSvc::chronoStart.
std::string m_perEventFile
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
tuple item
print s1,s2
Definition: ana.py:146
unsigned long nOfMeasurements() const
number of chrono measurements
Definition: ChronoEntity.h:194
MSG::Level m_statPrintLevel
bool m_chronoCoutFlag
flag for destination of the the final table
The basic counter used for Monitoring purposes.
Definition: StatEntity.h:64
IChronoSvc::ChronoStatus stop()
stop the chrono
double uMaximalTime() const
maximal measurement for user time
Definition: ChronoEntity.h:214
list i
Definition: ana.py:128
double eTotalTime() const
total Elapsed time
Definition: ChronoEntity.h:239
virtual void chronoPrint(const IChronoStatSvc::ChronoTag &chronoTag) override
Implementation of IChronoStatSvc::chronoPrint.
The interface implemented by the IncidentSvc service.
Definition: IIncidentSvc.h:21
std::string m_format1
format for regular statistical printout rows
The Chrono & Stat Sservice: service implements the IChronoStatSvc interface and provides the basic ch...
Definition: ChronoStatSvc.h:33
ChronoMap m_chronoEntities
chrono part
StatusCode finalize() override
Implementation of IService::finalize()
virtual const ChronoEntity * chrono(const IChronoStatSvc::ChronoTag &t) const override
extract the chrono entity for the given tag (name)