persistent_ptr.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
/* Copyright 2015-2021, Intel Corporation */
 
#ifndef LIBPMEMOBJ_CPP_PERSISTENT_PTR_HPP
#define LIBPMEMOBJ_CPP_PERSISTENT_PTR_HPP
 
#include <cassert>
#include <limits>
#include <memory>
#include <ostream>
 
#include <libpmemobj++/detail/common.hpp>
#include <libpmemobj++/detail/specialization.hpp>
#include <libpmemobj++/persistent_ptr_base.hpp>
#include <libpmemobj++/pool.hpp>
#include <libpmemobj/base.h>
 
namespace pmem
{
 
namespace obj
{
 
template <typename T>
class pool;
 
template <typename T>
class persistent_ptr;
 
template <>
class persistent_ptr<void> : public persistent_ptr_base {
public:
    typedef void element_type;
    typedef persistent_ptr<void> this_type;
 
    persistent_ptr() = default;
    using persistent_ptr_base::persistent_ptr_base;
    persistent_ptr(void *ptr) : persistent_ptr_base(pmemobj_oid(ptr))
    {
    }
 
    element_type *
    get() const noexcept
    {
        if (this->oid.pool_uuid_lo ==
            std::numeric_limits<decltype(oid.pool_uuid_lo)>::max())
            return reinterpret_cast<element_type *>(oid.off);
        else
            return static_cast<element_type *>(
                pmemobj_direct(this->oid));
    }
 
    template <typename Y,
          typename = typename std::enable_if<
              std::is_convertible<Y *, void *>::value>::type>
    persistent_ptr<void> &
    operator=(persistent_ptr<void> const &r)
    {
        this_type(r).swap(*this);
 
        return *this;
    }
 
    explicit operator bool() const noexcept
    {
        return get() != nullptr;
    }
};
 
template <>
class persistent_ptr<const void> : public persistent_ptr_base {
public:
    typedef const void element_type;
    typedef persistent_ptr<const void> this_type;
 
    persistent_ptr() = default;
    using persistent_ptr_base::persistent_ptr_base;
    persistent_ptr(const void *ptr) : persistent_ptr_base(pmemobj_oid(ptr))
    {
    }
 
    element_type *
    get() const noexcept
    {
        if (this->oid.pool_uuid_lo ==
            std::numeric_limits<decltype(oid.pool_uuid_lo)>::max())
            return reinterpret_cast<element_type *>(oid.off);
        else
            return static_cast<element_type *>(
                pmemobj_direct(this->oid));
    }
 
    template <typename Y,
          typename = typename std::enable_if<
              std::is_convertible<Y *, const void *>::value>::type>
    persistent_ptr<const void> &
    operator=(persistent_ptr<const void> const &r)
    {
        this_type(r).swap(*this);
 
        return *this;
    }
 
    explicit operator bool() const noexcept
    {
        return get() != nullptr;
    }
};
 
template <typename T>
class persistent_ptr : public persistent_ptr_base {
public:
    typedef persistent_ptr<T> this_type;
 
    template <typename U>
    friend class persistent_ptr;
 
    typedef typename pmem::detail::sp_element<T>::type element_type;
 
    persistent_ptr() = default;
    using persistent_ptr_base::persistent_ptr_base;
 
    /*
     * Constructors
     */
 
    explicit persistent_ptr(persistent_ptr<void> const &rhs) noexcept
        : persistent_ptr_base(rhs.raw())
    {
    }
 
    explicit persistent_ptr(persistent_ptr<const void> const &rhs) noexcept
        : persistent_ptr_base(rhs.raw())
    {
    }
 
    persistent_ptr(element_type *ptr)
        : persistent_ptr_base(pmemobj_oid(ptr))
    {
        verify_type();
    }
 
