EventContainers::InternalOnline Class Reference

#include <InternalOnline.h>

Inheritance diagram for EventContainers::InternalOnline:

Collaboration diagram for EventContainers::InternalOnline:

Public Types
typedef EventContainers::hashPair< void >	hashPair
typedef std::vector< hashPair >::const_iterator	InternalConstItr

Public Member Functions
	InternalOnline (EventContainers::IdentifiableCacheBase *cache)
virtual InternalConstItr	cbegin () const override
virtual InternalConstItr	cend () const override
virtual InternalConstItr	indexFind (IdentifierHash hashId) const override
virtual const std::vector< hashPair > &	getAllHashPtrPair () const override
virtual	~InternalOnline ()=default
virtual void	wait () const override
virtual bool	tryAddFromCache (IdentifierHash hashId, EventContainers::IDC_WriteHandleBase &lock) override
virtual bool	tryAddFromCache (IdentifierHash hashId) override
virtual std::vector< IdentifierHash >	getAllCurrentHashes () const override
virtual size_t	numberOfCollections () const override
void	resetMask ()
virtual size_t	fullSize () const noexcept override
virtual StatusCode	fetchOrCreate (IdentifierHash hashId) override
virtual StatusCode	fetchOrCreate (const std::vector< IdentifierHash > &hashIds) override
virtual bool	insert (IdentifierHash hashId, const void *ptr) override
virtual const void *	findIndexPtr (IdentifierHash hashId) const noexcept override
virtual StatusCode	addLock (IdentifierHash hashId, const void *ptr) override
virtual void *	removeCollection (IdentifierHash hashId) override
virtual void	destructor (deleter_f *) noexcept override
virtual void	cleanUp (deleter_f *) noexcept override

Private Attributes
EventContainers::IdentifiableCacheBase *	m_cacheLink
std::vector< IdentifierHash > m_waitlist	ATLAS_THREAD_SAFE
std::vector< I_InternalIDC::hashPair > m_map	ATLAS_THREAD_SAFE
std::mutex m_waitMutex	ATLAS_THREAD_SAFE
std::vector< bool > m_mask	ATLAS_THREAD_SAFE
std::atomic< bool > m_waitNeeded	ATLAS_THREAD_SAFE

Detailed Description

Definition at line 26 of file InternalOnline.h.

Member Typedef Documentation

hashPair

typedef EventContainers::hashPair<void> EventContainers::I_InternalIDC::hashPair

inherited

Definition at line 36 of file I_InternalIDC.h.

InternalConstItr

typedef std::vector< hashPair >::const_iterator EventContainers::I_InternalIDC::InternalConstItr

inherited

Definition at line 37 of file I_InternalIDC.h.

Constructor & Destructor Documentation

InternalOnline()

InternalOnline::InternalOnline

(

EventContainers::IdentifiableCacheBase *

cache

)

Definition at line 16 of file InternalOnline.cxx.

                                                                          : m_cacheLink(cache),
    m_mask(cache->fullSize(), false), m_waitNeeded(false) {}

~InternalOnline()

virtual EventContainers::InternalOnline::~InternalOnline ( )

virtualdefault

Member Function Documentation

addLock()

StatusCode InternalOnline::addLock ( IdentifierHash  hashId, const void *  ptr  )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 143 of file InternalOnline.cxx.

                                                                         {
    std::pair<bool, const void*> added = m_cacheLink->addLock(hashId, ptr);
    if(ATH_UNLIKELY(!added.first)) {
      throw std::runtime_error("IDC WARNING Deletion shouldn't occur in addLock paradigm");
    }
    m_mask[hashId] = true; //it wasn't added it is already present therefore mask could be true
    m_waitNeeded.store(true, std::memory_order_relaxed);
    return StatusCode::SUCCESS;
}

cbegin()

InternalConstItr InternalOnline::cbegin ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 32 of file InternalOnline.cxx.

                              {
    if(m_waitNeeded.load(std::memory_order_acquire)) wait();
    return m_map.cbegin();
}

cend()

