ATLAS Offline Software
Public Types | Public Member Functions | Private Attributes | List of all members
EventContainers::InternalOnline Class Referencefinal

#include <InternalOnline.h>

Inheritance diagram for EventContainers::InternalOnline:
Collaboration diagram for EventContainers::InternalOnline:

Public Types

typedef EventContainers::hashPair< void > hashPair
 
typedef std::vector< hashPair >::const_iterator InternalConstItr
 

Public Member Functions

 InternalOnline (EventContainers::IdentifiableCacheBase *cache)
 
virtual InternalConstItr cbegin () const override
 
virtual InternalConstItr cend () const override
 
virtual InternalConstItr indexFind (IdentifierHash hashId) const override
 
virtual const std::vector< hashPair > & getAllHashPtrPair () const override
 
virtual ~InternalOnline ()=default
 
virtual void wait () const override
 
virtual bool tryAddFromCache (IdentifierHash hashId, EventContainers::IDC_WriteHandleBase &lock) override
 
virtual bool tryAddFromCache (IdentifierHash hashId) override
 
virtual std::vector< IdentifierHash > getAllCurrentHashes () const override
 
virtual size_t numberOfCollections () const override
 
void resetMask ()
 
virtual size_t fullSize () const noexcept override
 
virtual StatusCode fetchOrCreate (IdentifierHash hashId) override
 
virtual StatusCode fetchOrCreate (const std::vector< IdentifierHash > &hashIds) override
 
virtual bool insert (IdentifierHash hashId, const void *ptr) override
 
virtual const void * findIndexPtr (IdentifierHash hashId) const noexcept override
 
virtual StatusCode addLock (IdentifierHash hashId, const void *ptr) override
 
virtual void * removeCollection (IdentifierHash hashId) override
 
virtual void destructor (deleter_f *) noexcept override
 
virtual void cleanUp (deleter_f *) noexcept override
 

Private Attributes

EventContainers::IdentifiableCacheBase * m_cacheLink
 
std::vector< IdentifierHash > m_waitlist ATLAS_THREAD_SAFE
 
std::vector< I_InternalIDC::hashPair > m_map ATLAS_THREAD_SAFE
 
std::mutex m_waitMutex ATLAS_THREAD_SAFE
 
std::vector< bool > m_mask ATLAS_THREAD_SAFE
 
std::atomic< bool > m_waitNeeded ATLAS_THREAD_SAFE
 

Detailed Description

Definition at line 26 of file InternalOnline.h.

Member Typedef Documentation

◆ hashPair

typedef EventContainers::hashPair<void> EventContainers::I_InternalIDC::hashPair
inherited

Definition at line 36 of file I_InternalIDC.h.

◆ InternalConstItr

typedef std::vector< hashPair >::const_iterator EventContainers::I_InternalIDC::InternalConstItr
inherited

Definition at line 37 of file I_InternalIDC.h.

Constructor & Destructor Documentation

◆ InternalOnline()

InternalOnline::InternalOnline ( EventContainers::IdentifiableCacheBase *  cache)

Definition at line 16 of file InternalOnline.cxx.

16  : m_cacheLink(cache),
17  m_mask(cache->fullSize(), false), m_waitNeeded(false) {}

◆ ~InternalOnline()

virtual EventContainers::InternalOnline::~InternalOnline ( )
virtualdefault

Member Function Documentation

◆ addLock()

StatusCode InternalOnline::addLock ( IdentifierHash  hashId,
const void *  ptr 
)
overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 143 of file InternalOnline.cxx.

143  {
144  std::pair<bool, const void*> added = m_cacheLink->addLock(hashId, ptr);
145  if(ATH_UNLIKELY(!added.first)) {
146  throw std::runtime_error("IDC WARNING Deletion shouldn't occur in addLock paradigm");
147  }
148  m_mask[hashId] = true; //it wasn't added it is already present therefore mask could be true
149  m_waitNeeded.store(true, std::memory_order_relaxed);
150  return StatusCode::SUCCESS;
151 }

◆ cbegin()

