Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Member Functions | Private Attributes | List of all members
AthenaSharedMemoryTool Class Reference

This class provides the IPCTool for SharedMemory objects. More...

#include <AthenaSharedMemoryTool.h>

Inheritance diagram for AthenaSharedMemoryTool:
Collaboration diagram for AthenaSharedMemoryTool:

Public Member Functions

 AthenaSharedMemoryTool (const std::string &type, const std::string &name, const IInterface *parent)
 Standard Service Constructor. More...
 
virtual ~AthenaSharedMemoryTool ()
 Destructor. More...
 
virtual StatusCode initialize () override
 Gaudi Service Interface method implementations: More...
 
virtual StatusCode stop () override
 
virtual StatusCode finalize () override
 
virtual StatusCode makeServer (int num, const std::string &streamPortSuffix) override
 
virtual bool isServer () const override
 
virtual StatusCode makeClient (int num, std::string &streamPortSuffix) override
 
virtual bool isClient () const override
 
virtual StatusCode putEvent ATLAS_NOT_THREAD_SAFE (long eventNumber, const void *source, size_t nbytes, unsigned int status) const override
 
virtual StatusCode getLockedEvent (void **target, unsigned int &status) const override
 
virtual StatusCode lockEvent (long eventNumber) const override
 
virtual StatusCode putObject (const void *source, size_t nbytes, int num=0) override
 
virtual StatusCode getObject (void **target, size_t &nbytes, int num=0) override
 
virtual StatusCode clearObject (const char **tokenString, int &num) override
 
virtual StatusCode lockObject (const char *tokenString, int num=0) override
 

Private Attributes

Gaudi::Property< std::string > m_sharedMemory {this, "SharedMemoryName", {}}
 
const size_t m_maxSize {64 * 1024 * 1024}
 
const int m_maxDataClients {256}
 
int m_num {-1}
 
int m_lastClient {-1}
 
std::set< int > m_dataClients
 
std::unique_ptr< boost::interprocess::mapped_region > m_payload
 
std::unique_ptr< boost::interprocess::mapped_region > m_status
 
long m_fileSeqNumber {0}
 
bool m_isServer {false}
 
bool m_isClient {false}
 
ServiceHandle< IIncidentSvc > m_incidentSvc
 

Detailed Description

This class provides the IPCTool for SharedMemory objects.

Definition at line 34 of file AthenaSharedMemoryTool.h.

Constructor & Destructor Documentation

◆ AthenaSharedMemoryTool()

AthenaSharedMemoryTool::AthenaSharedMemoryTool ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Standard Service Constructor.

Definition at line 36 of file AthenaSharedMemoryTool.cxx.

38  :
39  base_class(type, name, parent),
40  m_incidentSvc("IncidentSvc", name) {
41  m_sharedMemory.setValue(name);
42 }

◆ ~AthenaSharedMemoryTool()

AthenaSharedMemoryTool::~AthenaSharedMemoryTool ( )
virtual

Destructor.

Definition at line 45 of file AthenaSharedMemoryTool.cxx.

45  {
46 }

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

virtual StatusCode putEvent AthenaSharedMemoryTool::ATLAS_NOT_THREAD_SAFE ( long  eventNumber,
const void *  source,
size_t  nbytes,
unsigned int  status 
) const
overridevirtual

◆ clearObject()

StatusCode AthenaSharedMemoryTool::clearObject ( const char **  tokenString,
int &  num 
)
overridevirtual

Definition at line 358 of file AthenaSharedMemoryTool.cxx.

