SharedMemory.h

Go to the documentation of this file.

/*
 * SharedMemory.h
 *
 * Copyright (c) 2022 Dominic Clark <mrdomclark/at/gmail.com>
 * Copyright (c) 2025-2026 Dalton Messmer <messmer.dalton/at/gmail.com>
 *
 * This file is part of LMMS - https://lmms.io
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program 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
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program (see COPYING); if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 */
 
#ifndef LMMS_SHARED_MEMORY_H
#define LMMS_SHARED_MEMORY_H
 
#include <memory>
#include <memory_resource>
#include <new>
#include <string>
#include <type_traits>
 
 
namespace lmms
{
 
namespace detail
{
 
class SharedMemoryImpl;
 
class SharedMemoryData
{
public:
    SharedMemoryData() noexcept;
    SharedMemoryData(std::string&& key, bool readOnly, bool isArray);
    SharedMemoryData(std::string&& key, std::size_t size, bool readOnly, bool isArray);
    SharedMemoryData(std::size_t size, bool readOnly, bool isArray);
    ~SharedMemoryData();
 
    SharedMemoryData(SharedMemoryData&& other) noexcept;
    SharedMemoryData& operator=(SharedMemoryData&& other) noexcept
    {
        auto temp = std::move(other);
        swap(*this, temp);
        return *this;
    }
 
    friend void swap(SharedMemoryData& a, SharedMemoryData& b) noexcept
    {
        using std::swap;
        swap(a.m_key, b.m_key);
        swap(a.m_impl, b.m_impl);
        swap(a.m_ptr, b.m_ptr);
    }
 
    const std::string& key() const noexcept { return m_key; }
    void* get() const noexcept { return m_ptr; }
    std::size_t arraySize() const noexcept;
 
private:
    std::string m_key;
    std::unique_ptr<SharedMemoryImpl> m_impl;
    void* m_ptr = nullptr;
};
 
} // namespace detail
 

class SharedMemoryResource final : public std::pmr::memory_resource
{
public:
    SharedMemoryResource() = default;
    SharedMemoryResource(void* buffer, std::size_t bufferSize) noexcept
        : m_buffer{buffer}
        , m_availableBytes{bufferSize}
        , m_initialBuffer{buffer}
        , m_initialBufferSize{bufferSize}
    {}
 
    SharedMemoryResource(const SharedMemoryResource&) = delete;
    auto operator=(const SharedMemoryResource&) -> SharedMemoryResource& = delete;
    SharedMemoryResource(SharedMemoryResource&&) = default;
    auto operator=(SharedMemoryResource&&) -> SharedMemoryResource& = default;

    void reset() noexcept
    {
        m_buffer = m_initialBuffer;
        m_availableBytes = m_initialBufferSize;
    }

    auto availableBytes() const noexcept -> std::size_t { return m_availableBytes; }
 
    template<typename T>
    friend class SharedMemory;
 
private:
    void reset(void* newBuffer, std::size_t newBufferSize) noexcept
    {
        m_buffer = newBuffer;
        m_availableBytes = newBufferSize;
        m_initialBuffer = newBuffer;
        m_initialBufferSize = newBufferSize;
    }
 
    void* do_allocate(std::size_t bytes, std::size_t alignment) override
    {
        void* p = std::align(alignment, bytes, m_buffer, m_availableBytes);
        if (!p) { throw std::bad_alloc{}; }
 
        m_buffer = static_cast<char*>(m_buffer) + bytes;
        m_availableBytes -= bytes;
        return p;
    }
    void do_deallocate(void*, std::size_t, std::size_t) override {} // no-op
    bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override
    {
        return this == &other;
    }
 
private:
    void* m_buffer = nullptr;
    std::size_t m_availableBytes = 0;
    void* m_initialBuffer = nullptr;
    std::size_t m_initialBufferSize = 0;
};
 
 
template<typename T>
class SharedMemory
{
    // This is stricter than necessary, but keeps things easy for now
    static_assert(std::is_trivial_v<T>, "objects held in shared memory must be trivial");
    static_assert(sizeof(T) > 0);
 
public:
    SharedMemory() = default;
    SharedMemory(const SharedMemory&) = delete;
    SharedMemory& operator=(const SharedMemory&) = delete;
    SharedMemory(SharedMemory&&) = default;
    SharedMemory& operator=(SharedMemory&&) = default;
 
    void attach(std::string key)
    {
        m_data = detail::SharedMemoryData{std::move(key), std::is_const_v<T>, false};
    }
 
    void create(std::string key)
    {
        m_data = detail::SharedMemoryData{std::move(key), sizeof(T), std::is_const_v<T>, false};
    }
 
    void create()
    {
        m_data = detail::SharedMemoryData{sizeof(T), std::is_const_v<T>, false};
    }
 
    void detach() noexcept
    {
        m_data = detail::SharedMemoryData{};
    }
 
    const std::string& key() const noexcept { return m_data.key(); }
    T* get() const noexcept { return static_cast<T*>(m_data.get()); }
 
    std::size_t size() const noexcept { return get() ? 1 : 0; }
    std::size_t size_bytes() const noexcept { return get() ? sizeof(T) : 0; }
 
    T* operator->() const noexcept { return get(); }
    T& operator*() const noexcept { return *get(); }
    explicit operator bool() const noexcept { return get() != nullptr; }
 
private:
    detail::SharedMemoryData m_data;
};
 
template<typename T>
class SharedMemory<T[]>
{
    // This is stricter than necessary, but keeps things easy for now
    static_assert(std::is_trivial_v<T>, "objects held in shared memory must be trivial");
    static_assert(sizeof(T) > 0);
 
public:
    SharedMemory() = default;
    SharedMemory(const SharedMemory&) = delete;
    SharedMemory& operator=(const SharedMemory&) = delete;
    SharedMemory(SharedMemory&&) = default;
    SharedMemory& operator=(SharedMemory&&) = default;
 
    void attach(std::string key)
    {
        m_data = detail::SharedMemoryData{std::move(key), std::is_const_v<T>, true};
        m_resource.reset(m_data.get(), size_bytes());
    }
 
    void create(std::string key, std::size_t size)
    {
        m_data = detail::SharedMemoryData{std::move(key), size * sizeof(T), std::is_const_v<T>, true};
        m_resource.reset(m_data.get(), size_bytes());
    }
 
    void create(std::size_t size)
    {
        m_data = detail::SharedMemoryData{size * sizeof(T), std::is_const_v<T>, true};
        m_resource.reset(m_data.get(), size_bytes());
    }
 
    void detach() noexcept
    {
        m_data = detail::SharedMemoryData{};
        m_resource.reset(nullptr, 0);
    }
 
    const std::string& key() const noexcept { return m_data.key(); }
    T* get() const noexcept { return static_cast<T*>(m_data.get()); }
 
    std::size_t size() const noexcept { return m_data.arraySize() / sizeof(T); }
    std::size_t size_bytes() const noexcept { return m_data.arraySize(); }
 
    T& operator[](std::size_t index) const noexcept { return get()[index]; }
    explicit operator bool() const noexcept { return get() != nullptr; }
 
    SharedMemoryResource* resource() noexcept { return &m_resource; }
 
private:
    detail::SharedMemoryData m_data;
    SharedMemoryResource m_resource;
};
 
} // namespace lmms
 
#endif // LMMS_SHARED_MEMORY_H