InternalConstItr InternalOnline::cbegin ( ) const
overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 32 of file InternalOnline.cxx.

32  {
33  if(m_waitNeeded.load(std::memory_order_acquire)) wait();
34  return m_map.cbegin();
35 }

◆ cend()

InternalConstItr InternalOnline::cend ( ) const
overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 26 of file InternalOnline.cxx.

26  {
27  if(m_waitNeeded.load(std::memory_order_acquire)) wait();
28  return m_map.cend();
29 }

◆ cleanUp()

void InternalOnline::cleanUp ( deleter_f *  )
overridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 161 of file InternalOnline.cxx.

161  {
162  resetMask();
163 }

◆ destructor()

void InternalOnline::destructor ( deleter_f *  )
overridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 157 of file InternalOnline.cxx.

157  {
158  //deliberately empty
159 }

◆ fetchOrCreate() [1/2]

StatusCode InternalOnline::fetchOrCreate ( const std::vector< IdentifierHash > &  hashIds)
overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 120 of file InternalOnline.cxx.

120  {
121  throw std::runtime_error("Not implemented");
122 // if(ATH_UNLIKELY(!m_cacheLink->IMakerPresent())) return StatusCode::FAILURE;
123 // m_cacheLink->createSet(hashIds, m_mask);
124 // return StatusCode::SUCCESS;
125 }

◆ fetchOrCreate() [2/2]

StatusCode InternalOnline::fetchOrCreate ( IdentifierHash  hashId)
overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 113 of file InternalOnline.cxx.

113  {
114  if(ATH_UNLIKELY(!m_cacheLink->IMakerPresent())) return StatusCode::FAILURE;
115  auto ptr = m_cacheLink->get(hashId);
116  if(ptr) { m_mask[hashId] =true; m_waitNeeded.store(true, std::memory_order_relaxed); }
117  return StatusCode::SUCCESS;
118 }

◆ findIndexPtr()

const void * InternalOnline::findIndexPtr ( IdentifierHash  hashId) const
overridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 135 of file InternalOnline.cxx.

135  {
136  if(hashId < m_mask.size() and m_mask[hashId]) {
137  EventContainers::IdentifiableCacheBase* cacheLink ATLAS_THREAD_SAFE = m_cacheLink;
138  return cacheLink->findWait(hashId);
139  }
140  return nullptr;
141 }

◆ fullSize()

virtual size_t EventContainers::InternalOnline::fullSize ( ) const
inlineoverridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 40 of file InternalOnline.h.

40 { return m_mask.size(); }

◆ getAllCurrentHashes()

std::vector< IdentifierHash > InternalOnline::getAllCurrentHashes ( ) const
overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 91 of file InternalOnline.cxx.

91  {
92  if(m_waitNeeded.load(std::memory_order_acquire)) wait();
93  std::vector<IdentifierHash> ids;
94  ids.reserve(m_map.size());
95  for(auto &x : m_map) {
96  ids.emplace_back(x.first);
97  }
98  return ids;
99 }

◆ getAllHashPtrPair()

const std::vector< I_InternalIDC::hashPair > & InternalOnline::getAllHashPtrPair ( ) const
overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 19 of file InternalOnline.cxx.

19  {
20  if(m_waitNeeded.load(std::memory_order_acquire)) wait();
21  return m_map;
22 }

◆ indexFind()

InternalConstItr InternalOnline::indexFind ( IdentifierHash  hashId) const
overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 37 of file InternalOnline.cxx.

37  {
38  if(m_waitNeeded.load(std::memory_order_acquire)) wait();
39  auto itr = std::lower_bound( m_map.begin(), m_map.end(), hashId.value(), [](hashPair &lhs, IdentifierHash::value_type rhs) -> bool { return lhs.first < rhs; } );
40  if(itr!= m_map.end() && itr->first==hashId) return itr;
41  return m_map.end();
42 }

◆ insert()

bool InternalOnline::insert ( IdentifierHash  hashId,
const void *  ptr 
)
overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 128 of file InternalOnline.cxx.

