---

ChronoStatSvc.cpp

Go to the documentation of this file.

#ifdef _WIN32
#pragma warning( disable : 4786 )
#endif

#include <iostream> 
#include <iomanip> 
#include <string> 
#include <algorithm>
#include <functional>
 

#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/StatusCode.h"

#include "GaudiKernel/ISvcFactory.h"
#include "GaudiKernel/SvcFactory.h"

#include "GaudiKernel/IChronoStatSvc.h"

#include "GaudiKernel/MsgStream.h" 
#include "ChronoEntity.h"
#include "StatEntity.h"

#include "ChronoStatSvc.h"



static const  SvcFactory<ChronoStatSvc>                         s_factory ;
extern const ISvcFactory&                ChronoStatSvcFactory = s_factory ;


ChronoStatSvc::ChronoStatSvc( const std::string& name, ISvcLocator* svcloc )
  : Service( name , svcloc ) 
  , m_chronoEntities   ()  
  , m_chronoPrintLevel ( MSG::INFO ) 
  , m_statEntities     ()  
  , m_statPrintLevel   ( MSG::INFO ) 
{
  declareProperty("ChronoPrintOutTable"    , m_chronoTableFlag      = true      );
  declareProperty("ChronoDestinationCout"  , m_chronoCoutFlag       = false     );
  declareProperty("ChronoPrintLevel"       , m_intChronoPrintLevel  = MSG::INFO );
  declareProperty("ChronoTableToBeOrdered" , m_chronoOrderFlag      = true      );
  declareProperty("PrintUserTime"          , m_printUserTime        = true      );
  declareProperty("PrintSystemTime"        , m_printSystemTime      = false     );
  declareProperty("PrintEllapsedTime"      , m_printEllapsedTime    = false     );
  declareProperty("StatPrintOutTable"      , m_statTableFlag        = true      );
  declareProperty("StatDestinationCout"    , m_statCoutFlag         = false     );
  declareProperty("StatPrintLevel"         , m_intStatPrintLevel    = MSG::INFO );
  declareProperty("StatTableToBeOrdered"   , m_statOrderFlag        = true      );
};


ChronoStatSvc::~ChronoStatSvc()
{
  // clear the container of chrono entities 
  m_chronoEntities.clear();
  // clear the container of stat   entities 
  m_statEntities.clear();
};

StatusCode ChronoStatSvc::initialize()
{
  StatusCode sc = Service::initialize();
  if( sc.isFailure() ) return sc;
  // Set my own properties
  setProperties();  
  m_statPrintLevel = 
    ( MSG::FATAL < m_intStatPrintLevel   ) ? MSG::FATAL : 
    ( MSG::NIL   > m_intStatPrintLevel   ) ? MSG::NIL   : ( MSG::Level ) m_intStatPrintLevel  ; 
  m_chronoPrintLevel = 
    ( MSG::FATAL < m_intChronoPrintLevel ) ? MSG::FATAL : 
    ( MSG::NIL   > m_intChronoPrintLevel ) ? MSG::NIL   : ( MSG::Level ) m_intChronoPrintLevel ;
  if( m_chronoTableFlag  && 
      !m_printUserTime   && !m_printSystemTime && !m_printEllapsedTime ) { m_printUserTime   = true ; } 
  if(  m_printUserTime   ||  m_printSystemTime ||  m_printEllapsedTime ) { m_chronoTableFlag = true ; }    
  chronoStart( name() );
  return StatusCode::SUCCESS;
};


