xAOD::Internal::THolderCache Class Reference

Singleton, thread-safe THolder cache. More...

#include <THolderCache.h>

Collaboration diagram for xAOD::Internal::THolderCache:

Public Member Functions
std::pair< bool, ::TClass * >	getClass (const std::type_info &ti) const
	Get the dictionary for a given type info.
void	addClass (const std::type_info &ti, ::TClass *cl)
	Add the dictionary for a given type.
int	getRef (void *ptr) const
	Get the reference count of an object in memory.
int	incRef (void *ptr)
	Increment the reference count of an object in memory.
int	decRef (void *ptr)
	Decrease the reference count of an object in memory.

Static Public Member Functions
static THolderCache &	instance ()
	Singleton accessor.

Private Member Functions
	THolderCache ()
	Hide the constructor of the class from the outside.
	THolderCache (const THolderCache &)=delete
	Delete the copy constructor.

Private Attributes
std::map< const std::type_info *, TClass * >	m_typeMap
	The type map.
std::map< void *, int >	m_refMap
	The reference count map.
std::shared_timed_mutex	m_typeMapMutex
	Mutex for the type map.
std::shared_timed_mutex	m_refMapMutex
	Mutex for the reference count map.

Detailed Description

Singleton, thread-safe THolder cache.

The xAOD::THolder class needs to keep some global caches internally, due to the way it manages its own memory. This singleton helps doing that in a thread-safe way.

Author

Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h

Definition at line 31 of file THolderCache.h.

Constructor & Destructor Documentation

THolderCache() [1/2]

xAOD::Internal::THolderCache::THolderCache ( )

private

Hide the constructor of the class from the outside.

Definition at line 105 of file THolderCache.cxx.

         : m_typeMap(), m_refMap(), m_typeMapMutex(), m_refMapMutex() {
 
      }

THolderCache() [2/2]

xAOD::Internal::THolderCache::THolderCache ( const THolderCache & )

privatedelete

Delete the copy constructor.

Member Function Documentation

addClass()

void xAOD::Internal::THolderCache::addClass	(	const std::type_info &	ti,
		::TClass *	cl )

Add the dictionary for a given type.

Definition at line 49 of file THolderCache.cxx.

                                                                      {
 
         // Get a "write lock":
         unique_lock_t lock( m_typeMapMutex );
 
         // Extend the map:
         m_typeMap[ &ti ] = cl;
      }

decRef()

int xAOD::Internal::THolderCache::decRef

(

void *

ptr

)

Decrease the reference count of an object in memory.

Definition at line 81 of file THolderCache.cxx.

                                          {
 
         // Get a "write lock":
         unique_lock_t lock( m_refMapMutex );
 
         // Check if we know about this pointer:
         auto itr = m_refMap.find( ptr );
         if( itr == m_refMap.end() ) {
            return 0;
         }
 
         // Decrease the reference count, and remember the value:
         const int count = --( m_refMap[ ptr ] );
 
         // If the reference count went down to zero, let's forget about this
         // pointer:
         if( count == 0 ) {
            m_refMap.erase( itr );
         }
 
         // Return the new count:
         return count;
      }

getClass()

std::pair< bool,::TClass * > xAOD::Internal::THolderCache::getClass

(

const std::type_info &

ti

)

const

Get the dictionary for a given type info.

Definition at line 35 of file THolderCache.cxx.

                                                           {
 
         // Get a "read lock":
         shared_lock_t lock( m_typeMapMutex );
 
         // Look for the type in the cache:
         auto itr = m_typeMap.find( &ti );
         if( itr != m_typeMap.end() ) {
            return std::pair< bool, ::TClass* >( true, itr->second );
         } else {
            return std::pair< bool, ::TClass* >( false, nullptr );
         }
      }

getRef()

int xAOD::Internal::THolderCache::getRef

(

void *

ptr

)

const

Get the reference count of an object in memory.

Definition at line 58 of file THolderCache.cxx.

                                                {
 
         // Get a "read lock":
         shared_lock_t lock( m_refMapMutex );
 
         // Get the reference count:
         auto itr = m_refMap.find( ptr );
         if( itr != m_refMap.end() ) {
            return itr->second;
         } else {
            return 0;
         }
      }

incRef()

int xAOD::Internal::THolderCache::incRef

(

void *

ptr

)

Increment the reference count of an object in memory.

Definition at line 72 of file THolderCache.cxx.

                                          {
 
         // Get a "write lock":
         unique_lock_t lock( m_refMapMutex );
 
         // Increment the reference count, and return the new value:
         return ++( m_refMap[ ptr ] );
      }

instance()

THolderCache & xAOD::Internal::THolderCache::instance ( )

static

Singleton accessor.

Definition at line 29 of file THolderCache.cxx.

                                           {
         static THolderCache cache ATLAS_THREAD_SAFE;  // this class is thread-safe
         return cache;
      }

Member Data Documentation

m_refMap

std::map< void*, int > xAOD::Internal::THolderCache::m_refMap

private

The reference count map.

Definition at line 59 of file THolderCache.h.

m_refMapMutex

std::shared_timed_mutex xAOD::Internal::THolderCache::m_refMapMutex

mutableprivate

Mutex for the reference count map.

Definition at line 64 of file THolderCache.h.

m_typeMap

std::map< const std::type_info*, TClass* > xAOD::Internal::THolderCache::m_typeMap

private

The type map.

Definition at line 57 of file THolderCache.h.

m_typeMapMutex

std::shared_timed_mutex xAOD::Internal::THolderCache::m_typeMapMutex

mutableprivate

Mutex for the type map.

Definition at line 62 of file THolderCache.h.

---

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

• THolderCache.h
• THolderCache.cxx