shared_storage.hpp

Go to the documentation of this file.

#pragma once
#include <atomic>
#include <concepts>
#include <cstddef>
#include <memory>
#include <new>
#include <type_traits>
#include <uni20/common/trace.hpp>
#include <utility>
 
namespace uni20::async
{
 
class NodeInfo;
 
namespace detail
{
 
class shared_storage_control_block {
  public:
    explicit shared_storage_control_block(shared_storage_control_block* lifetime_owner = nullptr) noexcept
        : lifetime_owner_(lifetime_owner)
    {
      if (lifetime_owner_) lifetime_owner_->add_ref();
    }
 
    shared_storage_control_block(shared_storage_control_block const&) = delete;
    shared_storage_control_block& operator=(shared_storage_control_block const&) = delete;
 
    virtual ~shared_storage_control_block()
    {
      if (lifetime_owner_) lifetime_owner_->release_ref();
    }
 
    void add_ref() noexcept { strong_count_.fetch_add(1, std::memory_order_relaxed); }
 
    void release_ref() noexcept
    {
      if (strong_count_.fetch_sub(1, std::memory_order_acq_rel) == 1) delete this;
    }
 
    [[nodiscard]] std::size_t use_count() const noexcept { return strong_count_.load(std::memory_order_relaxed); }
 
    [[nodiscard]] bool constructed() const noexcept
    {
      return this->local_value_constructed() && (!lifetime_owner_ || lifetime_owner_->constructed());
    }
 
    [[nodiscard]] bool has_lifetime_owner() const noexcept { return lifetime_owner_ != nullptr; }
 
  private:
    [[nodiscard]] virtual bool local_value_constructed() const noexcept = 0;
 
