VTuneProfilerService Class Reference

#include <VTuneProfilerService.h>

Inheritance diagram for VTuneProfilerService:

Collaboration diagram for VTuneProfilerService:

Public Member Functions
	VTuneProfilerService (const std::string &name, ISvcLocator *svcloc)
	Standard Gaudi service constructor. More...
virtual StatusCode	initialize () override
	Standard Gaudi initialization function. More...
virtual StatusCode	resumeProfiling () override
	Resume profiling. More...
virtual StatusCode	pauseProfiling () override
	Pause profiling. More...
virtual bool	isProfilingRunning () const override
	Is the profiling running at the moment? More...
virtual void	handle (const Incident &inc) override
	Function handling incoming incidents. More...

Private Attributes
ServiceHandle< IIncidentSvc >	m_incidentSvc
	Handle to the incident service. More...
int	m_resumeEvent
	Property: Event in which profiling should start. More...
int	m_pauseEvent
	Property: Event in which profiling should pause. More...
std::vector< std::string >	m_algs
	Property: List of algorithms to profile. More...
std::unique_ptr< VTuneProfileRunner >	m_runner
	Unique ptr to the VTuneProfileRunner. More...
std::atomic< int >	m_processedEvents
	Number of events processed so far. More...
std::mutex	m_mutex

Detailed Description

Definition at line 27 of file VTuneProfilerService.h.

Constructor & Destructor Documentation

VTuneProfilerService()

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

Standard Gaudi service constructor.

Constructor.

Definition at line 21 of file VTuneProfilerService.cxx.

  : base_class( name, svcloc ),
    m_incidentSvc( "IncidentSvc", name ),
     m_processedEvents( 0 )  {
 
      declareProperty( "ResumeEvent", m_resumeEvent = 0,
                       "Event in which to resume the profiling." );
      declareProperty( "PauseEvent", m_pauseEvent = -1,
                       "Event in which to pause the profiling. Negative number "
                       "profiles the entire event-loop." );
      declareProperty( "ProfiledAlgs", m_algs,
                       "List of profiled algorithms." );
 
}

Member Function Documentation

handle()

void VTuneProfilerService::handle ( const Incident &  inc )

overridevirtual

Function handling incoming incidents.

Handle when to resume/pause the profiling.

Definition at line 122 of file VTuneProfilerService.cxx.

                                                       {
 
  // Use incidents only if there is no auditor
  // Next step is to get rid of the incidents altogether
  if ( !m_algs.empty() ) return;
 
  //
  // Pause the profiling after the last event
  //
  if( inc.type() == ENDEVTLOOP_INCIDENT_NAME ) {
    if( m_runner ) {
      if( pauseProfiling().isFailure() ) {
        REPORT_MESSAGE( MSG::ERROR )
           << "Could not pause the profiling";
      }
    }
    return;
  }
 
  //
  // Resume/Pause the profiling on the right event
  //
  if( inc.type() == BEGINEVENT_INCIDENT_NAME ) {
     if( m_resumeEvent == m_processedEvents &&
         !m_runner ) {
        std::lock_guard<std::mutex> lock(m_mutex);
        //double checked locking pattern 
        //https://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf
        //cppcheck-suppress identicalInnerCondition
        if (!m_runner) {
        if( resumeProfiling().isFailure() ) {
           REPORT_MESSAGE( MSG::ERROR )
              << "Could not resume the profiling";
        }
        }
     }
     ++m_processedEvents;
     return;
  }
  else if( inc.type() == ENDEVENT_INCIDENT_NAME ) {
     if( m_pauseEvent == m_processedEvents && m_runner) {
        std::lock_guard<std::mutex> lock(m_mutex);
        //double checked locking pattern 
        //https://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf
        //cppcheck-suppress identicalInnerCondition
        if (m_runner) {
        if( pauseProfiling().isFailure() &&
            m_runner ) {
           REPORT_MESSAGE( MSG::ERROR )
              << "Could not pause the profiling";
        }
        }
     }
     return;
  }
 
  // Complain if we received an incident that we didn't expect:
  ATH_MSG_WARNING( "Wrong incident type received: " << inc.type() );
  return;
 
}

initialize()

