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.
virtual	~AthenaSharedMemoryTool ()
	Destructor.
virtual StatusCode	initialize () override
	Gaudi Service Interface method implementations:
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", {}}
Gaudi::Property< size_t >	m_maxSize {this, "SharedMemoryObjectSize", 64 * 1024 * 1024, "Maximum shared memory object size in B (default = 64 MB)"}
Gaudi::Property< int >	m_maxDataClients {this, "SharedMemoryClientSize", 256, "Maximum number of clients (default = 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
std::optional< InputFileIncidentGuard > m_inputFileGuard	ATLAS_THREAD_SAFE

Detailed Description

This class provides the IPCTool for SharedMemory objects.

Definition at line 36 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.

                              :
  base_class(type, name, parent),
  m_incidentSvc("IncidentSvc", name) {
  m_sharedMemory.setValue(name);
}

~AthenaSharedMemoryTool()

AthenaSharedMemoryTool::~AthenaSharedMemoryTool ( )

virtual

Destructor.

Definition at line 45 of file AthenaSharedMemoryTool.cxx.

                                                {
}

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 356 of file AthenaSharedMemoryTool.cxx.

                                                                                 {
   if (m_isClient) {
      ShareEventHeader* evtH = static_cast<ShareEventHeader*>(m_status->get_address());
      if (evtH->evtProcessStatus != ShareEventHeader::CLEARED) {
         ATH_MSG_DEBUG("Waiting for FILL clearObject");
         return(StatusCode::RECOVERABLE);
      }
      *tokenString = evtH->token;
      evtH->evtProcessStatus = ShareEventHeader::UNLOCKED;
      return(StatusCode::SUCCESS);
   }
 
   for (int i = 1; i <= m_num; i++) { // FIXME: PvG, do round robin
      void* status = static_cast<char*>(m_status->get_address()) + i * sizeof(ShareEventHeader);
      ShareEventHeader* evtH = static_cast<ShareEventHeader*>(status);
      ShareEventHeader::ProcessStatus evtStatus = evtH->evtProcessStatus; // read only once
      if (evtStatus == ShareEventHeader::FILLED) {
         ATH_MSG_DEBUG("Waiting for UNFILL clearObject, client = " << i);
         return(StatusCode::RECOVERABLE);
      } else if (i == num && evtStatus != ShareEventHeader::LOCKED) {
         ATH_MSG_DEBUG("Waiting for LOCK clearObject, client = " << i);
         return(StatusCode::RECOVERABLE);
      }
      if (m_lastClient < 0 || m_lastClient == i) { // If Writer is not yet released, only consider last client
         if ((i == num || num < 0) && evtStatus == ShareEventHeader::LOCKED) {
            *tokenString = evtH->token;
            num = i;
            ATH_MSG_DEBUG("Setting LOCK clearObject, for client = " << num << ": " << evtH->token);
            m_lastClient = -1;
           // break;
         }
      }
   }
 
   if (num > 0 && *tokenString != nullptr) {
      m_lastClient = -1; // Release Writer from last client
      void* status = static_cast<char*>(m_status->get_address()) + num * sizeof(ShareEventHeader);
      ShareEventHeader* evtH = static_cast<ShareEventHeader*>(status);
      if (strncmp(*tokenString, "wait", 4) == 0) {
         ATH_MSG_INFO("Server clearObject() got wait, client = " << num);
         evtH->evtProcessStatus = ShareEventHeader::UNLOCKED;
         m_lastClient = num; // Keep Writer allocated
         num = -1;
         return(StatusCode::SUCCESS);
      }
      if (strncmp(*tokenString, "release", 7) == 0) {
         ATH_MSG_INFO("Server clearObject() got release, client = " << num);
         evtH->evtProcessStatus = ShareEventHeader::UNLOCKED;
         num = -1;
         return(StatusCode::SUCCESS);
      }
      if (strncmp(*tokenString, "start", 5) == 0) {
         ATH_MSG_INFO("Server clearObject() got start, client = " << num << ", of " << m_num - 1);
         if (m_dataClients.empty()) { // Annouce all workers to prevent early writer termination
            for (int i = 1; i < m_num - 1; i++) m_dataClients.insert(i);
         }
         m_dataClients.insert(num);
         evtH->evtProcessStatus = ShareEventHeader::UNLOCKED;
         num = -1;
         return(StatusCode::SUCCESS);
      }
      if (strncmp(*tokenString, "stop", 4) == 0) {
         ATH_MSG_INFO("Server clearObject() got stop, client = " << num);
         m_dataClients.erase(num);
         evtH->evtProcessStatus = ShareEventHeader::UNLOCKED;
         if (m_dataClients.empty()) {
            ATH_MSG_INFO("Server clearObject() got stop, client ALL: " << m_num);
            if (num == m_num - 1) { // mother process
              return(StatusCode::SUCCESS);
            }
            return(StatusCode::FAILURE);
         }
         num = -1;
         return(StatusCode::SUCCESS);
      }
      evtH->evtSize = 0;
      m_status->flush(0, sizeof(ShareEventHeader));
      evtH->evtProcessStatus = ShareEventHeader::CLEARED;
      return(StatusCode::SUCCESS);
   }
   return(StatusCode::RECOVERABLE);
}

finalize()

StatusCode AthenaSharedMemoryTool::finalize ( )

overridevirtual

Definition at line 77 of file AthenaSharedMemoryTool.cxx.

                                            {
   ATH_MSG_INFO("in finalize()");
   if (m_isServer) {
      try {
         boost::interprocess::shared_memory_object::remove(m_sharedMemory.value().c_str());
      } catch(boost::interprocess::interprocess_exception &e) {
         ATH_MSG_WARNING("Cannot remove shared memory " << m_sharedMemory.value() << ": " << boost::diagnostic_information(e));
      }
      const std::string statusName = m_sharedMemory.value() + "_status";
      try {
         boost::interprocess::shared_memory_object::remove(statusName.c_str());
      } catch(boost::interprocess::interprocess_exception &e) {
         ATH_MSG_WARNING("Cannot remove shared memory " << statusName << ": " << boost::diagnostic_information(e));
      }
   }
   // Release IncidentSvc
   if (!m_incidentSvc.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release IncidentSvc.");
   }
   return(::AthAlgTool::finalize());
}

getLockedEvent()

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

overridevirtual

Definition at line 241 of file AthenaSharedMemoryTool.cxx.

                                                                                           {
   ShareEventHeader* evtH = static_cast<ShareEventHeader*>(m_status->get_address());
   if (evtH->evtProcessStatus == ShareEventHeader::LOCKED) {
      const std::size_t nbytes = evtH->evtSize;
      if (target != nullptr) {
         char* buf = new char[nbytes];
         std::memcpy(buf, static_cast<char*>(m_payload->get_address()) + evtH->evtOffset, nbytes);
         *target = buf;
      }
      status = evtH->evtCoreStatusFlag;
   } else {
      ATH_MSG_ERROR("No event locked");
      return(StatusCode::FAILURE);
   }
   evtH->evtProcessStatus = ShareEventHeader::UNLOCKED;
   return(StatusCode::SUCCESS);
}

getObject()

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

overridevirtual

Definition at line 325 of file AthenaSharedMemoryTool.cxx.

                                                                                   {
   if (target == nullptr) {
      return(StatusCode::SUCCESS);
   }
   void* status = static_cast<char*>(m_status->get_address()) + num * sizeof(ShareEventHeader);
   ShareEventHeader* evtH = static_cast<ShareEventHeader*>(status);
   ShareEventHeader::ProcessStatus evtStatus = evtH->evtProcessStatus; // read only once
   size_t evtSize = evtH->evtSize; // read only once
   if (evtStatus != ShareEventHeader::FILLED) {
      ATH_MSG_DEBUG("Waiting for FILLED getObject, client = " << num);
      nbytes = 0;
      return(StatusCode::RECOVERABLE);
   }
   if (evtH->evtOffset < evtSize) {
      std::memcpy(&nbytes, static_cast<char*>(m_payload->get_address()) + evtH->evtOffset, sizeof(size_t));
      evtH->evtOffset += sizeof(size_t);
      *target = static_cast<char*>(m_payload->get_address()) + evtH->evtOffset;
      evtH->evtOffset += nbytes;
      return(StatusCode::SUCCESS); // return object
   }
   nbytes = 0;
   evtH->evtOffset = 0;
   m_status->flush(num * sizeof(ShareEventHeader), sizeof(ShareEventHeader));
   while (evtH->evtProcessStatus != ShareEventHeader::FILLED) {
      usleep(10);
   }
   evtH->evtProcessStatus = ShareEventHeader::UNLOCKED;
   return(StatusCode::SUCCESS); // unlock server
}

initialize()

StatusCode AthenaSharedMemoryTool::initialize ( )

overridevirtual

Gaudi Service Interface method implementations:

Definition at line 49 of file AthenaSharedMemoryTool.cxx.

                                              {
   ATH_MSG_INFO("Initializing " << name());
 
   ATH_CHECK( m_incidentSvc.retrieve() );
 
   return(StatusCode::SUCCESS);
}

isClient()

bool AthenaSharedMemoryTool::isClient ( ) const

overridevirtual

Definition at line 201 of file AthenaSharedMemoryTool.cxx.

                                            {
   return(m_isClient);
}

isServer()

bool AthenaSharedMemoryTool::isServer ( ) const

overridevirtual

Definition at line 141 of file AthenaSharedMemoryTool.cxx.

                                            {
   return(m_isServer);
}

lockEvent()

StatusCode AthenaSharedMemoryTool::lockEvent ( long eventNumber ) const

overridevirtual

Definition at line 260 of file AthenaSharedMemoryTool.cxx.

                                                                   {
   ShareEventHeader* evtH = static_cast<ShareEventHeader*>(m_status->get_address());
   if (evtH->evtSeqNumber > eventNumber) {
      ATH_MSG_ERROR("eventNumber = " << eventNumber << ", already processed");
      return(StatusCode::FAILURE);
   }
   if (evtH->evtSeqNumber == 0 && evtH->fileSeqNumber == 0 && evtH->evtSize == 0) {
      ATH_MSG_DEBUG("Server has been terminated");
      return(StatusCode::FAILURE);
   }
   if (evtH->evtSeqNumber != eventNumber || evtH->evtProcessStatus != ShareEventHeader::FILLED) {
      ATH_MSG_DEBUG("Waiting for lockEvent, eventNumber = " << eventNumber);
      return(StatusCode::RECOVERABLE);
   }
   if (evtH->fileSeqNumber != m_fileSeqNumber && m_fileSeqNumber > 0) {
      InputFileIncidentGuard::transition(m_inputFileGuard, *m_incidentSvc, name(), "SHM", {});
      const_cast<AthenaSharedMemoryTool*>(this)->m_fileSeqNumber = evtH->fileSeqNumber;
   }
   ATH_MSG_DEBUG("Locking eventNumber = " << eventNumber);
   evtH->evtProcessStatus = ShareEventHeader::LOCKED;
   return(StatusCode::SUCCESS);
}

lockObject()

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

overridevirtual

Definition at line 440 of file AthenaSharedMemoryTool.cxx.

                                                                              {
   if (strlen(tokenString) >= maxTokenLength) {
      ATH_MSG_ERROR("Token = " << tokenString << ", too long for AthenaSharedMemoryTool");
      return(StatusCode::FAILURE);
   }
   void* status = static_cast<char*>(m_status->get_address()) + num * sizeof(ShareEventHeader);
   ShareEventHeader* evtH = static_cast<ShareEventHeader*>(status);
   if (evtH->evtProcessStatus != ShareEventHeader::UNLOCKED) {
      ATH_MSG_DEBUG("Waiting for UNLOCKED lockObject: " << tokenString);
      return(StatusCode::RECOVERABLE);
   }
   strncpy(evtH->token, tokenString, maxTokenLength - 1); evtH->token[maxTokenLength - 1] = 0;
   if (m_isServer) {
      evtH->evtSize = 0;
      m_status->flush(num * sizeof(ShareEventHeader), sizeof(ShareEventHeader));
      evtH->evtProcessStatus = ShareEventHeader::CLEARED;
   } else {
      m_status->flush(num * sizeof(ShareEventHeader), sizeof(ShareEventHeader));
      evtH->evtProcessStatus = ShareEventHeader::LOCKED;
   }
   return(StatusCode::SUCCESS);
}

makeClient()

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

overridevirtual

Definition at line 146 of file AthenaSharedMemoryTool.cxx.

                                                                                  {
   if (m_isServer) {
      ATH_MSG_ERROR("Cannot make AthenaSharedMemoryTool a Client.");
      return(StatusCode::FAILURE);
   }
   if (num >= m_maxDataClients) {
      ATH_MSG_ERROR("Too many clients for AthenaSharedMemoryTool.");
      return(StatusCode::FAILURE);
   }
   if (m_num > 0 && num <= 0) {// stop running client
      ATH_MSG_DEBUG("Stop AthenaSharedMemoryTool Client.");
      m_num = -1;
      while (lockObject("stop").isRecoverable()) {
         usleep(100);
      }
      ShareEventHeader* evtH = static_cast<ShareEventHeader*>(m_status->get_address());
      while (evtH->evtProcessStatus != ShareEventHeader::UNLOCKED) {
         usleep(100);
      }
      m_payload.reset();
      m_status.reset();
      m_isClient = false;
      return(StatusCode::SUCCESS);
   }
   while (!m_isClient) {
      try { // Check whether Server created shared memory object
         const std::string statusName = m_sharedMemory.value() + "_status";
         boost::interprocess::shared_memory_object shm_status(boost::interprocess::open_only,
             statusName.c_str(),
             boost::interprocess::read_write);
         m_status = std::make_unique<boost::interprocess::mapped_region>(shm_status, boost::interprocess::read_write, num * sizeof(ShareEventHeader), sizeof(ShareEventHeader));
         boost::interprocess::shared_memory_object shm(boost::interprocess::open_only,
             m_sharedMemory.value().c_str(),
             boost::interprocess::read_write);
         m_payload = std::make_unique<boost::interprocess::mapped_region>(shm, boost::interprocess::read_write, 0, m_maxSize);
         m_isClient = true;
      } catch (boost::interprocess::interprocess_exception& e) {
         usleep(100000);
      }
   }
   if (m_num <= 0 && num > 0) {
      ShareEventHeader* evtH = static_cast<ShareEventHeader*>(m_status->get_address());
      streamPortSuffix.assign(evtH->token);
      while (lockObject("start").isRecoverable()) {
         usleep(100);
      }
      while (evtH->evtProcessStatus != ShareEventHeader::UNLOCKED) {
         usleep(100);
      }
      m_num = num;
   }
   return(StatusCode::SUCCESS);
}

makeServer()

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

overridevirtual

Definition at line 100 of file AthenaSharedMemoryTool.cxx.

                                                                                        {
   if (m_isServer || m_isClient) {
      ATH_MSG_ERROR("Cannot make AthenaSharedMemoryTool a Server.");
      return(StatusCode::FAILURE);
   }
   if (num > m_maxDataClients) {
      ATH_MSG_ERROR("Too many clients for AthenaSharedMemoryTool Server.");
      return(StatusCode::FAILURE);
   }
   m_num = num;
   m_isServer = true;
   ATH_MSG_DEBUG("Creating shared memory object with name \"" << m_sharedMemory.value() << "\"");
   std::optional<boost::interprocess::shared_memory_object> shm;
   try {
      shm.emplace(boost::interprocess::create_only, m_sharedMemory.value().c_str(), boost::interprocess::read_write);
   } catch(boost::interprocess::interprocess_exception &e) {
      ATH_MSG_ERROR("Cannot create shared memory " << m_sharedMemory.value() << ": " << boost::diagnostic_information(e));
      return StatusCode::FAILURE;
   }
   shm->truncate(m_maxSize);
   m_payload = std::make_unique<boost::interprocess::mapped_region>(*shm, boost::interprocess::read_write, 0, m_maxSize);
   const std::string statusName = m_sharedMemory.value() + "_status";
   std::optional<boost::interprocess::shared_memory_object> shm_status;
   try {
      shm_status.emplace(boost::interprocess::create_only, statusName.c_str(), boost::interprocess::read_write);
   } catch(boost::interprocess::interprocess_exception &e) {
      ATH_MSG_ERROR("Cannot create shared memory " << statusName << ": " << boost::diagnostic_information(e));
      return StatusCode::FAILURE;
   }
   shm_status->truncate(num * sizeof(ShareEventHeader));
   m_status = std::make_unique<boost::interprocess::mapped_region>(*shm_status, boost::interprocess::read_write, 0, num * sizeof(ShareEventHeader));
   ShareEventHeader evtH = { ShareEventHeader::UNLOCKED, -1, -1, 0, 0, 0, "" };
   std::memcpy(evtH.token, streamPortSuffix.c_str(), maxTokenLength - 1);
   evtH.token[maxTokenLength - 1] = 0;
   for (int i = 0; i < num; i++) {
      std::memcpy(static_cast<char*>(m_status->get_address()) + i * sizeof(ShareEventHeader), &evtH, sizeof(ShareEventHeader));
   }
   return(StatusCode::SUCCESS);
}

putObject()

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

overridevirtual

Definition at line 284 of file AthenaSharedMemoryTool.cxx.

                                                                                       {
   if (nbytes > m_maxSize) {
      ATH_MSG_ERROR("Object size = " << nbytes << " greater than maximum for client = " << num);
      return(StatusCode::FAILURE);
   }
   void* status = static_cast<char*>(m_status->get_address()) + num * sizeof(ShareEventHeader);
   ShareEventHeader* evtH = static_cast<ShareEventHeader*>(status);
   ShareEventHeader::ProcessStatus evtStatus = evtH->evtProcessStatus; // read only once
   if (evtStatus != ShareEventHeader::CLEARED) {
      ATH_MSG_DEBUG("Waiting for CLEARED putObject, client = " << num << ", in state " << evtStatus);
      return(StatusCode::RECOVERABLE);
   }
   if (source == nullptr) {
      evtH->evtSize = evtH->evtOffset;
      evtH->evtOffset = 0;
      m_payload->flush(0 + evtH->evtOffset, evtH->evtSize);
      m_status->flush(num * sizeof(ShareEventHeader), sizeof(ShareEventHeader));
      evtH->evtProcessStatus = ShareEventHeader::FILLED;
   } else {
      if (evtH->evtOffset + sizeof(size_t) + nbytes > m_maxSize) {
         ATH_MSG_ERROR("Object location = " << evtH->evtOffset << " greater than maximum for client = " << num);
         return(StatusCode::FAILURE);
      }
      bool first = (evtH->evtOffset == 0);
      std::memcpy(static_cast<char*>(m_payload->get_address()) + evtH->evtOffset, &nbytes, sizeof(size_t));
      evtH->evtOffset += sizeof(size_t);
      std::memcpy(static_cast<char*>(m_payload->get_address()) + evtH->evtOffset, source, nbytes);
      evtH->evtOffset += nbytes;
      if (evtH->evtSize == m_maxSize) {
         evtH->evtSize = evtH->evtOffset;
      }
      if (first) {
         evtH->evtSize = m_maxSize;
         m_payload->flush(0, evtH->evtOffset);
         m_status->flush(num * sizeof(ShareEventHeader), sizeof(ShareEventHeader));
      }
   }
   return(StatusCode::SUCCESS);
}

stop()

StatusCode AthenaSharedMemoryTool::stop ( )

overridevirtual

Definition at line 58 of file AthenaSharedMemoryTool.cxx.

                                        {
   ATH_MSG_INFO("in stop()");
   // Fire EndInputFile for any file still open.
   m_inputFileGuard.reset();
   if (m_isClient && m_num > 0) {
      ATH_MSG_INFO("Client stop() inform Server: " << m_num);
      m_num = -1;
      while (lockObject("stop").isRecoverable()) {
         usleep(100);
      }
      ShareEventHeader* evtH = static_cast<ShareEventHeader*>(m_status->get_address());
      while (evtH->evtProcessStatus != ShareEventHeader::UNLOCKED) {
         usleep(100);
      }
   }
   return(StatusCode::SUCCESS);
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::optional<InputFileIncidentGuard> m_inputFileGuard AthenaSharedMemoryTool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 76 of file AthenaSharedMemoryTool.h.

m_dataClients

std::set<int> AthenaSharedMemoryTool::m_dataClients

private

Definition at line 69 of file AthenaSharedMemoryTool.h.

m_fileSeqNumber

long AthenaSharedMemoryTool::m_fileSeqNumber {0}

private

Definition at line 72 of file AthenaSharedMemoryTool.h.

{0};

m_incidentSvc

ServiceHandle<IIncidentSvc> AthenaSharedMemoryTool::m_incidentSvc

private

Definition at line 75 of file AthenaSharedMemoryTool.h.

m_isClient

bool AthenaSharedMemoryTool::m_isClient {false}

private

Definition at line 74 of file AthenaSharedMemoryTool.h.

{false};

m_isServer

bool AthenaSharedMemoryTool::m_isServer {false}

private

Definition at line 73 of file AthenaSharedMemoryTool.h.

{false};

m_lastClient

int AthenaSharedMemoryTool::m_lastClient {-1}

private

Definition at line 68 of file AthenaSharedMemoryTool.h.

{-1};

m_maxDataClients

Gaudi::Property<int> AthenaSharedMemoryTool::m_maxDataClients {this, "SharedMemoryClientSize", 256, "Maximum number of clients (default = 256)"}

private

Definition at line 65 of file AthenaSharedMemoryTool.h.

{this, "SharedMemoryClientSize", 256, "Maximum number of clients (default = 256)"};

m_maxSize

Gaudi::Property<size_t> AthenaSharedMemoryTool::m_maxSize {this, "SharedMemoryObjectSize", 64 * 1024 * 1024, "Maximum shared memory object size in B (default = 64 MB)"}

private

Definition at line 64 of file AthenaSharedMemoryTool.h.

{this, "SharedMemoryObjectSize", 64 * 1024 * 1024, "Maximum shared memory object size in B (default = 64 MB)"};

m_num

int AthenaSharedMemoryTool::m_num {-1}

private

Definition at line 67 of file AthenaSharedMemoryTool.h.

{-1};

m_payload

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

private

Definition at line 70 of file AthenaSharedMemoryTool.h.

m_sharedMemory

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

private

Definition at line 63 of file AthenaSharedMemoryTool.h.

{this, "SharedMemoryName", {}};

m_status

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

private

Definition at line 71 of file AthenaSharedMemoryTool.h.

---

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

• AthenaSharedMemoryTool.h
• AthenaSharedMemoryTool.cxx