EventContainers::IdentifiableCacheBase Class Reference

#include <IdentifiableCacheBase.h>

Inherited by EventContainers::IdentifiableCache< InDetRawDataCollection< PixelRDORawData > >, EventContainers::IdentifiableCache< InDetRawDataCollection< SCT_RDORawData > >, EventContainers::IdentifiableCache< InDetRawDataCollection< TRT_RDORawData > >, EventContainers::IdentifiableCache< PixelClusterCollection >, EventContainers::IdentifiableCache< SCT_ClusterCollection >, EventContainers::IdentifiableCache< TRT_DriftCircleCollection >, EventContainers::IdentifiableCache< CscRawDataCollection >, EventContainers::IdentifiableCache< MdtCsm >, EventContainers::IdentifiableCache< Muon::MM_RawDataCollection >, EventContainers::IdentifiableCache< RpcPad >, EventContainers::IdentifiableCache< Muon::STGC_RawDataCollection >, EventContainers::IdentifiableCache< TgcL1Rdo >, EventContainers::IdentifiableCache< TgcRdo >, EventContainers::IdentifiableCache< Muon::CscPrepDataCollection >, EventContainers::IdentifiableCache< Muon::CscStripPrepDataCollection >, EventContainers::IdentifiableCache< Muon::MdtPrepDataCollection >, EventContainers::IdentifiableCache< Muon::RpcPrepDataCollection >, EventContainers::IdentifiableCache< Muon::TgcPrepDataCollection >, EventContainers::IdentifiableCache< Muon::sTgcPrepDataCollection >, EventContainers::IdentifiableCache< Muon::MMPrepDataCollection >, EventContainers::IdentifiableCache< Muon::RpcCoinDataCollection >, EventContainers::IdentifiableCache< Muon::TgcCoinDataCollection >, EventContainers::IdentifiableCache< SpacePointCollection >, and EventContainers::IdentifiableCache< T >.

Collaboration diagram for EventContainers::IdentifiableCacheBase:

Classes
class	void_unique_ptr
struct	IMaker

Public Types
typedef std::true_type	thread_safe
typedef void	deleter_f(const void *p)

Public Member Functions
const void *	find (IdentifierHash hash) noexcept
	Return payload if there, null if not there.
const void *	findWait (IdentifierHash hash)
	Retrieve ptr, will wait if there is something in progress.
const void *	get (IdentifierHash hash)
	Try to make payload if not there.
std::vector< IdentifierHash >	ids ()
	In a threaded situation this collection will be valid but will not container hashes later added.
std::pair< bool, const void * >	add (IdentifierHash hash, const void *p) noexcept
std::pair< bool, const void * >	addLock (IdentifierHash hash, const void *p) noexcept
std::pair< bool, const void * >	addLock (IdentifierHash hash, void_unique_ptr p) noexcept
std::pair< bool, const void * >	add (IdentifierHash hash, void_unique_ptr p) noexcept
bool	IMakerPresent () const
int	tryLock (IdentifierHash, IDC_WriteHandleBase &, std::vector< IdentifierHash > &)
	Checks if the item is completed if it is not started it extablishes lock (returns 0), If it is started but not completed it adds to wait list (returns 1) If the item is already completed it returns 2 If the item is aborted it does nothing and returns 3.
int	itemAborted (IdentifierHash)
	Returns 1 is the item has been aborted otherwise 0.
int	itemInProgress (IdentifierHash)
	Returns 1 is the item is inprogress otherwise 0.
const void *	waitFor (IdentifierHash)
	Halts the thread until the require hash is completed or aborted.
void	createSet (const std::vector< IdentifierHash > &hashes, std::vector< bool > &mask)
	Create a set of hashes, updates an IDC mask as appropriate.
size_t	fullSize () const
size_t	numberOfHashes ()
	In a concurrent situation this number isn't necessarily perfectly synchronised with ids().size().

Static Public Attributes
static constexpr uintptr_t	INVALIDflag = UINTPTR_MAX
static constexpr uintptr_t	ABORTEDflag = UINTPTR_MAX-1

Protected Member Functions
	IdentifiableCacheBase (IdentifierHash maxHash, const IMaker *maker)
	~IdentifiableCacheBase ()
void	clear (deleter_f *deleter)
void	cleanUp (deleter_f *deleter)
void	notifyHash (IdentifierHash hash)

Private Types
typedef std::mutex	mutex_t
typedef std::scoped_lock< mutex_t >	lock_t
typedef std::unique_lock< mutex_t >	uniqueLock

Private Attributes
std::vector< std::atomic< const void * > >	m_vec
const IMaker *	m_maker
mutex_t	m_mutex
std::atomic< size_t >	m_currentHashes
	Holds the number of valid hashes in container, in concurrent use it is not guaranteed to be up to date.

