memory.h

Go to the documentation of this file.

/*
 *  Copyright 2019 Patrick Stotko
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
 
#ifndef STDGPU_MEMORY_H
#define STDGPU_MEMORY_H
 
#include <functional>
#include <memory>
#include <type_traits>
 
#include <stdgpu/config.h>
#include <stdgpu/cstddef.h>
#include <stdgpu/execution.h>
#include <stdgpu/platform.h>
#include <stdgpu/type_traits.h>
 
enum class Initialization
{
    HOST,  
    DEVICE 
};
 
template <typename T>
[[nodiscard]] T*
createDeviceArray(const stdgpu::index64_t count, const T default_value = T());
 
template <typename T>
[[nodiscard]] T*
createHostArray(const stdgpu::index64_t count, const T default_value = T());
 
template <typename T>
[[nodiscard]] T*
createManagedArray(const stdgpu::index64_t count,
                   const T default_value = T(),
                   const Initialization initialize_on = Initialization::DEVICE);
 
template <typename T>
void
destroyDeviceArray(T*& device_array);
 
template <typename T>
void
destroyHostArray(T*& host_array);
 
template <typename T>
void
destroyManagedArray(T*& managed_array);
 
enum class MemoryCopy
{
    NO_CHECK,   
    RANGE_CHECK 
};
 
template <typename T>
[[nodiscard]] T*
copyCreateDevice2HostArray(const T* device_array,
                           const stdgpu::index64_t count,
                           const MemoryCopy check_safety = MemoryCopy::RANGE_CHECK);
 
template <typename T>
[[nodiscard]] T*
copyCreateHost2DeviceArray(const T* host_array,
                           const stdgpu::index64_t count,
                           const MemoryCopy check_safety = MemoryCopy::RANGE_CHECK);
 
template <typename T>
[[nodiscard]] T*
copyCreateHost2HostArray(const T* host_array,
                         const stdgpu::index64_t count,
                         const MemoryCopy check_safety = MemoryCopy::RANGE_CHECK);
 
template <typename T>
[[nodiscard]] T*
copyCreateDevice2DeviceArray(const T* device_array,
                             const stdgpu::index64_t count,
                             const MemoryCopy check_safety = MemoryCopy::RANGE_CHECK);
 
template <typename T>
void
copyDevice2HostArray(const T* source_device_array,
                     const stdgpu::index64_t count,
                     T* destination_host_array,
                     const MemoryCopy check_safety = MemoryCopy::RANGE_CHECK);
 
template <typename T>
void
copyHost2DeviceArray(const T* source_host_array,
                     const stdgpu::index64_t count,
                     T* destination_device_array,
                     const MemoryCopy check_safety = MemoryCopy::RANGE_CHECK);
 
template <typename T>
void
copyHost2HostArray(const T* source_host_array,
                   const stdgpu::index64_t count,
                   T* destination_host_array,
                   const MemoryCopy check_safety = MemoryCopy::RANGE_CHECK);
 
template <typename T>
void
copyDevice2DeviceArray(const T* source_device_array,
                       const stdgpu::index64_t count,
                       T* destination_device_array,
                       const MemoryCopy check_safety = MemoryCopy::RANGE_CHECK);
 
namespace stdgpu
{
 
struct null_object_t
{
    constexpr explicit null_object_t(int /* unspecified */) { }
};
 
inline constexpr null_object_t null_object{ 0 };
 
template <typename T>
class device_unique_object
{
public:
    explicit device_unique_object(null_object_t /*null_object*/);
 
    template <typename... Args>
    explicit device_unique_object(Args&&... args);
 
    template <typename ExecutionPolicy,
              typename... Args,
              STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
    explicit device_unique_object(ExecutionPolicy&& policy, Args&&... args);
 
    const T*
    operator->() const;
 
    T*
    operator->();
 
    const T&
    operator*() const;
 
    T&
    operator*();
 
    explicit operator bool() const;
 
private:
    std::unique_ptr<T, std::function<void(T*)>> _object;
};
 
enum class dynamic_memory_type
{
    host,    
    device,  
    managed, 
    invalid  
};
 
template <typename T>
dynamic_memory_type
get_dynamic_memory_type(T* array);
 
template <typename T>
struct safe_device_allocator
{
    using value_type = T; 
    constexpr static dynamic_memory_type memory_type = dynamic_memory_type::device;
 
    safe_device_allocator() noexcept = default;
 
    ~safe_device_allocator() noexcept = default;
 
    safe_device_allocator(const safe_device_allocator&) noexcept = default;
 
    template <typename U>
    explicit safe_device_allocator(const safe_device_allocator<U>& other) noexcept;
 
    safe_device_allocator&
    operator=(const safe_device_allocator&) noexcept = default;
 
    safe_device_allocator(safe_device_allocator&&) noexcept = default;
 
    safe_device_allocator&
    operator=(safe_device_allocator&&) noexcept = default;
 
    [[nodiscard]] T*
    allocate(index64_t n);
 
    void
    deallocate(T* p, index64_t n);
};
 
template <typename T>
struct safe_host_allocator
{
    using value_type = T; 
    constexpr static dynamic_memory_type memory_type = dynamic_memory_type::host;
 
    safe_host_allocator() noexcept = default;
 
    ~safe_host_allocator() noexcept = default;
 
    safe_host_allocator(const safe_host_allocator&) noexcept = default;
 
    template <typename U>
    explicit safe_host_allocator(const safe_host_allocator<U>& other) noexcept;
 
    safe_host_allocator&
    operator=(const safe_host_allocator&) noexcept = default;
 
    safe_host_allocator(safe_host_allocator&&) noexcept = default;
 
    safe_host_allocator&
    operator=(safe_host_allocator&&) noexcept = default;
 
