atomic_persistent_aware_ptr.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
/* Copyright 2021, Intel Corporation */
 
#ifndef LIBPMEMOBJ_CPP_ATOMIC_PERSISTENT_AWARE_PTR_HPP
#define LIBPMEMOBJ_CPP_ATOMIC_PERSISTENT_AWARE_PTR_HPP
 
#include <libpmemobj++/detail/atomic_backoff.hpp>
#include <libpmemobj++/detail/common.hpp>
#include <libpmemobj++/detail/self_relative_ptr_base_impl.hpp>
#include <libpmemobj++/experimental/atomic_self_relative_ptr.hpp>
#include <libpmemobj++/experimental/self_relative_ptr.hpp>
#include <libpmemobj++/transaction.hpp>
#include <libpmemobj++/utils.hpp>
 
#include <atomic>
 
namespace pmem
{
namespace obj
{
namespace experimental
{
 
template <typename T, typename ReadOptimized>
struct atomic_persistent_aware_ptr {
private:
    using ptr_type = pmem::detail::self_relative_ptr_base_impl<
        std::atomic<std::ptrdiff_t>>;
    using accessor = pmem::detail::self_relative_accessor<
        std::atomic<std::ptrdiff_t>>;
 
    static constexpr uintptr_t IS_DIRTY = 1;
 
public:
    using this_type = atomic_persistent_aware_ptr;
    using value_type = pmem::obj::experimental::self_relative_ptr<T>;
    using difference_type = typename value_type::difference_type;
 
    constexpr atomic_persistent_aware_ptr() noexcept = default;
 
    atomic_persistent_aware_ptr(value_type value) : ptr()
    {
        store(value);
    }
 
    atomic_persistent_aware_ptr(const atomic_persistent_aware_ptr &) =
        delete;
 
    template <typename OPT = ReadOptimized>
    typename std::enable_if<std::is_same<OPT, std::true_type>::value>::type
    store(value_type desired,
          std::memory_order order = std::memory_order_seq_cst) noexcept
    {
        auto dirty_desired = mark_dirty(desired);
        ptr.store(dirty_desired, order);
        pool_by_vptr(this).persist(&ptr, sizeof(ptr));
        ptr.compare_exchange_strong(dirty_desired, clear_dirty(desired),
                        order);
        /* Flushing is not necessary for correctness, it's enough that
         * dirty_desired is persistent */
#if LIBPMEMOBJ_CPP_VG_PMEMCHECK_ENABLED
        VALGRIND_PMC_DO_FLUSH(&ptr, sizeof(ptr));
#endif
    }
 
    template <typename OPT = ReadOptimized>
    typename std::enable_if<!std::is_same<OPT, std::true_type>::value>::type
    store(value_type desired,
          std::memory_order order = std::memory_order_seq_cst) noexcept
    {
        ptr.store(mark_dirty(desired), order);
    }
 
    template <typename OPT = ReadOptimized>
    typename std::enable_if<std::is_same<OPT, std::true_type>::value,
                value_type>::type
    load(std::memory_order order = std::memory_order_seq_cst) noexcept
    {
        /* This load relies on the store function to clear the dirty
         * flag. For correctness though, it flushes the dirty ptr and
         * returns the clear ptr for now. */
        auto val = ptr.load(order);
        if (is_dirty(val)) {
            pool_by_vptr(this).persist(&ptr, sizeof(ptr));
        }
        return clear_dirty(val);
    }
 
    template <typename OPT = ReadOptimized>
    typename std::enable_if<!std::is_same<OPT, std::true_type>::value,
                value_type>::type
    load(std::memory_order order = std::memory_order_seq_cst) noexcept
    {
        /* It flushes the ptr with the dirty flag - clears the flag
         * using CAS after flush. If CAS failed it simply returns the
         * old clear ptr and relies on a later load to clear the dirty
         * flag. */
        auto val = ptr.load(order);
        if (is_dirty(val)) {
            pool_by_vptr(this).persist(&ptr, sizeof(ptr));
            auto clear_val = clear_dirty(val);
            ptr.compare_exchange_strong(val, clear_val, order);
#if LIBPMEMOBJ_CPP_VG_PMEMCHECK_ENABLED
            VALGRIND_PMC_DO_FLUSH(&ptr, sizeof(ptr));
#endif
            return clear_val;
        }
        return clear_dirty(val);
    }
 
    bool
    is_lock_free() const noexcept
    {
        return ptr.is_lock_free();
    }
 
    /*
     * Operators
     */
 
    operator value_type() const noexcept
    {
        return load();
    }
 
    value_type
    operator=(value_type desired) noexcept
    {
        store(desired);
        return desired;
    }
 
    atomic_persistent_aware_ptr &
    operator=(const atomic_persistent_aware_ptr &) = delete;
 
private:
    value_type
    mark_dirty(value_type ptr) const
    {
        auto dirty_ptr =
            reinterpret_cast<uintptr_t>(ptr.get()) | IS_DIRTY;
        return value_type{reinterpret_cast<T *>(dirty_ptr)};
    }
 
    value_type
    clear_dirty(value_type ptr) const
    {
        auto clear_ptr =
            reinterpret_cast<uintptr_t>(ptr.get()) & ~IS_DIRTY;
        return value_type{reinterpret_cast<T *>(clear_ptr)};
    }
 
    bool
    is_dirty(value_type ptr) const
    {
        return reinterpret_cast<uintptr_t>(ptr.get()) & IS_DIRTY;
    }
 
    std::atomic<self_relative_ptr<T>> ptr;
};
} // namespace experimental
} // namespace obj
} // namespace pmem
 
#endif // LIBPMEMOBJ_CPP_ATOMIC_PERSISTENT_AWARE_PTR_HPP