InternalConstItr InternalOnline::cend ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 26 of file InternalOnline.cxx.

                            {
    if(m_waitNeeded.load(std::memory_order_acquire)) wait();
    return m_map.cend();
}

cleanUp()

void InternalOnline::cleanUp ( deleter_f *  )

overridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 161 of file InternalOnline.cxx.

                                                {
    resetMask();
}

destructor()

void InternalOnline::destructor ( deleter_f *  )

overridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 157 of file InternalOnline.cxx.

                                                   {
    //deliberately empty
}

fetchOrCreate() [1/2]

StatusCode InternalOnline::fetchOrCreate ( const std::vector< IdentifierHash > &  hashIds )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 120 of file InternalOnline.cxx.

                                                                           {
    throw std::runtime_error("Not implemented");
//    if(ATH_UNLIKELY(!m_cacheLink->IMakerPresent())) return StatusCode::FAILURE;
//    m_cacheLink->createSet(hashIds, m_mask);
//    return StatusCode::SUCCESS;
}

fetchOrCreate() [2/2]

StatusCode InternalOnline::fetchOrCreate ( IdentifierHash  hashId )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 113 of file InternalOnline.cxx.

                                                              {
    if(ATH_UNLIKELY(!m_cacheLink->IMakerPresent())) return StatusCode::FAILURE;
    auto ptr = m_cacheLink->get(hashId);
    if(ptr) { m_mask[hashId] =true; m_waitNeeded.store(true, std::memory_order_relaxed); }
    return StatusCode::SUCCESS;
}

findIndexPtr()

const void * InternalOnline::findIndexPtr ( IdentifierHash  hashId ) const

overridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 135 of file InternalOnline.cxx.

                                                                             {
    if(hashId < m_mask.size() and m_mask[hashId]) {
      EventContainers::IdentifiableCacheBase* cacheLink ATLAS_THREAD_SAFE = m_cacheLink;
      return cacheLink->findWait(hashId);
    }
    return nullptr;
}

fullSize()

virtual size_t EventContainers::InternalOnline::fullSize ( ) const

inlineoverridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 40 of file InternalOnline.h.

{ return m_mask.size(); }

getAllCurrentHashes()

std::vector< IdentifierHash > InternalOnline::getAllCurrentHashes ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 91 of file InternalOnline.cxx.

                                                                    {
    if(m_waitNeeded.load(std::memory_order_acquire)) wait();
    std::vector<IdentifierHash> ids;
    ids.reserve(m_map.size());
    for(auto &x : m_map) {
        ids.emplace_back(x.first);
    }
    return ids;
}

getAllHashPtrPair()

const std::vector< I_InternalIDC::hashPair > & InternalOnline::getAllHashPtrPair ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 19 of file InternalOnline.cxx.

                                                                                  {
  if(m_waitNeeded.load(std::memory_order_acquire)) wait();
  return m_map; 
}

indexFind()