    std::atomic<std::size_t> strong_count_{1};
    shared_storage_control_block* lifetime_owner_ = nullptr;
};
 
} // namespace detail
 
template <typename T> class shared_storage {
  private:
    friend class NodeInfo;
 
    struct control_block final : detail::shared_storage_control_block
    {
        explicit control_block(detail::shared_storage_control_block* lifetime_owner = nullptr) noexcept
            : detail::shared_storage_control_block(lifetime_owner)
        {}
 
        alignas(T) unsigned char storage[sizeof(T)];
        std::atomic<bool> constructed_{false};
 
        T* storage_address() noexcept { return reinterpret_cast<T*>(storage); }
 
        T* ptr() noexcept { return std::launder(this->storage_address()); }
 
        template <typename... Args> void construct(Args&&... args)
        {
          DEBUG_CHECK(!constructed_.load(std::memory_order_relaxed));
          ::new (storage) T(std::forward<Args>(args)...);
          constructed_.store(true, std::memory_order_release);
        }
 
        void destroy_object() noexcept
        {
          if (constructed_.exchange(false, std::memory_order_acq_rel)) ptr()->~T();
        }
 
        [[nodiscard]] bool value_constructed_locally() const noexcept
        {
          return constructed_.load(std::memory_order_acquire);
        }
 
        ~control_block() override { this->destroy_object(); }
 
      private:
        [[nodiscard]] bool local_value_constructed() const noexcept override
        {
          return this->value_constructed_locally();
        }
    };
 
    control_block* ctrl_ = nullptr;
 
    template <typename U, typename... Args> friend shared_storage<U> make_shared_storage(Args&&... args);
    template <typename U> friend shared_storage<U> make_unconstructed_shared_storage();
    template <typename U, typename Owner, typename... Args>
    friend shared_storage<U> make_shared_storage_alias(shared_storage<Owner> const& owner, Args&&... args);
 
    explicit shared_storage(control_block* c) noexcept : ctrl_(c) {}
 
    [[nodiscard]] static bool diagnostic_constructed_from_control(void const* control) noexcept
    {
      auto const* block = static_cast<control_block const*>(control);
      return block && block->constructed();
    }
 
    [[nodiscard]] static void const* diagnostic_value_address_from_control(void const* control) noexcept
    {
      auto* block = const_cast<control_block*>(static_cast<control_block const*>(control));
      return block && block->constructed() ? static_cast<void const*>(block->ptr()) : nullptr;
    }
 
  public:
    using element_type = T;
 
    shared_storage() noexcept = default;
 
    shared_storage(const shared_storage& other) noexcept : ctrl_(other.ctrl_)
    {
      if (ctrl_) ctrl_->add_ref();
    }
 
    shared_storage(shared_storage&& other) noexcept : ctrl_(std::exchange(other.ctrl_, nullptr)) {}
 
    shared_storage& operator=(const shared_storage& other) noexcept
    {
      if (this != &other)
      {
        this->reset();
        ctrl_ = other.ctrl_;
        if (ctrl_) ctrl_->add_ref();
      }
      return *this;
    }
 
    shared_storage& operator=(shared_storage&& other) noexcept
    {
      if (this != &other)
      {
        this->reset();
        ctrl_ = std::exchange(other.ctrl_, nullptr);
      }
      return *this;
    }
 
    ~shared_storage() { reset(); }
 
    void reset() noexcept
    {
      if (ctrl_)
      {
        ctrl_->release_ref();
        ctrl_ = nullptr;
      }
    }
 
    [[nodiscard]] bool constructed() const noexcept { return ctrl_ && ctrl_->constructed(); }
 
    [[nodiscard]] bool valid() const noexcept { return ctrl_ != nullptr; }
 
    [[nodiscard]] void const* control_address() const noexcept { return static_cast<void const*>(ctrl_); }
 
    [[nodiscard]] size_t use_count() const noexcept { return ctrl_ ? ctrl_->use_count() : 0; }
 
    [[nodiscard]] bool has_lifetime_owner() const noexcept { return ctrl_ && ctrl_->has_lifetime_owner(); }
 
    [[nodiscard]] T* storage_address() noexcept { return ctrl_ ? ctrl_->storage_address() : nullptr; }
 
    [[nodiscard]] T const* storage_address() const noexcept { return ctrl_ ? ctrl_->storage_address() : nullptr; }
 
    template <typename... Args>
      requires std::constructible_from<T, Args...>
    T& emplace(Args&&... args)
    {
      DEBUG_CHECK(ctrl_, "shared_storage must be initialized with make_shared_storage()");
      if (ctrl_->value_constructed_locally()) ctrl_->destroy_object();
      ctrl_->construct(std::forward<Args>(args)...);
      return *ctrl_->ptr();
    }
 
    bool operator!() const noexcept { return !ctrl_; }; // no control block
    explicit operator bool() const noexcept { return bool(ctrl_); }; // has control block
 
    void destroy() noexcept
    {
      if (ctrl_) ctrl_->destroy_object();
    }
 
    [[nodiscard]] T* get() noexcept { return constructed() ? ctrl_->ptr() : nullptr; }
    [[nodiscard]] const T* get() const noexcept { return this->constructed() ? ctrl_->ptr() : nullptr; }
 
    T& operator*() noexcept
    {
      DEBUG_CHECK(constructed());
      return *this->get();
    }
    const T& operator*() const noexcept
    {
      DEBUG_CHECK(constructed());
      return *this->get();
    }
 
    T* operator->() noexcept
    {
      DEBUG_CHECK(constructed());
      return this->get();
    }
    const T* operator->() const noexcept
    {
      DEBUG_CHECK(constructed());
      return get();
    }
 
    T take() noexcept(std::is_nothrow_move_constructible_v<T>)
    {
      T x = std::move(**this);
      this->destroy();
      return x;
    }
 
    template <typename... Args> static shared_storage make_constructed(Args&&... args)
    {
      auto* c = new control_block{};
      try
      {
        c->construct(std::forward<Args>(args)...);
      }
      catch (...)
      {
        delete c;
        throw;
      }
      return shared_storage(c);
    }
 
    template <typename... Args>
    static shared_storage make_constructed_alias(detail::shared_storage_control_block* lifetime_owner, Args&&... args)
    {
      auto* c = new control_block{lifetime_owner};
      try
      {
        c->construct(std::forward<Args>(args)...);
      }
      catch (...)
      {
        delete c;
        throw;
      }
      return shared_storage(c);
    }
 
    friend bool operator==(const shared_storage& a, const shared_storage& b) noexcept { return a.ctrl_ == b.ctrl_; }
};
 
template <typename T> [[nodiscard]] inline shared_storage<T> make_unconstructed_shared_storage()
{
  using ctrl_t = typename shared_storage<T>::control_block;
  return shared_storage<T>(new ctrl_t{});
}
 
template <typename T, typename... Args> [[nodiscard]] inline shared_storage<T> make_shared_storage(Args&&... args)
{
  return shared_storage<T>::make_constructed(std::forward<Args>(args)...);
}
 
template <typename T, typename Owner, typename... Args>
[[nodiscard]] inline shared_storage<T> make_shared_storage_alias(shared_storage<Owner> const& owner, Args&&... args)
{
  CHECK(owner.valid());
  return shared_storage<T>::make_constructed_alias(owner.ctrl_, std::forward<Args>(args)...);
}
 
} // namespace uni20::async