Concrete implementation of Monitor to monitor utilisation of individual threads in a MT job. More...

#include <MonitorThreadOccupancy.h>

Inheritance diagram for MonitorThreadOccupancy:

Collaboration diagram for MonitorThreadOccupancy:

Public Member Functions
	MonitorThreadOccupancy ()=delete
	Forbid default constructor. More...

	MonitorThreadOccupancy (const std::string &name, const MonitoredRange *parent)
	Construct monitor. More...

virtual	~MonitorThreadOccupancy ()=default
	Default destructor. More...

MonitorThreadOccupancy &	operator= (const MonitorThreadOccupancy &)=delete
	Forbid assignment. More...

	MonitorThreadOccupancy (const MonitorThreadOccupancy &)=delete
	Forbid copy. More...

virtual StatusCode	newEvent (const CostData &data, const float weight=1.) override
	Concrete dispatch method. More...

virtual std::unique_ptr< CounterBase >	newCounter (const std::string &name) override
	Concrete counter instantiation. More...

StatusCode	postProcess (float weight)
	Get the global start and stop timestamps over all threads and sync these to the individual threads. More...

const std::string &	getName () const
	Getter for Monitor's name. More...

const MonitoredRange *	getParent () const
	Return cached non-owning const ptr to this Monitor's parent Range. More...

TH1 *	bookGetPointer (TH1 *hist, const std::string &tDir="") const
	Appends Monitor name (to histogram path) and forwards histogram book request to parent Range. More...

bool	counterExists (const std::string &name) const
	Check if a counter of a given name exists. More...

CounterBase *	getCounter (const std::string &name)
	Retrieve counter by name. More...

virtual StatusCode	endEvent (float weight=1.)
	Called by the framework. More...

MsgStream &	msg ()
	Logging. More...

MsgStream &	msg (const MSG::Level lvl)
	Logging on a given level. More...

bool	msgLvl (const MSG::Level lvl)
	Returns if requested level is same or higher than logging level. More...

Public Attributes
std::unordered_map< uint32_t, std::string >	m_threadToCounterMap
	Map thread's hash ID to a counting numeral embedded in a string. More...

size_t	m_threadCounter
	Count how many unique thread ID we have seen. More...

Protected Attributes
std::unordered_map< std::string, std::unique_ptr< CounterBase > >	m_counters
	Storage of Monitor's collection of Counters. More...

MsgStream	m_msgStream
	Logging member. More...

Private Attributes
const std::string	m_name
	Monitor's name. More...

const MonitoredRange *	m_parent
	Monitor's parent Range. More...

Detailed Description

Concrete implementation of Monitor to monitor utilisation of individual threads in a MT job.

Definition at line 14 of file MonitorThreadOccupancy.h.

Constructor & Destructor Documentation

◆ MonitorThreadOccupancy() [1/3]

MonitorThreadOccupancy::MonitorThreadOccupancy ( )

delete

Forbid default constructor.

◆ MonitorThreadOccupancy() [2/3]

MonitorThreadOccupancy::MonitorThreadOccupancy	(	const std::string &	name,
		const MonitoredRange *	parent
	)

Construct monitor.

Parameters

[in]	name	Monitor's name
[in]	parent	Monitor's parent Range, cached non-owning pointer.

Definition at line 8 of file MonitorThreadOccupancy.cxx.

   : MonitorBase(name, parent),
   m_threadToCounterMap(),
   m_threadCounter(0) {}

◆ ~MonitorThreadOccupancy()

virtual MonitorThreadOccupancy::~MonitorThreadOccupancy ( )

virtualdefault

Default destructor.

◆ MonitorThreadOccupancy() [3/3]

MonitorThreadOccupancy::MonitorThreadOccupancy ( const MonitorThreadOccupancy & )

delete

Forbid copy.

Member Function Documentation

◆ bookGetPointer()

TH1 * MonitorBase::bookGetPointer	(	TH1 *	hist,
		const std::string &	tDir = `""`
	)		const

inherited

Appends Monitor name (to histogram path) and forwards histogram book request to parent Range.

Parameters

[in]	hist	Bare pointer to histogram. Ownership transferred to THistSvc.
[in]	tDir	Histogram name & directory.

Returns: Cached pointer to histogram. Used to fill histogram without having to perform THishSvc lookup.