358  {
359  if (m_isClient) {
360  ShareEventHeader* evtH = static_cast<ShareEventHeader*>(m_status->get_address());
361  if (evtH->evtProcessStatus != ShareEventHeader::CLEARED) {
362  ATH_MSG_DEBUG("Waiting for FILL clearObject");
363  return(StatusCode::RECOVERABLE);
364  }
365  *tokenString = evtH->token;
366  evtH->evtProcessStatus = ShareEventHeader::UNLOCKED;
367  return(StatusCode::SUCCESS);
368  }
369 
370  for (int i = 1; i <= m_num; i++) { // FIXME: PvG, do round robin
371  void* status = static_cast<char*>(m_status->get_address()) + i * sizeof(ShareEventHeader);
372  ShareEventHeader* evtH = static_cast<ShareEventHeader*>(status);
373  ShareEventHeader::ProcessStatus evtStatus = evtH->evtProcessStatus; // read only once
374  if (evtStatus == ShareEventHeader::FILLED) {
375  ATH_MSG_DEBUG("Waiting for UNFILL clearObject, client = " << i);
376  return(StatusCode::RECOVERABLE);
377  } else if (i == num && evtStatus != ShareEventHeader::LOCKED) {
378  ATH_MSG_DEBUG("Waiting for LOCK clearObject, client = " << i);
379  return(StatusCode::RECOVERABLE);
380  }
381  if (m_lastClient < 0 || m_lastClient == i) { // If Writer is not yet released, only consider last client
382  if ((i == num || num < 0) && evtStatus == ShareEventHeader::LOCKED) {
383  *tokenString = evtH->token;
384  num = i;
385  ATH_MSG_DEBUG("Setting LOCK clearObject, for client = " << num << ": " << evtH->token);
386  m_lastClient = -1;
387  // break;
388  }
389  }
390  }
391 
392  if (num > 0 && *tokenString != nullptr) {
393  m_lastClient = -1; // Release Writer from last client
394  void* status = static_cast<char*>(m_status->get_address()) + num * sizeof(ShareEventHeader);
395  ShareEventHeader* evtH = static_cast<ShareEventHeader*>(status);
396  if (strncmp(*tokenString, "wait", 4) == 0) {
397  ATH_MSG_INFO("Server clearObject() got wait, client = " << num);
398  evtH->evtProcessStatus = ShareEventHeader::UNLOCKED;
399  m_lastClient = num; // Keep Writer allocated
400  num = -1;
401  return(StatusCode::SUCCESS);
402  }
403  if (strncmp(*tokenString, "release", 7) == 0) {
404  ATH_MSG_INFO("Server clearObject() got release, client = " << num);
405  evtH->evtProcessStatus = ShareEventHeader::UNLOCKED;
406  num = -1;
407  return(StatusCode::SUCCESS);
408  }
409  if (strncmp(*tokenString, "start", 5) == 0) {
410  ATH_MSG_INFO("Server clearObject() got start, client = " << num << ", of " << m_num - 1);
411  if (m_dataClients.empty()) { // Annouce all workers to prevent early writer termination
412  for (int i = 1; i < m_num - 1; i++) m_dataClients.insert(i);
413  }
414  m_dataClients.insert(num);
415  evtH->evtProcessStatus = ShareEventHeader::UNLOCKED;
416  num = -1;
417  return(StatusCode::SUCCESS);
418  }
419  if (strncmp(*tokenString, "stop", 4) == 0) {
420  ATH_MSG_INFO("Server clearObject() got stop, client = " << num);
421  m_dataClients.erase(num);
422  evtH->evtProcessStatus = ShareEventHeader::UNLOCKED;
423  if (m_dataClients.empty()) {
424  ATH_MSG_INFO("Server clearObject() got stop, client ALL: " << m_num);
425  if (num == m_num - 1) { // mother process
426  return(StatusCode::SUCCESS);
427  }
428  return(StatusCode::FAILURE);
429  }
430  num = -1;
431  return(StatusCode::SUCCESS);
432  }
433  evtH->evtSize = 0;
434  m_status->flush(0, sizeof(ShareEventHeader));
435  evtH->evtProcessStatus = ShareEventHeader::CLEARED;
436  return(StatusCode::SUCCESS);
437  }
438  return(StatusCode::RECOVERABLE);
439 }

◆ finalize()

StatusCode AthenaSharedMemoryTool::finalize ( )
overridevirtual

Definition at line 75 of file AthenaSharedMemoryTool.cxx.

75  {
76  ATH_MSG_INFO("in finalize()");
77  if (m_isServer) {
78  try {
79  boost::interprocess::shared_memory_object::remove(m_sharedMemory.value().c_str());
80  } catch(boost::interprocess::interprocess_exception &e) {
81  ATH_MSG_WARNING("Cannot remove shared memory " << m_sharedMemory.value() << ": " << boost::diagnostic_information(e));
82  }
83  const std::string statusName = m_sharedMemory.value() + "_status";
84  try {
85  boost::interprocess::shared_memory_object::remove(statusName.c_str());
86  } catch(boost::interprocess::interprocess_exception &e) {
87  ATH_MSG_WARNING("Cannot remove shared memory " << statusName << ": " << boost::diagnostic_information(e));
88  }
89  }
90  // Release IncidentSvc
91  if (!m_incidentSvc.release().isSuccess()) {
92  ATH_MSG_WARNING("Cannot release IncidentSvc.");
93  }
94  return(::AthAlgTool::finalize());
95 }

