GPT::ProfilerService Class Reference

Implementation of the IProfilerSvc interface. More...

#include <ProfilerService.h>

Inheritance diagram for GPT::ProfilerService:

Collaboration diagram for GPT::ProfilerService:

Public Member Functions
	ProfilerService (const std::string &name, ISvcLocator *svcloc)
	Standard Gaudi service constructor.
virtual	~ProfilerService ()
	Destructor.
virtual StatusCode	initialize () override
	Standard Gaudi initialization function.
virtual StatusCode	finalize () override
	Standard Gaudi finalization function.
virtual StatusCode	startCPUProfiling (const std::string &filename) override
	Start GPT profiling.
virtual StatusCode	stopCPUProfiling () override
	Stop the GPT profiling.
virtual bool	isCPUProfilingRunning () const override
	Is the GPT profiling running at the moment?
virtual void	handle (const Incident &inc) override
	Function handling incoming incidents.

Private Attributes
ServiceHandle< IIncidentSvc >	m_incidentSvc
	Handle to the incident service.
bool	m_controlledProfiling
	Property: Is profiling controlled from the outside?
int	m_initEvent
	Property: Event in which non-controlled profiling should start.
std::string	m_profFileName
	Property: Profile file name in non-controlled profiling.
bool	m_running
	Is the CPU profiling running at the moment?
std::string	m_fileName
	Name of the current profile file.
int	m_processedEvents
	Number of events processed so far.

Detailed Description

Implementation of the IProfilerSvc interface.

   This service should be the only component talking directly with
   the GPT functions. Every other component should interact with
   GPT through this service.

Author

Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h

Definition at line 33 of file ProfilerService.h.

Constructor & Destructor Documentation

ProfilerService()

GPT::ProfilerService::ProfilerService	(	const std::string &	name,
		ISvcLocator *	svcloc )

Standard Gaudi service constructor.

Definition at line 27 of file ProfilerService.cxx.

      : base_class( name, svcloc ),
        m_incidentSvc( "IncidentSvc", name ),
        m_running( false ), m_fileName( "" ), m_processedEvents( 0 ) {
 
      declareProperty( "ControlledProfiling", m_controlledProfiling = false,
                       "Will the service be controlled by another component?" );
      declareProperty( "InitEvent", m_initEvent = -1,
                       "Event in which to start the profiling. Negative number "
                       "profiles the entire job." );
      declareProperty( "ProfileFileName", m_profFileName = "gpt.profile",
                       "Profile file name in con-controlled mode." );
   }

~ProfilerService()

GPT::ProfilerService::~ProfilerService ( )

virtual

Destructor.

Definition at line 41 of file ProfilerService.cxx.

                                     {
 
      // Stop the CPU profiling at this point if it's still running:
      if( m_running ) {
         stop().ignore();
      }
   }

Member Function Documentation

finalize()

StatusCode GPT::ProfilerService::finalize ( )

overridevirtual

Standard Gaudi finalization function.

Definition at line 81 of file ProfilerService.cxx.

                                        {
 
      ATH_MSG_INFO( "Finalizing GPT::ProfilerService" );
 
      // The profiling should only be stopped in the destructor even if we
      // are not under user control...
 
      return StatusCode::SUCCESS;
   }

handle()

void GPT::ProfilerService::handle ( const Incident & inc )

overridevirtual

Function handling incoming incidents.

The event loop is profiled by listening to incidents coming from the event loop manager.

This function is called every time an "interesting" incident happens.

Parameters

inc	The incident that happened

Definition at line 167 of file ProfilerService.cxx.

                                                     {
 
      //
      // Stop the profiling after the last event, if we are only profiling
      // the event loop:
      //
      if( ( inc.type() == ENDEVTLOOP_INCIDENT_NAME ) &&
          ( ! m_controlledProfiling ) &&
          ( m_initEvent >= 0 ) ) {
         if( stopCPUProfiling().isFailure() ) {
            REPORT_MESSAGE( MSG::ERROR )
               << "Could not stop the CPU profiling";
         }
         return;
      }
 
      //
      // Start the profiling if we only profile the event loop,
      // and we're in the correct event:
      //
      if( ( inc.type() == BEGINEVENT_INCIDENT_NAME ) &&
          ( ! m_controlledProfiling ) ) {
         if( m_initEvent == m_processedEvents ) {
            if( startCPUProfiling( m_profFileName ).isFailure() ) {
               REPORT_MESSAGE( MSG::ERROR )
                  << "Could not start the CPU profiling";
            }
         }
         ++m_processedEvents;
         return;
      }
 
      // Complain if we received an incident that we didn't expect:
      ATH_MSG_WARNING( "Wrong incident type received: " << inc.type() );
      return;
   }