    template <typename U,
          typename = typename std::enable_if<
              !std::is_same<T, U>::value &&
              std::is_same<typename std::remove_cv<T>::type,
                       U>::value>::type>
    persistent_ptr(persistent_ptr<U> const &r) noexcept
        : persistent_ptr_base(r.oid)
    {
        this->oid.off +=
            static_cast<std::uint64_t>(calculate_offset<U>());
        verify_type();
    }
 
    template <
        typename U, typename Dummy = void,
        typename = typename std::enable_if<
            !std::is_same<
                typename std::remove_cv<T>::type,
                typename std::remove_cv<U>::type>::value &&
                !std::is_void<U>::value,
            decltype(static_cast<T *>(std::declval<U *>()))>::type>
    persistent_ptr(persistent_ptr<U> const &r) noexcept
        : persistent_ptr_base(r.oid)
    {
        this->oid.off +=
            static_cast<std::uint64_t>(calculate_offset<U>());
        verify_type();
    }
 
    /*
     * Operators
     */
 
    operator persistent_ptr<void>() const noexcept
    {
        return this->get();
    }
 
    typename pmem::detail::sp_dereference<T>::type operator*() const
        noexcept
    {
        return *this->get();
    }
 
    typename pmem::detail::sp_member_access<T>::type operator->() const
        noexcept
    {
        return this->get();
    }
 
    template <typename = typename std::enable_if<!std::is_void<T>::value>>
    typename pmem::detail::sp_array_access<T>::type
    operator[](std::ptrdiff_t i) const noexcept
    {
        assert(i >= 0 &&
               (i < pmem::detail::sp_extent<T>::value ||
            pmem::detail::sp_extent<T>::value == 0) &&
               "persistent array index out of bounds");
 
        return this->get()[i];
    }
 
    inline persistent_ptr<T> &
    operator++()
    {
        detail::conditional_add_to_tx(this);
        this->oid.off += sizeof(T);
 
        return *this;
    }
 
    inline persistent_ptr<T>
    operator++(int)
    {
        PMEMoid noid = this->oid;
        ++(*this);
 
        return persistent_ptr<T>(noid);
    }
 
    inline persistent_ptr<T> &
    operator--()
    {
        detail::conditional_add_to_tx(this);
        this->oid.off -= sizeof(T);
 
        return *this;
    }
 
    inline persistent_ptr<T>
    operator--(int)
    {
        PMEMoid noid = this->oid;
        --(*this);
 
        return persistent_ptr<T>(noid);
    }
 
    inline persistent_ptr<T> &
    operator+=(std::ptrdiff_t s)
    {
        detail::conditional_add_to_tx(this);
        this->oid.off += static_cast<std::uint64_t>(s) * sizeof(T);
 
        return *this;
    }
 
    inline persistent_ptr<T> &
    operator-=(std::ptrdiff_t s)
    {
        detail::conditional_add_to_tx(this);
        this->oid.off -= static_cast<std::uint64_t>(s) * sizeof(T);
 
        return *this;
    }
 
    template <typename Y,
          typename = typename std::enable_if<
              std::is_convertible<Y *, T *>::value>::type>
    persistent_ptr<T> &
    operator=(persistent_ptr<Y> const &r)
    {
        this_type(r).swap(*this);
 
        return *this;
    }
 
    /*
     * Bool conversion operator.
     */
    explicit operator bool() const noexcept
    {
        return get() != nullptr;
    }
 
    /*
     * Persist/flush methods
     */
 
    void
    persist(pool_base &pop)
    {
        pop.persist(this->get(), sizeof(T));
    }
 
    void
    persist(void)
    {
        pmemobjpool *pop = pmemobj_pool_by_oid(this->raw());
 
        if (pop == nullptr)
            throw pmem::pool_error(
                "Cannot get pool from persistent pointer");
 
        pmemobj_persist(pop, this->get(), sizeof(T));
    }
 
    void
    flush(pool_base &pop)
    {
        pop.flush(this->get(), sizeof(T));
    }
 
