#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

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::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 100 of file IdentifiableCacheBase.h.

◆ mutex_t

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

privateinherited

Definition at line 99 of file IdentifiableCacheBase.h.

◆ thread_safe

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

inherited

Definition at line 34 of file IdentifiableCacheBase.h.

◆ uniqueLock

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

privateinherited

Definition at line 101 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 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() [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 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
	)

noexceptinherited

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
	)

noexceptinherited

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 )

protectedinherited

Definition at line 78 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 59 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 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()

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 84 of file IdentifiableCacheBase.h.

84 { 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 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

inlineinherited

Definition at line 64 of file IdentifiableCacheBase.h.

64 { 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 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 )

inherited

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 )

protectedinherited

Definition at line 131 of file IdentifiableCacheBase.cxx.

 {
     m_vec[hash].notify_all();
 }

◆ numberOfHashes()

size_t EventContainers::IdentifiableCacheBase::numberOfHashes ( )

inherited

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
	)

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 39 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 )

inherited

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;
 }

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 104 of file IdentifiableCacheBase.h.

◆ m_maker

const IMaker* EventContainers::IdentifiableCacheBase::m_maker

privateinherited

Definition at line 97 of file IdentifiableCacheBase.h.

◆ m_mutex

mutex_t EventContainers::IdentifiableCacheBase::m_mutex

privateinherited

Definition at line 102 of file IdentifiableCacheBase.h.

◆ m_vec

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

privateinherited

Definition at line 95 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_maker

◆ m_mutex

◆ m_vec

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