StatusCode ChronoStatSvc::finalize()
{
  std::string local = name()+".finalize()"; 
  MsgStream log( msgSvc() , local ); 
  chronoStop( name() );
  
  if( m_chronoTableFlag && !m_chronoEntities.empty() && ( m_printUserTime || m_printSystemTime ) )   
    {
      MsgStream log( msgSvc() , "*****Chrono*****" ); 
      const std::string stars( ( m_chronoCoutFlag ) ? 126 : 100  , '*' );  
      if( m_chronoCoutFlag  ) 
        { 
          std::cout << stars << std::endl;                           
          std::cout << local <<  " The Final CPU consumption (Chrono) Table " 
                    << ( m_chronoOrderFlag ? "(ordered)" : "(not ordered)" ) << std::endl; 
          std::cout << stars << std::endl;                           
        }
      else 
        {
          log << (MSG::Level) m_chronoPrintLevel << stars << endreq;   
          log << (MSG::Level) m_chronoPrintLevel << " The Final CPU consumption ( Chrono ) Table " 
              << ( m_chronoOrderFlag ? "(ordered)" : "(not ordered)" ) << endreq;  
          log << (MSG::Level) m_chronoPrintLevel << stars << endreq;   
        }
      {  // prepare container for printing 
        typedef std::pair<ChronoEntity*,const ChronoTag*>        MPair;
        typedef std::vector<MPair>                               MCont;
        MCont tmpCont;
        for( ChronoMap::iterator it = m_chronoEntities.begin() ; m_chronoEntities.end() != it ;  ++it ) 
          { tmpCont.push_back( MPair( &(it->second) , &(it->first) ) ) ; } 
        // sort it  
        if( m_chronoOrderFlag ) 
          { std::sort( tmpCont.begin(), tmpCont.end() , ChronoEntity::ComparePairOfChronoEntityAndChronoTag() ); } 
        // print User Time statistics 
        if( m_printUserTime   ) 
          {
            for( MCont::iterator iter = tmpCont.begin() ;  tmpCont.end() != iter ; ++iter ) 
              {
                // 
                ChronoEntity*    entity = iter->first  ; if( 0 == entity ) { continue ; } 
                const ChronoTag* tag    = iter->second ; if( 0 == tag    ) { continue ; } 

                entity->stop();              

                if     ( m_chronoCoutFlag )  
                  { std::cout << *tag << "\t"  << entity->outputUserTime  () << std::endl ; } 
                else                         
                  { 
                    MsgStream log( msgSvc() , *tag ) ; 
                    log << m_chronoPrintLevel << entity->outputUserTime  () << endreq ; 
                  }
                //
              }
          }
        if( m_printSystemTime ) 
          {
            if      ( m_printUserTime && m_chronoCoutFlag   ) 
              { std::cout << stars << std::endl;                           } 
            else if ( m_printUserTime && !m_chronoCoutFlag  ) 
              { log << (MSG::Level) m_chronoPrintLevel << stars << endreq; }  
            for( MCont::iterator iter = tmpCont.begin() ;  tmpCont.end() != iter ; ++iter ) 
              {
                ChronoEntity*    entity = iter->first  ; if( 0 == entity ) { continue ; } 
                const ChronoTag* tag    = iter->second ; if( 0 == tag    ) { continue ; } 

                entity->stop();              

                if     ( m_chronoCoutFlag )  
                  { std::cout << *tag << "\t"  << entity->outputSystemTime() << std::endl ; }
                else                         
                  { 
                    MsgStream log( msgSvc() , *tag ) ;  
                    log << m_chronoPrintLevel << entity->outputSystemTime() << endreq ; 
                  }
                //
              }
          }
        if( m_printEllapsedTime ) 
          {
            if      ( ( m_printUserTime || m_printSystemTime ) &&  m_chronoCoutFlag  ) 
              { std::cout << stars << std::endl;                           } 
            else if ( ( m_printUserTime || m_printSystemTime ) && !m_chronoCoutFlag  ) 
              { log << (MSG::Level) m_chronoPrintLevel << stars << endreq; }  
            for( MCont::iterator iter = tmpCont.begin() ;  tmpCont.end() != iter ; ++iter ) 
              {
                ChronoEntity*    entity = iter->first  ; if( 0 == entity ) { continue ; } 
                const ChronoTag* tag    = iter->second ; if( 0 == tag    ) { continue ; } 

                entity->stop();              

                if     ( m_chronoCoutFlag )  
                  { std::cout << *tag << "\t"  << entity->outputEllapsedTime() << std::endl ; }
                else                         
                  { 
                    MsgStream log( msgSvc() , *tag ) ;  
                    log << m_chronoPrintLevel << entity->outputEllapsedTime() << endreq ; 
                  }
                //
              }
          }
        tmpCont.clear();   
      }
      if( m_chronoCoutFlag  ) { std::cout << stars << std::endl;              } 
      else                    { log << m_chronoPrintLevel << stars << endreq; }  
    }
  
  if( m_statTableFlag &&  !m_statEntities.empty() )   
    {
      MsgStream log( msgSvc() , "******Stat******" ); 
      const std::string stars( ( m_statCoutFlag ) ? 126 : 100  , '*' ) ;   
      if( m_statCoutFlag  ) 
        { 
          std::cout << stars << std::endl;   
          std::cout << local <<  " The Final stat Table " 
                    << ( m_statOrderFlag ? "(ordered)" : "(not ordered)" ) << std::endl;
          std::cout << stars << std::endl;            
        }
      else 
        {
          log << m_statPrintLevel << stars << endreq; 
          log <<  m_statPrintLevel << " The Final stat Table " 
              << ( m_statOrderFlag ? "(ordered)" : "(not ordered)" ) << endreq;   
          log << m_statPrintLevel << stars << endreq; 
        }  
      {  // prepare container for printing 
        typedef std::pair<const StatEntity*,const StatTag*>  SPair;
        typedef std::vector<SPair>                           SCont;
        SCont tmpCont;
        for( StatMap::const_iterator it = m_statEntities.begin(); it != m_statEntities.end(); it++ ) 
          { tmpCont.push_back( SPair( &(it->second) , &(it->first) ) ) ; } 
        // sort it 
        if( m_statOrderFlag ) 
          { std::sort( tmpCont.begin(), tmpCont.end() , StatEntity::ComparePairOfStatEntityAndStatTag() ); }
        for( SCont::iterator iter = tmpCont.begin() ; tmpCont.end() != iter ; ++iter ) 
          {
            const StatEntity* entity = iter->first  ; if( 0 == entity ) { continue ; } 
            const StatTag*    tag    = iter->second ; if( 0 == tag    ) { continue ; } 

            if ( m_statCoutFlag ) { std::cout << *tag << "\t" << entity->stringOutPut() << std::endl; } 
            else          
              { 
                MsgStream log( msgSvc() , *tag ) ; 
                log << m_statPrintLevel << entity->stringOutPut() << endreq ; 
              } 
          }
        tmpCont.clear();   
      }
      if( m_statCoutFlag  ) { std::cout << stars << std::endl;            } 
      else                  { log << m_statPrintLevel << stars << endreq; }  
    }
  
  log << MSG::INFO << " Service finalized succesfully " << endreq; 
  
  return StatusCode::SUCCESS;
};