128  {
129  std::pair<bool, const void*> cacheinserted = m_cacheLink->add(hashId, ptr);
130  m_mask[hashId] = true; //it wasn't added it is already present therefore mask could be true
131  m_waitNeeded.store(true, std::memory_order_relaxed);
132  return ptr == cacheinserted.second;
133 }

◆ numberOfCollections()

size_t InternalOnline::numberOfCollections ( ) const
overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 101 of file InternalOnline.cxx.

101  {
102  if(m_waitNeeded.load(std::memory_order_acquire)) wait();
103  return m_map.size();
104 }

◆ removeCollection()

void * InternalOnline::removeCollection ( IdentifierHash  hashId)
overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 153 of file InternalOnline.cxx.

153  {
154  throw std::runtime_error("Do not remove things from an online IDC");
155 }

◆ resetMask()

void InternalOnline::resetMask ( )

Definition at line 106 of file InternalOnline.cxx.

106  {
107  if(m_waitNeeded.load(std::memory_order_relaxed)) wait();
108  m_mask.assign(m_cacheLink->fullSize(), false);
109  m_map.clear();
110  m_waitNeeded.store(true, std::memory_order_relaxed);
111 }

◆ tryAddFromCache() [1/2]

bool InternalOnline::tryAddFromCache ( IdentifierHash  hashId)
overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 80 of file InternalOnline.cxx.

81 {
82  auto ptr = m_cacheLink->find(hashId);
83  if(ptr==nullptr) {
84  return false;
85  }
86  m_mask[hashId] = true;
87  m_waitNeeded.store(true, std::memory_order_relaxed);
88  return true;
89 }

◆ tryAddFromCache() [2/2]

bool InternalOnline::tryAddFromCache ( IdentifierHash  hashId,
EventContainers::IDC_WriteHandleBase &  lock 
)
overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 66 of file InternalOnline.cxx.

66  {
67  int flag = m_cacheLink->tryLock(hashId, lock, m_waitlist);
68  //Relaxed since this should not be running in threaded situation.
69  if(!m_waitlist.empty()) m_waitNeeded.store(true, std::memory_order_relaxed);
70  if(flag > 0) {
71  if(flag!=3){
72  m_mask[hashId] = true;
73  m_waitNeeded.store(true, std::memory_order_relaxed);
74  }
75  return true;
76  }
77  return false;
78 }

◆ wait()

void InternalOnline::wait ( ) const
overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 44 of file InternalOnline.cxx.

44  {
45  //lockguard to protect m_waitlist from multiple wait calls
46  std::scoped_lock lock (m_waitMutex);
47  if(m_waitNeeded.load(std::memory_order_acquire) == false) return;
48  using namespace EventContainers;
49  const void* ABORTstate = reinterpret_cast<const void*>(IdentifiableCacheBase::ABORTEDflag);
50  while(!m_waitlist.empty()) {
51  IdentifierHash hash = m_waitlist.back();
52  EventContainers::IdentifiableCacheBase* cacheLink ATLAS_THREAD_SAFE = m_cacheLink;
53  const void* ptr = cacheLink->waitFor(hash);
54  if(ptr == ABORTstate) {
55  m_mask[hash] = false;
56  }
57  m_waitlist.pop_back();
58  }
59  m_map.clear();
60  for(size_t i =0;i<m_mask.size();i++){
61  if(m_mask[i]) m_map.emplace_back(i, m_cacheLink->m_vec[i].load(std::memory_order_relaxed));//acquire sync is done by m_waitNeeded
62  }
63  m_waitNeeded.store(false, std::memory_order_release);
64 }

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/5]

std::vector< IdentifierHash > m_waitlist EventContainers::InternalOnline::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 51 of file InternalOnline.h.

◆ ATLAS_THREAD_SAFE [2/5]

std::vector<I_InternalIDC::hashPair> m_map EventContainers::InternalOnline::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 52 of file InternalOnline.h.

◆ ATLAS_THREAD_SAFE [3/5]

std::mutex m_waitMutex EventContainers::InternalOnline::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 53 of file InternalOnline.h.