◆ getLockedEvent()

StatusCode AthenaSharedMemoryTool::getLockedEvent ( void **  target,
unsigned int &  status 
) const
overridevirtual

Definition at line 239 of file AthenaSharedMemoryTool.cxx.

239  {
240  ShareEventHeader* evtH = static_cast<ShareEventHeader*>(m_status->get_address());
241  if (evtH->evtProcessStatus == ShareEventHeader::LOCKED) {
242  const std::size_t nbytes = evtH->evtSize;
243  if (target != nullptr) {
244  char* buf = new char[nbytes];
245  std::memcpy(buf, static_cast<char*>(m_payload->get_address()) + evtH->evtOffset, nbytes);
246  *target = buf;
247  }
248  status = evtH->evtCoreStatusFlag;
249  } else {
250  ATH_MSG_ERROR("No event locked");
251  return(StatusCode::FAILURE);
252  }
253  evtH->evtProcessStatus = ShareEventHeader::UNLOCKED;
254  return(StatusCode::SUCCESS);
255 }

◆ getObject()

StatusCode AthenaSharedMemoryTool::getObject ( void **  target,
size_t &  nbytes,
int  num = 0 
)
overridevirtual

Definition at line 326 of file AthenaSharedMemoryTool.cxx.

326  {
327  if (target == nullptr) {
328  return(StatusCode::SUCCESS);
329  }
330  void* status = static_cast<char*>(m_status->get_address()) + num * sizeof(ShareEventHeader);
331  ShareEventHeader* evtH = static_cast<ShareEventHeader*>(status);
332  ShareEventHeader::ProcessStatus evtStatus = evtH->evtProcessStatus; // read only once
333  size_t evtSize = evtH->evtSize; // read only once
334  if (evtStatus != ShareEventHeader::FILLED) {
335  ATH_MSG_DEBUG("Waiting for FILLED getObject, client = " << num);
336  nbytes = 0;
337  return(StatusCode::RECOVERABLE);
338  }
339  if (evtH->evtOffset < evtSize) {
340  std::memcpy(&nbytes, static_cast<char*>(m_payload->get_address()) + evtH->evtOffset, sizeof(size_t));
341  evtH->evtOffset += sizeof(size_t);
342  *target = static_cast<char*>(m_payload->get_address()) + evtH->evtOffset;
343  evtH->evtOffset += nbytes;
344  }
345  if (evtH->evtOffset == evtSize) {
346  evtH->evtOffset = 0;
347  m_status->flush(num * sizeof(ShareEventHeader), sizeof(ShareEventHeader));
348  while (evtH->evtProcessStatus != ShareEventHeader::FILLED) {
349  usleep(10);
350  }
351  evtH->evtProcessStatus = ShareEventHeader::UNLOCKED;
352  }
353 
354  return(StatusCode::SUCCESS);
355 }

◆ initialize()

StatusCode AthenaSharedMemoryTool::initialize ( )
overridevirtual

Gaudi Service Interface method implementations:

Definition at line 49 of file AthenaSharedMemoryTool.cxx.

49  {
50  ATH_MSG_INFO("Initializing " << name());
51 
52  ATH_CHECK( m_incidentSvc.retrieve() );
53 
54  return(StatusCode::SUCCESS);
55 }

◆ isClient()

bool AthenaSharedMemoryTool::isClient ( ) const
overridevirtual

Definition at line 199 of file AthenaSharedMemoryTool.cxx.

199  {
200  return(m_isClient);
201 }

◆ isServer()

bool AthenaSharedMemoryTool::isServer ( ) const
overridevirtual

Definition at line 139 of file AthenaSharedMemoryTool.cxx.

139  {
140  return(m_isServer);
141 }

◆ lockEvent()

StatusCode AthenaSharedMemoryTool::lockEvent ( long  eventNumber) const
overridevirtual

Definition at line 258 of file AthenaSharedMemoryTool.cxx.