    [[nodiscard]] T*
    allocate(index64_t n);
 
    void
    deallocate(T* p, index64_t n);
};
 
template <typename T>
struct safe_managed_allocator
{
    using value_type = T; 
    constexpr static dynamic_memory_type memory_type = dynamic_memory_type::managed;
 
    safe_managed_allocator() noexcept = default;
 
    ~safe_managed_allocator() noexcept = default;
 
    safe_managed_allocator(const safe_managed_allocator&) noexcept = default;
 
    template <typename U>
    explicit safe_managed_allocator(const safe_managed_allocator<U>& other) noexcept;
 
    safe_managed_allocator&
    operator=(const safe_managed_allocator&) noexcept = default;
 
    safe_managed_allocator(safe_managed_allocator&&) noexcept = default;
 
    safe_managed_allocator&
    operator=(safe_managed_allocator&&) noexcept = default;
 
    [[nodiscard]] T*
    allocate(index64_t n);
 
    void
    deallocate(T* p, index64_t n);
};
 
template <typename Allocator>
struct allocator_traits
{
    using allocator_type = Allocator;                  
    using value_type = typename Allocator::value_type; 
    using pointer = value_type*;                       
    using const_pointer = typename std::pointer_traits<pointer>::template rebind<
            const value_type>; 
    using void_pointer = typename std::pointer_traits<pointer>::template rebind<
            void>; 
    using const_void_pointer = typename std::pointer_traits<pointer>::template rebind<
            const void>; 
    using difference_type =
            typename std::pointer_traits<pointer>::difference_type; 
    using index_type = index64_t;                                   
    using propagate_on_container_copy_assignment = std::false_type; 
    using propagate_on_container_move_assignment = std::false_type; 
    using propagate_on_container_swap = std::false_type;            
    using is_always_equal = std::is_empty<Allocator>;               
    template <typename T>
    using rebind_alloc = typename std::allocator_traits<Allocator>::template rebind_alloc<
            T>; 
    template <typename T>
    using rebind_traits = allocator_traits<rebind_alloc<T>>; 
    [[nodiscard]] static pointer
    allocate(Allocator& a, index_type n);
 
    [[nodiscard]] static pointer
    allocate(Allocator& a, index_type n, const_void_pointer hint);
 
    static void
    deallocate(Allocator& a, pointer p, index_type n);
 
    template <typename ExecutionPolicy,
              STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
    [[nodiscard]] static pointer
    allocate_filled(ExecutionPolicy&& policy, Allocator& a, index_type n, const value_type& default_value);
 
    template <typename ExecutionPolicy,
              STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
    static void
    deallocate_filled(ExecutionPolicy&& policy, Allocator& a, pointer p, index_type n);
 
    template <typename T, class... Args>
    static STDGPU_HOST_DEVICE void
    construct(Allocator& a, T* p, Args&&... args);
 
    template <typename T>
    static STDGPU_HOST_DEVICE void
    destroy(Allocator& a, T* p);
 
    static STDGPU_HOST_DEVICE index_type
    max_size(const Allocator& a) noexcept;
 
    static Allocator
    select_on_container_copy_construction(const Allocator& a);
};
 
template <typename T>
STDGPU_HOST_DEVICE T*
to_address(T* p) noexcept;
 
template <typename Ptr, STDGPU_DETAIL_OVERLOAD_IF(detail::has_arrow_operator_v<Ptr>)>
STDGPU_HOST_DEVICE auto
to_address(const Ptr& p) noexcept;
 
template <typename Ptr, STDGPU_DETAIL_OVERLOAD_IF(!detail::has_arrow_operator_v<Ptr> && detail::has_get_v<Ptr>)>
STDGPU_HOST_DEVICE auto
to_address(const Ptr& p) noexcept;
 
template <typename T, typename... Args>
STDGPU_HOST_DEVICE T*
construct_at(T* p, Args&&... args);
 
template <typename T>
STDGPU_HOST_DEVICE void
destroy_at(T* p);
 
template <typename ExecutionPolicy,
          typename Iterator,
          typename T,
          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
void
uninitialized_fill(ExecutionPolicy&& policy, Iterator begin, Iterator end, const T& value);
 
template <typename ExecutionPolicy,
          typename Iterator,
          typename Size,
          typename T,
          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
Iterator
uninitialized_fill_n(ExecutionPolicy&& policy, Iterator begin, Size n, const T& value);
 
template <typename ExecutionPolicy,
          typename InputIt,
          typename OutputIt,
          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
OutputIt
uninitialized_copy(ExecutionPolicy&& policy, InputIt begin, InputIt end, OutputIt output_begin);
 
template <typename ExecutionPolicy,
          typename InputIt,
          typename Size,
          typename OutputIt,
          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
OutputIt
uninitialized_copy_n(ExecutionPolicy&& policy, InputIt begin, Size n, OutputIt output_begin);
 
template <typename ExecutionPolicy,
          typename Iterator,
          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
void
destroy(ExecutionPolicy&& policy, Iterator first, Iterator last);
 
template <typename ExecutionPolicy,
          typename Iterator,
          typename Size,
          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
Iterator
destroy_n(ExecutionPolicy&& policy, Iterator first, Size n);
 
template <typename T>
void
register_memory(T* p, index64_t n, dynamic_memory_type memory_type);
 
template <typename T>
void
deregister_memory(T* p, index64_t n, dynamic_memory_type memory_type);
 
index64_t
get_allocation_count(dynamic_memory_type memory_type);
 
index64_t
get_deallocation_count(dynamic_memory_type memory_type);
 
template <typename T>
index64_t
size_bytes(T* array);
 
} // namespace stdgpu
 
#include <stdgpu/impl/memory_detail.h>
 
#endif // STDGPU_MEMORY_H