SG::AuxVectorData::Cache Class Reference

Manage cache of pointers to aux element vectors. More...

Collaboration diagram for SG::AuxVectorData::Cache:

Public Member Functions
	Cache ()
	Cache manager constructor. More...
	Cache (Cache &&rhs)
	Cache manager move constructor. More...
Cache &	operator= (Cache &&rhs)
	Cache manager move assignment. More...
	~Cache ()
	Cache manager destructor. More...
void *	cachePtr (SG::auxid_t auxid)
	Test to see if auxid is valid in the cache. More...
void *	getDataArray (SG::auxid_t auxid, AuxVectorData &parent)
	Return a pointer to the start of an aux data vector. More...
const void *	getDataArray (SG::auxid_t auxid, const AuxVectorData &parent)
	Return a const pointer to the start of an aux data vector. More...
const void *	getDataArrayAllowMissing (SG::auxid_t auxid, const AuxVectorData &parent)
	Return a const pointer to the start of an aux data vector. More...
void *	getDecorationArray (SG::auxid_t auxid, const AuxVectorData &parent)
	Return a pointer to the start of an aux decoration vector. More...
void	swap (Cache &other)
	Swap this cache object with another. More...
void	clear ()
	Clear the cache (and free any old cache vectors). More...
void	clear (SG::auxid_t auxid)
	Clear the cached pointer for a single variable. More...
void	store (SG::auxid_t auxid, void *ptr)
	Store a pointer for auxid in the cache. More...

Public Attributes
void **	m_cache [2]
	Pointer to the cache vector. More...
size_t	m_cache_len
	Length of the cache vector. More...
std::vector< void ** >	m_allcache
	All cache vectors that have been allocated. More...

Private Member Functions
	Cache (const Cache &)
Cache &	operator= (const Cache &)

Detailed Description

Manage cache of pointers to aux element vectors.

See the thread-safety comments at the start of this file for notes on what's going on here.

Definition at line 671 of file AuxVectorData.h.

Constructor & Destructor Documentation

Cache() [1/3]

SG::AuxVectorData::Cache::Cache

(

)

Cache manager constructor.

Definition at line 432 of file AuxVectorData.cxx.

  : m_cache(),
    m_cache_len(0)
{
}

Cache() [2/3]

SG::AuxVectorData::Cache::Cache

(

Cache &&

rhs

)

Cache manager move constructor.

Parameters

rhs	The cache from which to copy.

Definition at line 443 of file AuxVectorData.cxx.

  : m_cache_len (rhs.m_cache_len),
    m_allcache (std::move (rhs.m_allcache))
{
  m_cache[0] = rhs.m_cache[0];
  m_cache[1] = rhs.m_cache[1];
  rhs.m_cache[0] = 0;
  rhs.m_cache[1] = 0;
  rhs.m_cache_len = 0;
}

~Cache()

SG::AuxVectorData::Cache::~Cache

(

)

Cache manager destructor.

Definition at line 479 of file AuxVectorData.cxx.

{
  for (size_t i=0; i < m_allcache.size(); i++) delete [] m_allcache[i];
}

Cache() [3/3]

SG::AuxVectorData::Cache::Cache ( const Cache &  )

private

Member Function Documentation

cachePtr()

void* SG::AuxVectorData::Cache::cachePtr

(

SG::auxid_t

auxid

)

Test to see if auxid is valid in the cache.

Returns

If auxid is valid, return the pointer to the vector, else 0.

clear() [1/2]

void SG::AuxVectorData::Cache::clear

(

)

Clear the cache (and free any old cache vectors).

Definition at line 500 of file AuxVectorData.cxx.

{
  if (m_cache_len > 0) {
    if (m_allcache.size() > 1) {
      for (size_t i=0; i < m_allcache.size()-1; i++)
        delete [] m_allcache[i];
      m_allcache[0] = m_allcache.back();
      m_allcache.resize(1);
}
    std::fill (m_cache[0], m_cache[0] + m_cache_len, static_cast<void*>(0));
  }
}

clear() [2/2]

void SG::AuxVectorData::Cache::clear

(

SG::auxid_t

auxid

)

Clear the cached pointer for a single variable.

Parameters

auxid

ID of the variable to clear.

Not really safe to use if another thread may be accessing the same variable.

Definition at line 521 of file AuxVectorData.cxx.

{
  if (auxid < m_cache_len) {
    m_cache[0][auxid] = nullptr;
  }
}

getDataArray() [1/2]

void* SG::AuxVectorData::Cache::getDataArray	(	SG::auxid_t	auxid,
		AuxVectorData &	parent
	)

Return a pointer to the start of an aux data vector.

Parameters

auxid	The desired aux data item.
parent	The containing AuxVectorData object.

This will return a pointer to the start of the data for aux data item auxid. If the item doesn't exist, it will be created. Errors are signaled by raising an exception.