◆ ATLAS_THREAD_SAFE [4/5]

std::vector<bool> m_mask EventContainers::InternalOnline::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 54 of file InternalOnline.h.

◆ ATLAS_THREAD_SAFE [5/5]

std::atomic<bool> m_waitNeeded EventContainers::InternalOnline::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 55 of file InternalOnline.h.

◆ m_cacheLink

EventContainers::IdentifiableCacheBase* EventContainers::InternalOnline::m_cacheLink
private

Definition at line 50 of file InternalOnline.h.

The documentation for this class was generated from the following files:
IdentifierHash::value_type
unsigned int value_type
Definition: IdentifierHash.h:48
EventContainers::IdentifiableCacheBase::findWait
const void * findWait(IdentifierHash hash)
Retrieve ptr, will wait if there is something in progress.
Definition: IdentifiableCacheBase.cxx:158
EventContainers::IdentifiableCacheBase
Definition: IdentifiableCacheBase.h:26
EventContainers::IdentifiableCacheBase::get
const void * get(IdentifierHash hash)
Try to make payload if not there.
Definition: IdentifiableCacheBase.cxx:179
EventContainers::IdentifiableCacheBase::ABORTEDflag
static constexpr uintptr_t ABORTEDflag
Definition: IdentifiableCacheBase.h:31
ATH_UNLIKELY
#define ATH_UNLIKELY(x)
Definition: AthUnlikelyMacros.h:17
EventContainers::InternalOnline::wait
virtual void wait() const override
Definition: InternalOnline.cxx:44
EventContainers
Definition: T_AthenaPoolCreateFuncs.h:33
EventContainers::hashPair
Definition: I_InternalIDC.h:25
x
#define x
lumiFormat.i
int i
Definition: lumiFormat.py:92
EventContainers::InternalOnline::resetMask
void resetMask()
Definition: InternalOnline.cxx:106
master.flag
bool flag
Definition: master.py:29
EventContainers::IdentifiableCacheBase::tryLock
int tryLock(IdentifierHash, IDC_WriteHandleBase &, std::vector< IdentifierHash > &)
Checks if the item is completed if it is not started it extablishes lock (returns 0),...
Definition: IdentifiableCacheBase.cxx:57
EventContainers::IdentifiableCacheBase::fullSize
size_t fullSize() const
Definition: IdentifiableCacheBase.h:89
EventContainers::IdentifiableCacheBase::IMakerPresent
bool IMakerPresent() const
Definition: IdentifiableCacheBase.h:69
python.subdetectors.mmg.ids
ids
Definition: mmg.py:8
EventContainers::IdentifiableCacheBase::m_vec
std::vector< std::atomic< const void * > > m_vec
Definition: IdentifiableCacheBase.h:103
EventContainers::InternalOnline::m_cacheLink
EventContainers::IdentifiableCacheBase * m_cacheLink
Definition: InternalOnline.h:50
EventContainers::InternalOnline::ATLAS_THREAD_SAFE
std::vector< IdentifierHash > m_waitlist ATLAS_THREAD_SAFE
Definition: InternalOnline.h:51
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
EventContainers::IdentifiableCacheBase::find
const void * find(IdentifierHash hash) noexcept
Return payload if there, null if not there.
Definition: IdentifiableCacheBase.cxx:126
EventContainers::IdentifiableCacheBase::waitFor
const void * waitFor(IdentifierHash)
Halts the thread until the require hash is completed or aborted.
Definition: IdentifiableCacheBase.cxx:135
EventContainers::IdentifiableCacheBase::add
std::pair< bool, const void * > add(IdentifierHash hash, const void *p) noexcept
Definition: IdentifiableCacheBase.cxx:247
EventContainers::IdentifiableCacheBase::addLock
std::pair< bool, const void * > addLock(IdentifierHash hash, const void *p) noexcept
Definition: IdentifiableCacheBase.cxx:266
Generated on Fri Jun 28 2024 22:17:16 for ATLAS Offline Software by   doxygen 1.8.18