HiveExSvc Class Reference

#include <HiveExSvc.h>

Inheritance diagram for HiveExSvc:

Collaboration diagram for HiveExSvc:

Classes
struct	tDat

Public Member Functions
	HiveExSvc (const std::string &name, ISvcLocator *svc)
virtual	~HiveExSvc ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual void	add (const EventContext &, const std::string &, const unsigned int &) override

Private Attributes
std::vector< std::list< tDat > >	m_times
std::vector< std::unique_ptr< std::mutex > >	m_locks

Detailed Description

Definition at line 24 of file HiveExSvc.h.

Constructor & Destructor Documentation

HiveExSvc()

HiveExSvc::HiveExSvc	(	const std::string &	name,
		ISvcLocator *	svc )

Definition at line 14 of file HiveExSvc.cxx.

  : base_class( name, svc ) {}

~HiveExSvc()

HiveExSvc::~HiveExSvc ( )

virtualdefault

Member Function Documentation

add()

void HiveExSvc::add ( const EventContext & ctx, const std::string & algName, const unsigned int & time )

overridevirtual

Definition at line 77 of file HiveExSvc.cxx.

                                                                                          {
 
  // even though we have separate data structures per concurrent
  // event (slot), we can't be sure that multiple threads aren't
  // processing the same slot at the same time, so need to lock the mutex.
  // this reduces the waiting for a lock, compared with locking the
  // whole structure, as it's unlikely that we'll have the same Alg in
  // different concurrent events executing at the same time.
 
  // for a true lock-free design, we would need a separate container for
  // each Algorithm in each slot
 
  const EventContext::ContextID_t slot = ctx.slot();
  std::lock_guard<std::mutex> lock ( *m_locks[slot] );
  m_times[slot].push_back( tDat(algName, time) );
}

finalize()

StatusCode HiveExSvc::finalize ( )

overridevirtual

Definition at line 46 of file HiveExSvc.cxx.

                    {
  ATH_MSG_INFO("finalize");
 
  // calculate the standard deviation of the sleep times
  std::map<std::string,unsigned int> sum;
  std::map<std::string,unsigned int> sumSq;
  std::map<std::string,unsigned int> num;
 
  for (const auto &ve : m_times) {
    for (const auto &e : ve) {
      sum[e.algName] += e.sleep_time;
      sumSq[e.algName] += e.sleep_time * e.sleep_time;
      num[e.algName] ++;
    }
  }
 
  info() << "listing timing by alg:";
  for (const auto &s : sum) {
    float avg = static_cast<float>(s.second)/num[s.first];
    float sig = sqrt( ( sumSq[s.first] - 2*s.second*avg + num[s.first]*avg*avg  )/(num[s.first]) );
    info() << "\n  " << s.first 
           << "  avg: " << avg << "  sig: " << sig;
  }
  info() << endmsg;
    
  return StatusCode::SUCCESS;
}

initialize()

StatusCode HiveExSvc::initialize ( )

overridevirtual

Definition at line 24 of file HiveExSvc.cxx.

                      {
 
  size_t nslots = Gaudi::Concurrency::ConcurrencyFlags::numConcurrentEvents();
  if (nslots == 0) {
    nslots = 1;
  }
 
  ATH_MSG_INFO("initialize structures of size " << nslots);
  
  // initialize the structures with the number of concurrent events
  m_times.resize( nslots );
  m_locks.resize( nslots );
  for ( auto & m : m_locks ) {
    m = std::make_unique<std::mutex>();
  }
  
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_locks

std::vector< std::unique_ptr<std::mutex> > HiveExSvc::m_locks

private

Definition at line 49 of file HiveExSvc.h.

m_times

std::vector< std::list<tDat> > HiveExSvc::m_times

private

Definition at line 45 of file HiveExSvc.h.

---

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

• HiveExSvc.h
• HiveExSvc.cxx