Friends
class	InternalOnline

Detailed Description

Definition at line 22 of file IdentifiableCacheBase.h.

Member Typedef Documentation

deleter_f

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

Definition at line 14 of file IdentifiableCacheBase.h.

lock_t

typedef std::scoped_lock<mutex_t> EventContainers::IdentifiableCacheBase::lock_t

private

Definition at line 97 of file IdentifiableCacheBase.h.

mutex_t

typedef std::mutex EventContainers::IdentifiableCacheBase::mutex_t

private

Definition at line 96 of file IdentifiableCacheBase.h.

thread_safe

typedef std::true_type EventContainers::IdentifiableCacheBase::thread_safe

Definition at line 31 of file IdentifiableCacheBase.h.

uniqueLock

typedef std::unique_lock<mutex_t> EventContainers::IdentifiableCacheBase::uniqueLock

private

Definition at line 98 of file IdentifiableCacheBase.h.

Constructor & Destructor Documentation

IdentifiableCacheBase()

EventContainers::IdentifiableCacheBase::IdentifiableCacheBase ( IdentifierHash maxHash, const IMaker * maker )

protected

Definition at line 29 of file IdentifiableCacheBase.cxx.

  : m_vec(maxHash),
    m_maker (maker),
    m_currentHashes(0)
{
}

~IdentifiableCacheBase()

EventContainers::IdentifiableCacheBase::~IdentifiableCacheBase ( )

protecteddefault

Member Function Documentation

add() [1/2]

std::pair< bool, const void * > EventContainers::IdentifiableCacheBase::add ( IdentifierHash hash, const void * p )

noexcept

Definition at line 204 of file IdentifiableCacheBase.cxx.

{
  if (ATH_UNLIKELY(hash >= m_vec.size())) return std::make_pair(false, nullptr);
  if(p==nullptr) return std::make_pair(false, nullptr);
  const void* nul=nullptr;
  if(m_vec[hash].compare_exchange_strong(nul, p, std::memory_order_release, std::memory_order_relaxed)){
     m_currentHashes.fetch_add(1, std::memory_order_relaxed);
     return std::make_pair(true, p);
  }
  const void* invalid = INVALID;
  if(m_vec[hash].compare_exchange_strong(invalid, p, std::memory_order_release, std::memory_order_acquire)){
     m_currentHashes.fetch_add(1, std::memory_order_relaxed);
     notifyHash(hash);
     return std::make_pair(true, p);
  }
  return std::make_pair(false, invalid);
}

add() [2/2]

std::pair< bool, const void * > EventContainers::IdentifiableCacheBase::add ( IdentifierHash hash, void_unique_ptr p )

noexcept

Definition at line 251 of file IdentifiableCacheBase.cxx.

{
  std::pair<bool, const void*> b = add(hash, p.get());
  if(b.first) p.release();
  return b;
}

addLock() [1/2]

std::pair< bool, const void * > EventContainers::IdentifiableCacheBase::addLock ( IdentifierHash hash, const void * p )

noexcept

Definition at line 223 of file IdentifiableCacheBase.cxx.

{ //Same as method above except we check for invalid state first,
  // more optimal for calling using writehandle lock method
  assert(hash < m_vec.size());
  if(p==nullptr) return std::make_pair(false, nullptr);
  const void* invalid = INVALID;
  if(m_vec[hash].compare_exchange_strong(invalid, p, std::memory_order_release, std::memory_order_relaxed)){
     m_currentHashes.fetch_add(1, std::memory_order_relaxed);
     notifyHash(hash);
     return std::make_pair(true, p);
  }
  const void* nul=nullptr;
  if(m_vec[hash].compare_exchange_strong(nul, p, std::memory_order_release, std::memory_order_acquire)){
     m_currentHashes.fetch_add(1, std::memory_order_relaxed);
     return std::make_pair(true, p);
  }
  return std::make_pair(false, nul);
}

addLock() [2/2]

std::pair< bool, const void * > EventContainers::IdentifiableCacheBase::addLock ( IdentifierHash hash, void_unique_ptr p )

noexcept

Definition at line 242 of file IdentifiableCacheBase.cxx.

{
  std::pair<bool, const void*> b = addLock(hash, p.get());
  if(b.first) p.release();
  return b;
}

cleanUp()

void EventContainers::IdentifiableCacheBase::cleanUp ( deleter_f * deleter )

protected

Definition at line 79 of file IdentifiableCacheBase.cxx.

