SharedMemoryObject.hpp

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
 *****************************************************************************
 * Project    : Zeus Base Library
 * Module     : SharedMemoryObject
 * Package    : Zeus.ZeusBase.System
 * Author     : Benjamin Hadorn
 * Date       : 27.12.2011
 * System     : Zeus-Framework
 *****************************************************************************
 * Licence:                                                                  *
 *   This library is free software; you can redistribute it and/or modify    *
 *   it under the terms of the GNU Lesser General Public License as          *
 *   published by the Free Software Foundation; either version               *
 *   2.1 of the License, or (at your option) any later version.              *
 *                                                                           *
 *   This library is distributed in the hope that it will be useful,         *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
 *   GNU Lesser General Public License for more details.                     *
 *                                                                           *
 *   You should have received a copy of the GNU Lesser General Public        *
 *   License along with this library; if not, write to the Free Software     *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA    *
 *****************************************************************************/

/*****************************************************************************
 * Changes:
 *  27.12.2011 bha: created zeus 2.0
 *****************************************************************************/

#ifndef SharedMemoryObjectHPP
#define SharedMemoryObjectHPP

#include <zeusbase/System/ZObject.h>

#if defined(ENABLE_LINUX_BINDING)
  #include <sys/stat.h>
  #include <sys/types.h> //shm_open
  #include <sys/mman.h>  //mmap
  #include <unistd.h>    //close
  #include <fcntl.h>
  #include <stdio.h>

#elif defined(ENABLE_WIN32_BINDING)
  #include <windows.h>
#endif


BEGIN_NAMESPACE_Zeus

/**************************************************************************/
/**************************************************************************/
template <class T> class TSharedMemoryObject : public TZObject
{
  public:
    TSharedMemoryObject(const TString& rstrName);
    TSharedMemoryObject(const TString& rstrName, const T& rData);

    bool available() const;
    void clean();
    T* getData();
    const T* getData() const;
    void setData(const T& rData);

  protected:
    virtual ~TSharedMemoryObject();

    /**********************************************************************/
    /**********************************************************************/
    struct TypeMemory
    {
      Uint uiSize;
      T tData;
    };

  private:
    void create(const TString& rstrName);

    #if defined(ENABLE_LINUX_BINDING)
      void* m_pMemoryObject;
      int m_iMemFD;
    #elif defined(ENABLE_WIN32_BINDING)

      HANDLE m_hMemory;
      LPVOID m_pMemoryObject;
    #endif

    TypeMemory* m_pData;

};

