EventContainers::InternalOfflineFast Class Reference

#include <InternalOfflineFast.h>

Inheritance diagram for EventContainers::InternalOfflineFast:

Collaboration diagram for EventContainers::InternalOfflineFast:

Public Types
typedef EventContainers::hashPair< void >	hashPair
typedef std::vector< hashPair >::const_iterator	InternalConstItr
typedef void	deleter_f(const void *p)

Public Member Functions
	InternalOfflineFast (size_t max)
virtual	~InternalOfflineFast ()=default
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 bool	tryAddFromCache (IdentifierHash hashId, EventContainers::IDC_WriteHandleBase &lock) override
virtual bool	tryAddFromCache (IdentifierHash hashId) override
virtual void	wait () const override
virtual std::vector< IdentifierHash >	getAllCurrentHashes () const override
virtual size_t	numberOfCollections () const override
virtual void	cleanUp (deleter_f *deleter) noexcept override
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

Private Attributes
std::vector< I_InternalIDC::hashPair > m_map	ATLAS_THREAD_SAFE
std::vector< const void * >	m_fullMap
std::mutex m_waitMutex	ATLAS_THREAD_SAFE
std::atomic< bool > m_needsupdate	ATLAS_THREAD_SAFE

Detailed Description

Definition at line 19 of file InternalOfflineFast.h.

Member Typedef Documentation

deleter_f

typedef void EventContainers::I_InternalIDC::deleter_f(const void *p)

inherited

Definition at line 14 of file I_InternalIDC.h.

hashPair

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

inherited

Definition at line 37 of file I_InternalIDC.h.

InternalConstItr

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

inherited

Definition at line 38 of file I_InternalIDC.h.

Constructor & Destructor Documentation

InternalOfflineFast()

InternalOfflineFast::InternalOfflineFast

(

size_t

max

)

Definition at line 12 of file InternalOfflineFast.cxx.

: m_fullMap(max, nullptr), m_needsupdate(false) {}

~InternalOfflineFast()

virtual EventContainers::InternalOfflineFast::~InternalOfflineFast ( )

virtualdefault

Member Function Documentation

addLock()

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

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 99 of file InternalOfflineFast.cxx.

                                                                              {
    bool added = insert(hashId, ptr);
    if(!added) {
      throw std::runtime_error("IDC WARNING Deletion shouldn't occur in addLock paradigm");
    }
    return StatusCode::SUCCESS;
}

cbegin()

InternalConstItr InternalOfflineFast::cbegin ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 57 of file InternalOfflineFast.cxx.

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

cend()

InternalConstItr InternalOfflineFast::cend ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 46 of file InternalOfflineFast.cxx.

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

cleanUp()

void InternalOfflineFast::cleanUp ( deleter_f * deleter )

overridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 74 of file InternalOfflineFast.cxx.

                                                             {
    if(!m_needsupdate.load(std::memory_order_acquire)) {
        for(const auto& x : m_map) { deleter(x.second); m_fullMap[x.first] = nullptr; }
        if(!m_map.empty()) m_needsupdate.store(true, std::memory_order_relaxed);
    }
    else {
      for(size_t i=0 ;i < m_fullMap.size(); ++i){
         if(m_fullMap[i]) { deleter(m_fullMap[i]); m_fullMap[i] = nullptr; }
      }
    }
    m_map.clear();
}

destructor()

void InternalOfflineFast::destructor ( deleter_f * deleter )

overridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 122 of file InternalOfflineFast.cxx.

                                                                {
    if(!m_needsupdate.load(std::memory_order_acquire)) for(const auto& x : m_map)  deleter(x.second);
    else {
      for(size_t i=0 ;i < m_fullMap.size(); ++i){
         if(m_fullMap[i]) deleter(m_fullMap[i]);
      }
    }
}

fetchOrCreate() [1/2]

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

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 117 of file InternalOfflineFast.cxx.

{
    throw std::runtime_error("Not implemented in offline mode");
}

fetchOrCreate() [2/2]

StatusCode InternalOfflineFast::fetchOrCreate ( IdentifierHash hashId )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 114 of file InternalOfflineFast.cxx.

                                                            {
    throw std::runtime_error("Not implemented in offline mode");
}

findIndexPtr()

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

overridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 94 of file InternalOfflineFast.cxx.

                                                                                 {
    if(hashId >= m_fullMap.size()) return nullptr;
    return m_fullMap[hashId];
}

fullSize()

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

inlineoverridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 33 of file InternalOfflineFast.h.

{return m_fullMap.size();}

getAllCurrentHashes()

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

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 35 of file InternalOfflineFast.cxx.

                                                                         {
    if(m_needsupdate.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 > & InternalOfflineFast::getAllHashPtrPair ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 51 of file InternalOfflineFast.cxx.

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

indexFind()

InternalConstItr InternalOfflineFast::indexFind ( IdentifierHash hashId ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 62 of file InternalOfflineFast.cxx.

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

insert()

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

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 87 of file InternalOfflineFast.cxx.

                                                                       {
    if(m_fullMap[hashId]!= nullptr) return false; //already in
    m_fullMap[hashId] = ptr;
    m_needsupdate.store(true, std::memory_order_relaxed);
    return true;
}

numberOfCollections()

size_t InternalOfflineFast::numberOfCollections ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 69 of file InternalOfflineFast.cxx.

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

removeCollection()

void * InternalOfflineFast::removeCollection ( IdentifierHash hashId )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 107 of file InternalOfflineFast.cxx.

                                                                   {
   void* ptr ATLAS_THREAD_SAFE = const_cast< void* > (m_fullMap[hashId]);
   m_fullMap[hashId] = nullptr;
   m_needsupdate.store(true, std::memory_order_relaxed);
   return ptr;
}

tryAddFromCache() [1/2]

bool InternalOfflineFast::tryAddFromCache ( IdentifierHash hashId )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 19 of file InternalOfflineFast.cxx.

{
    return m_fullMap[hash] != nullptr;
}

tryAddFromCache() [2/2]

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

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 15 of file InternalOfflineFast.cxx.

                                                                                                  {
    return m_fullMap[hash] != nullptr;
}

wait()

void InternalOfflineFast::wait ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 24 of file InternalOfflineFast.cxx.

                                     {
   std::scoped_lock lock (m_waitMutex);
   if(m_needsupdate.load(std::memory_order_acquire) == false) return;
   m_map.clear();
   for(size_t i=0 ;i < m_fullMap.size(); ++i){
    if(m_fullMap[i]) m_map.emplace_back(i, m_fullMap[i]);
   }
   m_map.shrink_to_fit();
   m_needsupdate.store(false, std::memory_order_release);
}

Member Data Documentation

ATLAS_THREAD_SAFE [1/3]

std::atomic<bool> m_needsupdate EventContainers::InternalOfflineFast::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 45 of file InternalOfflineFast.h.

ATLAS_THREAD_SAFE [2/3]

std::mutex m_waitMutex EventContainers::InternalOfflineFast::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 44 of file InternalOfflineFast.h.

ATLAS_THREAD_SAFE [3/3]

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

mutableprivate

Definition at line 42 of file InternalOfflineFast.h.

m_fullMap

std::vector<const void*> EventContainers::InternalOfflineFast::m_fullMap

private

Definition at line 43 of file InternalOfflineFast.h.

---

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

• InternalOfflineFast.h
• InternalOfflineFast.cxx