    void
    flush(void)
    {
        pmemobjpool *pop = pmemobj_pool_by_oid(this->raw());
 
        if (pop == nullptr)
            throw pmem::pool_error(
                "Cannot get pool from persistent pointer");
 
        pmemobj_flush(pop, this->get(), sizeof(T));
    }
 
    /*
     * Pointer traits related.
     */
 
    static persistent_ptr<T>
    pointer_to(T &ref)
    {
        return persistent_ptr<T>(std::addressof(ref), 0);
    }
 
    element_type *
    get() const noexcept
    {
        if (this->oid.pool_uuid_lo ==
            std::numeric_limits<decltype(oid.pool_uuid_lo)>::max())
            return reinterpret_cast<element_type *>(oid.off);
        else
            return static_cast<element_type *>(
                pmemobj_direct(this->oid));
    }
 
    template <class U>
    using rebind = pmem::obj::persistent_ptr<U>;
 
    using persistency_type = p<T>;
 
    using bool_type = bool;
 
    using iterator_category = std::random_access_iterator_tag;
 
    using difference_type = std::ptrdiff_t;
 
    using value_type = T;
 
    using reference = T &;
 
    using pointer = persistent_ptr<T>;
 
protected:
    void
    verify_type()
    {
        static_assert(!std::is_polymorphic<element_type>::value,
                  "Polymorphic types are not supported");
    }
 
    persistent_ptr(element_type *vptr, int) : persistent_ptr_base(vptr)
    {
        if (OID_IS_NULL(oid)) {
            oid.pool_uuid_lo = std::numeric_limits<decltype(
                oid.pool_uuid_lo)>::max();
            oid.off = reinterpret_cast<decltype(oid.off)>(vptr);
        }
    }
 
