#include <IdentifiableCache.h>

Inheritance diagram for EventContainers::IdentifiableCache< T >:

Collaboration diagram for EventContainers::IdentifiableCache< T >:

Classes
class	Maker

Public Types
typedef std::true_type	thread_safe

Public Member Functions
	IdentifiableCache (IdentifierHash maxHash, const Maker *maker)

	IdentifiableCache (IdentifierHash maxHash, const Maker *maker, size_t lockBucketSize)

	~IdentifiableCache ()

const T *	find (IdentifierHash hash)

const T *	findWait (IdentifierHash hash)

const T *	get (IdentifierHash hash)

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

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

void	clearCache ()

std::vector< IdentifierHash >	ids ()
	In a threaded situation this collection will be valid but will not container hashes later added. More...

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

std::pair< bool, const void * >	add (IdentifierHash hash, void_unique_ptr 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

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. More...

int	itemAborted (IdentifierHash)
	Returns 1 is the item has been aborted otherwise 0. More...

int	itemInProgress (IdentifierHash)
	Returns 1 is the item is inprogress otherwise 0. More...

const void *	waitFor (IdentifierHash)
	Halts the thread until the require hash is completed or aborted. More...

void	createSet (const std::vector< IdentifierHash > &hashes, std::vector< bool > &mask)
	Create a set of hashes, updates an IDC mask as appropriate. More...

size_t	fullSize () const

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

Static Public Attributes
static constexpr uintptr_t	INVALIDflag = UINTPTR_MAX

static constexpr uintptr_t	ABORTEDflag = UINTPTR_MAX-1

static constexpr size_t	s_defaultBucketSize =2

Protected Member Functions
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::unique_ptr< mutexPair[]>	m_HoldingMutexes
	Pool of mutexes used for waiting on completion if in a concurrent environment. More...

size_t	m_NMutexes

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. More...

Detailed Description

template<class T>
class EventContainers::IdentifiableCache< T >

Definition at line 27 of file IdentifiableCache.h.

Member Typedef Documentation

◆ lock_t

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

privateinherited

Definition at line 108 of file IdentifiableCacheBase.h.

◆ mutex_t

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

privateinherited

Definition at line 107 of file IdentifiableCacheBase.h.

◆ thread_safe

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

inherited

Definition at line 39 of file IdentifiableCacheBase.h.

◆ uniqueLock

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

privateinherited

Definition at line 109 of file IdentifiableCacheBase.h.

Constructor & Destructor Documentation

◆ IdentifiableCache() [1/2]

template<class T >

EventContainers::IdentifiableCache< T >::IdentifiableCache	(	IdentifierHash	maxHash,
		const Maker *	maker
	)

inline

Definition at line 43 of file IdentifiableCache.h.

     : IdentifiableCacheBase (maxHash, maker)
   {
   }

◆ IdentifiableCache() [2/2]

template<class T >

EventContainers::IdentifiableCache< T >::IdentifiableCache	(	IdentifierHash	maxHash,
		const Maker *	maker,
		size_t	lockBucketSize
	)

inline

Definition at line 48 of file IdentifiableCache.h.

     : IdentifiableCacheBase (maxHash, maker, lockBucketSize)
   {
   }

◆ ~IdentifiableCache()

template<class T >

EventContainers::IdentifiableCache< T >::~IdentifiableCache ( )

inline

Definition at line 53 of file IdentifiableCache.h.

   {
     IdentifiableCacheBase::cleanUp (void_unique_ptr::Deleter<T>::deleter);
   }

Member Function Documentation

◆ add() [1/4]

template<class T >

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

inline

Definition at line 74 of file IdentifiableCache.h.

   {
     return IdentifiableCacheBase::add (hash, p);
   }

◆ add() [2/4]

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

noexceptinherited

Definition at line 247 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() [3/4]

template<class T >

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

inline

Definition at line 79 of file IdentifiableCache.h.

   {
     return IdentifiableCacheBase::add (hash, void_unique_ptr(std::move(p)));
   }

◆ add() [4/4]

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

noexceptinherited

Definition at line 294 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
	)

noexceptinherited

Definition at line 266 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
	)

noexceptinherited

Definition at line 285 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 )

protectedinherited

Definition at line 102 of file IdentifiableCacheBase.cxx.

 {
   std::atomic_thread_fence(std::memory_order_acquire);
   if(0 != m_currentHashes.load(std::memory_order_relaxed)){ //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 )

protectedinherited

Definition at line 83 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
   }
 }

◆ clearCache()

template<class T >

void EventContainers::IdentifiableCache< T >::clearCache ( )

inline

Definition at line 84 of file IdentifiableCache.h.

                    {
     IdentifiableCacheBase::clear (void_unique_ptr::Deleter<T>::deleter);
   }

◆ createSet()

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

inherited

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

Definition at line 219 of file IdentifiableCacheBase.cxx.

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

◆ find()

template<class T >

const T* EventContainers::IdentifiableCache< T >::find ( IdentifierHash hash )

inline

Definition at line 59 of file IdentifiableCache.h.

   {
     return reinterpret_cast<const T*> (IdentifiableCacheBase::find (hash));
   }

◆ findWait()

template<class T >

const T* EventContainers::IdentifiableCache< T >::findWait ( IdentifierHash hash )

inline

Definition at line 64 of file IdentifiableCache.h.

   {
     return reinterpret_cast<const T*> (IdentifiableCacheBase::findWait (hash));
   }

◆ fullSize()

size_t EventContainers::IdentifiableCacheBase::fullSize ( ) const

inlineinherited

