#include <IdentifiableCacheBase.h>

Inheritance diagram for EventContainers::IdentifiableCacheBase:

Collaboration diagram for EventContainers::IdentifiableCacheBase:

Classes
struct	IMaker

Public Types
typedef std::true_type	thread_safe

Public Member Functions
const void *	find (IdentifierHash hash) noexcept
	Return payload if there, null if not there. More...

const void *	findWait (IdentifierHash hash)
	Retrieve ptr, will wait if there is something in progress. More...

const void *	get (IdentifierHash hash)
	Try to make payload if not there. More...

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

Friends
class	InternalOnline

Detailed Description

Definition at line 22 of file IdentifiableCacheBase.h.

Member Typedef Documentation

◆ 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 205 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 252 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 224 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 243 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.

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

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 177 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 103 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 124 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.

81 { return m_vec.size(); }

◆ get()

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

Try to make payload if not there.

Definition at line 137 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 (...) {
        // FIXME: Can this be done with RAII?
        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 191 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.

61 { return m_maker!=nullptr; }

◆ itemAborted()

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

Returns 1 is the item has been aborted otherwise 0.

Definition at line 91 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 97 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 132 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 186 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 112 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 Function Documentation

◆ InternalOnline

friend class InternalOnline

friend

Definition at line 93 of file IdentifiableCacheBase.h.

Member Data Documentation

◆ ABORTEDflag

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

staticconstexpr

Definition at line 28 of file IdentifiableCacheBase.h.

◆ INVALIDflag

constexpr 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:

Classes

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Private Types

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ lock_t

◆ mutex_t

◆ thread_safe

◆ uniqueLock

Constructor & Destructor Documentation

◆ IdentifiableCacheBase()

◆ ~IdentifiableCacheBase()

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ addLock() [1/2]

◆ addLock() [2/2]

◆ cleanUp()

◆ clear()

◆ createSet()

◆ find()

◆ findWait()

◆ fullSize()

◆ get()

◆ ids()

◆ IMakerPresent()

◆ itemAborted()

◆ itemInProgress()

◆ notifyHash()

◆ numberOfHashes()

◆ tryLock()

◆ waitFor()

Friends And Related Function Documentation

◆ InternalOnline

Member Data Documentation

◆ ABORTEDflag

◆ INVALIDflag

◆ m_currentHashes

◆ m_maker

◆ m_mutex

◆ m_vec