object_ptr_privates.h

Go to the documentation of this file.

#pragma once
 
#include "object_ptr_intf.h"
 
#include <adtfucom3/interfaces/object_intf.h>
 
#include <atomic>
#include <cstddef>
#include <exception>
#include <memory>
#include <new>
#include <type_traits>
#include <optional>
 
namespace adtf
{
namespace ucom
{
namespace ant
{

namespace detail
{
 
// base class for the shared reference counter, reatained for legacy reasons only.
class [[deprecated("Reliance on IObject::Destroy results in mismatched deallocation.")]]
object_reference_counter final : public iobject_ptr_ref<size_t>
{
public: // types
    typedef iobject_ptr_ref<size_t>::size_type size_type;
 
public:
    template<typename U>
    explicit object_reference_counter(U* pObjImpl):
        m_szUseCount(), m_szWeakCount(1), m_pObjImpl(ucom_cast<const IObject*>(pObjImpl))
    {
    }
 
    virtual ~object_reference_counter()
    {
    }
 
    virtual void IncreaseUseCount()
    {
        m_szUseCount++;
    }
 
    virtual void DecreaseUseCount()
    {
        // if the use count is zero, delete the shared resource
        if (0 == --m_szUseCount)
        {
            Destroy();
            DecreaseWeakCount();
        }
    }
 
    virtual void IncreaseWeakCount()
    {
        m_szWeakCount++;
    }
 
    virtual void DecreaseWeakCount()
    {
        // if the weak count is zero, delete the resource manager
        if (0 == --m_szWeakCount)
        {
            delete this;
        }
    }
 
    virtual bool IncreaseUseCountNonZero()
    {
        size_type szExpected = m_szUseCount;
        // Loop as long as either the use count got increased by one or the use count is 0
        // This step is necessary to ensure the use count won't be zero between two non atomic
        // operations
        // Mind that szExpected is set to the current value by the compare and exchange method call.
        while (0 != szExpected && !m_szUseCount.compare_exchange_weak(szExpected, szExpected + 1))
            ;
 
        return 0 != szExpected;
    }
 
private:
    void Destroy()
    {
        if (m_pObjImpl)
        {
            // IObject::Destroy() is deprecated, but so is this whole class. Suppress the inner warning.
#if defined(_MSC_VER)
    #pragma warning(push)
    #pragma warning(disable : 4996)
#elif defined(__GNUC__)
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
            m_pObjImpl->Destroy();
#if defined(_MSC_VER)
    #pragma warning(pop)
#elif defined(__GNUC__)
    #pragma GCC diagnostic pop
#endif
            m_pObjImpl = nullptr;
        }
    }
 
private: // types
    ::std::atomic<size_type> m_szUseCount; 
    ::std::atomic<size_type> m_szWeakCount; 
    IObject const* m_pObjImpl; 
};
 
} // namespace detail
} // namespace ant
namespace vision
{
namespace detail
{
#ifdef _MSC_VER
    #pragma warning(push)
    // Disable warning about (necessary) padding bytes after m_aObjectStorage
    #pragma warning(disable : 4324)
#endif
 
template<typename T, bool Fused>
struct fused_storage;
 
template<typename T>
struct fused_storage<T, true>
{
    union aligned_storage
    {
        T oInstance;
        constexpr aligned_storage() noexcept
        {
            // oInstance is constructed by fused_object_reference_counter
        }
        ~aligned_storage() noexcept
        {
            // oInstance is destroyed by fused_object_reference_counter
        }
    } oBuffer;
};
 
template<typename T>
struct fused_storage<T, false>
{
};
 
// base class for the allocator aware shared reference counter with optionally fused allocation
template<typename T, typename Allocator, bool Fused = true>
class fused_object_reference_counter final : public ant::detail::iobject_ptr_ref<size_t>
{
public:
    using allocator_type =
        typename ::std::allocator_traits<Allocator>::template rebind_alloc<fused_object_reference_counter>;
    using object_allocator_type = ::std::
        conditional_t<Fused, allocator_type, typename ::std::allocator_traits<Allocator>::template rebind_alloc<T>>;
 
    template<typename ExternalAllocator, typename... Args>
    static fused_object_reference_counter* Create(ExternalAllocator&& oExternalAllocator, Args&&... args)
    {
        allocator_type oAllocator(::std::forward<ExternalAllocator>(oExternalAllocator));
        static_assert(::std::is_same_v<typename ::std::allocator_traits<allocator_type>::value_type,
                                       fused_object_reference_counter>);
        fused_object_reference_counter* pCounter = ::std::allocator_traits<allocator_type>::allocate(oAllocator, 1);
        try
        {
            ::std::allocator_traits<allocator_type>::construct(oAllocator, pCounter, oAllocator,
                                                               ::std::forward<Args>(args)...);
        }
        catch (...)
        {
            ::std::allocator_traits<allocator_type>::deallocate(oAllocator, pCounter, 1);
            throw;
        }
        return std::launder(pCounter);
    }
 