StatusCode    ChronoStatSvc::queryInterface(const IID& riid, void** ppvInterface)
{
  if ( IID_IChronoStatSvc == riid ) { *ppvInterface = (IChronoStatSvc*) this             ; }
  else                              { return Service::queryInterface(riid, ppvInterface) ; }
  addRef();
  return StatusCode::SUCCESS;
};

StatusCode    ChronoStatSvc::chronoStart( const ChronoTag& chronoTag )
{
  m_chronoEntities[ chronoTag ].start(); 
  return StatusCode::SUCCESS;
};

StatusCode    ChronoStatSvc::chronoStop ( const IChronoStatSvc::ChronoTag& chronoTag )
{ m_chronoEntities[ chronoTag ].stop(); return StatusCode::SUCCESS; };

StatusCode    ChronoStatSvc::chronoPrint( const IChronoStatSvc::ChronoTag& chronoTag )
{
  MsgStream log ( msgSvc() , chronoTag );
  if( m_printUserTime   ) { log << (MSG::Level) m_chronoPrintLevel 
                                << m_chronoEntities[ chronoTag ].outputUserTime  () << endreq; }
  if( m_printSystemTime ) { log << (MSG::Level) m_chronoPrintLevel 
                                << m_chronoEntities[ chronoTag ].outputSystemTime() << endreq; }
  return StatusCode::SUCCESS;
};

IChronoStatSvc::ChronoStatus ChronoStatSvc::chronoStatus( const IChronoStatSvc::ChronoTag& chronoTag )
{ return m_chronoEntities[ chronoTag ].status(); };


StatusCode    ChronoStatSvc::stat( const IChronoStatSvc::StatTag    & statTag    ,
                                   const IChronoStatSvc::StatFlag   & statFlag   , 
                                   const IChronoStatSvc::StatWeight & statWeight )
{
  StatEntity& se = m_statEntities[ statTag ]; 
  se.addFlagAndWeight( statFlag, statWeight ) ; 
  return StatusCode::SUCCESS;
};

StatusCode    ChronoStatSvc::statPrint( const IChronoStatSvc::StatTag& statTag )
{
  MsgStream log ( msgSvc() , statTag ) ;
  log << (MSG::Level) m_statPrintLevel << m_statEntities[ statTag ].stringOutPut() << endreq; 
  return StatusCode::SUCCESS;
};

---