edm::AtomicPtrCache< T > Class Template Reference

#include "DataFormats/Common/interface/AtomicPtrCache.h"

Public Member Functions
	AtomicPtrCache ()
	AtomicPtrCache (T *)
	Takes exclusive ownership of the value. More...
	AtomicPtrCache (const AtomicPtrCache< T > &)
	Uses T's copy constructor to make a copy. More...
bool	isSet () const
T const *	load () const
T *	load ()
T const &	operator* () const
T &	operator* ()
T const *	operator-> () const
T *	operator-> ()
AtomicPtrCache &	operator= (const AtomicPtrCache< T > &)
void	reset ()
	unsets the value and deletes the memory More...
bool	set (std::unique_ptr< T > iNewValue) const
	~AtomicPtrCache ()

Private Attributes
std::atomic< T * >	m_data

Detailed Description

template<typename T>
class edm::AtomicPtrCache< T >

Description: A thread safe cache managed by a pointer

Usage: Data products which need to cache results into non-trivial structures (e.g. an std::vector) can use this class to manage the cache in a thread-safe way. The thread-safety guarantee is only the standard C++, if calls are made to const functions simultaneously then everything is thread safe. Calling a non-const function while calling any other functions is not thread-safe.

This class also hides the std::atomic from ROOT so this class can safely be used in a stored class.

WARNING: member data which uses this class must be made transient in the classes_def.xml file!

Definition at line 40 of file AtomicPtrCache.h.

Constructor & Destructor Documentation

template<typename T >

edm::AtomicPtrCache< T >::AtomicPtrCache ( )

inline

Definition at line 88 of file AtomicPtrCache.h.

:m_data{nullptr} {}

template<typename T>

edm::AtomicPtrCache< T >::AtomicPtrCache ( T *  iValue )

inlineexplicit

Takes exclusive ownership of the value.

Definition at line 91 of file AtomicPtrCache.h.

: m_data{iValue} {}

template<typename T>

edm::AtomicPtrCache< T >::AtomicPtrCache ( const AtomicPtrCache< T > &  iOther )

inline

Uses T's copy constructor to make a copy.

Definition at line 94 of file AtomicPtrCache.h.

                                                                         :
  m_data{nullptr}
  {
    auto ptr = iOther.m_data.load(std::memory_order_acquire);
    if(ptr != nullptr) {
      m_data.store( new T{*ptr}, std::memory_order_release);
    }
  }

template<typename T >

edm::AtomicPtrCache< T >::~AtomicPtrCache ( )

inline

Definition at line 120 of file AtomicPtrCache.h.

                                           {
    delete m_data.load(std::memory_order_acquire);
  }

Member Function Documentation

template<typename T >

bool edm::AtomicPtrCache< T >::isSet ( ) const

inline

Definition at line 131 of file AtomicPtrCache.h.

Referenced by pat::Jet::getPFConstituents(), pat::Tau::isolationPFCands(), pat::Tau::isolationPFChargedHadrCands(), pat::Tau::isolationPFGammaCands(), pat::Tau::isolationPFNeutrHadrCands(), pat::Tau::isolationTracks(), pat::Tau::signalPFCands(), pat::Tau::signalPFChargedHadrCands(), pat::Tau::signalPFGammaCands(), pat::Tau::signalPFNeutrHadrCands(), pat::Tau::signalTracks(), pat::Photon::superCluster(), and pat::Electron::superCluster().

{ return nullptr!=m_data.load(std::memory_order_acquire);}

template<typename T >

T const * edm::AtomicPtrCache< T >::load ( ) const

inline

Definition at line 128 of file AtomicPtrCache.h.

Referenced by edm::AtomicPtrCache< reco::TrackRefVector >::operator*(), and edm::AtomicPtrCache< reco::TrackRefVector >::operator->().

{ return m_data.load(std::memory_order_acquire);}

template<typename T >

T * edm::AtomicPtrCache< T >::load ( )

inline

Definition at line 125 of file AtomicPtrCache.h.

{ return m_data.load(std::memory_order_acquire);}

template<typename T>

T const& edm::AtomicPtrCache< T >::operator* ( ) const

inline

Definition at line 57 of file AtomicPtrCache.h.

{return *load(); }

template<typename T>

T& edm::AtomicPtrCache< T >::operator* ( )

inline

Definition at line 70 of file AtomicPtrCache.h.

{return *load();}

template<typename T>

T const* edm::AtomicPtrCache< T >::operator-> ( ) const

inline

Definition at line 56 of file AtomicPtrCache.h.

{ return load();}

template<typename T>

T* edm::AtomicPtrCache< T >::operator-> ( )

inline

Definition at line 69 of file AtomicPtrCache.h.

{ return load();}

template<typename T>

AtomicPtrCache< T > & edm::AtomicPtrCache< T >::operator= ( const AtomicPtrCache< T > &  iOther )

inline

Definition at line 103 of file AtomicPtrCache.h.

References edm::AtomicPtrCache< T >::m_data.

                                                                                        {
    auto ptr = iOther.m_data.load(std::memory_order_acquire);
    if(ptr != nullptr) {
      auto ourPtr =m_data.load(std::memory_order_acquire);
      if( ourPtr !=nullptr) {
        *ourPtr = *ptr;
      } else {
        m_data.store( new T{*ptr}, std::memory_order_release);
      }
    } else {
      delete m_data.exchange(nullptr, std::memory_order_acq_rel);
    }
    return *this;
  }

template<typename T >

void edm::AtomicPtrCache< T >::reset ( void  )

inline

unsets the value and deletes the memory

Definition at line 144 of file AtomicPtrCache.h.

Referenced by pat::Jet::setPFCandidates().

{ delete m_data.exchange(nullptr,std::memory_order_acq_rel);}

template<typename T>

bool edm::AtomicPtrCache< T >::set ( std::unique_ptr< T >  iNewValue ) const

inline

returns true if actually was set. Will delete value held by iNewValue if not the first time set

Definition at line 134 of file AtomicPtrCache.h.

Referenced by pat::Jet::cachePFCandidates(), betterConfigParser.BetterConfigParser::getGeneral(), pat::Tau::isolationPFCands(), pat::Tau::isolationPFChargedHadrCands(), pat::Tau::isolationPFGammaCands(), pat::Tau::isolationPFNeutrHadrCands(), pat::Tau::isolationTracks(), pat::Tau::signalPFCands(), pat::Tau::signalPFChargedHadrCands(), pat::Tau::signalPFGammaCands(), pat::Tau::signalPFNeutrHadrCands(), pat::Tau::signalTracks(), pat::Photon::superCluster(), and pat::Electron::superCluster().

                                                                     {
    bool retValue;
    T* expected = nullptr;
    if( (retValue = m_data.compare_exchange_strong(expected,iNewValue.get(), std::memory_order_acq_rel)) ) {
      iNewValue.release();
    }
    return retValue;
  }

Member Data Documentation

template<typename T>

std::atomic<T*> edm::AtomicPtrCache< T >::m_data

mutableprivate

Definition at line 81 of file AtomicPtrCache.h.

Referenced by edm::AtomicPtrCache< T >::operator=().