    fused_object_reference_counter() = delete;
 
    template<typename... Args>
    fused_object_reference_counter(const allocator_type& allocator, Args&&... args):
        m_oAllocator(allocator), m_szUseCount(0), m_szWeakCount(1), m_pObject(nullptr)
    {
        object_allocator_type oObjectAllocator(m_oAllocator);
        T* pObject;
        if constexpr (Fused)
        {
            pObject = &m_sObjectStorage.oBuffer.oInstance;
        }
        else
        {
            pObject = ::std::allocator_traits<object_allocator_type>::allocate(oObjectAllocator, 1);
        }
        try
        {
            ::std::allocator_traits<object_allocator_type>::construct(oObjectAllocator, pObject,
                                                                      ::std::forward<Args>(args)...);
        }
        catch (...)
        {
            if constexpr (!Fused)
            {
                ::std::allocator_traits<object_allocator_type>::deallocate(oObjectAllocator, pObject, 1);
            }
            throw;
        }
        m_pObject = std::launder(pObject);
    }
 
    ~fused_object_reference_counter() = default;
 
    T* GetSharedObject()
    {
        return m_pObject;
    }
 
private:
    void IncreaseUseCount() noexcept final override
    {
        m_szUseCount.fetch_add(1, ::std::memory_order_relaxed);
    }
 
    void DecreaseUseCount() final override
    {
        if (1 == m_szUseCount.fetch_sub(1, ::std::memory_order_release))
        {
            ::std::atomic_thread_fence(::std::memory_order_acquire);
            ::std::optional<::std::exception_ptr> eptr;
            object_allocator_type oObjectAllocator(m_oAllocator);
            try
            {
                ::std::allocator_traits<object_allocator_type>::destroy(oObjectAllocator, m_pObject);
            }
            catch (...)
            {
                eptr = ::std::current_exception();
            }
            if constexpr (!Fused)
            {
                ::std::allocator_traits<object_allocator_type>::deallocate(oObjectAllocator, m_pObject, 1);
            }
            m_pObject = nullptr;
            DecreaseWeakCount();
            if (eptr)
            {
                ::std::rethrow_exception(std::move(*eptr));
            }
        }
    }
 
    void IncreaseWeakCount() noexcept final override
    {
        m_szWeakCount.fetch_add(1, ::std::memory_order_relaxed);
    }
 
    void DecreaseWeakCount() final override
    {
        if (1 == m_szWeakCount.fetch_sub(1, ::std::memory_order_release))
        {
            ::std::atomic_thread_fence(::std::memory_order_acquire);
            ::std::optional<::std::exception_ptr> eptr;
            static_assert(::std::is_same_v<typename ::std::allocator_traits<allocator_type>::value_type,
                                           fused_object_reference_counter>);
            allocator_type oAllocator(std::move(m_oAllocator));
            auto pSelf = std::launder(this);
            try
            {
                ::std::allocator_traits<allocator_type>::destroy(oAllocator, pSelf);
            }
            catch (...)
            {
                eptr = std::current_exception();
            }
            ::std::allocator_traits<allocator_type>::deallocate(oAllocator, pSelf, 1);
            if (eptr)
            {
                ::std::rethrow_exception(std::move(*eptr));
            }
        }
    }
 
    bool IncreaseUseCountNonZero() noexcept final override
    {
        size_type szExpected = m_szUseCount.load(std::memory_order_relaxed);
        while (0 != szExpected &&
               !m_szUseCount.compare_exchange_weak(szExpected, szExpected + 1, std::memory_order_acquire))
            ;
 
        return 0 != szExpected;
    }
 
    allocator_type m_oAllocator;
    ::std::atomic<size_t> m_szUseCount; 
    ::std::atomic<size_t> m_szWeakCount; 
    T* m_pObject;
 
    static constexpr std::size_t hardware_destructive_interference_size = 64;
    // Keep the bookkeeping stuff in a cache line separated from the main object storage.
    alignas((::std::max) (hardware_destructive_interference_size,
                          alignof(fused_storage<T, Fused>))) fused_storage<T, Fused> m_sObjectStorage;
};
 
#ifdef _MSC_VER
    #pragma warning(pop)
#endif
} // namespace detail
} // namespace vision
} // namespace ucom
} // namespace adtf