Definition at line 37 of file Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.cxx.

                                                                        {
   std::string dir = getName();
   if (tDir != "") {
     dir += "/";
     dir += tDir;
   }
   return getParent()->bookGetPointer(hist, dir);
 }

◆ counterExists()

bool MonitorBase::counterExists ( const std::string & name ) const

inherited

Check if a counter of a given name exists.

Parameters

[in] name Name of Counter.

Returns: True if counter already exists.

Definition at line 47 of file Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.cxx.

                                                            {
   return (m_counters.count(name) == 1);
 }

◆ endEvent()

StatusCode MonitorBase::endEvent ( float weight = 1. )

virtualinherited

Called by the framework.

Causes per-Event Variables to fill their histograms with their accumulated data.

Definition at line 29 of file Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.cxx.

                                              {
   for (auto& nameCounterPair : m_counters ) {
     ATH_CHECK( nameCounterPair.second->endEvent(weight) );
   }
   return StatusCode::SUCCESS;
 }

◆ getCounter()

CounterBase * MonitorBase::getCounter ( const std::string & name )

inherited

Retrieve counter by name.

If no such counter exists, a new one will be instanced and returned.

Parameters

[in] name Name of Counter.

Returns: Mutable base-class pointer to Counter.

Definition at line 52 of file Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.cxx.

                                                           {
   auto it = m_counters.find(name);
   if (it != m_counters.end()) {
     return it->second.get();
   }
   // If no counter exists, then we make a new one on the fly & return it.
   auto result = m_counters.insert( std::make_pair(name, newCounter(name)) ); // newCounter is specialised
   it = result.first;
   return it->second.get();
 }

◆ getName()

const std::string & MonitorBase::getName ( ) const

inherited

Getter for Monitor's name.

Returns: Counter's name const string reference.

Definition at line 19 of file Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.cxx.

                                             {
   return m_name;
 }

◆ getParent()

const MonitoredRange * MonitorBase::getParent ( ) const

inherited

Return cached non-owning const ptr to this Monitor's parent Range.

Returns: Cached pointer parent Range.

Definition at line 24 of file Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.cxx.

                                                    {
   return m_parent;
 }

◆ msg() [1/2]

MsgStream & MonitorBase::msg ( )

inherited

Logging.

Returns: Message stream reference.

Definition at line 64 of file Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.cxx.

                             {
   return m_msgStream;
 }

◆ msg() [2/2]

MsgStream & MonitorBase::msg ( const MSG::Level lvl )

inherited

Logging on a given level.

Parameters

[in] lvl Verbosity level

Returns: Message stream reference.

Definition at line 68 of file Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.cxx.

                                               {
   return m_msgStream << lvl;
 }

◆ msgLvl()

bool MonitorBase::msgLvl ( const MSG::Level lvl )

inherited

Returns if requested level is same or higher than logging level.

Parameters

[in] lvl Verbosity level

Returns: If requested level is same or higher than logging level

Definition at line 72 of file Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.cxx.

                                           {
   return lvl >= m_msgStream.level();
 }

◆ newCounter()

std::unique_ptr< CounterBase > MonitorThreadOccupancy::newCounter ( const std::string & name )

overridevirtual

Concrete counter instantiation.

Mints named counter of CounterThread type.

Parameters

[in] name Name of Counter to mint.

Returns: Owning unique ptr object typed on the CounterBase base class which points to concrete Counter of specialised type.

Implements MonitorBase.

Definition at line 69 of file MonitorThreadOccupancy.cxx.

                                                                                    {
   return std::make_unique<CounterThread>(name, this);
 } 

◆ newEvent()

StatusCode MonitorThreadOccupancy::newEvent	(	const CostData &	data,
		const float	weight = `1.`
	)

overridevirtual

Concrete dispatch method.

Iterate over all Algorithms in event data and dispatch to owned Counters

Parameters

[in]	data	Access to event data
[in]	weight	Global event weight

Implements MonitorBase.