{
  if(0 != m_currentHashes.load(std::memory_order_acquire)){ //Reduce overhead if cache was unused
    size_t s = m_vec.size();
    for (size_t i=0; i<s ;i++) {
      const void* p = m_vec[i].load(std::memory_order_relaxed);
      if(p && p < ABORTED) deleter (p);
    }
  }
}

clear()

void EventContainers::IdentifiableCacheBase::clear ( deleter_f * deleter )

protected

Definition at line 60 of file IdentifiableCacheBase.cxx.

{
  size_t s = m_vec.size();
  if(0 != m_currentHashes.load(std::memory_order_relaxed)){
     for (size_t i=0; i<s ;i++) {
       const void* ptr = m_vec[i].load(std::memory_order_relaxed);
       m_vec[i].store(nullptr, std::memory_order_relaxed);
       if (ptr && ptr < ABORTED){
         deleter (ptr);
      }
     }
     m_currentHashes.store(0, std::memory_order_relaxed);
  }else{
    for (size_t i=0; i<s ;i++) m_vec[i].store(nullptr, std::memory_order_relaxed);//Need to clear incase of aborts
  }
}

createSet()

void EventContainers::IdentifiableCacheBase::createSet	(	const std::vector< IdentifierHash > &	hashes,
		std::vector< bool > &	mask )

Create a set of hashes, updates an IDC mask as appropriate.

Definition at line 176 of file IdentifiableCacheBase.cxx.

                                                                                                    {
   assert(mask.size() == fullSize());
   for(IdentifierHash hash : hashes){
      const void* ptr = get(hash);
      if(ptr !=nullptr) mask[hash] = true;
   }
}

find()

const void * EventContainers::IdentifiableCacheBase::find ( IdentifierHash hash )

noexcept

Return payload if there, null if not there.

Definition at line 102 of file IdentifiableCacheBase.cxx.

{
  if (ATH_UNLIKELY(hash >= m_vec.size())) return nullptr;
  const void* p = m_vec[hash].load(std::memory_order_acquire);
  if (p >= ABORTED)
    return nullptr;
  return p;
}

findWait()

const void * EventContainers::IdentifiableCacheBase::findWait

(

IdentifierHash

hash

)

Retrieve ptr, will wait if there is something in progress.

Definition at line 123 of file IdentifiableCacheBase.cxx.

{
  if (ATH_UNLIKELY(hash >= m_vec.size())) return nullptr;
  const void* p = waitFor(hash);
  if(p>=ABORTED) return nullptr;
  return p;
}

fullSize()

size_t EventContainers::IdentifiableCacheBase::fullSize ( ) const

inline

Definition at line 81 of file IdentifiableCacheBase.h.

{ return m_vec.size(); }

get()

const void * EventContainers::IdentifiableCacheBase::get

(

IdentifierHash

hash

)

Try to make payload if not there.

Definition at line 136 of file IdentifiableCacheBase.cxx.

{
  // If it's there already, return directly without locking.
  const void* ptr = nullptr;
  if (ATH_UNLIKELY(hash >= m_vec.size())) return ptr;
 
  if(m_vec[hash].compare_exchange_strong(ptr, INVALID) ) {//Exchanges ptr with current value!!
     // Make the payload.
     if(m_maker == nullptr){
        m_vec[hash].store( ABORTED );
        return nullptr;
     }
     uniqueLock lock(m_mutex, std::defer_lock);
     if(!m_maker->m_IsReEntrant) lock.lock();//Allow reentrant or non reentrant makers
 
     try {
       ptr = m_maker->typelessMake (hash).release();
     }
     catch (...) {
       m_vec[hash].store( ABORTED );
       notifyHash(hash);
       throw;
     }
     assert(m_vec[hash] == INVALID);
     if(ptr){
        m_vec[hash].store( ptr );
        m_currentHashes++;
     }else{
        m_vec[hash].store( ABORTED );
     }
     notifyHash(hash);
  }
  else if(ptr == INVALID){
     ptr= waitFor(hash);
  }
  if(ptr == ABORTED) return nullptr;
  assert(ptr < ABORTED);
  return ptr;
}

ids()

std::vector< IdentifierHash > EventContainers::IdentifiableCacheBase::ids

(

)

In a threaded situation this collection will be valid but will not container hashes later added.

Definition at line 190 of file IdentifiableCacheBase.cxx.

{
  std::vector<IdentifierHash> ret;
  ret.reserve (m_currentHashes.load(std::memory_order_relaxed));
  size_t s = m_vec.size();
  for (size_t i =0; i<s; i++) {
    const void* p = m_vec[i].load(std::memory_order_relaxed);
    if (p && p < ABORTED)
      ret.push_back (i);
  }
  return ret;
}

IMakerPresent()

bool EventContainers::IdentifiableCacheBase::IMakerPresent ( ) const

inline

