SharedMemoryObject< T > Class Template Reference

#include <SharedMemory.h>

Inheritance diagram for SharedMemoryObject< T >:

Collaboration diagram for SharedMemoryObject< T >:

Public Member Functions
	SharedMemoryObject ()=default
bool	createNew (const std::string &name, bool allowOverwrite=false)
void	attach (const std::string &name)
void	closeNew ()
void	detach ()
T *	get ()
T &	operator() ()

Private Attributes
T *	_data = nullptr
std::string	_name
size_t	_size
int	_fd

Detailed Description

template<typename T>
class SharedMemoryObject< T >

A container class for an object which is stored in shared memory. This object can then be viewed in multiple processes or programs. Note that there is significant overhead when creating a shared memory object, so it is recommended that two programs that communicate should have one single large SharedMemoryObject instead of many small ones.

A name string is used to identify shared objects across different programs

Before a shared memory object can be used, you must either allocate new memory, or connect it to an existing shared memory object.

Creating/deleting the memory can be done with createNew/closeNew. Viewing an existing object allocated with createNew can be done with attach/detach

For an example, see test_sharedMemory.cpp

Definition at line 112 of file SharedMemory.h.

Constructor & Destructor Documentation

template<typename T>

SharedMemoryObject< T >::SharedMemoryObject ( )

default

Member Function Documentation

template<typename T>

void SharedMemoryObject< T >::attach ( const std::string &  name )

inline

Attach to an existing shared memory object.

Definition at line 191 of file SharedMemory.h.

                                     {
    assert(!_data);
    _name = name;
    _size = sizeof(T);
    printf("[Shared Memory] open existing %s size %ld bytes\n", name.c_str(),
           _size);
    _fd = shm_open(name.c_str(), O_RDWR,
                   S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP | S_IROTH);
    if (_fd == -1) {
      printf("[ERROR] SharedMemoryObject::attach shm_open(%s) failed: %s\n",
             _name.c_str(), strerror(errno));
      throw std::runtime_error("Failed to create shared memory!");
      return;
    }

    struct stat s;
    if (fstat(_fd, &s)) {
      printf("[ERROR] SharedMemoryObject::attach(%s) stat: %s\n", name.c_str(),
             strerror(errno));
      throw std::runtime_error("Failed to create shared memory!");
      return;
    }

    if ((size_t)s.st_size != _size) {
      printf(
          "[ERROR] SharedMemoryObject::attach(%s) on something that was "
          "incorrectly "
          "sized (size is %ld bytes, should be %ld)\n",
          _name.c_str(), s.st_size, _size);
      throw std::runtime_error("Failed to create shared memory!");
      return;
    }

    void* mem =
        mmap(nullptr, _size, PROT_READ | PROT_WRITE, MAP_SHARED, _fd, 0);
    if (mem == MAP_FAILED) {
      printf("[ERROR] SharedMemory::attach(%s) mmap fail: %s\n", _name.c_str(),
             strerror(errno));
      throw std::runtime_error("Failed to create shared memory!");
      return;
    }

    _data = (T*)mem;
  }

Here is the caller graph for this function:

template<typename T>

void SharedMemoryObject< T >::closeNew ( )

inline

Free memory associated with the current open shared memory object. The object could have been opened with either attach or createNew. After calling this, no process can use this shared object

Definition at line 241 of file SharedMemory.h.

                  {
    assert(_data);
    // first, unmap
    if (munmap((void*)_data, _size)) {
      printf("[ERROR] SharedMemoryObject::closeNew (%s) munmap %s\n",
             _name.c_str(), strerror(errno));
      throw std::runtime_error("Failed to create shared memory!");
      return;
    }

    _data = nullptr;

    if (shm_unlink(_name.c_str())) {
      printf("[ERROR] SharedMemoryObject::closeNew (%s) shm_unlink %s\n",
             _name.c_str(), strerror(errno));
      throw std::runtime_error("Failed to create shared memory!");
      return;
    }

    // close fd
    if (close(_fd)) {
      printf("[ERROR] SharedMemoryObject::closeNew (%s) close %s\n",
             _name.c_str(), strerror(errno));
      throw std::runtime_error("Failed to create shared memory!");
      return;
    }

    _fd = 0;
  }

Here is the caller graph for this function:

template<typename T>

bool SharedMemoryObject< T >::createNew ( const std::string &  name, bool  allowOverwrite = false  )

inline