StatusCode VTuneProfilerService::initialize ( )

overridevirtual

Standard Gaudi initialization function.

Initalize the service.

Definition at line 39 of file VTuneProfilerService.cxx.

                                            {
 
  // Print information
  ATH_MSG_INFO( "Initializing VTuneProfilerService" );
 
  // Use the auditor if a list of algorithms is provided
  if(!m_algs.empty()) {
 
    // Resume/Pause event don't work in conjuction w/ a list of algorithms
    ATH_MSG_INFO("ResumeEvent/PauseEvent don't work in conjuction with ProfiledAlgs. " <<
                 "Execute methods of all provided algorithms will be sampled in all events." );
 
    // Create the auditor
    ATH_CHECK( auditorSvc()->addAuditor("VTuneAuditor") );
  }
 
  // Set up listening to the incidents
  CHECK( m_incidentSvc.retrieve() );
  m_incidentSvc->addListener( this, BEGINEVENT_INCIDENT_NAME );
  m_incidentSvc->addListener( this, ENDEVENT_INCIDENT_NAME   );
  m_incidentSvc->addListener( this, ENDEVTLOOP_INCIDENT_NAME );
 
  // Reset the event counter:
  m_processedEvents = 0;
 
  return StatusCode::SUCCESS;
 
}

isProfilingRunning()

bool VTuneProfilerService::isProfilingRunning ( ) const

overridevirtual

Is the profiling running at the moment?

Is the profiling running?

Definition at line 113 of file VTuneProfilerService.cxx.

                                                    {
 
  return (m_runner!=nullptr);
 
}

pauseProfiling()

StatusCode VTuneProfilerService::pauseProfiling ( )

overridevirtual

Pause profiling.

Pause the profiling.

Definition at line 92 of file VTuneProfilerService.cxx.

                                                {
 
  // Check whether the profiling is already running:
  if( !m_runner ) {
    ATH_MSG_INFO( "VTune profiling is not running!" );
    return StatusCode::SUCCESS;
  }
 
  // Print information
  ATH_MSG_INFO( "Stopping VTune profiling." );
 
  // Pause VTune
  m_runner.reset();
 
  return StatusCode::SUCCESS;
 
}

resumeProfiling()

StatusCode VTuneProfilerService::resumeProfiling ( )

overridevirtual

Resume profiling.

Resume the profiling.

Definition at line 71 of file VTuneProfilerService.cxx.

                                                 {
 
  // Check whether the profiling is already running:
  if( m_runner ) {
    ATH_MSG_INFO( "VTune profiling already running!" );
    return StatusCode::SUCCESS;
  }
 
  // Print information
  ATH_MSG_INFO( "Starting VTune profiling." );
 
  // Resume VTune
  m_runner = std::make_unique< VTuneProfileRunner >();
 
  return StatusCode::SUCCESS;
 
}

Member Data Documentation

m_algs

std::vector<std::string> VTuneProfilerService::m_algs

private

Property: List of algorithms to profile.

Definition at line 63 of file VTuneProfilerService.h.

m_incidentSvc

ServiceHandle< IIncidentSvc > VTuneProfilerService::m_incidentSvc

private

Handle to the incident service.

Definition at line 54 of file VTuneProfilerService.h.

m_mutex

std::mutex VTuneProfilerService::m_mutex

private

Definition at line 71 of file VTuneProfilerService.h.

m_pauseEvent

int VTuneProfilerService::m_pauseEvent

private

Property: Event in which profiling should pause.

Definition at line 60 of file VTuneProfilerService.h.

m_processedEvents

std::atomic<int> VTuneProfilerService::m_processedEvents

private

Number of events processed so far.

Definition at line 69 of file VTuneProfilerService.h.

m_resumeEvent

int VTuneProfilerService::m_resumeEvent

private

Property: Event in which profiling should start.

Definition at line 57 of file VTuneProfilerService.h.

m_runner

std::unique_ptr< VTuneProfileRunner > VTuneProfilerService::m_runner

private

Unique ptr to the VTuneProfileRunner.

Definition at line 66 of file VTuneProfilerService.h.

---

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

• VTuneProfilerService.h
• VTuneProfilerService.cxx