InternalConstItr InternalOnline::indexFind ( IdentifierHash  hashId ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 37 of file InternalOnline.cxx.

                                                                       {
  if(m_waitNeeded.load(std::memory_order_acquire)) wait();
   auto itr = std::lower_bound( m_map.begin(), m_map.end(), hashId.value(), [](hashPair &lhs,  IdentifierHash::value_type rhs) -> bool { return lhs.first < rhs; } );
   if(itr!= m_map.end() && itr->first==hashId) return itr;
   return m_map.end();
}

insert()

bool InternalOnline::insert ( IdentifierHash  hashId, const void *  ptr  )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 128 of file InternalOnline.cxx.

                                                                  {
    std::pair<bool, const void*> cacheinserted = m_cacheLink->add(hashId, ptr);
    m_mask[hashId] = true; //it wasn't added it is already present therefore mask could be true
    m_waitNeeded.store(true, std::memory_order_relaxed);
    return ptr == cacheinserted.second;
}

numberOfCollections()

size_t InternalOnline::numberOfCollections ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 101 of file InternalOnline.cxx.

                                                 {
    if(m_waitNeeded.load(std::memory_order_acquire)) wait();
    return m_map.size();
}

removeCollection()

void * InternalOnline::removeCollection ( IdentifierHash  hashId )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 153 of file InternalOnline.cxx.

                                                        {
    throw std::runtime_error("Do not remove things from an online IDC");
}

resetMask()

void InternalOnline::resetMask

(

)

Definition at line 106 of file InternalOnline.cxx.

                               {
    if(m_waitNeeded.load(std::memory_order_relaxed)) wait();
    m_mask.assign(m_cacheLink->fullSize(), false);
    m_map.clear();
    m_waitNeeded.store(true, std::memory_order_relaxed);
}

tryAddFromCache() [1/2]

bool InternalOnline::tryAddFromCache ( IdentifierHash  hashId )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 80 of file InternalOnline.cxx.

{
    auto ptr = m_cacheLink->find(hashId);
    if(ptr==nullptr) {
        return false;
    }
    m_mask[hashId] = true;
    m_waitNeeded.store(true, std::memory_order_relaxed);
    return true;
}

tryAddFromCache() [2/2]

bool InternalOnline::tryAddFromCache ( IdentifierHash  hashId, EventContainers::IDC_WriteHandleBase &  lock  )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 66 of file InternalOnline.cxx.

                                                                                                    {
    int flag = m_cacheLink->tryLock(hashId, lock, m_waitlist);
    //Relaxed since this should not be running in threaded situation.
    if(!m_waitlist.empty()) m_waitNeeded.store(true, std::memory_order_relaxed);
    if(flag > 0) {
        if(flag!=3){
           m_mask[hashId] = true;
           m_waitNeeded.store(true, std::memory_order_relaxed);
        }
        return true;
    }
    return false;
}

wait()

void InternalOnline::wait ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 44 of file InternalOnline.cxx.

                                {
    //lockguard to protect m_waitlist from multiple wait calls
    std::scoped_lock lock (m_waitMutex);
    if(m_waitNeeded.load(std::memory_order_acquire) == false) return;
    using namespace EventContainers;
    const void* ABORTstate = reinterpret_cast<const void*>(IdentifiableCacheBase::ABORTEDflag);
    while(!m_waitlist.empty()) {
        IdentifierHash hash = m_waitlist.back();
        EventContainers::IdentifiableCacheBase* cacheLink ATLAS_THREAD_SAFE = m_cacheLink;
        const void* ptr = cacheLink->waitFor(hash);
        if(ptr == ABORTstate) {
          m_mask[hash] = false;
        }
        m_waitlist.pop_back();
    }
    m_map.clear();
    for(size_t i =0;i<m_mask.size();i++){
        if(m_mask[i]) m_map.emplace_back(i, m_cacheLink->m_vec[i].load(std::memory_order_relaxed));//acquire sync is done by  m_waitNeeded
    }
    m_waitNeeded.store(false, std::memory_order_release);
}

Member Data Documentation

ATLAS_THREAD_SAFE [1/5]

std::vector< IdentifierHash > m_waitlist EventContainers::InternalOnline::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 51 of file InternalOnline.h.

ATLAS_THREAD_SAFE [2/5]

std::vector<I_InternalIDC::hashPair> m_map EventContainers::InternalOnline::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 52 of file InternalOnline.h.

ATLAS_THREAD_SAFE [3/5]

std::mutex m_waitMutex EventContainers::InternalOnline::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 53 of file InternalOnline.h.

ATLAS_THREAD_SAFE [4/5]

std::vector<bool> m_mask EventContainers::InternalOnline::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 54 of file InternalOnline.h.

ATLAS_THREAD_SAFE [5/5]

std::atomic<bool> m_waitNeeded EventContainers::InternalOnline::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 55 of file InternalOnline.h.

m_cacheLink

EventContainers::IdentifiableCacheBase* EventContainers::InternalOnline::m_cacheLink

private

Definition at line 50 of file InternalOnline.h.

---

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

• InternalOnline.h
• InternalOnline.cxx