    template <typename U>
    inline ptrdiff_t
    calculate_offset() const
    {
        static const ptrdiff_t ptr_offset_magic = 0xF00000000000000;
 
        static_assert(ptr_offset_magic % alignof(U) == 0, "");
        static_assert(ptr_offset_magic % alignof(T) == 0, "");
 
        U *tmp{reinterpret_cast<U *>(ptr_offset_magic)};
        T *diff = static_cast<T *>(tmp);
        return reinterpret_cast<ptrdiff_t>(diff) -
            reinterpret_cast<ptrdiff_t>(tmp);
    }
};
 
template <class T>
inline void
swap(persistent_ptr<T> &a, persistent_ptr<T> &b)
{
    a.swap(b);
}
 
template <typename T, typename Y>
inline bool
operator==(persistent_ptr<T> const &lhs, persistent_ptr<Y> const &rhs) noexcept
{
    return OID_EQUALS(lhs.raw(), rhs.raw());
}
 
template <typename T, typename Y>
inline bool
operator!=(persistent_ptr<T> const &lhs, persistent_ptr<Y> const &rhs) noexcept
{
    return !(lhs == rhs);
}
 
template <typename T>
inline bool
operator==(persistent_ptr<T> const &lhs, std::nullptr_t) noexcept
{
    return lhs.get() == nullptr;
}
 
template <typename T>
inline bool
operator==(std::nullptr_t, persistent_ptr<T> const &lhs) noexcept
{
    return lhs.get() == nullptr;
}
 
template <typename T>
inline bool
operator!=(persistent_ptr<T> const &lhs, std::nullptr_t) noexcept
{
    return lhs.get() != nullptr;
}
 
template <typename T>
inline bool
operator!=(std::nullptr_t, persistent_ptr<T> const &lhs) noexcept
{
    return lhs.get() != nullptr;
}
 
template <typename T, typename Y>
inline bool
operator<(persistent_ptr<T> const &lhs, persistent_ptr<Y> const &rhs) noexcept
{
    if (lhs.raw().pool_uuid_lo == rhs.raw().pool_uuid_lo)
        return lhs.raw().off < rhs.raw().off;
    else
        return lhs.raw().pool_uuid_lo < rhs.raw().pool_uuid_lo;
}
 
template <typename T, typename Y>
inline bool
operator<=(persistent_ptr<T> const &lhs, persistent_ptr<Y> const &rhs) noexcept
{
    return !(rhs < lhs);
}
 
template <typename T, typename Y>
inline bool
operator>(persistent_ptr<T> const &lhs, persistent_ptr<Y> const &rhs) noexcept
{
    return (rhs < lhs);
}
 
template <typename T, typename Y>
inline bool
operator>=(persistent_ptr<T> const &lhs, persistent_ptr<Y> const &rhs) noexcept
{
    return !(lhs < rhs);
}
 
/* nullptr comparisons */
 
template <typename T>
inline bool
operator<(persistent_ptr<T> const &lhs, std::nullptr_t) noexcept
{
    return std::less<typename persistent_ptr<T>::element_type *>()(
        lhs.get(), nullptr);
}
 
template <typename T>
inline bool
operator<(std::nullptr_t, persistent_ptr<T> const &rhs) noexcept
{
    return std::less<typename persistent_ptr<T>::element_type *>()(
        nullptr, rhs.get());
}
 
template <typename T>
inline bool
operator<=(persistent_ptr<T> const &lhs, std::nullptr_t) noexcept
{
    return !(nullptr < lhs);
}
 
template <typename T>
inline bool
operator<=(std::nullptr_t, persistent_ptr<T> const &rhs) noexcept
{
    return !(rhs < nullptr);
}
 
template <typename T>
inline bool
operator>(persistent_ptr<T> const &lhs, std::nullptr_t) noexcept
{
    return nullptr < lhs;
}
 
template <typename T>
inline bool
operator>(std::nullptr_t, persistent_ptr<T> const &rhs) noexcept
{
    return rhs < nullptr;
}
 
template <typename T>
inline bool
operator>=(persistent_ptr<T> const &lhs, std::nullptr_t) noexcept
{
    return !(lhs < nullptr);
}
 
template <typename T>
inline bool
operator>=(std::nullptr_t, persistent_ptr<T> const &rhs) noexcept
{
    return !(nullptr < rhs);
}
 
template <typename T>
inline persistent_ptr<T>
operator+(persistent_ptr<T> const &lhs, std::ptrdiff_t s)
{
    PMEMoid noid;
    noid.pool_uuid_lo = lhs.raw().pool_uuid_lo;
    noid.off = lhs.raw().off + static_cast<std::uint64_t>(s) * sizeof(T);
 
    return persistent_ptr<T>(noid);
}
 
template <typename T>
inline persistent_ptr<T>
operator-(persistent_ptr<T> const &lhs, std::ptrdiff_t s)
{
    PMEMoid noid;
    noid.pool_uuid_lo = lhs.raw().pool_uuid_lo;
    noid.off = lhs.raw().off - static_cast<std::uint64_t>(s) * sizeof(T);
 
    return persistent_ptr<T>(noid);
}
 
template <typename T, typename Y,
      typename = typename std::enable_if<
          std::is_same<typename std::remove_cv<T>::type,
                   typename std::remove_cv<Y>::type>::value>>
inline ptrdiff_t
operator-(persistent_ptr<T> const &lhs, persistent_ptr<Y> const &rhs)
{
    assert(lhs.raw().pool_uuid_lo == rhs.raw().pool_uuid_lo);
    auto d = static_cast<std::ptrdiff_t>(lhs.raw().off - rhs.raw().off);
 
    return d / static_cast<std::ptrdiff_t>(sizeof(T));
}
 
template <typename T>
std::ostream &
operator<<(std::ostream &os, persistent_ptr<T> const &pptr)
{
    PMEMoid raw_oid = pptr.raw();
    os << std::hex << "0x" << raw_oid.pool_uuid_lo << ", 0x" << raw_oid.off
       << std::dec;
    return os;
}
 
} /* namespace obj */
 
} /* namespace pmem */
 
#endif /* LIBPMEMOBJ_CPP_PERSISTENT_PTR_HPP */