258  {
259  ShareEventHeader* evtH = static_cast<ShareEventHeader*>(m_status->get_address());
260  if (evtH->evtSeqNumber > eventNumber) {
261  ATH_MSG_ERROR("eventNumber = " << eventNumber << ", already processed");
262  return(StatusCode::FAILURE);
263  }
264  if (evtH->evtSeqNumber == 0 && evtH->fileSeqNumber == 0 && evtH->evtSize == 0) {
265  ATH_MSG_DEBUG("Server has been terminated");
266  return(StatusCode::FAILURE);
267  }
268  if (evtH->evtSeqNumber != eventNumber || evtH->evtProcessStatus != ShareEventHeader::FILLED) {
269  ATH_MSG_DEBUG("Waiting for lockEvent, eventNumber = " << eventNumber);
270  return(StatusCode::RECOVERABLE);
271  }
272  if (evtH->fileSeqNumber != m_fileSeqNumber && m_fileSeqNumber > 0) {
273  FileIncident endFileIncident(name(), "EndInputFile", "SHM");
274  m_incidentSvc->fireIncident(endFileIncident);
275  const_cast<AthenaSharedMemoryTool*>(this)->m_fileSeqNumber = evtH->fileSeqNumber;
276  FileIncident beginFileIncident(name(), "BeginInputFile", "SHM");
277  m_incidentSvc->fireIncident(beginFileIncident);
278  }
279  ATH_MSG_DEBUG("Locking eventNumber = " << eventNumber);
280  evtH->evtProcessStatus = ShareEventHeader::LOCKED;
281  return(StatusCode::SUCCESS);
282 }

◆ lockObject()

StatusCode AthenaSharedMemoryTool::lockObject ( const char *  tokenString,
int  num = 0 
)
overridevirtual

Definition at line 442 of file AthenaSharedMemoryTool.cxx.

442  {
443  if (strlen(tokenString) >= maxTokenLength) {
444  ATH_MSG_ERROR("Token = " << tokenString << ", too long for AthenaSharedMemoryTool");
445  return(StatusCode::FAILURE);
446  }
447  void* status = static_cast<char*>(m_status->get_address()) + num * sizeof(ShareEventHeader);
448  ShareEventHeader* evtH = static_cast<ShareEventHeader*>(status);
449  if (evtH->evtProcessStatus != ShareEventHeader::UNLOCKED) {
450  ATH_MSG_DEBUG("Waiting for UNLOCKED lockObject: " << tokenString);
451  return(StatusCode::RECOVERABLE);
452  }
453  strncpy(evtH->token, tokenString, maxTokenLength - 1); evtH->token[maxTokenLength - 1] = 0;
454  if (m_isServer) {
455  evtH->evtSize = 0;
456  m_status->flush(num * sizeof(ShareEventHeader), sizeof(ShareEventHeader));
457  evtH->evtProcessStatus = ShareEventHeader::CLEARED;
458  } else {
459  m_status->flush(num * sizeof(ShareEventHeader), sizeof(ShareEventHeader));
460  evtH->evtProcessStatus = ShareEventHeader::LOCKED;
461  }
462  return(StatusCode::SUCCESS);
463 }

◆ makeClient()

StatusCode AthenaSharedMemoryTool::makeClient ( int  num,
std::string &  streamPortSuffix 
)
overridevirtual

Definition at line 144 of file AthenaSharedMemoryTool.cxx.