Definition at line 61 of file IdentifiableCacheBase.h.

{ return m_maker!=nullptr; }

itemAborted()

int EventContainers::IdentifiableCacheBase::itemAborted

(

IdentifierHash

hash

)

Returns 1 is the item has been aborted otherwise 0.

Definition at line 90 of file IdentifiableCacheBase.cxx.

                                                          {
   const void* p = m_vec[hash].load(std::memory_order_relaxed); //Relaxed because it is not returning a pointer to anything
   return (p == ABORTED);
}

itemInProgress()

int EventContainers::IdentifiableCacheBase::itemInProgress

(

IdentifierHash

hash

)

Returns 1 is the item is inprogress otherwise 0.

Definition at line 96 of file IdentifiableCacheBase.cxx.

                                                             {
   const void* p = m_vec[hash].load(std::memory_order_relaxed); //Relaxed because it is not returning a pointer to anything
   return (p == INVALID);
}

notifyHash()

void EventContainers::IdentifiableCacheBase::notifyHash ( IdentifierHash hash )

protected

Definition at line 131 of file IdentifiableCacheBase.cxx.

{
    m_vec[hash].notify_all();
}

numberOfHashes()

size_t EventContainers::IdentifiableCacheBase::numberOfHashes

(

)

In a concurrent situation this number isn't necessarily perfectly synchronised with ids().size().

Definition at line 185 of file IdentifiableCacheBase.cxx.

{
  return m_currentHashes.load(std::memory_order_relaxed); //Not to be used for syncing
}

tryLock()

int EventContainers::IdentifiableCacheBase::tryLock	(	IdentifierHash	hash,
		IDC_WriteHandleBase &	lock,
		std::vector< IdentifierHash > &	wait )

Checks if the item is completed if it is not started it extablishes lock (returns 0), If it is started but not completed it adds to wait list (returns 1) If the item is already completed it returns 2 If the item is aborted it does nothing and returns 3.

Definition at line 40 of file IdentifiableCacheBase.cxx.

                                                                                                                 {
   const void *ptr1 =nullptr;
 
   if(m_vec[hash].compare_exchange_strong(ptr1, INVALID, std::memory_order_relaxed, std::memory_order_relaxed)){//atomic swap (replaces ptr1 with value)
      //First call
      //Setup the IDC_WriteHandle to "lock" on this hash's pointer
      lock.LockOn(&m_vec[hash]);
      return 0;
   }
 
   if(ptr1 == INVALID){
      //Second call while not finished
      wait.emplace_back(hash);
      return 1;
   }
   if(ptr1 == ABORTED) return 3;
   return 2;   //Already completed
}

waitFor()

const void * EventContainers::IdentifiableCacheBase::waitFor

(

IdentifierHash

hash

)

Halts the thread until the require hash is completed or aborted.

Definition at line 111 of file IdentifiableCacheBase.cxx.

{
   std::atomic<const void*> &myatomic = m_vec[hash];
   const void* item = myatomic.load(std::memory_order_acquire);
   //Wait until pointer is set then retrieve and verify
   while(item == INVALID){//Loop to check for spurious wakeups
      myatomic.wait(item, std::memory_order_relaxed);
      item = myatomic.load(std::memory_order_acquire);
   }
   return item;
}

Friends And Related Symbol Documentation

InternalOnline

friend class InternalOnline

friend

Definition at line 93 of file IdentifiableCacheBase.h.

Member Data Documentation

ABORTEDflag

uintptr_t EventContainers::IdentifiableCacheBase::ABORTEDflag = UINTPTR_MAX-1

staticconstexpr

Definition at line 28 of file IdentifiableCacheBase.h.

INVALIDflag

uintptr_t EventContainers::IdentifiableCacheBase::INVALIDflag = UINTPTR_MAX

staticconstexpr

Definition at line 27 of file IdentifiableCacheBase.h.

m_currentHashes

std::atomic<size_t> EventContainers::IdentifiableCacheBase::m_currentHashes

private

Holds the number of valid hashes in container, in concurrent use it is not guaranteed to be up to date.

Definition at line 101 of file IdentifiableCacheBase.h.

m_maker

const IMaker* EventContainers::IdentifiableCacheBase::m_maker

private

Definition at line 94 of file IdentifiableCacheBase.h.

m_mutex

mutex_t EventContainers::IdentifiableCacheBase::m_mutex

private

Definition at line 99 of file IdentifiableCacheBase.h.

m_vec

std::vector<std::atomic<const void*> > EventContainers::IdentifiableCacheBase::m_vec

private

Definition at line 92 of file IdentifiableCacheBase.h.

---

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

• IdentifiableCacheBase.h
• IdentifiableCacheBase.cxx