Definition at line 89 of file IdentifiableCacheBase.h.

89 { return m_vec.size(); }

◆ get()

template<class T >

const T* EventContainers::IdentifiableCache< T >::get ( IdentifierHash hash )

inline

Definition at line 69 of file IdentifiableCache.h.

   {
     return reinterpret_cast<const T*> (IdentifiableCacheBase::get (hash));
   }

◆ ids()

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

inherited

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

Definition at line 233 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

inlineinherited

Definition at line 69 of file IdentifiableCacheBase.h.

69 { return m_maker!=nullptr; }

◆ itemAborted()

int EventContainers::IdentifiableCacheBase::itemAborted ( IdentifierHash hash )

inherited

Returns 1 is the item has been aborted otherwise 0.

Definition at line 114 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 )

inherited

Returns 1 is the item is inprogress otherwise 0.

Definition at line 120 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 )

protectedinherited

Definition at line 166 of file IdentifiableCacheBase.cxx.

 {
 #ifndef __cpp_lib_atomic_wait
     if(m_NMutexes==0) return;
     size_t slot = hash % m_NMutexes;
     mutexPair &mutpair = m_HoldingMutexes[slot];
     lock_t lk(mutpair.mutex);
     mutpair.condition.notify_all();
 #else
     m_vec[hash].notify_all();
 #endif
 }

◆ numberOfHashes()

size_t EventContainers::IdentifiableCacheBase::numberOfHashes ( )

inherited

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

Definition at line 228 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
	)

inherited

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 57 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
 #ifndef __cpp_lib_atomic_wait
       size_t slot = hash % m_NMutexes;
       auto &mutexpair = m_HoldingMutexes[slot];
       lock.LockOn(&m_vec[hash], &mutexpair);
 #else
       //Setup the IDC_WriteHandle to "lock" on this hash's pointer
       lock.LockOn(&m_vec[hash]);
 #endif
       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 )

inherited

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

Definition at line 135 of file IdentifiableCacheBase.cxx.

 {
    std::atomic<const void*> &myatomic = m_vec[hash];
    const void* item = myatomic.load(std::memory_order_acquire);
 #ifndef __cpp_lib_atomic_wait
    if(m_NMutexes != 0 && item == INVALID){
       size_t slot = hash % m_NMutexes;
       mutexPair &mutpair = m_HoldingMutexes[slot];
       uniqueLock lk(mutpair.mutex);
       while( (item =myatomic.load(std::memory_order_acquire)) ==  INVALID){
         mutpair.condition.wait(lk);
       }
    }
 #else
    //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);
    }
 #endif
    return item;
 }

Member Data Documentation

◆ ABORTEDflag

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

staticconstexprinherited

Definition at line 31 of file IdentifiableCacheBase.h.

◆ INVALIDflag

constexpr uintptr_t EventContainers::IdentifiableCacheBase::INVALIDflag = UINTPTR_MAX

staticconstexprinherited

Definition at line 30 of file IdentifiableCacheBase.h.

◆ m_currentHashes

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

privateinherited

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

Definition at line 117 of file IdentifiableCacheBase.h.

◆ m_HoldingMutexes

std::unique_ptr<mutexPair[]> EventContainers::IdentifiableCacheBase::m_HoldingMutexes

privateinherited

Pool of mutexes used for waiting on completion if in a concurrent environment.

Definition at line 113 of file IdentifiableCacheBase.h.

◆ m_maker

const IMaker* EventContainers::IdentifiableCacheBase::m_maker

privateinherited

Definition at line 105 of file IdentifiableCacheBase.h.

◆ m_mutex

mutex_t EventContainers::IdentifiableCacheBase::m_mutex

privateinherited

Definition at line 110 of file IdentifiableCacheBase.h.

◆ m_NMutexes

size_t EventContainers::IdentifiableCacheBase::m_NMutexes

privateinherited

Definition at line 114 of file IdentifiableCacheBase.h.

◆ m_vec

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

privateinherited

Definition at line 103 of file IdentifiableCacheBase.h.

◆ s_defaultBucketSize

constexpr size_t EventContainers::IdentifiableCacheBase::s_defaultBucketSize =2

staticconstexprinherited

Definition at line 36 of file IdentifiableCacheBase.h.

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

IdentifiableCache.h

Classes

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Private Types

Private Attributes

Detailed Description

template<class T> class EventContainers::IdentifiableCache< T >

Member Typedef Documentation

◆ lock_t

◆ mutex_t

◆ thread_safe

◆ uniqueLock

Constructor & Destructor Documentation

◆ IdentifiableCache() [1/2]

◆ IdentifiableCache() [2/2]

◆ ~IdentifiableCache()

Member Function Documentation

◆ add() [1/4]

◆ add() [2/4]

◆ add() [3/4]

◆ add() [4/4]

◆ addLock() [1/2]

◆ addLock() [2/2]

◆ cleanUp()

◆ clear()

◆ clearCache()

◆ createSet()

◆ find()

◆ findWait()

◆ fullSize()

◆ get()

◆ ids()

◆ IMakerPresent()

◆ itemAborted()

◆ itemInProgress()

◆ notifyHash()

◆ numberOfHashes()

◆ tryLock()

◆ waitFor()

Member Data Documentation

◆ ABORTEDflag

◆ INVALIDflag

◆ m_currentHashes

◆ m_HoldingMutexes

◆ m_maker

◆ m_mutex

◆ m_NMutexes

◆ m_vec

◆ s_defaultBucketSize

template<class T>
class EventContainers::IdentifiableCache< T >