/**************************************************************************/
/**************************************************************************/
template <class T> inline TSharedMemoryObject<T>::TSharedMemoryObject(const TString& rstrName)
 : TZObject(rstrName)
{
  create(rstrName);
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline TSharedMemoryObject<T>::TSharedMemoryObject(const TString& rstrName, const T& rData)
 : TZObject(rstrName)
{
  create(rstrName);
  setData(rData);
}

/**************************************************************************/
/**************************************************************************/
template <class T> void TSharedMemoryObject<T>::create(const TString& rstrName)
{
  m_pData = NULL;

  #if defined(ENABLE_LINUX_BINDING)
    bool bFirstProcess = true;
    m_pMemoryObject = NULL;
    m_iMemFD = shm_open(rstrName.c_str(NULL), 
                        (O_RDWR),
                        (S_IRWXU | S_IRWXG));

    if (m_iMemFD >= 0)
    {
      bFirstProcess = false;
      //printf("\nShared Memory already existed [%s, %d]\n", rstrName.c_str(NULL), m_iMemFD);
    }
    else
    {
      m_iMemFD = shm_open(rstrName.c_str(NULL),
                          (O_CREAT | O_RDWR),
                          (S_IRWXU | S_IRWXG));
      //printf("\n New Shared Memory [%s, %d]\n", rstrName.c_str(NULL), m_iMemFD);
    }

    if (m_iMemFD >= 0)
    {
      // Set the size of the SHM to be the size of the struct
      ftruncate(m_iMemFD, sizeof(TypeMemory));

      /* Connect the conf pointer to set to the shared memory area,
         with desired permissions
      */
      m_pMemoryObject = mmap(NULL,
                             sizeof(TypeMemory),
                             PROT_EXEC | PROT_READ | PROT_WRITE,
                             MAP_SHARED,
                             m_iMemFD,
                             0);

      if (m_pMemoryObject == MAP_FAILED)
      {
        m_pMemoryObject = NULL;
        //printf("\nMapping of Shared Memory failed [%s, %d]\n", rstrName.c_str(NULL), m_iMemFD);
      }
      else
      {
        //printf("\nMapping of Shared Memory ok [%s, %d]\n", rstrName.c_str(NULL), (int)m_pMemoryObject);
      }
    }

  #elif defined(ENABLE_WIN32_BINDING)
    m_pMemoryObject = NULL;
    m_hMemory       = ::CreateFileMapping( (HANDLE)0xFFFFFFFF,  // Paging File benutzen
                                           NULL,                // Keine Security Attributes
                                           PAGE_READWRITE,      // read/write access
                                           0,                   // Groesse des Files (obere 32 Bit): 0
                                           sizeof(TypeMemory),  // Groesse des Files (untere 32 Bit)
                                           rstrName.c_bstr());    // Ein Name fuer unser File-Mapping-Objekt
    bool bFirstProcess = (::GetLastError() != ERROR_ALREADY_EXISTS);
    if(!bFirstProcess)
    {
      m_hMemory = ::OpenFileMapping(FILE_MAP_ALL_ACCESS,   // Full access
                                    FALSE,                 // dont inherit name
                                    rstrName.c_bstr());    // Name of the object
    }

    if (m_hMemory != NULL)
    {
      m_pMemoryObject = ::MapViewOfFile( m_hMemory,          // Das Objekt
                                         FILE_MAP_ALL_ACCESS, // Voller Zugriff
                                         0,                   // high offset:  Von Anfang
                                         0,                   // low offset:   Von Anfang
                                         0);                  // default: Das ganze File mappen
    }
  #endif

  //Reset the data
  if (m_pMemoryObject != NULL)
  {
    m_pData = (TypeMemory*)m_pMemoryObject;

    //The first process creating the structure must clean it
    if (bFirstProcess)
    {
      clean();
    } //bFirstProcess
    else
    {
      //Checks if the size of the data type equals the shared memory object
      if (m_pData->uiSize != sizeof(T))
      {
        //printf("\nInvalid size of Shared Memory [%s, %d]\n", rstrName.c_str(NULL), m_pData->uiSize);
        m_pData = NULL;
      }
    } 
  }
}

/**************************************************************************/
/**************************************************************************/
template <class T> TSharedMemoryObject<T>::~TSharedMemoryObject()
{
  m_pData = NULL;

  #if defined(ENABLE_LINUX_BINDING)
    if (m_iMemFD > 0)
    {
      close(m_iMemFD);
    }
  #elif defined(ENABLE_WIN32_BINDING)
    if (m_pMemoryObject != NULL)
    {
      ::UnmapViewOfFile(m_pMemoryObject);
    }
    if (m_hMemory != NULL)
    {
      ::CloseHandle(m_hMemory);
    }
  #endif
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline bool TSharedMemoryObject<T>::available() const
{
  return (m_pData != NULL);
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline void TSharedMemoryObject<T>::clean()
{
  if (m_pMemoryObject != NULL)
  {
    memset(m_pMemoryObject, '\0', sizeof(TypeMemory));
  }
  if (m_pData != NULL)
  {
    m_pData->uiSize = sizeof(T);
  }
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline T* TSharedMemoryObject<T>::getData()
{
  T* pRetval = NULL;
  if (m_pData != NULL)
  {
    pRetval = &m_pData->tData;
  }
  return pRetval;
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline const T* TSharedMemoryObject<T>::getData() const
{
  T* pRetval = NULL;
  if (m_pData != NULL)
  {
    pRetval = &m_pData->tData;
  }
  return pRetval;
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline void TSharedMemoryObject<T>::setData(const T& rData)
{
  if (m_pData != NULL)
  {
    m_pData->tData = rData;
  }
}

END_NAMESPACE_Zeus

#endif