SG::HiveMgrSvc Class Reference

#include <SGHiveMgrSvc.h>

Inheritance diagram for SG::HiveMgrSvc:

Collaboration diagram for SG::HiveMgrSvc:

Public Member Functions
virtual StatusCode	selectStore (size_t slotIndex) override
	Activate an given 'slot' for all subsequent calls within the same thread id.
virtual StatusCode	clearStore (size_t slotIndex) override
	Clear a given 'slot'.
virtual StatusCode	setNumberOfStores (size_t slots) override
	Set the number of 'slots'.
virtual size_t	getNumberOfStores () const override
	Get the number of 'slots'.
virtual bool	exists (const DataObjID &) override
	Check if a data object exists in store.
virtual size_t	allocateStore (int evtnumber) override
	Allocate a store slot for new event.
virtual StatusCode	freeStore (size_t slotIndex) override
	Free a store slot.
virtual size_t	getPartitionNumber (int eventnumber) const override
	Get the slot number corresponding to a given event.
virtual size_t	freeSlots () override
	Get free slots number.
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	start () override
	HiveMgrSvc (const std::string &name, ISvcLocator *svc)
	Standard Service Constructor. sets active store to default event store.
virtual	~HiveMgrSvc ()

Static Private Member Functions
static void	setNumProcs (size_t numProcs)
	Set number of concurrent processes.

Private Attributes
ServiceHandle< StoreGateSvc >	m_hiveStore
size_t	m_nSlots
std::vector< SG::HiveEventSlot >	m_slots
std::mutex	m_mutex
std::atomic< size_t >	m_freeSlots {0}

Friends
class	TestSGHiveMgrSvc
class	::HltEventLoopMgr

Detailed Description

Definition at line 30 of file SGHiveMgrSvc.h.

Constructor & Destructor Documentation

HiveMgrSvc()

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

Standard Service Constructor. sets active store to default event store.

Definition at line 18 of file SGHiveMgrSvc.cxx.

                                         : base_class(name, svc),
                                           m_hiveStore(StoreID::storeName(StoreID::EVENT_STORE), name),
                                           m_nSlots(1)
{
  declareProperty("HiveStoreSvc", m_hiveStore);
  declareProperty("NSlots", m_nSlots, "number of event slots");
}

~HiveMgrSvc()

virtual SG::HiveMgrSvc::~HiveMgrSvc ( )

inlinevirtual

Definition at line 106 of file SGHiveMgrSvc.h.

{}

Member Function Documentation

allocateStore()

size_t HiveMgrSvc::allocateStore ( int evtNumber )

overridevirtual

Allocate a store slot for new event.

Parameters

evtnumber	[IN] Event number
slot	[OUT] Returned slot or slot number

Returns

Slot number (npos to indicate an error).

Definition at line 103 of file SGHiveMgrSvc.cxx.

                                                {
  if (m_freeSlots == 0) {
    SG_MSG_ERROR ("No slots available for event number {}", evtNumber);
    return std::string::npos;
  }
  std::scoped_lock lock{m_mutex};
  for (size_t index=0; index<m_nSlots; ++index) {
    if( m_slots[index].eventNumber == evtNumber) {
      SG_MSG_ERROR ("Attempt to allocate an event slot for an event that is still active: event number {}", evtNumber);
      return std::string::npos;
    } else if (m_slots[index].eventNumber == -1) {
      m_slots[index].eventNumber = evtNumber;
      SG_MSG_DEBUG ("Slot {} allocated to event number {}", index, evtNumber);
      m_freeSlots--;
      return index;
    }
  }
  SG_MSG_ERROR ("No slots available for event number {}", evtNumber);
  return std::string::npos;
}

clearStore()

StatusCode HiveMgrSvc::clearStore ( size_t slotIndex )

overridevirtual

Clear a given 'slot'.

Parameters

slot	[IN] Slot number (event slot) *

Returns

Status code indicating failure or success.

Definition at line 58 of file SGHiveMgrSvc.cxx.

                                                  {
  StatusCode rc(StatusCode::FAILURE);
  if (slotIndex < m_nSlots) {
    rc=m_slots[slotIndex].pEvtStore->clearStore();
    if (rc.isSuccess()) {
      SG_MSG_DEBUG ("cleared store {}", slotIndex);
    }
  }    
  if (!rc.isSuccess()) {
    SG_MSG_ERROR ("could not clear store {}", slotIndex);
  }
  return rc;
}