144  {
145  if (m_isServer) {
146  ATH_MSG_ERROR("Cannot make AthenaSharedMemoryTool a Client.");
147  return(StatusCode::FAILURE);
148  }
149  if (num >= m_maxDataClients) {
150  ATH_MSG_ERROR("Too many clients for AthenaSharedMemoryTool.");
151  return(StatusCode::FAILURE);
152  }
153  if (m_num > 0 && num <= 0) {// stop running client
154  ATH_MSG_DEBUG("Stop AthenaSharedMemoryTool Client.");
155  m_num = -1;
156  while (lockObject("stop").isRecoverable()) {
157  usleep(100);
158  }
159  ShareEventHeader* evtH = static_cast<ShareEventHeader*>(m_status->get_address());
160  while (evtH->evtProcessStatus != ShareEventHeader::UNLOCKED) {
161  usleep(100);
162  }
163  m_payload.reset();
164  m_status.reset();
165  m_isClient = false;
166  return(StatusCode::SUCCESS);
167  }
168  while (!m_isClient) {
169  try { // Check whether Server created shared memory object
170  const std::string statusName = m_sharedMemory.value() + "_status";
171  boost::interprocess::shared_memory_object shm_status(boost::interprocess::open_only,
172  statusName.c_str(),
173  boost::interprocess::read_write);
174  m_status = std::make_unique<boost::interprocess::mapped_region>(shm_status, boost::interprocess::read_write, num * sizeof(ShareEventHeader), sizeof(ShareEventHeader));
175  boost::interprocess::shared_memory_object shm(boost::interprocess::open_only,
176  m_sharedMemory.value().c_str(),
177  boost::interprocess::read_write);
178  m_payload = std::make_unique<boost::interprocess::mapped_region>(shm, boost::interprocess::read_write, 0, m_maxSize);
179  m_isClient = true;
180  } catch (boost::interprocess::interprocess_exception& e) {
181  usleep(100000);
182  }
183  }
184  if (m_num <= 0 && num > 0) {
185  ShareEventHeader* evtH = static_cast<ShareEventHeader*>(m_status->get_address());
186  streamPortSuffix.assign(evtH->token);
187  while (lockObject("start").isRecoverable()) {
188  usleep(100);
189  }
190  while (evtH->evtProcessStatus != ShareEventHeader::UNLOCKED) {
191  usleep(100);
192  }
193  m_num = num;
194  }
195  return(StatusCode::SUCCESS);
196 }

◆ makeServer()

StatusCode AthenaSharedMemoryTool::makeServer ( int  num,
const std::string &  streamPortSuffix 
)
overridevirtual

Definition at line 98 of file AthenaSharedMemoryTool.cxx.

98  {
99  if (m_isServer || m_isClient) {
100  ATH_MSG_ERROR("Cannot make AthenaSharedMemoryTool a Server.");
101  return(StatusCode::FAILURE);
102  }
103  if (num > m_maxDataClients) {
104  ATH_MSG_ERROR("Too many clients for AthenaSharedMemoryTool Server.");
105  return(StatusCode::FAILURE);
106  }
107  m_num = num;
108  m_isServer = true;
109  ATH_MSG_DEBUG("Creating shared memory object with name \"" << m_sharedMemory.value() << "\"");
110  std::optional<boost::interprocess::shared_memory_object> shm;
111  try {
112  shm.emplace(boost::interprocess::create_only, m_sharedMemory.value().c_str(), boost::interprocess::read_write);
113  } catch(boost::interprocess::interprocess_exception &e) {
114  ATH_MSG_ERROR("Cannot create shared memory " << m_sharedMemory.value() << ": " << boost::diagnostic_information(e));
115  return StatusCode::FAILURE;
116  }
117  shm->truncate(m_maxSize);
118  m_payload = std::make_unique<boost::interprocess::mapped_region>(*shm, boost::interprocess::read_write, 0, m_maxSize);
119  const std::string statusName = m_sharedMemory.value() + "_status";
120  std::optional<boost::interprocess::shared_memory_object> shm_status;
121  try {
122  shm_status.emplace(boost::interprocess::create_only, statusName.c_str(), boost::interprocess::read_write);
123  } catch(boost::interprocess::interprocess_exception &e) {
124  ATH_MSG_ERROR("Cannot create shared memory " << statusName << ": " << boost::diagnostic_information(e));
125  return StatusCode::FAILURE;
126  }
127  shm_status->truncate(num * sizeof(ShareEventHeader));
128  m_status = std::make_unique<boost::interprocess::mapped_region>(*shm_status, boost::interprocess::read_write, 0, num * sizeof(ShareEventHeader));
129  ShareEventHeader evtH = { ShareEventHeader::UNLOCKED, -1, -1, 0, 0, 0, "" };
130  std::memcpy(evtH.token, streamPortSuffix.c_str(), maxTokenLength - 1);
131  evtH.token[maxTokenLength - 1] = 0;
132  for (int i = 0; i < num; i++) {
133  std::memcpy(static_cast<char*>(m_status->get_address()) + i * sizeof(ShareEventHeader), &evtH, sizeof(ShareEventHeader));
134  }
135  return(StatusCode::SUCCESS);
136 }

◆ putObject()

StatusCode AthenaSharedMemoryTool::putObject ( const void *  source,
size_t  nbytes,
int  num = 0 
)
overridevirtual

