shared_objects.h

Go to the documentation of this file.

/*
 * Copyright 2024 MusicScience37 (Kenta Kabashima)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include <atomic>
#include <memory>
#include <new>
#include <optional>
#include <utility>
#include <vector>
 
namespace msgpack_rpc::util::impl {

template <typename T>
class SharedObjectBuffer {
public:
    SharedObjectBuffer() noexcept = default;

    [[nodiscard]] bool try_start_use() noexcept {
        int empty = -1;
        constexpr int initial = 1;
        return reference_count_.compare_exchange_strong(empty, initial,
            std::memory_order_acquire, std::memory_order_relaxed);
    }

    template <typename... Args>
    void emplace(Args&&... args) {
        buffer_.emplace(std::forward<Args>(args)...);
    }

    void add_reference() noexcept {
        reference_count_.fetch_add(1, std::memory_order_relaxed);
    }

    void release() noexcept {
        const int reference_count =
            reference_count_.fetch_sub(1, std::memory_order_acq_rel);
        if (reference_count == 1) {
            buffer_.reset();
            const int empty = -1;
            reference_count_.store(empty, std::memory_order_release);
        }
    }

    [[nodiscard]] T* get() noexcept {
        return &(*buffer_);  // NOLINT
    }
 
private:
    std::atomic<int> reference_count_{-1};

    std::optional<T> buffer_{};
};
 
template <typename T>
class SharedObjectMemoryPool;

template <typename T>
class SharedObject {
public:
    SharedObject() noexcept = default;

    explicit SharedObject(SharedObjectBuffer<T>* buffer,
        std::shared_ptr<SharedObjectMemoryPool<T>> memory_pool) noexcept
        : buffer_(buffer), memory_pool_(std::move(memory_pool)) {}

    SharedObject(const SharedObject& other) noexcept
        : buffer_(other.buffer_), memory_pool_(other.memory_pool_) {
        if (buffer_ != nullptr) {
            buffer_->add_reference();
        }
    }

    SharedObject(SharedObject&& other) noexcept
        : buffer_(std::exchange(other.buffer_, nullptr)),
          memory_pool_(std::exchange(other.memory_pool_,
              std::shared_ptr<SharedObjectMemoryPool<T>>())) {}

    SharedObject& operator=(const SharedObject& other) noexcept {
        if (this == &other) {
            return *this;
        }
        reset();
        buffer_ = other.buffer_;
        memory_pool_ = other.memory_pool_;
        if (buffer_ != nullptr) {
            buffer_->add_reference();
        }
        return *this;
    }

    SharedObject& operator=(SharedObject&& other) noexcept {
        reset();
        buffer_ = std::exchange(other.buffer_, nullptr);
        memory_pool_ = std::exchange(
            other.memory_pool_, std::shared_ptr<SharedObjectMemoryPool<T>>());
        return *this;
    }

    ~SharedObject() noexcept { reset(); }

    void reset() noexcept {
        if (buffer_ != nullptr) {
            buffer_->release();
            buffer_ = nullptr;
            memory_pool_.reset();
        }
    }
 
private:
    SharedObjectBuffer<T>* buffer_{nullptr};

    std::shared_ptr<SharedObjectMemoryPool<T>> memory_pool_{};
};

template <typename T>
class SharedObjectMemoryPool
    : public std::enable_shared_from_this<SharedObjectMemoryPool<T>> {
public:
    static std::shared_ptr<SharedObjectMemoryPool<T>> create(
        std::size_t num_buffers) {
        return std::make_shared<SharedObjectMemoryPool<T>>(num_buffers);
    }

    explicit SharedObjectMemoryPool(std::size_t num_buffers)
        : buffers_(num_buffers) {}
 
    SharedObjectMemoryPool(const SharedObjectMemoryPool&) = delete;
    SharedObjectMemoryPool(SharedObjectMemoryPool&&) = delete;
    SharedObjectMemoryPool& operator=(const SharedObjectMemoryPool&) = delete;
    SharedObjectMemoryPool& operator=(SharedObjectMemoryPool&&) = delete;

    ~SharedObjectMemoryPool() = default;

    template <typename... Args>
    [[nodiscard]] SharedObject<T> create(Args&&... args) {
        const std::size_t initial_buffer_index = next_buffer_index_;
        while (true) {
            const std::size_t buffer_index = next_buffer_index_++;
            next_buffer_index_ %= buffers_.size();
            SharedObjectBuffer<T>& buffer = buffers_[buffer_index];
            if (!buffer.try_start_use()) {
                if (next_buffer_index_ == initial_buffer_index) {
                    throw std::bad_alloc();
                }
                continue;
            }
 
            try {
                buffer.emplace(std::forward<Args>(args)...);
                return SharedObject<T>(&buffer, this->shared_from_this());
            } catch (...) {
                buffer.release();
                throw;
            }
        }
    }
 
private:
    std::vector<SharedObjectBuffer<T>> buffers_;

    std::size_t next_buffer_index_{0};
};
 
}  // namespace msgpack_rpc::util::impl