exists()

bool HiveMgrSvc::exists ( const DataObjID & id )

overridevirtual

Check if a data object exists in store.

TODO: remove the method ASA a cross-experiment event data store interface emerges

Returns

boolean

Definition at line 165 of file SGHiveMgrSvc.cxx.

                                            {
  // this should only get called in error situations, so we
  // don't care if it's slow
  std::string key = id.key();
  key.erase(0,key.find('+')+1);
 
  if (id.clid() == 0) {
    // this is an ugly hack in case the DataObjID gets munged
    // upstream, and we have to re-separate it into (class,key)
    // from "class/key"
    std::string cl = id.fullKey();
    cl.erase(cl.find('/'),cl.length());
 
    DataObjID d2(std::move(cl),key);
    return m_hiveStore->transientContains(d2.clid(), key);
  } else {    
    return m_hiveStore->transientContains(id.clid(), key);
  }
 
} 

finalize()

StatusCode HiveMgrSvc::finalize ( )

overridevirtual

Definition at line 224 of file SGHiveMgrSvc.cxx.

                                {
  SG_MSG_INFO ("Finalizing {}", name());
 
  for (SG::HiveEventSlot& s : m_slots) {
    // The impl services are not set to active, so ServiceManager
    // won't finalize them.
    CHECK( s.pEvtStore->finalize() );
    s.pEvtStore->release();
  }
 
  return StatusCode::SUCCESS;
}

freeSlots()

size_t HiveMgrSvc::freeSlots ( )

overridevirtual

Get free slots number.

Definition at line 161 of file SGHiveMgrSvc.cxx.

                             {
  return m_freeSlots;
}

freeStore()

StatusCode HiveMgrSvc::freeStore ( size_t slotIndex )

overridevirtual

Free a store slot.

Parameters

slot	[IN] Slot number

Returns

Status code indicating failure or success.

Definition at line 129 of file SGHiveMgrSvc.cxx.

                                                   {
  if (slotIndex < m_nSlots) {
    std::scoped_lock lock{m_mutex};
    if (m_slots[slotIndex].eventNumber == -1) {
      SG_MSG_DEBUG ("Slot {} is already free", slotIndex);
    }
    else {
      m_slots[slotIndex].eventNumber = -1;
      m_freeSlots++;
      SG_MSG_DEBUG ("Freed slot {}", slotIndex);
    }
    return StatusCode::SUCCESS;
  } else {
    SG_MSG_ERROR ("no slot at {}", slotIndex);
    return StatusCode::FAILURE;
  }
}

getNumberOfStores()

size_t HiveMgrSvc::getNumberOfStores ( ) const

overridevirtual

Get the number of 'slots'.

Returns

Number of event stores allocated in the whiteboard

Definition at line 91 of file SGHiveMgrSvc.cxx.

                                           {
  return m_nSlots;
}

getPartitionNumber()

size_t HiveMgrSvc::getPartitionNumber ( int evtNumber ) const

overridevirtual

Get the slot number corresponding to a given event.

Parameters

evtnumber

[IN] Event number

Returns

slot number (npos to indicate an error).

Parameters

evtNumber

[IN] Event number

Returns

slot number (npos to indicate an error).

Definition at line 153 of file SGHiveMgrSvc.cxx.

                                                         {
  std::scoped_lock lock{m_mutex};
  for (size_t index=0; index<m_nSlots; ++index) {
    if( m_slots[index].eventNumber == evtNumber) return index;
  }
  return std::string::npos;
}

initialize()

StatusCode HiveMgrSvc::initialize ( )

overridevirtual

Definition at line 186 of file SGHiveMgrSvc.cxx.

                                  {
  SG_MSG_VERBOSE ("Initializing {}", name());
 
  if ( !(Service::initialize().isSuccess()) )  {
    SG_MSG_FATAL ("Unable to initialize base class");
    return StatusCode::FAILURE;
  }
  //this sets the hiveStore pointer to StoreGateSvc.defaultStore
  if (!(m_hiveStore.retrieve()).isSuccess()) {
    SG_MSG_FATAL ("Unable to get hive event store");
    return StatusCode::FAILURE;
  }
 
  //use hiveStore default impl store as prototype
  Service* child(0);
  SGImplSvc* pSG(0);
 
  for( size_t i = 0; i< m_nSlots; ++i) {
    std::ostringstream oss;
    std::print (oss, "{}_{}", i, m_hiveStore->currentStore()->name());
    if (CloneService::clone(m_hiveStore->currentStore(), oss.str(), child).isSuccess() &&
        child->initialize().isSuccess() &&
        0 != (pSG = dynamic_cast<SGImplSvc*>(child)) )
      {
        pSG->setSlotNumber (i, m_nSlots);
        m_slots.push_back(SG::HiveEventSlot(pSG));
      } else {
      SG_MSG_FATAL ("Unable to clone event store {}", oss.str());
      return StatusCode::FAILURE;
    }
  }
  
  m_freeSlots.store( m_nSlots );
  Gaudi::Concurrency::ConcurrencyFlags::setNumConcEvents( m_nSlots );
 
  return selectStore(0);
}