Definition at line 285 of file AthenaSharedMemoryTool.cxx.

285  {
286  if (nbytes > m_maxSize) {
287  ATH_MSG_ERROR("Object size = " << nbytes << " greater than maximum for client = " << num);
288  return(StatusCode::FAILURE);
289  }
290  void* status = static_cast<char*>(m_status->get_address()) + num * sizeof(ShareEventHeader);
291  ShareEventHeader* evtH = static_cast<ShareEventHeader*>(status);
292  ShareEventHeader::ProcessStatus evtStatus = evtH->evtProcessStatus; // read only once
293  if (evtStatus != ShareEventHeader::CLEARED) {
294  ATH_MSG_DEBUG("Waiting for CLEARED putObject, client = " << num << ", in state " << evtStatus);
295  return(StatusCode::RECOVERABLE);
296  }
297  if (source == nullptr) {
298  evtH->evtSize = evtH->evtOffset;
299  evtH->evtOffset = 0;
300  m_payload->flush(0 + evtH->evtOffset, evtH->evtSize);
301  m_status->flush(num * sizeof(ShareEventHeader), sizeof(ShareEventHeader));
302  evtH->evtProcessStatus = ShareEventHeader::FILLED;
303  } else {
304  if (evtH->evtOffset + sizeof(size_t) + nbytes > m_maxSize) {
305  ATH_MSG_ERROR("Object location = " << evtH->evtOffset << " greater than maximum for client = " << num);
306  return(StatusCode::FAILURE);
307  }
308  bool first = (evtH->evtOffset == 0);
309  std::memcpy(static_cast<char*>(m_payload->get_address()) + evtH->evtOffset, &nbytes, sizeof(size_t));
310  evtH->evtOffset += sizeof(size_t);
311  std::memcpy(static_cast<char*>(m_payload->get_address()) + evtH->evtOffset, source, nbytes);
312  evtH->evtOffset += nbytes;
313  if (evtH->evtSize == m_maxSize) {
314  evtH->evtSize = evtH->evtOffset;
315  }
316  if (first) {
317  evtH->evtSize = m_maxSize;
318  m_payload->flush(0, evtH->evtOffset);
319  m_status->flush(num * sizeof(ShareEventHeader), sizeof(ShareEventHeader));
320  }
321  }
322  return(StatusCode::SUCCESS);
323 }

◆ stop()

StatusCode AthenaSharedMemoryTool::stop ( )
overridevirtual

Definition at line 58 of file AthenaSharedMemoryTool.cxx.

58  {
59  ATH_MSG_INFO("in stop()");
60  if (m_isClient && m_num > 0) {
61  ATH_MSG_INFO("Client stop() inform Server: " << m_num);
62  m_num = -1;
63  while (lockObject("stop").isRecoverable()) {
64  usleep(100);
65  }
66  ShareEventHeader* evtH = static_cast<ShareEventHeader*>(m_status->get_address());
67  while (evtH->evtProcessStatus != ShareEventHeader::UNLOCKED) {
68  usleep(100);
69  }
70  }
71  return(StatusCode::SUCCESS);
72 }

Member Data Documentation

◆ m_dataClients

std::set<int> AthenaSharedMemoryTool::m_dataClients
private

Definition at line 67 of file AthenaSharedMemoryTool.h.

◆ m_fileSeqNumber

long AthenaSharedMemoryTool::m_fileSeqNumber {0}
private

Definition at line 70 of file AthenaSharedMemoryTool.h.

◆ m_incidentSvc

ServiceHandle<IIncidentSvc> AthenaSharedMemoryTool::m_incidentSvc
private

Definition at line 73 of file AthenaSharedMemoryTool.h.

◆ m_isClient

bool AthenaSharedMemoryTool::m_isClient {false}
private

Definition at line 72 of file AthenaSharedMemoryTool.h.

◆ m_isServer

bool AthenaSharedMemoryTool::m_isServer {false}
private

Definition at line 71 of file AthenaSharedMemoryTool.h.

◆ m_lastClient

int AthenaSharedMemoryTool::m_lastClient {-1}
private

Definition at line 66 of file AthenaSharedMemoryTool.h.

◆ m_maxDataClients

const int AthenaSharedMemoryTool::m_maxDataClients {256}
private