getDataArray() [2/2]

const void* SG::AuxVectorData::Cache::getDataArray	(	SG::auxid_t	auxid,
		const AuxVectorData &	parent
	)

Return a const pointer to the start of an aux data vector.

Parameters

auxid	The desired aux data item.
parent	The containing AuxVectorData object.

This will return a pointer to the start of the data for aux data item auxid. Errors are signaled by raising an exception.

getDataArrayAllowMissing()

const void* SG::AuxVectorData::Cache::getDataArrayAllowMissing	(	SG::auxid_t	auxid,
		const AuxVectorData &	parent
	)

Return a const pointer to the start of an aux data vector.

Parameters

auxid	The desired aux data item.
parent	The containing AuxVectorData object.

This will return a pointer to the start of the data for aux data item auxid. If the item does not exist, this will return nullptr rather than raising an exception.

getDecorationArray()

void* SG::AuxVectorData::Cache::getDecorationArray	(	SG::auxid_t	auxid,
		const AuxVectorData &	parent
	)

Return a pointer to the start of an aux decoration vector.

Parameters

auxid	The desired aux decoration item.
parent	The containing AuxVectorData object.

This will return a pointer to the start of the data for aux decoration item auxid. If the item doesn't exist, it will be created. Errors are signaled by raising an exception.

The difference between getDecorationArray and getDataArray is that getDecorationArray takes a const container as input, but returns a non-const pointer. This will only succeed if either the container is not locked or the item was first accessed as a decoration.

operator=() [1/2]

AuxVectorData::Cache & SG::AuxVectorData::Cache::operator=

(

Cache &&

rhs

)

Cache manager move assignment.

Parameters

rhs	The cache from which to copy.

Definition at line 459 of file AuxVectorData.cxx.

{
  if (this != &rhs) {
    clear();
    m_cache_len = rhs.m_cache_len;
    m_allcache = std::move (rhs.m_allcache);
    
    m_cache[0] = rhs.m_cache[0];
    m_cache[1] = rhs.m_cache[1];
    rhs.m_cache[0] = 0;
    rhs.m_cache[1] = 0;
    rhs.m_cache_len = 0;
  }
  return *this;
}

operator=() [2/2]

Cache& SG::AuxVectorData::Cache::operator= ( const Cache &  )

private

store()

void SG::AuxVectorData::Cache::store	(	SG::auxid_t	auxid,
		void *	ptr
	)

Store a pointer for auxid in the cache.

Parameters

auxid	The aux data item being stored.
ptr	Pointer to the start of the aux vector for auxid.

Definition at line 534 of file AuxVectorData.cxx.

{
  // We must be holding the container lock m_mutex to call this.
 
  if (auxid >= m_cache_len) {
    // We need to expand the cache vector.   Allocate a new one.
    size_t newlen =
      std::max (static_cast<SG::auxid_t>(AuxVectorData::s_minCacheLen),
                (auxid+1)*3/2);
    void** newcache = new void*[newlen];
    m_allcache.push_back (newcache);
    void** oldcache = m_cache[0];
 
    // Copy old vector to the new one and clear the remainder.
    std::copy (oldcache, oldcache + m_cache_len, newcache);
    std::fill (newcache + m_cache_len, newcache + newlen,
               static_cast<void*>(0));
 
    // The above writes must be visible before we update the cache pointers.
    AthContainers_detail::fence_seq_cst();
 
    // Store so that other threads can see it.
    // The stores to m_cache must happen before the store to m_cache_len;
    // we use a fence to ensure this.
    m_cache[0] = newcache;
    m_cache[1] = newcache;
    AthContainers_detail::fence_seq_cst();
    m_cache_len = newlen;
  }
 
  // We have room in the cache vector now.  Store the pointer.
  m_cache[0][auxid] = ptr;
}

swap()

void SG::AuxVectorData::Cache::swap

(

Cache &

other

)

Swap this cache object with another.

Parameters

other

The cache object with which to swap.

Definition at line 489 of file AuxVectorData.cxx.

{
  m_allcache.swap (other.m_allcache);
  std::swap (m_cache, other.m_cache);
  std::swap (m_cache_len, other.m_cache_len);
}

Member Data Documentation

m_allcache

std::vector<void**> SG::AuxVectorData::Cache::m_allcache

All cache vectors that have been allocated.

Definition at line 805 of file AuxVectorData.h.

m_cache

void** SG::AuxVectorData::Cache::m_cache[2]

Pointer to the cache vector.

The two pointers here are the same; see the thread-safety discussion in the file header above.

Definition at line 796 of file AuxVectorData.h.

m_cache_len

size_t SG::AuxVectorData::Cache::m_cache_len

Length of the cache vector.

Definition at line 799 of file AuxVectorData.h.

---

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

• AuxVectorData.h
• AuxVectorData.cxx