initialize()

StatusCode GPT::ProfilerService::initialize ( )

overridevirtual

Standard Gaudi initialization function.

Definition at line 49 of file ProfilerService.cxx.

                                          {
 
      ATH_MSG_INFO( "Initializing GPT::ProfilerService" );
 
      // Don't do anything fancy if the profiling is under user control, just
      // remind the user of it:
      if( m_controlledProfiling ) {
         ATH_MSG_INFO( "  Profiling is under user control" );
         return StatusCode::SUCCESS;
      }
 
      // Start the profiling at this point if full-job profiling is requested:
      if( m_initEvent < 0 ) {
 
         CHECK( startCPUProfiling( m_profFileName ) );
 
      } else {
 
         // Set up listening to the incidents only if we are profiling the
         // event loop with this service:
         CHECK( m_incidentSvc.retrieve() );
         m_incidentSvc->addListener( this, BEGINEVENT_INCIDENT_NAME );
         m_incidentSvc->addListener( this, ENDEVTLOOP_INCIDENT_NAME );
 
      }
 
      // Reset the event counter:
      m_processedEvents = 0;
 
      return StatusCode::SUCCESS;
   }

isCPUProfilingRunning()

bool GPT::ProfilerService::isCPUProfilingRunning ( ) const

overridevirtual

Is the GPT profiling running at the moment?

This function can be used to ask the service whether CPU profiling is running at the moment.

Returns

true if the profiling is running at the moment, false otherwise

Definition at line 155 of file ProfilerService.cxx.

                                                     {
 
      return m_running;
   }

startCPUProfiling()

StatusCode GPT::ProfilerService::startCPUProfiling ( const std::string & filename )

overridevirtual

Start GPT profiling.

This function can be used to start the profiling, collecting the data into a file with the specified name.

Parameters

filename

Name of the GPT profile file

Returns

StatusCode::SUCCESS if the operation was successful, something else otherwise

Definition at line 99 of file ProfilerService.cxx.

                                                                            {
 
      // Check whether the CPU profiling is already running:
      if( m_running ) {
         CHECK( stopCPUProfiling() );
      }
 
      // Tell the user what's happening:
      ATH_MSG_INFO( "Starting CPU profiling using output file: " << filename );
 
      // Remember the profile file name:
      m_fileName = filename;
 
      // Start the Google profiler:
      ProfilerStart( m_fileName.c_str() );
 
      // Remember that we are in a running state:
      m_running = true;
 
      return StatusCode::SUCCESS;
   }

stopCPUProfiling()

StatusCode GPT::ProfilerService::stopCPUProfiling ( )

overridevirtual

Stop the GPT profiling.

This function should be called to stop the CPU profiling.

Returns

StatusCode::SUCCESS if the operation was successful, something else otherwise

Definition at line 127 of file ProfilerService.cxx.

                                                {
 
      // This should not be called when we are not running:
      if( ! m_running ) {
         REPORT_MESSAGE( MSG::ERROR )
            << "CPU profiling not running at the time of call";
         return StatusCode::RECOVERABLE;
      }
 
      // Stop the profiler:
      ProfilerStop();
 
      // Tell the user what happened:
      ATH_MSG_INFO( "Stopped CPU profiling using output file: " << m_fileName );
 
      // Remember that we are not running anymore:
      m_running = false;
 
      return StatusCode::SUCCESS;
   }

Member Data Documentation

m_controlledProfiling

bool GPT::ProfilerService::m_controlledProfiling

private

Property: Is profiling controlled from the outside?

Definition at line 63 of file ProfilerService.h.

m_fileName

std::string GPT::ProfilerService::m_fileName

private

Name of the current profile file.

Definition at line 72 of file ProfilerService.h.

m_incidentSvc

ServiceHandle< IIncidentSvc > GPT::ProfilerService::m_incidentSvc

private

Handle to the incident service.

Definition at line 60 of file ProfilerService.h.

m_initEvent

int GPT::ProfilerService::m_initEvent

private

Property: Event in which non-controlled profiling should start.

Definition at line 65 of file ProfilerService.h.

m_processedEvents

int GPT::ProfilerService::m_processedEvents

private

Number of events processed so far.

Definition at line 75 of file ProfilerService.h.

m_profFileName

std::string GPT::ProfilerService::m_profFileName

private

Property: Profile file name in non-controlled profiling.

Definition at line 67 of file ProfilerService.h.

m_running

bool GPT::ProfilerService::m_running

private

Is the CPU profiling running at the moment?

Definition at line 70 of file ProfilerService.h.

---

The documentation for this class was generated from the following files:

• ProfilerService.h
• ProfilerService.cxx