self_relative_ptr_base_impl.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
/* Copyright 2020-2021, Intel Corporation */
 
#ifndef LIBPMEMOBJ_CPP_SELF_RELATIVE_PTR_BASE_IMPL_HPP
#define LIBPMEMOBJ_CPP_SELF_RELATIVE_PTR_BASE_IMPL_HPP
 
#include <cstdint>
#include <type_traits>
 
#include <libpmemobj++/detail/common.hpp>
#include <libpmemobj++/detail/specialization.hpp>
 
namespace pmem
{
 
namespace detail
{
 
template <typename OffsetType>
class self_relative_ptr_base_impl {
public:
    using this_type = self_relative_ptr_base_impl;
    using difference_type = std::ptrdiff_t;
    using offset_type = OffsetType;
    using byte_type = uint8_t;
    using byte_ptr_type = byte_type *;
    using const_byte_ptr_type = const byte_type *;
 
    /*
     * Constructors
     */
 
    constexpr self_relative_ptr_base_impl() noexcept
        : offset(nullptr_offset)
    {
    }
 
    constexpr self_relative_ptr_base_impl(std::nullptr_t) noexcept
        : offset(nullptr_offset)
    {
    }
 
    self_relative_ptr_base_impl(void *ptr) noexcept
        : offset(pointer_to_offset(ptr))
    {
    }
 
    self_relative_ptr_base_impl(
        self_relative_ptr_base_impl const &r) noexcept
        : offset(pointer_to_offset(r))
    {
    }
 
    self_relative_ptr_base_impl &
    operator=(self_relative_ptr_base_impl const &r)
    {
        if (this == &r)
            return *this;
        detail::conditional_add_to_tx(this);
        offset = pointer_to_offset(r);
        return *this;
    }
 
    self_relative_ptr_base_impl &
    operator=(std::nullptr_t &&)
    {
        detail::conditional_add_to_tx(this);
        offset = pointer_to_offset(nullptr);
        return *this;
    }
 
    void
    swap(self_relative_ptr_base_impl &other)
    {
        if (this == &other)
            return;
        detail::conditional_add_to_tx(this);
        detail::conditional_add_to_tx(&other);
        auto first = this->to_byte_pointer();
        auto second = other.to_byte_pointer();
        this->offset = pointer_to_offset(second);
        other.offset = other.pointer_to_offset(first);
    }
 
    byte_ptr_type
    to_byte_pointer() const noexcept
    {
        return static_cast<byte_ptr_type>(this->to_void_pointer());
    }
 
    void *
    to_void_pointer() const noexcept
    {
        return offset_to_pointer(this->offset);
    }
 
    explicit operator void *() const noexcept
    {
        return to_void_pointer();
    }
 
    explicit operator byte_ptr_type() const noexcept
    {
        return to_byte_pointer();
    }
 
    static difference_type
    distance_between(const self_relative_ptr_base_impl &first,
             const self_relative_ptr_base_impl &second)
    {
        return second.to_byte_pointer() - first.to_byte_pointer();
    }
 
    inline bool
    is_null() const noexcept
    {
        return offset == nullptr_offset;
    }
 
protected:
    self_relative_ptr_base_impl(difference_type offset) noexcept
        : offset(offset)
    {
    }
 
    void *
    offset_to_pointer(difference_type other_offset) const noexcept
    {
        /*
        This version without branches is vectorization-friendly.
        mask = is_null() should not create a branch in the code.
        In this line, we just assign 0 or 1 to the mask variable.
 
        This code is equal:
        if (is_null())
            return nullptr;
        return reinterpret_cast<byte_ptr_type>(
                   const_cast<this_type *>(this)) +
            offset + 1;
        */
        uintptr_t mask = other_offset == nullptr_offset;
        --mask;
        uintptr_t ptr = static_cast<uintptr_t>(
            reinterpret_cast<intptr_t>(this) + other_offset + 1);
        ptr &= mask;
        return reinterpret_cast<void *>(ptr);
    }
 
    difference_type
    pointer_to_offset(const self_relative_ptr_base_impl &ptr) const noexcept
    {
        /*
        This version without branches is vectorization-friendly.
        mask = is_null() should not create a branch in the code.
        In this line, we just assign 0 or 1 to the mask variable.
 
        This code is equal:
        return ptr.is_null()
            ? nullptr_offset
            : ptr.offset + this->distance_between_self(ptr);
        */
        uintptr_t mask = ptr.is_null();
        --mask;
        difference_type distance_between_self =
            reinterpret_cast<const_byte_ptr_type>(&ptr) -
            reinterpret_cast<const_byte_ptr_type>(this);
        distance_between_self &=
            reinterpret_cast<difference_type &>(mask);
        return ptr.offset + distance_between_self;
    }
 
    difference_type
    pointer_to_offset(void *ptr) const noexcept
    {
        /*
        This version without branches is vectorization-friendly.
        mask = ptr == nullptr should not create a branch in the code.
        In this line, we just assign 0 or 1 to the mask variable.
 
        This code is equal:
        if (ptr == nullptr)
            return nullptr_offset
        else
            return ptr - this - 1;
        */
        uintptr_t mask = ptr == nullptr;
        --mask;
        difference_type new_offset = static_cast<byte_ptr_type>(ptr) -
            reinterpret_cast<const_byte_ptr_type>(this) - 1;
        new_offset &= reinterpret_cast<difference_type &>(mask);
        return new_offset;
    }
 
    /* The offset from self */
    offset_type offset;
 
private:
    static constexpr difference_type nullptr_offset = 0;
 
    template <typename T>
    friend class self_relative_accessor;
};
 
template <typename T>
class self_relative_accessor {
public:
    using access_type = self_relative_ptr_base_impl<T>;
    using difference_type = typename access_type::difference_type;
 
    template <typename PointerType>
    static difference_type
    pointer_to_offset(const access_type &obj, PointerType *ptr)
    {
        return obj.pointer_to_offset(static_cast<void *>(ptr));
    }
 
    template <typename PointerType>
    static PointerType *
    offset_to_pointer(difference_type offset, const access_type &obj)
    {
        auto ptr = obj.offset_to_pointer(offset);
        return static_cast<PointerType *>(ptr);
    }
 
    static T &
    get_offset(access_type &ptr)
    {
        return ptr.offset;
    }
 
    static const T &
    get_offset(const access_type &ptr)
    {
        return ptr.offset;
    }
};
 
} /* namespace detail */
 
} /* namespace pmem */
 
#endif /* LIBPMEMOBJ_CPP_SELF_RELATIVE_PTR_BASE_IMPL_HPP */