Definition at line 14 of file MonitorThreadOccupancy.cxx.

                                                                                     {
   // Only look at events in the master slot
   if (not data.isMasterSlot()) {
     return StatusCode::SUCCESS;
   }
  
   // Check if we ran with EnableMultiSlot=true - in the master slot (online slot) there are algorithms executed on different slot
   bool isMultiSlot = false;
   for (const xAOD::TrigComposite* tc : data.costCollection()) {
     const uint32_t slot = tc->getDetail<uint32_t>("slot");
     if (slot != data.onlineSlot()){
       isMultiSlot = true;
       break;
     }
   }
  
   if (!isMultiSlot){
     ATH_MSG_DEBUG("Saving data from multiple slots to master slot was not enabled - ThreadOccupancy Monitoring won't be executed");
     return StatusCode::SUCCESS; 
   }
  
   for (const xAOD::TrigComposite* tc : data.costCollection()) {
     const uint32_t threadID = tc->getDetail<uint32_t>("thread");
     if (m_threadToCounterMap.count(threadID) == 0) {
       std::stringstream threadIDStr;
       threadIDStr << "Thread_" << std::setfill('0') << std::setw(5) << threadID;
       m_threadToCounterMap[threadID] = threadIDStr.str();
     }
     ATH_CHECK( getCounter(m_threadToCounterMap[threadID])->newEvent(data, tc->index(), weight) );
   }
  
   ATH_CHECK( postProcess(weight) );
  
  
   return StatusCode::SUCCESS; 
 }

◆ operator=()

MonitorThreadOccupancy& MonitorThreadOccupancy::operator= ( const MonitorThreadOccupancy & )

delete

Forbid assignment.

◆ postProcess()

StatusCode MonitorThreadOccupancy::postProcess ( float weight )

Get the global start and stop timestamps over all threads and sync these to the individual threads.

Definition at line 52 of file MonitorThreadOccupancy.cxx.

                                                            {
   uint64_t lowTimestamp = std::numeric_limits<uint64_t>::max();
   uint64_t highTimestamp = 0;
   for (const auto& nameCounterPair : m_counters) {
     const CounterThread* ptr = dynamic_cast<const CounterThread*>(nameCounterPair.second.get());
     lowTimestamp = std::min(lowTimestamp, ptr->getLowTimestamp());
     highTimestamp = std::max(highTimestamp, ptr->getHighTimestamp());
   }
   for (auto& nameCounterPair : m_counters) {
     CounterThread* ptr = dynamic_cast<CounterThread*>(nameCounterPair.second.get());
     ptr->setAllThreadsTimestamps(lowTimestamp, highTimestamp);
     ATH_CHECK( ptr->postProcess(weight) );
   }
   return StatusCode::SUCCESS;
 }

Member Data Documentation

◆ m_counters

std::unordered_map< std::string, std::unique_ptr<CounterBase> > MonitorBase::m_counters

protectedinherited

Storage of Monitor's collection of Counters.

Keyed by name.

Definition at line 138 of file Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.h.

◆ m_msgStream

MsgStream MonitorBase::m_msgStream

protectedinherited

Logging member.

Definition at line 140 of file Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.h.

◆ m_name

const std::string MonitorBase::m_name

privateinherited

Monitor's name.

Definition at line 144 of file Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.h.

◆ m_parent

const MonitoredRange* MonitorBase::m_parent

privateinherited

Monitor's parent Range.

Cached non-owning const ptr.

Definition at line 145 of file Trigger/TrigCost/TrigCostAnalysis/src/MonitorBase.h.

◆ m_threadCounter

size_t MonitorThreadOccupancy::m_threadCounter

Count how many unique thread ID we have seen.

Definition at line 63 of file MonitorThreadOccupancy.h.

◆ m_threadToCounterMap

std::unordered_map<uint32_t, std::string> MonitorThreadOccupancy::m_threadToCounterMap

Map thread's hash ID to a counting numeral embedded in a string.

Definition at line 62 of file MonitorThreadOccupancy.h.

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

Public Member Functions

Public Attributes

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MonitorThreadOccupancy() [1/3]

◆ MonitorThreadOccupancy() [2/3]

◆ ~MonitorThreadOccupancy()

◆ MonitorThreadOccupancy() [3/3]

Member Function Documentation

◆ bookGetPointer()

◆ counterExists()

◆ endEvent()

◆ getCounter()

◆ getName()

◆ getParent()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ newCounter()

◆ newEvent()

◆ operator=()

◆ postProcess()

Member Data Documentation

◆ m_counters

◆ m_msgStream

◆ m_name

◆ m_parent

◆ m_threadCounter

◆ m_threadToCounterMap