GenericMonitoringTool Class Reference

#include <GenericMonitoringTool.h>

Inheritance diagram for GenericMonitoringTool:

Collaboration diagram for GenericMonitoringTool:

Classes
class	GenericMonitoringArray
class	GenericMonitoringTool

Public Member Functions
virtual	~GenericMonitoringTool () override
virtual StatusCode	initialize () override
virtual StatusCode	start () override
virtual StatusCode	stop () override
void	handle (const Incident &) override
void	invokeFillers (const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &monitoredVariables) const
	feed the fillers More...
StatusCode	book ()
	Book histograms. More...
void	setPath (const std::string &newPath)
	Overrride configured booking path. More...
const std::string &	getPath () const
virtual const ServiceHandle< ITHistSvc > &	histogramService () const
virtual uint32_t	runNumber ()
virtual uint32_t	lumiBlock ()

Public Attributes
	log = logging.getLogger(__name__)

Private Member Functions
void	invokeFillersDebug (const std::shared_ptr< Monitored::HistogramFiller > &filler, const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &monitoredVariables) const

Private Attributes
ServiceHandle< ITHistSvc >	m_histSvc { this, "THistSvc", "THistSvc", "Histogramming svc" }
	THistSvc (do NOT fix the service type (only the name) to allow for a different implementation online. More...
Gaudi::Property< std::string >	m_histoPath { this, "HistPath", {}, "Directory for histograms [name of parent if not set]" }
Gaudi::Property< std::vector< std::string > >	m_histograms { this, "Histograms", {}, "Definitions of histograms", "OrderedSet<std::string>"}
Gaudi::Property< bool >	m_explicitBooking { this, "ExplicitBooking", false, "Do not create histograms automatically in initialize but wait until the method book is called." }
Gaudi::Property< bool >	m_failOnEmpty { this, "FailOnEmpty", true, "Fail in initialize() if no histograms defined" }
BooleanProperty	m_useCache { this, "UseCache", true, "Cache filler lookups" }
BooleanProperty	m_registerHandler { this, "RegisterHandler", true, "Use incident handler to make 'always book' plots (else only check once)" }
std::vector< std::shared_ptr< Monitored::HistogramFiller > >	m_fillers
	plain list of fillers More...
std::vector< std::shared_ptr< Monitored::HistogramFiller > >	m_alwaysCreateFillers
	fillers that need touching, usually empty More...
std::map< std::vector< std::string >, std::unique_ptr< std::vector< std::shared_ptr< Monitored::HistogramFiller > > >, std::less<> > m_fillerCacheMap	ATLAS_THREAD_SAFE
	lookup map to speed up filler searches More...
std::mutex	m_cacheMutex

Detailed Description

Definition at line 53 of file GenericMonitoringTool.h.

Constructor & Destructor Documentation

~GenericMonitoringTool()

GenericMonitoringTool::~GenericMonitoringTool ( )

overridevirtual

Definition at line 23 of file GenericMonitoringTool.cxx.

{ }

Member Function Documentation

book()

StatusCode GenericMonitoringTool::book

(

)

Book histograms.

Definition at line 56 of file GenericMonitoringTool.cxx.

                                       {
 
  // If no histogram path given use parent or our own name
  if (m_histoPath.empty()) {
    auto named = dynamic_cast<const INamedInterface*>(parent());
    m_histoPath = named ? named->name() : name();
  }
 
  // Replace dot (e.g. MyAlg.MyTool) with slash to create sub-directory
  std::replace( m_histoPath.begin(), m_histoPath.end(), '.', '/' );
 
  ATH_MSG_DEBUG("Booking histograms in path: " << m_histoPath.value());
 
  HistogramFillerFactory factory(this, m_histoPath);
 
  for (const std::string& item : m_histograms) {
    if (item.empty()) {
      ATH_MSG_DEBUG( "Skipping empty histogram definition" );
      continue;
    }
    ATH_MSG_DEBUG( "Configuring monitoring for: " << item );
    HistogramDef def = HistogramDef::parse(item);
 
    if (def.ok) {
      std::shared_ptr<HistogramFiller> filler(factory.create(def));
 
      if (filler) {
        if (def.kAlwaysCreate) {
          if (m_registerHandler) {
            m_alwaysCreateFillers.push_back(filler); // prepare list of fillers for handler
          } else {
            filler->touch(); // create now and be done with it
          }
        }
        m_fillers.push_back(filler);
      } else {
        ATH_MSG_WARNING( "The histogram filler cannot be instantiated for: " << def.name );
      }
    } else {
      ATH_MSG_ERROR( "Unparsable histogram definition: " << item );
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG( "Monitoring for variable " << def.name << " prepared" );
  }
 
  if ( m_fillers.empty() && m_failOnEmpty ) {
    std::string hists;
    for (const auto &h : m_histograms) hists += (h+",");
    ATH_MSG_ERROR("No monitored variables created based on histogram definition: [" << hists <<
                  "] Remove this monitoring tool or check its configuration.");
    return StatusCode::FAILURE;
  }
 
  // are there some histograms that should always be made?
  // then register to be notified on every event
  if (! m_alwaysCreateFillers.empty() && m_registerHandler) {
    ATH_MSG_DEBUG("Registering incident handler");
    SmartIF<IIncidentSvc> incSvc{service("IncidentSvc")};
    ATH_CHECK(incSvc.isValid());
    incSvc->addListener(this, IncidentType::BeginEvent);
  }
 
  return StatusCode::SUCCESS;
}

getPath()

const std::string& GenericMonitoringTool::getPath ( ) const

inline

Definition at line 70 of file GenericMonitoringTool.h.

{ return m_histoPath; }

handle()

void GenericMonitoringTool::handle ( const Incident &  )

override

Definition at line 50 of file GenericMonitoringTool.cxx.

                                                    {
  for (const auto& filler : m_alwaysCreateFillers) {
    filler->touch();
  }
}

histogramService()

virtual const ServiceHandle<ITHistSvc>& GenericMonitoringTool::histogramService ( ) const

inlinevirtual

Definition at line 72 of file GenericMonitoringTool.h.

{ return m_histSvc; }

initialize()

StatusCode GenericMonitoringTool::initialize ( )

overridevirtual

Definition at line 25 of file GenericMonitoringTool.cxx.

                                             {
  ATH_CHECK(m_histSvc.retrieve());
  return StatusCode::SUCCESS;
}

invokeFillers()

void GenericMonitoringTool::invokeFillers

(

const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &

monitoredVariables

)

const

feed the fillers

Definition at line 164 of file GenericMonitoringTool.cxx.

                                                                                                                                      {
  // This is the list of fillers to consider in the invocation.
  // If we are using the cache then this may be a proper subset of m_fillers; otherwise will just be m_fillers
  const std::vector<std::shared_ptr<Monitored::HistogramFiller>>* fillerList{nullptr};
  // do we need to update the cache?
  bool makeCache = false;
  // pointer to list of matched fillers, if we need to update the cache (default doesn't create the vector)
  std::unique_ptr<std::vector<std::shared_ptr<Monitored::HistogramFiller>>> matchedFillerList;
  if (m_useCache) {
    // lock the cache during lookup
    std::scoped_lock cacheguard(m_cacheMutex);
    const auto match = m_fillerCacheMap.find(monitoredVariables);
    if (match != m_fillerCacheMap.end()) {
      fillerList = match->second.get();
    } else {
      fillerList = &m_fillers;
      matchedFillerList = std::make_unique<std::vector<std::shared_ptr<Monitored::HistogramFiller>>>();
      makeCache = true;
    }
  } else {
    fillerList = &m_fillers;
  }
 
  for ( auto filler: *fillerList ) {
    tl_vars.reset();
    const int fillerCardinality = filler->histogramVariablesNames().size() + (filler->histogramWeightName().empty() ? 0: 1) + (filler->histogramCutMaskName().empty() ? 0 : 1);
 
    if ( fillerCardinality == 1 ) { // simplest case, optimising this to be super fast
      for ( auto& var: monitoredVariables ) {
        if ( var.get().name().compare( filler->histogramVariablesNames()[0] ) == 0 )  {
          tl_vars.var[0] = &var.get();
          {
            auto guard{filler->getLock()};
            filler->fill( tl_vars );
          }
          if (makeCache) { 
            matchedFillerList->push_back(filler); 
          }
          break;
        }
      }
    } else { // a more complicated case, and cuts or weights
      int matchesCount = 0;
      for ( const auto& var: monitoredVariables ) {
        bool matched = false;
        for ( unsigned fillerVarIndex = 0; fillerVarIndex < filler->histogramVariablesNames().size(); ++fillerVarIndex ) {
          if ( var.get().name().compare( filler->histogramVariablesNames()[fillerVarIndex] ) == 0 ) {
            tl_vars.set(fillerVarIndex, &var.get());
            matched = true;
            matchesCount++;
            break;
          }
        }
        if ( matchesCount == fillerCardinality ) break;
        if ( not matched ) { // may be a weight or cut variable still
          if ( var.get().name().compare( filler->histogramWeightName() ) == 0 )  {
            tl_vars.weight = &var.get();
            matchesCount ++;
          } else if ( var.get().name().compare( filler->histogramCutMaskName() ) == 0 )  {
            tl_vars.cut = &var.get();
            matchesCount++;
         }
        }
        if ( matchesCount == fillerCardinality ) break;
      }
      if ( matchesCount == fillerCardinality ) {
        {
          auto guard{filler->getLock()};
          filler->fill( tl_vars );
        }
        if (makeCache) { 
          matchedFillerList->push_back(filler); 
        }
      } else if ( ATH_UNLIKELY( matchesCount != 0 ) ) { // something has matched, but not all, worth informing user
        invokeFillersDebug(filler, monitoredVariables);
      }
    }
  }
 
  if (makeCache) {
    // we may hit this multiple times. If another thread has updated the cache in the meanwhile, don't update
    // (or we might delete the fillerList under another thread)
    std::scoped_lock cacheguard(m_cacheMutex);
    const auto match = m_fillerCacheMap.find(monitoredVariables);
    if (match == m_fillerCacheMap.end()) {
      std::vector<std::string> key;
      key.reserve(monitoredVariables.size());
      for (const auto& mv : monitoredVariables) {
        key.push_back(mv.get().name());
      }
      m_fillerCacheMap[key].swap(matchedFillerList);
    }
  }
}

invokeFillersDebug()

void GenericMonitoringTool::invokeFillersDebug ( const std::shared_ptr< Monitored::HistogramFiller > &  filler, const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &  monitoredVariables  ) const

private

Definition at line 259 of file GenericMonitoringTool.cxx.

                                                                                                                                             {
  bool reasonFound = false;
  if (ATH_UNLIKELY(!filler->histogramWeightName().empty() && !tl_vars.weight)) {
    reasonFound = true;
    ATH_MSG_DEBUG("Filler weight not found in monitoredVariables:"
      << "\n  Filler weight               : " << filler->histogramWeightName()
      << "\n  Asked to fill from mon. tl_vars: " << monitoredVariables);
  }
  if (ATH_UNLIKELY(!filler->histogramCutMaskName().empty() && !tl_vars.cut)) {
    reasonFound = true;
    ATH_MSG_DEBUG("Filler cut mask not found in monitoredVariables:"
      << "\n  Filler cut mask             : " << filler->histogramCutMaskName()
      << "\n  Asked to fill from mon. tl_vars: " << monitoredVariables);
  }
  if ( not reasonFound ) {
    ATH_MSG_DEBUG("Filler has different variables than monitoredVariables:"
      << "\n  Filler variables            : " << filler->histogramVariablesNames()
      << "\n  Asked to fill from mon. tl_vars: " << monitoredVariables
      << "\n  Selected monitored variables: " << tl_vars.names() );
  }
}

lumiBlock()

uint32_t GenericMonitoringTool::lumiBlock ( )

virtual

Definition at line 286 of file GenericMonitoringTool.cxx.

                                          {
  return Gaudi::Hive::currentContext().eventID().lumi_block();
}

runNumber()

uint32_t GenericMonitoringTool::runNumber ( )

virtual

Definition at line 282 of file GenericMonitoringTool.cxx.

                                          {
  return Gaudi::Hive::currentContext().eventID().run_number();
}

setPath()

void GenericMonitoringTool::setPath ( const std::string &  newPath )

inline

Overrride configured booking path.

Definition at line 69 of file GenericMonitoringTool.h.

{ m_histoPath = newPath; }

start()

StatusCode GenericMonitoringTool::start ( )

overridevirtual

Definition at line 30 of file GenericMonitoringTool.cxx.

                                        {
  if ( not m_explicitBooking ) {
    ATH_MSG_DEBUG("Proceeding to histogram booking");
    return book();
  }
  return StatusCode::SUCCESS;
}

stop()

StatusCode GenericMonitoringTool::stop ( )

overridevirtual

Definition at line 38 of file GenericMonitoringTool.cxx.

                                       {
  m_alwaysCreateFillers.clear();
  m_fillers.clear();
  if (m_registerHandler) {
    ATH_MSG_DEBUG("Deregistering incident handler");
    SmartIF<IIncidentSvc> incSvc{service("IncidentSvc")};
    ATH_CHECK(incSvc.isValid());
    incSvc->removeListener(this, IncidentType::BeginEvent);
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::map<std::vector<std::string>,std::unique_ptr<std::vector<std::shared_ptr<Monitored::HistogramFiller> > >,std::less<> > m_fillerCacheMap GenericMonitoringTool::ATLAS_THREAD_SAFE

mutableprivate

lookup map to speed up filler searches

Definition at line 91 of file GenericMonitoringTool.h.

log

GenericMonitoringTool.log = logging.getLogger(__name__)

Definition at line 9 of file GenericMonitoringTool.py.

m_alwaysCreateFillers

std::vector<std::shared_ptr<Monitored::HistogramFiller> > GenericMonitoringTool::m_alwaysCreateFillers

private

fillers that need touching, usually empty

Definition at line 90 of file GenericMonitoringTool.h.

m_cacheMutex

std::mutex GenericMonitoringTool::m_cacheMutex

mutableprivate

Definition at line 92 of file GenericMonitoringTool.h.

m_explicitBooking

Gaudi::Property<bool> GenericMonitoringTool::m_explicitBooking { this, "ExplicitBooking", false, "Do not create histograms automatically in initialize but wait until the method book is called." }

private

Definition at line 84 of file GenericMonitoringTool.h.

m_failOnEmpty

Gaudi::Property<bool> GenericMonitoringTool::m_failOnEmpty { this, "FailOnEmpty", true, "Fail in initialize() if no histograms defined" }

private

Definition at line 85 of file GenericMonitoringTool.h.

m_fillers

std::vector<std::shared_ptr<Monitored::HistogramFiller> > GenericMonitoringTool::m_fillers

private

plain list of fillers

Definition at line 89 of file GenericMonitoringTool.h.

m_histograms

Gaudi::Property<std::vector<std::string> > GenericMonitoringTool::m_histograms { this, "Histograms", {}, "Definitions of histograms", "OrderedSet<std::string>"}

private

Definition at line 83 of file GenericMonitoringTool.h.

m_histoPath

Gaudi::Property<std::string> GenericMonitoringTool::m_histoPath { this, "HistPath", {}, "Directory for histograms [name of parent if not set]" }

private

Definition at line 82 of file GenericMonitoringTool.h.

m_histSvc

ServiceHandle<ITHistSvc> GenericMonitoringTool::m_histSvc { this, "THistSvc", "THistSvc", "Histogramming svc" }

private

THistSvc (do NOT fix the service type (only the name) to allow for a different implementation online.

Definition at line 81 of file GenericMonitoringTool.h.

m_registerHandler

BooleanProperty GenericMonitoringTool::m_registerHandler { this, "RegisterHandler", true, "Use incident handler to make 'always book' plots (else only check once)" }

private

Definition at line 87 of file GenericMonitoringTool.h.

m_useCache

BooleanProperty GenericMonitoringTool::m_useCache { this, "UseCache", true, "Cache filler lookups" }

private

Definition at line 86 of file GenericMonitoringTool.h.

---

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

• GenericMonitoringTool.h
• GenericMonitoringTool.py
• GenericMonitoringTool.cxx