selectStore()

StatusCode HiveMgrSvc::selectStore ( size_t slotIndex )

overridevirtual

Activate an given 'slot' for all subsequent calls within the same thread id.

Parameters

slot	[IN] Slot number (event slot) *

Returns

Status code indicating failure or success.

Definition at line 47 of file SGHiveMgrSvc.cxx.

                                                   {
  s_current = &m_slots[slotIndex];
  StoreGateSvc::setSlot(s_current);
  return StatusCode::SUCCESS;
}

setNumberOfStores()

StatusCode HiveMgrSvc::setNumberOfStores ( size_t slots )

overridevirtual

Set the number of 'slots'.

Parameters

slot	[IN] Slot number (event slot) *

Returns

Status code indicating failure or success.

Definition at line 77 of file SGHiveMgrSvc.cxx.

                                                     {
  //FIXME what if running?
  if(FSMState() ==  Gaudi::StateMachine::INITIALIZED) {
    SG_MSG_FATAL ("Too late to change the number of slots!");
    return StatusCode::FAILURE;
  } else {
    m_slots.resize(slots);
    m_nSlots = slots;
    m_freeSlots.store(slots);
    Gaudi::Concurrency::ConcurrencyFlags::setNumConcEvents( slots );
    return StatusCode::SUCCESS;
  }
}

setNumProcs()

void HiveMgrSvc::setNumProcs ( size_t numProcs )

staticprivate

Set number of concurrent processes.

This can only be called by "friends" of this class. Its sole purpose is to have a common entry point within ATLAS to call the private methods of Gaudi::ConcurrencyFlags.

Parameters

numProcs

[IN] Number of concurrent processes

Definition at line 36 of file SGHiveMgrSvc.cxx.

{
  Gaudi::Concurrency::ConcurrencyFlags::setNumProcs(numProcs);
}

start()

StatusCode HiveMgrSvc::start ( )

overridevirtual

Definition at line 238 of file SGHiveMgrSvc.cxx.

{
  // On a start transition, merge the string pool from the default store
  // into that of each store, so that they will know about any explicit
  // registrations that were done during initialize().
  // See ATEAM-846.
  for (SG::HiveEventSlot& slot : m_slots) {
    slot.pEvtStore->mergeStringPool (*m_hiveStore->currentStore());
  }
  return StatusCode::SUCCESS;
}

Friends And Related Symbol Documentation

::HltEventLoopMgr

friend class ::HltEventLoopMgr

friend

Definition at line 32 of file SGHiveMgrSvc.h.

TestSGHiveMgrSvc

friend class TestSGHiveMgrSvc

friend

Definition at line 31 of file SGHiveMgrSvc.h.

Member Data Documentation

m_freeSlots

std::atomic<size_t> SG::HiveMgrSvc::m_freeSlots {0}

private

Definition at line 123 of file SGHiveMgrSvc.h.

{0};

m_hiveStore

ServiceHandle<StoreGateSvc> SG::HiveMgrSvc::m_hiveStore

private

Definition at line 119 of file SGHiveMgrSvc.h.

m_mutex

std::mutex SG::HiveMgrSvc::m_mutex

mutableprivate

Definition at line 122 of file SGHiveMgrSvc.h.

m_nSlots

size_t SG::HiveMgrSvc::m_nSlots

private

Definition at line 120 of file SGHiveMgrSvc.h.

m_slots

std::vector<SG::HiveEventSlot> SG::HiveMgrSvc::m_slots

private

Definition at line 121 of file SGHiveMgrSvc.h.

---

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

• SGHiveMgrSvc.h
• SGHiveMgrSvc.cxx