Allocate memory for the shared memory object and attach to it. If allowOverwrite is true, and there's already an object with this name, the old object is overwritten Note that if this happens, the object may be initialized in a very weird state.

Otherwise, if an object with the name already exists, throws a std::runtime_error

Definition at line 125 of file SharedMemory.h.

                                                                     {
    bool hadToDelete = false;
    assert(!_data);
    _name = name;
    _size = sizeof(T);
    printf("[Shared Memory] open new %s, size %ld bytes\n", name.c_str(),
           _size);

    _fd = shm_open(name.c_str(), O_RDWR | O_CREAT,
                   S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP | S_IROTH);
    if (_fd == -1) {
      printf("[ERROR] SharedMemoryObject shm_open failed: %s\n",
             strerror(errno));
      throw std::runtime_error("Failed to create shared memory!");
      return false;
    }

    struct stat s;
    if (fstat(_fd, &s)) {
      printf("[ERROR] SharedMemoryObject::createNew(%s) stat: %s\n",
             name.c_str(), strerror(errno));
      throw std::runtime_error("Failed to create shared memory!");
      return false;
    }

    if (s.st_size) {
      printf(
          "[Shared Memory] SharedMemoryObject::createNew(%s) on something that "
          "wasn't new (size is %ld bytes)\n",
          _name.c_str(), s.st_size);
      hadToDelete = true;
      if (!allowOverwrite)
        throw std::runtime_error(
            "Failed to create shared memory - it already exists.");
      printf("\tusing existing shared memory!\n");
      // return false;
    }

    if (ftruncate(_fd, _size)) {
      printf("[ERROR] SharedMemoryObject::createNew(%s) ftruncate(%ld): %s\n",
             name.c_str(), _size, strerror(errno));
      throw std::runtime_error("Failed to create shared memory!");
      return false;
    }

    void* mem =
        mmap(nullptr, _size, PROT_READ | PROT_WRITE, MAP_SHARED, _fd, 0);
    if (mem == MAP_FAILED) {
      printf("[ERROR] SharedMemory::createNew(%s) mmap fail: %s\n",
             _name.c_str(), strerror(errno));
      throw std::runtime_error("Failed to create shared memory!");
      return false;
    }

    // there is a chance that the shared memory is not zeroed if we are reusing
    // old memory. this causes all sorts of weird issues, especially if the
    // layout of the object in memory has changed.
    memset(mem, 0, _size);

    _data = (T*)mem;
    return hadToDelete;
  }

Here is the caller graph for this function:

template<typename T>

void SharedMemoryObject< T >::detach ( )

inline

Close this view of the currently opened shared memory object. The object can be opened with either attach or createNew. After calling this, this process can no longer use this shared object, but other processes still can.

Definition at line 277 of file SharedMemory.h.

                {
    assert(_data);
    // first, unmap
    if (munmap((void*)_data, _size)) {
      printf("[ERROR] SharedMemoryObject::detach (%s) munmap %s\n",
             _name.c_str(), strerror(errno));
      throw std::runtime_error("Failed to create shared memory!");
      return;
    }

    _data = nullptr;

    // close fd
    if (close(_fd)) {
      printf("[ERROR] SharedMemoryObject::detach (%s) close %s\n",
             _name.c_str(), strerror(errno));
      throw std::runtime_error("Failed to create shared memory!");
      return;
    }

    _fd = 0;
  }

Here is the caller graph for this function:

template<typename T>

T* SharedMemoryObject< T >::get ( )

inline

Get the shared memory object.

Definition at line 303 of file SharedMemory.h.

           {
    assert(_data);
    return _data;
  }

Here is the caller graph for this function:

template<typename T>

T& SharedMemoryObject< T >::operator() ( )

inline

Get the shared memory object.

Definition at line 311 of file SharedMemory.h.

                  {
    assert(_data);
    return *_data;
  }

Member Data Documentation

template<typename T>

T* SharedMemoryObject< T >::_data = nullptr

private

Definition at line 317 of file SharedMemory.h.

template<typename T>

int SharedMemoryObject< T >::_fd

private

Definition at line 320 of file SharedMemory.h.

template<typename T>

std::string SharedMemoryObject< T >::_name

private

Definition at line 318 of file SharedMemory.h.

template<typename T>

size_t SharedMemoryObject< T >::_size

private

Definition at line 319 of file SharedMemory.h.

---

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

• SharedMemory.h