SharedMemory.hpp

#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/TypeName.hxx"
#include "Arp/System/Commons/Logging.h"
#include "Arp/System/Commons/Threading/Thread.hpp"
#include "Arp/System/Commons/Exceptions/InvalidOperationException.hpp"
#include "boost/interprocess/managed_shared_memory.hpp"
#include <array>
#include <algorithm>
#include <new>      // using displacement new
 
namespace Arp { namespace System { namespace Commons { namespace Ipc
{
 
class SharedMemory : private Loggable<SharedMemory>
{
public: // usings
    using SharedMemoryImpl          = boost::interprocess::managed_shared_memory;
    using SegmentManager            = SharedMemoryImpl::segment_manager;
    using SharedMemoryPermission    = boost::interprocess::permissions;
 
    template <class T>
    using Ptr = boost::interprocess::offset_ptr<T>;
 
public: // construction/destruction
    explicit SharedMemory(const char* name);
    SharedMemory(const char* name, size_t memorySize);
    SharedMemory(const SharedMemory& arg) = delete;
    SharedMemory(SharedMemory&& arg)noexcept = delete;
    SharedMemory& operator=(const SharedMemory& arg) = delete;
    SharedMemory& operator=(SharedMemory&& arg)noexcept = delete;
    ~SharedMemory(void);
 
public: // operations
    void    Dispose(void);
 
public: // properties
    bool            IsOwner(void)const;
    size_t          GetSize(void)const;
    const String&   GetName(void)const;
 
public: // operations
    byte*   Allocate(size_t size);
    void    Deallocate(byte* pMemory);
    size_t  GetFreeMemory(void)const;
    void    ZeroFreeMemory(void);
    bool    AllMemoryDeallocated(void);
    bool    CheckSanity(void);
 
public: // template operations
    template<class T>
    Ptr<T>  Get(const char* name);
 
    template<class T, typename ...TArgs>
    Ptr<T>  GetOrConstruct(const char* name, TArgs&& ... args);
 
    template<class T, typename ...TArgs>
    Ptr<T>  Construct(const char* name, TArgs&& ... args);
 
    template<class T>
    void    Destroy(const char* name);
 
    template<class T, typename ...TArgs>
    Ptr<T>  ConstructUnnamed(TArgs&& ... args);
 
    template<class T>
    void    DestroyUnnamed(SharedMemory::Ptr<T> ptr);
 
protected: // fields
    SharedMemoryImpl sharedMemoryImpl;  
 
private: // methods
    void Create(void);
    bool TryCreate(void);
    void Open(void);
    bool TryOpen(void);
    void Remove(void);
    bool TryRemove(void);
 
private: // fields
    String  memoryName;        
    size_t  memorySize = 0;
 
private: // nested class
    template<class T> class AlignmentProxy
    {
    public: // construction/destruction
        template<typename ...Args>
        explicit AlignmentProxy(Args&& ... args);
        AlignmentProxy(const AlignmentProxy& arg) = delete;
        AlignmentProxy(AlignmentProxy&& arg)noexcept = delete;
        AlignmentProxy& operator=(const AlignmentProxy& arg) = delete;
        AlignmentProxy& operator=(AlignmentProxy&& arg)noexcept = delete;
        ~AlignmentProxy(void);
 
    public: // operations
        T* GetAlignedObjectPtr(void);
 
    private: // fields
        static constexpr size_t alignment = static_cast<size_t>(std::max(static_cast<int>(alignof(T)) - static_cast<int>(alignof(void*)), 0));
        static constexpr size_t alignedSize = sizeof(T) + alignment;
        std::array<byte, alignedSize> buffer{};
    };
};
 
// inline methods of class SharedMemory
 
template<class T>
inline SharedMemory::Ptr<T> SharedMemory::Get(const char* name)
{
    SharedMemory::Ptr<AlignmentProxy<T>> proxyPtr = sharedMemoryImpl.find<AlignmentProxy<T>>(name).first;
    if (!proxyPtr)
    {
        return nullptr;
    }
    // else
    return proxyPtr.get()->GetAlignedObjectPtr();
}
 
template<class T, typename ...TArgs>
inline SharedMemory::Ptr<T> SharedMemory::GetOrConstruct(const char* name, TArgs&& ... args)
{
    Ptr<T> result = Get<T>(name);
    if (!result)
    {
        return Construct<T>(name, std::forward<TArgs>(args)...);
    }
    return result;
}
 
template<class T, typename ...TArgs>
inline SharedMemory::Ptr<T> SharedMemory::Construct(const char* name, TArgs&& ... args)
{
    return this->sharedMemoryImpl.construct<AlignmentProxy<T>>(name)(std::forward<TArgs>(args)...)->GetAlignedObjectPtr();
}
 
template<class T>
inline void SharedMemory::Destroy(const char* name)
{
    SharedMemory::Ptr<AlignmentProxy<T>> proxyPtr = sharedMemoryImpl.find<AlignmentProxy<T>>(name).first;
 
    if (proxyPtr != nullptr)
    {
        // free memory
        this->sharedMemoryImpl.destroy<AlignmentProxy<T>>(name);
    }
}
 
template<class T, typename ...TArgs>
inline SharedMemory::Ptr<T> SharedMemory::ConstructUnnamed(TArgs&& ... args)
{
    // allocate memory
    void* pResult = this->sharedMemoryImpl.allocate(sizeof(T));
    // call ctor using placement new operator with allocated memory pointer
    return new (pResult) T(std::forward<TArgs>(args)...);
}
 
template<class T>
inline void SharedMemory::DestroyUnnamed(SharedMemory::Ptr<T> ptr)
{
    if (ptr != nullptr)
    {
        // call dtor of object explicitly
        ptr->~T();
        // free memory
        this->sharedMemoryImpl.deallocate(ptr.get());
    }
}
 
// inline methods of class SharedMemory::AlignmentProxy<T>
 
template<class T>
template<typename ...Args>
inline SharedMemory::AlignmentProxy<T>::AlignmentProxy(Args&& ... args)
{
    new (this->GetAlignedObjectPtr()) T(std::forward<Args>(args)...);
}
 
template<class T>
inline SharedMemory::AlignmentProxy<T>::~AlignmentProxy()
{
    this->GetAlignedObjectPtr()->~T();
}
 
template<class T>
inline T* SharedMemory::AlignmentProxy<T>::GetAlignedObjectPtr()
{
    size_t alignedSpace = alignedSize;
    void* pBuffer = buffer.data();
 
    void* pResult = std::align(alignof(T), sizeof(T), pBuffer, alignedSpace);
    if (pResult == nullptr)
    {
        // aligning failed
        throw InvalidOperationException::Create("Could not construct shared memory object due to failing alignment.");
    }
    // else
    return reinterpret_cast<T*>(pResult);
};
 
}}}} // end of namespace Arp::System::Commons::Ipc