ValgrindAuditor Class Reference

Valgrind auditor. More...

#include <ValgrindAuditor.h>

Inheritance diagram for ValgrindAuditor:

Collaboration diagram for ValgrindAuditor:

Public Member Functions
	ValgrindAuditor (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~ValgrindAuditor ()
virtual StatusCode	initialize () override
virtual void	handle (const Incident &incident) override
	Incident handler.

Auditor hooks
typedef std::pair< boost::regex, std::string >	NameEvt
	Typedef for algorithm/event pair, e.g. ("MyAlg","initialize")
ServiceHandle< IValgrindSvc >	m_valSvc
	Handle to ValgrindSvc.
std::vector< std::string >	m_algs
	List of algorithms to profile.
std::vector< std::string >	m_intervals
	List of auditor intervals to profile.
unsigned int	m_ignoreFirstNEvents
	Don't profile on the first N events.
bool	m_dumpAfterEachInterval
	Dump profile after each interval.
unsigned int	m_eventCounter
	Internal event counter for BeginEvent incident.
std::vector< boost::regex >	m_algsRegEx
	Regular expressions for algorithm name matching.
std::vector< std::pair< NameEvt, NameEvt > >	m_hooks
	Internal storage of intervals.
virtual void	before (const std::string &event, const std::string &name, const EventContext &ctx) override
virtual void	after (const std::string &event, const std::string &name, const EventContext &ctx, const StatusCode &sc) override
virtual void	do_beforeExecute (const std::string &name)
	Start callgrind instrumentation.
virtual void	do_afterExecute (const std::string &name)
	Stop callgrind instrumentation.
void	do_before (const std::string &name, const std::string &hook)
void	do_after (const std::string &name, const std::string &hook)
StatusCode	decodeIntervals ()
bool	algMatch (const std::string &name)

Detailed Description

Valgrind auditor.

Gaudi auditor to programmatically control valgrind. Currently only callgrind controls are implemented. Turns callgrind instrumentation on/off before/afterExecute.

Author

Frank Winklmeier

Definition at line 34 of file ValgrindAuditor.h.

Member Typedef Documentation

NameEvt

typedef std::pair<boost::regex,std::string> ValgrindAuditor::NameEvt

Typedef for algorithm/event pair, e.g. ("MyAlg","initialize")

Definition at line 64 of file ValgrindAuditor.h.

Constructor & Destructor Documentation

ValgrindAuditor()

ValgrindAuditor::ValgrindAuditor	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 24 of file ValgrindAuditor.cxx.

  : Auditor(name, pSvcLocator),
    m_valSvc("ValgrindSvc", this->name()),
    m_eventCounter(0)
{
  declareProperty("ProfiledAlgs", m_algs,
                  "List of algorithms to run in valgrind");
 
  declareProperty("ProfiledIntervals", m_intervals,
                  "Intervals to profile (e.g. 'MyAlg.initialize:MyAlg.finalize'" );
 
  declareProperty("IgnoreFirstNEvents", m_ignoreFirstNEvents = 0,
                  "Do not profile the first N events");
 
  declareProperty("DumpAfterEachInterval", m_dumpAfterEachInterval = true,
                  "Dump separate profile after each interval in ProfiledIntervals" );
}

~ValgrindAuditor()

ValgrindAuditor::~ValgrindAuditor ( )

virtual

Definition at line 44 of file ValgrindAuditor.cxx.

{
}

Member Function Documentation

after()

void ValgrindAuditor::after ( const std::string & event, const std::string & name, const EventContext & ctx, const StatusCode & sc )

overridevirtual

Definition at line 170 of file ValgrindAuditor.cxx.

{
  if ( event == IAuditor::Execute ) do_afterExecute(name);
  else do_after(name, boost::to_lower_copy(event));
}

algMatch()

bool ValgrindAuditor::algMatch ( const std::string & name )

private

Definition at line 314 of file ValgrindAuditor.cxx.

{
  std::vector<boost::regex>::const_iterator iter;
  for ( iter=m_algsRegEx.begin(); iter!=m_algsRegEx.end(); ++iter ) {
    if ( boost::regex_match(name,*iter) ) return true;
  }
  return false;
}

before()

void ValgrindAuditor::before ( const std::string & event, const std::string & name, const EventContext & ctx )

overridevirtual

Definition at line 163 of file ValgrindAuditor.cxx.

{
  if ( event == IAuditor::Execute ) do_beforeExecute(name);
  else do_before(name, boost::to_lower_copy(event));
}

decodeIntervals()

StatusCode ValgrindAuditor::decodeIntervals ( )

private

Definition at line 279 of file ValgrindAuditor.cxx.

{  
  m_hooks.clear();
  m_hooks.reserve(m_intervals.size());
  
  std::vector<string>::const_iterator iter = m_intervals.begin();
  for (; iter!=m_intervals.end(); ++iter) {
    const string& spec = *iter;
    string::size_type loc = spec.find(':');
 
    // If there is no delimiter interpret as [a,a]
    string s1, s2;
    if (loc==string::npos) s1 = s2 = spec;
    else {  // Extract interval
      s1 = spec.substr(0,loc);
      s2 = spec.substr(loc+1);
    }
 
    NameEvt ne1, ne2;
    if ( s1=="" || s2=="" ||
         decodeNameEvt(s1,ne1).isFailure() || decodeNameEvt(s2,ne2).isFailure() ) {
      msgStream() << MSG::ERROR << "Invalid profiling interval [" << spec << "]" << endmsg;
      return StatusCode::FAILURE;
    }
 
    std::pair<NameEvt,NameEvt> p(ne1,ne2);
    m_hooks.emplace_back(std::move(p));
  }
 
  return StatusCode::SUCCESS;
}

do_after()

void ValgrindAuditor::do_after ( const std::string & name, const std::string & hook )

private

Definition at line 232 of file ValgrindAuditor.cxx.

{
  std::vector< std::pair<NameEvt,NameEvt> >::const_iterator iter;
 
  for (iter=m_hooks.begin(); iter!=m_hooks.end(); ++iter) {
    if ( boost::regex_match(name, iter->second.first) &&
         iter->second.second == hook ) {
      m_valSvc->callgrindStopInstrumentation();
      if ( msgLevel() <= MSG::DEBUG )
        msgStream() << MSG::DEBUG << "Stopping callgrind after " << hook
                    << " of " << name << endmsg;
 
      if ( m_dumpAfterEachInterval ) {
        m_valSvc->callgrindDumpStats(msgStream().stream());
        msgStream() << MSG::INFO << "Creating callgrind profile #" << m_valSvc->profileCount()
                    << " after " << hook << " of " << name << endmsg;
      }
    }
  }
}

do_afterExecute()

void ValgrindAuditor::do_afterExecute ( const std::string & name )

virtual

Stop callgrind instrumentation.

Definition at line 198 of file ValgrindAuditor.cxx.

{
  if ( algMatch(name) ) {
    if (m_eventCounter > m_ignoreFirstNEvents) {
      m_valSvc->callgrindStopInstrumentation();      
      if ( msgLevel() <= MSG::DEBUG )
        msgStream() << MSG::DEBUG << "Stopping callgrind after execute of " << name
                    << " [event #" << m_eventCounter << "]" << endmsg;
    }
  }
}

do_before()

void ValgrindAuditor::do_before ( const std::string & name, const std::string & hook )

private

Definition at line 214 of file ValgrindAuditor.cxx.

{
  std::vector< std::pair<NameEvt,NameEvt> >::const_iterator iter;
 
  for (iter=m_hooks.begin(); iter!=m_hooks.end(); ++iter) {
    if ( boost::regex_match(name, iter->first.first) &&
         iter->first.second == hook ) {
      m_valSvc->callgrindStartInstrumentation();
      if ( msgLevel() <= MSG::DEBUG )
        msgStream() << MSG::DEBUG << "Starting callgrind before " << hook
                    << " of " << name << endmsg;
    }
  }
}

do_beforeExecute()

void ValgrindAuditor::do_beforeExecute ( const std::string & name )

virtual

Start callgrind instrumentation.

Definition at line 181 of file ValgrindAuditor.cxx.

{
  if ( algMatch(name) ) {
    if (m_eventCounter > m_ignoreFirstNEvents) {
      if ( msgLevel() <= MSG::DEBUG )
        msgStream() << MSG::DEBUG << "Starting callgrind before execute of " << name
                    << " [event #" << m_eventCounter << "]" << endmsg;
      
      m_valSvc->callgrindStartInstrumentation();
    }
  }
}

handle()

void ValgrindAuditor::handle ( const Incident & incident )

overridevirtual

Incident handler.

Definition at line 144 of file ValgrindAuditor.cxx.

{
  // Internal event counter
  if ( inc.type() == IncidentType::BeginEvent ) {
    m_eventCounter++;
  }
 
  // Check if the incident appears at beginning or end of interval
  std::vector< std::pair<NameEvt,NameEvt> >::const_iterator h;
  for (h=m_hooks.begin(); h!=m_hooks.end(); ++h) {
    if ( h->first.second=="incident" ) do_before(inc.type(), "incident");
    if ( h->second.second=="incident" ) do_after(inc.type(), "incident");
  }
}

initialize()

StatusCode ValgrindAuditor::initialize ( )

overridevirtual

Definition at line 49 of file ValgrindAuditor.cxx.

{
  if ( !m_valSvc.retrieve().isSuccess())  {
    msgStream() << MSG::ERROR << "Could not retrieve the ValgrindSvc" << endmsg;
    return StatusCode::FAILURE;
  }
 
  const IProperty* valSvcProp = dynamic_cast<const IProperty*>(&(*m_valSvc));
  if ( !valSvcProp ) {
    msgStream() << MSG::ERROR
                << "Could not retrieve IProperty interface to ValgrindSvc."
                << endmsg;
    return StatusCode::FAILURE;
  }
 
  // We inherit the OutputLevel from ValgrindSvc
  ATH_CHECK(setProperty(valSvcProp->getProperty("OutputLevel")));
 
  msgStream() << MSG::VERBOSE
              << "Initializing " << name() << "..." 
              << endmsg;
 
  // Copy some properties from ValgrindSvc
  std::string properties[] = {"ProfiledAlgs",
                              "ProfiledIntervals",
                              "IgnoreFirstNEvents",
                              "DumpAfterEachInterval"};
 
  for( std::string prop : properties ) {
    if ( !setProperty(valSvcProp->getProperty(prop)) ) {
      msgStream() << MSG::ERROR << "Cannot set " << prop << " property." << endmsg;
      return StatusCode::FAILURE;
    }     
  }
 
  // Reset internal event counter
  m_eventCounter = 0;
 
  // Create regular expressions from algorithm names
  for( const std::string& re : m_algs ) {
    try {
      m_algsRegEx.push_back( boost::regex(re) );
    }
    catch ( const boost::regex_error& ) {
      msgStream() << MSG::ERROR << "Ignoring invalid regular expression: " << re << endmsg;
    }
  }
    
  if ( msgLevel() <= MSG::INFO ) {
    std::ostringstream out;
    out << "[ ";
    std::copy( m_algs.begin(), m_algs.end(),
               std::ostream_iterator<std::string>( out, " " ) );
    out << "]";
    msgStream() << MSG::INFO << "Profiled algorithms: " << out.str() << endmsg;
 
    out.str("");
    out << "[ ";
    std::copy( m_intervals.begin(), m_intervals.end(),
               std::ostream_iterator<std::string>( out, " " ) );
    out << "]";
    msgStream() << MSG::INFO << "Profiled intervals: " << out.str() << endmsg;
  }
 
  if (!m_intervals.empty()) {
    if ( decodeIntervals().isFailure() ) {
      msgStream() << MSG::ERROR << "Syntax error in ProfiledIntervals" << endmsg;
      return StatusCode::FAILURE;
    }
  }
 
  // Register incidents
  ServiceHandle<IIncidentSvc> incSvc("IncidentSvc", this->name());
  if ( !incSvc.retrieve().isSuccess() ) {
    msgStream() << MSG::ERROR << "Unable to get the IncidentSvc" << endmsg;
    return StatusCode::FAILURE;
  }
  // Try to be the first incident handler to be called
  const long prio = std::numeric_limits<long>::max();
  
  incSvc->addListener( this, IncidentType::BeginEvent, prio );
 
  for( const std::pair<NameEvt,NameEvt>& h : m_hooks ) {
    // No regular expressions allowed for incidents. Take the original string.
    if ( h.first.second=="incident" ) incSvc->addListener( this, h.first.first.str(), prio );
    if ( h.second.second=="incident" ) incSvc->addListener( this, h.second.first.str(), prio );      
  }
  
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_algs

std::vector<std::string> ValgrindAuditor::m_algs

private

List of algorithms to profile.

Definition at line 72 of file ValgrindAuditor.h.

m_algsRegEx

std::vector<boost::regex> ValgrindAuditor::m_algsRegEx

private

Regular expressions for algorithm name matching.

Definition at line 87 of file ValgrindAuditor.h.

m_dumpAfterEachInterval

bool ValgrindAuditor::m_dumpAfterEachInterval

private

Dump profile after each interval.

Definition at line 81 of file ValgrindAuditor.h.

m_eventCounter

unsigned int ValgrindAuditor::m_eventCounter

private

Internal event counter for BeginEvent incident.

Definition at line 84 of file ValgrindAuditor.h.

m_hooks

std::vector< std::pair<NameEvt,NameEvt> > ValgrindAuditor::m_hooks

private

Internal storage of intervals.

Definition at line 90 of file ValgrindAuditor.h.

m_ignoreFirstNEvents

unsigned int ValgrindAuditor::m_ignoreFirstNEvents

private

Don't profile on the first N events.

Definition at line 78 of file ValgrindAuditor.h.

m_intervals

std::vector<std::string> ValgrindAuditor::m_intervals

private

List of auditor intervals to profile.

Definition at line 75 of file ValgrindAuditor.h.

m_valSvc

ServiceHandle<IValgrindSvc> ValgrindAuditor::m_valSvc

private

Handle to ValgrindSvc.

Definition at line 69 of file ValgrindAuditor.h.

---

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

• ValgrindAuditor.h
• ValgrindAuditor.cxx