Definition at line 64 of file AthenaSharedMemoryTool.h.

◆ m_maxSize

const size_t AthenaSharedMemoryTool::m_maxSize {64 * 1024 * 1024}
private

Definition at line 63 of file AthenaSharedMemoryTool.h.

◆ m_num

int AthenaSharedMemoryTool::m_num {-1}
private

Definition at line 65 of file AthenaSharedMemoryTool.h.

◆ m_payload

std::unique_ptr<boost::interprocess::mapped_region> AthenaSharedMemoryTool::m_payload
private

Definition at line 68 of file AthenaSharedMemoryTool.h.

◆ m_sharedMemory

Gaudi::Property<std::string> AthenaSharedMemoryTool::m_sharedMemory {this, "SharedMemoryName", {}}
private

Definition at line 61 of file AthenaSharedMemoryTool.h.

◆ m_status

std::unique_ptr<boost::interprocess::mapped_region> AthenaSharedMemoryTool::m_status
private

Definition at line 69 of file AthenaSharedMemoryTool.h.

The documentation for this class was generated from the following files:
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
AthenaSharedMemoryTool::m_isServer
bool m_isServer
Definition: AthenaSharedMemoryTool.h:71
python.tests.PyTestsLib.finalize
def finalize(self)
_info( "content of StoreGate..." ) self.sg.dump()
Definition: PyTestsLib.py:50
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
AthenaSharedMemoryTool::m_maxDataClients
const int m_maxDataClients
Definition: AthenaSharedMemoryTool.h:64
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
AthenaSharedMemoryTool::m_lastClient
int m_lastClient
Definition: AthenaSharedMemoryTool.h:66
PixelModuleFeMask_create_db.remove
string remove
Definition: PixelModuleFeMask_create_db.py:83
AthenaSharedMemoryTool::lockObject
virtual StatusCode lockObject(const char *tokenString, int num=0) override
Definition: AthenaSharedMemoryTool.cxx:442
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
AthenaSharedMemoryTool::m_isClient
bool m_isClient
Definition: AthenaSharedMemoryTool.h:72
lumiFormat.i
int i
Definition: lumiFormat.py:85
python.DecayParser.buf
buf
print ("=> [%s]"cmd)
Definition: DecayParser.py:27
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthenaSharedMemoryTool::m_dataClients
std::set< int > m_dataClients
Definition: AthenaSharedMemoryTool.h:67
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
taskman.statusName
statusName
Definition: taskman.py:461
xAOD::eventNumber
eventNumber
Definition: EventInfo_v1.cxx:124
AthenaSharedMemoryTool::m_status
std::unique_ptr< boost::interprocess::mapped_region > m_status
Definition: AthenaSharedMemoryTool.h:69
trigbs_pickEvents.num
num
Definition: trigbs_pickEvents.py:76
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
AthenaSharedMemoryTool::m_maxSize
const size_t m_maxSize
Definition: AthenaSharedMemoryTool.h:63
AthenaSharedMemoryTool::m_fileSeqNumber
long m_fileSeqNumber
Definition: AthenaSharedMemoryTool.h:70
maxTokenLength
const std::size_t maxTokenLength
Definition: AthenaSharedMemoryTool.cxx:20
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
copySelective.target
string target
Definition: copySelective.py:37
DeMoScan.first
bool first
Definition: DeMoScan.py:536
copySelective.source
string source
Definition: copySelective.py:32
AthenaSharedMemoryTool
This class provides the IPCTool for SharedMemory objects.
Definition: AthenaSharedMemoryTool.h:34
merge.status
status
Definition: merge.py:17
AthenaSharedMemoryTool::m_sharedMemory
Gaudi::Property< std::string > m_sharedMemory
Definition: AthenaSharedMemoryTool.h:61
AthenaSharedMemoryTool::m_num
int m_num
Definition: AthenaSharedMemoryTool.h:65
AthenaSharedMemoryTool::m_incidentSvc
ServiceHandle< IIncidentSvc > m_incidentSvc
Definition: AthenaSharedMemoryTool.h:73
AthenaSharedMemoryTool::m_payload
std::unique_ptr< boost::interprocess::mapped_region > m_payload
Definition: AthenaSharedMemoryTool.h:68
Generated on Tue Apr 15 2025 21:27:32 for ATLAS Offline Software by   doxygen 1.8.18